1 #include <linux/kernel.h>
2 #include <linux/module.h>
3 #include <linux/slab.h>
4 #include <linux/delay.h>
5 #include <linux/mtd/mtd.h>
6 #include <linux/platform_device.h>
7 #include <linux/bcma/bcma.h>
8 
9 #include "bcm47xxsflash.h"
10 
11 MODULE_LICENSE("GPL");
12 MODULE_DESCRIPTION("Serial flash driver for BCMA bus");
13 
14 static const char * const probes[] = { "bcm47xxpart", NULL };
15 
16 /**************************************************
17  * Various helpers
18  **************************************************/
19 
20 static void bcm47xxsflash_cmd(struct bcm47xxsflash *b47s, u32 opcode)
21 {
22 	int i;
23 
24 	b47s->cc_write(b47s, BCMA_CC_FLASHCTL, BCMA_CC_FLASHCTL_START | opcode);
25 	for (i = 0; i < 1000; i++) {
26 		if (!(b47s->cc_read(b47s, BCMA_CC_FLASHCTL) &
27 		      BCMA_CC_FLASHCTL_BUSY))
28 			return;
29 		cpu_relax();
30 	}
31 	pr_err("Control command failed (timeout)!\n");
32 }
33 
34 static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout)
35 {
36 	unsigned long deadline = jiffies + timeout;
37 
38 	do {
39 		switch (b47s->type) {
40 		case BCM47XXSFLASH_TYPE_ST:
41 			bcm47xxsflash_cmd(b47s, OPCODE_ST_RDSR);
42 			if (!(b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
43 			      SR_ST_WIP))
44 				return 0;
45 			break;
46 		case BCM47XXSFLASH_TYPE_ATMEL:
47 			bcm47xxsflash_cmd(b47s, OPCODE_AT_STATUS);
48 			if (b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
49 			    SR_AT_READY)
50 				return 0;
51 			break;
52 		}
53 
54 		cpu_relax();
55 		udelay(1);
56 	} while (!time_after_eq(jiffies, deadline));
57 
58 	pr_err("Timeout waiting for flash to be ready!\n");
59 
60 	return -EBUSY;
61 }
62 
63 /**************************************************
64  * MTD ops
65  **************************************************/
66 
67 static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase)
68 {
69 	struct bcm47xxsflash *b47s = mtd->priv;
70 	int err;
71 
72 	switch (b47s->type) {
73 	case BCM47XXSFLASH_TYPE_ST:
74 		bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
75 		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr);
76 		/* Newer flashes have "sub-sectors" which can be erased
77 		 * independently with a new command: ST_SSE. The ST_SE command
78 		 * erases 64KB just as before.
79 		 */
80 		if (b47s->blocksize < (64 * 1024))
81 			bcm47xxsflash_cmd(b47s, OPCODE_ST_SSE);
82 		else
83 			bcm47xxsflash_cmd(b47s, OPCODE_ST_SE);
84 		break;
85 	case BCM47XXSFLASH_TYPE_ATMEL:
86 		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr << 1);
87 		bcm47xxsflash_cmd(b47s, OPCODE_AT_PAGE_ERASE);
88 		break;
89 	}
90 
91 	err = bcm47xxsflash_poll(b47s, HZ);
92 	if (err)
93 		erase->state = MTD_ERASE_FAILED;
94 	else
95 		erase->state = MTD_ERASE_DONE;
96 
97 	if (erase->callback)
98 		erase->callback(erase);
99 
100 	return err;
101 }
102 
103 static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
104 			      size_t *retlen, u_char *buf)
105 {
106 	struct bcm47xxsflash *b47s = mtd->priv;
107 
108 	/* Check address range */
109 	if ((from + len) > mtd->size)
110 		return -EINVAL;
111 
112 	memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(b47s->window + from),
113 		      len);
114 	*retlen = len;
115 
116 	return len;
117 }
118 
119 static int bcm47xxsflash_write_st(struct mtd_info *mtd, u32 offset, size_t len,
120 				  const u_char *buf)
121 {
122 	struct bcm47xxsflash *b47s = mtd->priv;
123 	int written = 0;
124 
125 	/* Enable writes */
126 	bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
127 
128 	/* Write first byte */
129 	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, offset);
130 	b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
131 
132 	/* Program page */
133 	if (b47s->bcma_cc->core->id.rev < 20) {
134 		bcm47xxsflash_cmd(b47s, OPCODE_ST_PP);
135 		return 1; /* 1B written */
136 	}
137 
138 	/* Program page and set CSA (on newer chips we can continue writing) */
139 	bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | OPCODE_ST_PP);
140 	offset++;
141 	len--;
142 	written++;
143 
144 	while (len > 0) {
145 		/* Page boundary, another function call is needed */
146 		if ((offset & 0xFF) == 0)
147 			break;
148 
149 		bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | *buf++);
150 		offset++;
151 		len--;
152 		written++;
153 	}
154 
155 	/* All done, drop CSA & poll */
156 	b47s->cc_write(b47s, BCMA_CC_FLASHCTL, 0);
157 	udelay(1);
158 	if (bcm47xxsflash_poll(b47s, HZ / 10))
159 		pr_err("Flash rejected dropping CSA\n");
160 
161 	return written;
162 }
163 
164 static int bcm47xxsflash_write_at(struct mtd_info *mtd, u32 offset, size_t len,
165 				  const u_char *buf)
166 {
167 	struct bcm47xxsflash *b47s = mtd->priv;
168 	u32 mask = b47s->blocksize - 1;
169 	u32 page = (offset & ~mask) << 1;
170 	u32 byte = offset & mask;
171 	int written = 0;
172 
173 	/* If we don't overwrite whole page, read it to the buffer first */
174 	if (byte || (len < b47s->blocksize)) {
175 		int err;
176 
177 		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
178 		bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_LOAD);
179 		/* 250 us for AT45DB321B */
180 		err = bcm47xxsflash_poll(b47s, HZ / 1000);
181 		if (err) {
182 			pr_err("Timeout reading page 0x%X info buffer\n", page);
183 			return err;
184 		}
185 	}
186 
187 	/* Change buffer content with our data */
188 	while (len > 0) {
189 		/* Page boundary, another function call is needed */
190 		if (byte == b47s->blocksize)
191 			break;
192 
193 		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, byte++);
194 		b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
195 		bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_WRITE);
196 		len--;
197 		written++;
198 	}
199 
200 	/* Program page with the buffer content */
201 	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
202 	bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_PROGRAM);
203 
204 	return written;
205 }
206 
207 static int bcm47xxsflash_write(struct mtd_info *mtd, loff_t to, size_t len,
208 			       size_t *retlen, const u_char *buf)
209 {
210 	struct bcm47xxsflash *b47s = mtd->priv;
211 	int written;
212 
213 	/* Writing functions can return without writing all passed data, for
214 	 * example when the hardware is too old or when we git page boundary.
215 	 */
216 	while (len > 0) {
217 		switch (b47s->type) {
218 		case BCM47XXSFLASH_TYPE_ST:
219 			written = bcm47xxsflash_write_st(mtd, to, len, buf);
220 			break;
221 		case BCM47XXSFLASH_TYPE_ATMEL:
222 			written = bcm47xxsflash_write_at(mtd, to, len, buf);
223 			break;
224 		default:
225 			BUG_ON(1);
226 		}
227 		if (written < 0) {
228 			pr_err("Error writing at offset 0x%llX\n", to);
229 			return written;
230 		}
231 		to += (loff_t)written;
232 		len -= written;
233 		*retlen += written;
234 		buf += written;
235 	}
236 
237 	return 0;
238 }
239 
240 static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s)
241 {
242 	struct mtd_info *mtd = &b47s->mtd;
243 
244 	mtd->priv = b47s;
245 	mtd->name = "bcm47xxsflash";
246 	mtd->owner = THIS_MODULE;
247 
248 	mtd->type = MTD_NORFLASH;
249 	mtd->flags = MTD_CAP_NORFLASH;
250 	mtd->size = b47s->size;
251 	mtd->erasesize = b47s->blocksize;
252 	mtd->writesize = 1;
253 	mtd->writebufsize = 1;
254 
255 	mtd->_erase = bcm47xxsflash_erase;
256 	mtd->_read = bcm47xxsflash_read;
257 	mtd->_write = bcm47xxsflash_write;
258 }
259 
260 /**************************************************
261  * BCMA
262  **************************************************/
263 
264 static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
265 {
266 	return bcma_cc_read32(b47s->bcma_cc, offset);
267 }
268 
269 static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
270 					u32 value)
271 {
272 	bcma_cc_write32(b47s->bcma_cc, offset, value);
273 }
274 
275 static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
276 {
277 	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
278 	struct bcm47xxsflash *b47s;
279 	int err;
280 
281 	b47s = devm_kzalloc(&pdev->dev, sizeof(*b47s), GFP_KERNEL);
282 	if (!b47s)
283 		return -ENOMEM;
284 	sflash->priv = b47s;
285 
286 	b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
287 	b47s->cc_read = bcm47xxsflash_bcma_cc_read;
288 	b47s->cc_write = bcm47xxsflash_bcma_cc_write;
289 
290 	switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
291 	case BCMA_CC_FLASHT_STSER:
292 		b47s->type = BCM47XXSFLASH_TYPE_ST;
293 		break;
294 	case BCMA_CC_FLASHT_ATSER:
295 		b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
296 		break;
297 	}
298 
299 	b47s->window = sflash->window;
300 	b47s->blocksize = sflash->blocksize;
301 	b47s->numblocks = sflash->numblocks;
302 	b47s->size = sflash->size;
303 	bcm47xxsflash_fill_mtd(b47s);
304 
305 	err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
306 	if (err) {
307 		pr_err("Failed to register MTD device: %d\n", err);
308 		return err;
309 	}
310 
311 	if (bcm47xxsflash_poll(b47s, HZ / 10))
312 		pr_warn("Serial flash busy\n");
313 
314 	return 0;
315 }
316 
317 static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
318 {
319 	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
320 	struct bcm47xxsflash *b47s = sflash->priv;
321 
322 	mtd_device_unregister(&b47s->mtd);
323 
324 	return 0;
325 }
326 
327 static struct platform_driver bcma_sflash_driver = {
328 	.probe	= bcm47xxsflash_bcma_probe,
329 	.remove = bcm47xxsflash_bcma_remove,
330 	.driver = {
331 		.name = "bcma_sflash",
332 	},
333 };
334 
335 /**************************************************
336  * Init
337  **************************************************/
338 
339 module_platform_driver(bcma_sflash_driver);
340