4 * Driver for Microchip 23k256 SPI RAM chips
6 * Copyright © 2016 Andrew Lunn <andrew@lunn.ch>
8 * This code is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/device.h>
14 #include <linux/module.h>
15 #include <linux/mtd/mtd.h>
16 #include <linux/mtd/partitions.h>
17 #include <linux/mutex.h>
18 #include <linux/sched.h>
19 #include <linux/sizes.h>
20 #include <linux/spi/flash.h>
21 #include <linux/spi/spi.h>
22 #include <linux/of_device.h>
24 #define MAX_CMD_SIZE 4
31 struct mchp23k256_flash
{
32 struct spi_device
*spi
;
35 const struct mchp23_caps
*caps
;
38 #define MCHP23K256_CMD_WRITE_STATUS 0x01
39 #define MCHP23K256_CMD_WRITE 0x02
40 #define MCHP23K256_CMD_READ 0x03
41 #define MCHP23K256_MODE_SEQ BIT(6)
43 #define to_mchp23k256_flash(x) container_of(x, struct mchp23k256_flash, mtd)
45 static void mchp23k256_addr2cmd(struct mchp23k256_flash
*flash
,
46 unsigned int addr
, u8
*cmd
)
51 * Address is sent in big endian (MSB first) and we skip
52 * the first entry of the cmd array which contains the cmd
55 for (i
= flash
->caps
->addr_width
; i
> 0; i
--, addr
>>= 8)
59 static int mchp23k256_cmdsz(struct mchp23k256_flash
*flash
)
61 return 1 + flash
->caps
->addr_width
;
64 static int mchp23k256_write(struct mtd_info
*mtd
, loff_t to
, size_t len
,
65 size_t *retlen
, const unsigned char *buf
)
67 struct mchp23k256_flash
*flash
= to_mchp23k256_flash(mtd
);
68 struct spi_transfer transfer
[2] = {};
69 struct spi_message message
;
70 unsigned char command
[MAX_CMD_SIZE
];
72 spi_message_init(&message
);
74 command
[0] = MCHP23K256_CMD_WRITE
;
75 mchp23k256_addr2cmd(flash
, to
, command
);
77 transfer
[0].tx_buf
= command
;
78 transfer
[0].len
= mchp23k256_cmdsz(flash
);
79 spi_message_add_tail(&transfer
[0], &message
);
81 transfer
[1].tx_buf
= buf
;
82 transfer
[1].len
= len
;
83 spi_message_add_tail(&transfer
[1], &message
);
85 mutex_lock(&flash
->lock
);
87 spi_sync(flash
->spi
, &message
);
89 if (retlen
&& message
.actual_length
> sizeof(command
))
90 *retlen
+= message
.actual_length
- sizeof(command
);
92 mutex_unlock(&flash
->lock
);
96 static int mchp23k256_read(struct mtd_info
*mtd
, loff_t from
, size_t len
,
97 size_t *retlen
, unsigned char *buf
)
99 struct mchp23k256_flash
*flash
= to_mchp23k256_flash(mtd
);
100 struct spi_transfer transfer
[2] = {};
101 struct spi_message message
;
102 unsigned char command
[MAX_CMD_SIZE
];
104 spi_message_init(&message
);
106 memset(&transfer
, 0, sizeof(transfer
));
107 command
[0] = MCHP23K256_CMD_READ
;
108 mchp23k256_addr2cmd(flash
, from
, command
);
110 transfer
[0].tx_buf
= command
;
111 transfer
[0].len
= mchp23k256_cmdsz(flash
);
112 spi_message_add_tail(&transfer
[0], &message
);
114 transfer
[1].rx_buf
= buf
;
115 transfer
[1].len
= len
;
116 spi_message_add_tail(&transfer
[1], &message
);
118 mutex_lock(&flash
->lock
);
120 spi_sync(flash
->spi
, &message
);
122 if (retlen
&& message
.actual_length
> sizeof(command
))
123 *retlen
+= message
.actual_length
- sizeof(command
);
125 mutex_unlock(&flash
->lock
);
130 * Set the device into sequential mode. This allows read/writes to the
131 * entire SRAM in a single operation
133 static int mchp23k256_set_mode(struct spi_device
*spi
)
135 struct spi_transfer transfer
= {};
136 struct spi_message message
;
137 unsigned char command
[2];
139 spi_message_init(&message
);
141 command
[0] = MCHP23K256_CMD_WRITE_STATUS
;
142 command
[1] = MCHP23K256_MODE_SEQ
;
144 transfer
.tx_buf
= command
;
145 transfer
.len
= sizeof(command
);
146 spi_message_add_tail(&transfer
, &message
);
148 return spi_sync(spi
, &message
);
151 static const struct mchp23_caps mchp23k256_caps
= {
156 static const struct mchp23_caps mchp23lcv1024_caps
= {
161 static int mchp23k256_probe(struct spi_device
*spi
)
163 struct mchp23k256_flash
*flash
;
164 struct flash_platform_data
*data
;
167 flash
= devm_kzalloc(&spi
->dev
, sizeof(*flash
), GFP_KERNEL
);
172 mutex_init(&flash
->lock
);
173 spi_set_drvdata(spi
, flash
);
175 err
= mchp23k256_set_mode(spi
);
179 data
= dev_get_platdata(&spi
->dev
);
181 flash
->caps
= of_device_get_match_data(&spi
->dev
);
183 flash
->caps
= &mchp23k256_caps
;
185 mtd_set_of_node(&flash
->mtd
, spi
->dev
.of_node
);
186 flash
->mtd
.dev
.parent
= &spi
->dev
;
187 flash
->mtd
.type
= MTD_RAM
;
188 flash
->mtd
.flags
= MTD_CAP_RAM
;
189 flash
->mtd
.writesize
= 1;
190 flash
->mtd
.size
= flash
->caps
->size
;
191 flash
->mtd
._read
= mchp23k256_read
;
192 flash
->mtd
._write
= mchp23k256_write
;
194 err
= mtd_device_register(&flash
->mtd
, data
? data
->parts
: NULL
,
195 data
? data
->nr_parts
: 0);
202 static int mchp23k256_remove(struct spi_device
*spi
)
204 struct mchp23k256_flash
*flash
= spi_get_drvdata(spi
);
206 return mtd_device_unregister(&flash
->mtd
);
209 static const struct of_device_id mchp23k256_of_table
[] = {
211 .compatible
= "microchip,mchp23k256",
212 .data
= &mchp23k256_caps
,
215 .compatible
= "microchip,mchp23lcv1024",
216 .data
= &mchp23lcv1024_caps
,
220 MODULE_DEVICE_TABLE(of
, mchp23k256_of_table
);
222 static struct spi_driver mchp23k256_driver
= {
224 .name
= "mchp23k256",
225 .of_match_table
= of_match_ptr(mchp23k256_of_table
),
227 .probe
= mchp23k256_probe
,
228 .remove
= mchp23k256_remove
,
231 module_spi_driver(mchp23k256_driver
);
233 MODULE_DESCRIPTION("MTD SPI driver for MCHP23K256 RAM chips");
234 MODULE_AUTHOR("Andrew Lunn <andre@lunn.ch>");
235 MODULE_LICENSE("GPL v2");
236 MODULE_ALIAS("spi:mchp23k256");