projects / openwrt.git / blob
? search:


6e6734d434e498c72e3d91136324bad36f13bbc6
[openwrt.git] / target / linux / atheros-2.6 / files / drivers / mtd / devices / spiflash.c
1
2 /*
3 * MTD driver for the SPI Flash Memory support.
4 *
5 * Copyright (c) 2005-2006 Atheros Communications Inc.
6 * Copyright (C) 2006 FON Technology, SL.
7 * Copyright (C) 2006 Imre Kaloz <kaloz@openwrt.org>
8 * Copyright (C) 2006 Felix Fietkau <nbd@openwrt.org>
9 *
10 * This code is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 */
15
16 /*===========================================================================
17 ** !!!! VERY IMPORTANT NOTICE !!!! FLASH DATA STORED IN LITTLE ENDIAN FORMAT
18 **
19 ** This module contains the Serial Flash access routines for the Atheros SOC.
20 ** The Atheros SOC integrates a SPI flash controller that is used to access
21 ** serial flash parts. The SPI flash controller executes in "Little Endian"
22 ** mode. THEREFORE, all WRITES and READS from the MIPS CPU must be
23 ** BYTESWAPPED! The SPI Flash controller hardware by default performs READ
24 ** ONLY byteswapping when accessed via the SPI Flash Alias memory region
25 ** (Physical Address 0x0800_0000 - 0x0fff_ffff). The data stored in the
26 ** flash sectors is stored in "Little Endian" format.
27 **
28 ** The spiflash_write() routine performs byteswapping on all write
29 ** operations.
30 **===========================================================================*/
31
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/version.h>
36 #include <linux/errno.h>
37 #include <linux/slab.h>
38 #include <linux/mtd/mtd.h>
39 #include <linux/mtd/partitions.h>
40 #include <linux/platform_device.h>
41 #include <linux/squashfs_fs.h>
42 #include <linux/root_dev.h>
43 #include <asm/delay.h>
44 #include <asm/io.h>
45 #include "spiflash.h"
46
47 /* debugging */
48 /* #define SPIFLASH_DEBUG */
49
50 #ifndef __BIG_ENDIAN
51 #error This driver currently only works with big endian CPU.
52 #endif
53
54 #define MAX_PARTS 32
55
56 static char module_name[] = "spiflash";
57
58 #define MIN(a,b) ((a) < (b) ? (a) : (b))
59 #define FALSE 0
60 #define TRUE 1
61
62 #define ROOTFS_NAME "rootfs"
63
64 static __u32 spiflash_regread32(int reg);
65 static void spiflash_regwrite32(int reg, __u32 data);
66 static __u32 spiflash_sendcmd (int op);
67
68 int __init spiflash_init (void);
69 void __exit spiflash_exit (void);
70 static int spiflash_probe_chip (void);
71 static int spiflash_erase (struct mtd_info *mtd,struct erase_info *instr);
72 static int spiflash_read (struct mtd_info *mtd, loff_t from,size_t len,size_t *retlen,u_char *buf);
73 static int spiflash_write (struct mtd_info *mtd,loff_t to,size_t len,size_t *retlen,const u_char *buf);
74
75 /* Flash configuration table */
76 struct flashconfig {
77 __u32 byte_cnt;
78 __u32 sector_cnt;
79 __u32 sector_size;
80 __u32 cs_addrmask;
81 } flashconfig_tbl[MAX_FLASH] =
82 {
83 { 0, 0, 0, 0},
84 { STM_1MB_BYTE_COUNT, STM_1MB_SECTOR_COUNT, STM_1MB_SECTOR_SIZE, 0x0},
85 { STM_2MB_BYTE_COUNT, STM_2MB_SECTOR_COUNT, STM_2MB_SECTOR_SIZE, 0x0},
86 { STM_4MB_BYTE_COUNT, STM_4MB_SECTOR_COUNT, STM_4MB_SECTOR_SIZE, 0x0},
87 { STM_8MB_BYTE_COUNT, STM_8MB_SECTOR_COUNT, STM_8MB_SECTOR_SIZE, 0x0}
88 };
89
90 /* Mapping of generic opcodes to STM serial flash opcodes */
91 struct opcodes {
92 __u16 code;
93 __s8 tx_cnt;
94 __s8 rx_cnt;
95 } stm_opcodes[] = {
96 {STM_OP_WR_ENABLE, 1, 0},
97 {STM_OP_WR_DISABLE, 1, 0},
98 {STM_OP_RD_STATUS, 1, 1},
99 {STM_OP_WR_STATUS, 1, 0},
100 {STM_OP_RD_DATA, 4, 4},
101 {STM_OP_FAST_RD_DATA, 1, 0},
102 {STM_OP_PAGE_PGRM, 8, 0},
103 {STM_OP_SECTOR_ERASE, 4, 0},
104 {STM_OP_BULK_ERASE, 1, 0},
105 {STM_OP_DEEP_PWRDOWN, 1, 0},
106 {STM_OP_RD_SIG, 4, 1}
107 };
108
109 /* Driver private data structure */
110 struct spiflash_data {
111 struct mtd_info *mtd;
112 struct mtd_partition *parsed_parts; /* parsed partitions */
113 void *spiflash_readaddr; /* memory mapped data for read */
114 void *spiflash_mmraddr; /* memory mapped register space */
115 spinlock_t mutex;
116 };
117
118 static struct spiflash_data *spidata;
119
120 extern int parse_redboot_partitions(struct mtd_info *master, struct mtd_partition **pparts);
121
122 /***************************************************************************************************/
123
124 static __u32
125 spiflash_regread32(int reg)
126 {
127 volatile __u32 *data = (__u32 *)(spidata->spiflash_mmraddr + reg);
128
129 return (*data);
130 }
131
132 static void
133 spiflash_regwrite32(int reg, __u32 data)
134 {
135 volatile __u32 *addr = (__u32 *)(spidata->spiflash_mmraddr + reg);
136
137 *addr = data;
138 return;
139 }
140
141 static __u32
142 spiflash_sendcmd (int op)
143 {
144 __u32 reg;
145 __u32 mask;
146 struct opcodes *ptr_opcode;
147
148 ptr_opcode = &stm_opcodes[op];
149
150 do {
151 reg = spiflash_regread32(SPI_FLASH_CTL);
152 } while (reg & SPI_CTL_BUSY);
153
154 spiflash_regwrite32(SPI_FLASH_OPCODE, ptr_opcode->code);
155
156 reg = (reg & ~SPI_CTL_TX_RX_CNT_MASK) | ptr_opcode->tx_cnt |
157 (ptr_opcode->rx_cnt << 4) | SPI_CTL_START;
158
159 spiflash_regwrite32(SPI_FLASH_CTL, reg);
160
161 if (ptr_opcode->rx_cnt > 0) {
162 do {
163 reg = spiflash_regread32(SPI_FLASH_CTL);
164 } while (reg & SPI_CTL_BUSY);
165
166 reg = (__u32) spiflash_regread32(SPI_FLASH_DATA);
167
168 switch (ptr_opcode->rx_cnt) {
169 case 1:
170 mask = 0x000000ff;
171 break;
172 case 2:
173 mask = 0x0000ffff;
174 break;
175 case 3:
176 mask = 0x00ffffff;
177 break;
178 default:
179 mask = 0xffffffff;
180 break;
181 }
182
183 reg &= mask;
184 }
185 else {
186 reg = 0;
187 }
188
189 return reg;
190 }
191
192 /* Probe SPI flash device
193 * Function returns 0 for failure.
194 * and flashconfig_tbl array index for success.
195 */
196 static int
197 spiflash_probe_chip (void)
198 {
199 __u32 sig;
200 int flash_size;
201
202 /* Read the signature on the flash device */
203 sig = spiflash_sendcmd(SPI_RD_SIG);
204
205 switch (sig) {
206 case STM_8MBIT_SIGNATURE:
207 flash_size = FLASH_1MB;
208 break;
209 case STM_16MBIT_SIGNATURE:
210 flash_size = FLASH_2MB;
211 break;
212 case STM_32MBIT_SIGNATURE:
213 flash_size = FLASH_4MB;
214 break;
215 case STM_64MBIT_SIGNATURE:
216 flash_size = FLASH_8MB;
217 break;
218 default:
219 printk (KERN_WARNING "%s: Read of flash device signature failed!\n", module_name);
220 return (0);
221 }
222
223 return (flash_size);
224 }
225
226
227 static int
228 spiflash_erase (struct mtd_info *mtd,struct erase_info *instr)
229 {
230 struct opcodes *ptr_opcode;
231 __u32 temp, reg;
232 int finished = FALSE;
233
234 #ifdef SPIFLASH_DEBUG
235 printk (KERN_DEBUG "%s(addr = 0x%.8x, len = %d)\n",__FUNCTION__,instr->addr,instr->len);
236 #endif
237
238 /* sanity checks */
239 if (instr->addr + instr->len > mtd->size) return (-EINVAL);
240
241 ptr_opcode = &stm_opcodes[SPI_SECTOR_ERASE];
242
243 temp = ((__u32)instr->addr << 8) | (__u32)(ptr_opcode->code);
244 spin_lock(&spidata->mutex);
245 spiflash_sendcmd(SPI_WRITE_ENABLE);
246 do {
247 schedule();
248 reg = spiflash_regread32(SPI_FLASH_CTL);
249 } while (reg & SPI_CTL_BUSY);
250
251 spiflash_regwrite32(SPI_FLASH_OPCODE, temp);
252
253 reg = (reg & ~SPI_CTL_TX_RX_CNT_MASK) | ptr_opcode->tx_cnt | SPI_CTL_START;
254 spiflash_regwrite32(SPI_FLASH_CTL, reg);
255
256 do {
257 schedule();
258 reg = spiflash_sendcmd(SPI_RD_STATUS);
259 if (!(reg & SPI_STATUS_WIP)) {
260 finished = TRUE;
261 }
262 } while (!finished);
263 spin_unlock(&spidata->mutex);
264
265 instr->state = MTD_ERASE_DONE;
266 if (instr->callback) instr->callback (instr);
267
268 #ifdef SPIFLASH_DEBUG
269 printk (KERN_DEBUG "%s return\n",__FUNCTION__);
270 #endif
271 return (0);
272 }
273
274 static int
275 spiflash_read (struct mtd_info *mtd, loff_t from,size_t len,size_t *retlen,u_char *buf)
276 {
277 u_char *read_addr;
278
279 #ifdef SPIFLASH_DEBUG
280 printk (KERN_DEBUG "%s(from = 0x%.8x, len = %d)\n",__FUNCTION__,(__u32) from,(int)len);
281 #endif
282
283 /* sanity checks */
284 if (!len) return (0);
285 if (from + len > mtd->size) return (-EINVAL);
286
287
288 /* we always read len bytes */
289 *retlen = len;
290
291 read_addr = (u_char *)(spidata->spiflash_readaddr + from);
292 spin_lock(&spidata->mutex);
293 memcpy(buf, read_addr, len);
294 spin_unlock(&spidata->mutex);
295
296 return (0);
297 }
298
299 static int
300 spiflash_write (struct mtd_info *mtd,loff_t to,size_t len,size_t *retlen,const u_char *buf)
301 {
302 int done = FALSE, page_offset, bytes_left, finished;
303 __u32 xact_len, spi_data = 0, opcode, reg;
304
305 #ifdef SPIFLASH_DEBUG
306 printk (KERN_DEBUG "%s(to = 0x%.8x, len = %d)\n",__FUNCTION__,(__u32) to,len);
307 #endif
308
309 *retlen = 0;
310
311 /* sanity checks */
312 if (!len) return (0);
313 if (to + len > mtd->size) return (-EINVAL);
314
315 opcode = stm_opcodes[SPI_PAGE_PROGRAM].code;
316 bytes_left = len;
317
318 while (done == FALSE) {
319 xact_len = MIN(bytes_left, sizeof(__u32));
320
321 /* 32-bit writes cannot span across a page boundary
322 * (256 bytes). This types of writes require two page
323 * program operations to handle it correctly. The STM part
324 * will write the overflow data to the beginning of the
325 * current page as opposed to the subsequent page.
326 */
327 page_offset = (to & (STM_PAGE_SIZE - 1)) + xact_len;
328
329 if (page_offset > STM_PAGE_SIZE) {
330 xact_len -= (page_offset - STM_PAGE_SIZE);
331 }
332
333 spin_lock(&spidata->mutex);
334 spiflash_sendcmd(SPI_WRITE_ENABLE);
335
336 do {
337 schedule();
338 reg = spiflash_regread32(SPI_FLASH_CTL);
339 } while (reg & SPI_CTL_BUSY);
340
341 switch (xact_len) {
342 case 1:
343 spi_data = (u32) ((u8) *buf);
344 break;
345 case 2:
346 spi_data = (buf[1] << 8) | buf[0];
347 break;
348 case 3:
349 spi_data = (buf[2] << 16) | (buf[1] << 8) | buf[0];
350 break;
351 case 4:
352 spi_data = (buf[3] << 24) | (buf[2] << 16) |
353 (buf[1] << 8) | buf[0];
354 break;
355 default:
356 printk("spiflash_write: default case\n");
357 break;
358 }
359
360 spiflash_regwrite32(SPI_FLASH_DATA, spi_data);
361 opcode = (opcode & SPI_OPCODE_MASK) | ((__u32)to << 8);
362 spiflash_regwrite32(SPI_FLASH_OPCODE, opcode);
363
364 reg = (reg & ~SPI_CTL_TX_RX_CNT_MASK) | (xact_len + 4) | SPI_CTL_START;
365 spiflash_regwrite32(SPI_FLASH_CTL, reg);
366 finished = FALSE;
367
368 do {
369 schedule();
370 reg = spiflash_sendcmd(SPI_RD_STATUS);
371 if (!(reg & SPI_STATUS_WIP)) {
372 finished = TRUE;
373 }
374 } while (!finished);
375 spin_unlock(&spidata->mutex);
376
377 bytes_left -= xact_len;
378 to += xact_len;
379 buf += xact_len;
380
381 *retlen += xact_len;
382
383 if (bytes_left == 0) {
384 done = TRUE;
385 }
386 }
387
388 return (0);
389 }
390
391
392 #ifdef CONFIG_MTD_PARTITIONS
393 static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL };
394 #endif
395
396
397 static int spiflash_probe(struct platform_device *pdev)
398 {
399 int result = -1, i, j;
400 u32 len;
401 int index, num_parts;
402 struct mtd_info *mtd;
403 struct mtd_partition *mtd_parts;
404 char *buf;
405 struct mtd_partition *part;
406 struct squashfs_super_block *sb;
407 u32 config_start;
408
409 spidata->spiflash_mmraddr = ioremap_nocache(SPI_FLASH_MMR, SPI_FLASH_MMR_SIZE);
410
411 if (!spidata->spiflash_mmraddr) {
412 printk (KERN_WARNING "%s: Failed to map flash device\n", module_name);
413 kfree(spidata);
414 spidata = NULL;
415 }
416
417 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
418 if (!mtd) {
419 kfree(spidata);
420 return (-ENXIO);
421 }
422
423 printk ("MTD driver for SPI flash.\n");
424 printk ("%s: Probing for Serial flash ...\n", module_name);
425 if (!(index = spiflash_probe_chip())) {
426 printk (KERN_WARNING "%s: Found no serial flash device\n", module_name);
427 kfree(mtd);
428 kfree(spidata);
429 return (-ENXIO);
430 }
431
432 printk ("%s: Found SPI serial Flash.\n", module_name);
433
434 spidata->spiflash_readaddr = ioremap_nocache(SPI_FLASH_READ, flashconfig_tbl[index].byte_cnt);
435 if (!spidata->spiflash_readaddr) {
436 printk (KERN_WARNING "%s: Failed to map flash device\n", module_name);
437 kfree(mtd);
438 kfree(spidata);
439 return (-ENXIO);
440 }
441
442 mtd->name = module_name;
443 mtd->type = MTD_NORFLASH;
444 mtd->flags = (MTD_CAP_NORFLASH|MTD_WRITEABLE);
445 mtd->size = flashconfig_tbl[index].byte_cnt;
446 mtd->erasesize = flashconfig_tbl[index].sector_size;
447 mtd->writesize = 1;
448 mtd->numeraseregions = 0;
449 mtd->eraseregions = NULL;
450 mtd->erase = spiflash_erase;
451 mtd->read = spiflash_read;
452 mtd->write = spiflash_write;
453 mtd->owner = THIS_MODULE;
454
455 #ifdef SPIFLASH_DEBUG
456 printk (KERN_DEBUG
457 "mtd->name = %s\n"
458 "mtd->size = 0x%.8x (%uM)\n"
459 "mtd->erasesize = 0x%.8x (%uK)\n"
460 "mtd->numeraseregions = %d\n",
461 mtd->name,
462 mtd->size, mtd->size / (1024*1024),
463 mtd->erasesize, mtd->erasesize / 1024,
464 mtd->numeraseregions);
465
466 if (mtd->numeraseregions) {
467 for (result = 0; result < mtd->numeraseregions; result++) {
468 printk (KERN_DEBUG
469 "\n\n"
470 "mtd->eraseregions[%d].offset = 0x%.8x\n"
471 "mtd->eraseregions[%d].erasesize = 0x%.8x (%uK)\n"
472 "mtd->eraseregions[%d].numblocks = %d\n",
473 result,mtd->eraseregions[result].offset,
474 result,mtd->eraseregions[result].erasesize,mtd->eraseregions[result].erasesize / 1024,
475 result,mtd->eraseregions[result].numblocks);
476 }
477 }
478 #endif
479
480 /* parse redboot partitions */
481 num_parts = parse_mtd_partitions(mtd, part_probe_types, &spidata->parsed_parts, 0);
482
483 mtd_parts = kzalloc(sizeof(struct mtd_partition) * MAX_PARTS, GFP_KERNEL);
484 buf = kmalloc(mtd->erasesize, GFP_KERNEL);
485 sb = (struct squashfs_super_block *) buf;
486 for (i = j = 0; i < num_parts; i++, j++) {
487 part = &mtd_parts[j];
488 memcpy(part, &spidata->parsed_parts[i], sizeof(struct mtd_partition));
489
490 if (!strcmp(part->name, ROOTFS_NAME)) {
491 /* create the root device */
492 ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, i);
493
494 part->size -= mtd->erasesize;
495 config_start = part->offset + part->size;
496
497 while ((mtd->read(mtd, part->offset, mtd->erasesize, &len, buf) == 0) &&
498 (len == mtd->erasesize) &&
499 (*((u32 *) buf) == SQUASHFS_MAGIC) &&
500 (sb->bytes_used > 0)) {
501
502 /* this is squashfs, allocate another partition starting from the end of filesystem data */
503 memcpy(&mtd_parts[j + 1], part, sizeof(struct mtd_partition));
504
505 len = (u32) sb->bytes_used;
506 len += (part->offset & 0x000fffff);
507 len += (mtd->erasesize - 1);
508 len &= ~(mtd->erasesize - 1);
509 len -= (part->offset & 0x000fffff);
510
511 if (len + mtd->erasesize > part->size)
512 break;
513
514 part = &mtd_parts[++j];
515
516 part->offset += len;
517 part->size -= len;
518
519 part->name = kmalloc(10, GFP_KERNEL);
520 sprintf(part->name, "rootfs%d", j - i);
521 }
522 }
523 if (!strcmp(part->name, "RedBoot config")) {
524 /* add anoterh partition for the board config data */
525 memcpy(&mtd_parts[j + 1], part, sizeof(struct mtd_partition));
526 j++;
527 part = &mtd_parts[j];
528 part->offset += part->size;
529 part->size = mtd->erasesize;
530
531 part->name = kmalloc(16, GFP_KERNEL);
532 sprintf(part->name, "board_config");
533 }
534 }
535 num_parts += j - i;
536 kfree(buf);
537
538 #ifdef SPIFLASH_DEBUG
539 printk (KERN_DEBUG "Found %d redboot partitions\n", num_parts);
540 #endif
541 if (num_parts) {
542 result = add_mtd_partitions(mtd, mtd_parts, num_parts);
543 } else {
544 #ifdef SPIFLASH_DEBUG
545 printk (KERN_DEBUG "Did not find any redboot partitions\n");
546 #endif
547 kfree(mtd);
548 kfree(spidata);
549 return (-ENXIO);
550 }
551
552 spidata->mtd = mtd;
553
554 return (result);
555 }
556
557 static int spiflash_remove (struct platform_device *pdev)
558 {
559 del_mtd_partitions (spidata->mtd);
560 kfree(spidata->mtd);
561
562 return 0;
563 }
564
565 struct platform_driver spiflash_driver = {
566 .driver.name = "spiflash",
567 .probe = spiflash_probe,
568 .remove = spiflash_remove,
569 };
570
571 int __init
572 spiflash_init (void)
573 {
574 spidata = kmalloc(sizeof(struct spiflash_data), GFP_KERNEL);
575 if (!spidata)
576 return (-ENXIO);
577
578 spin_lock_init(&spidata->mutex);
579 platform_driver_register(&spiflash_driver);
580
581 return 0;
582 }
583
584 void __exit
585 spiflash_exit (void)
586 {
587 kfree(spidata);
588 }
589
590 module_init (spiflash_init);
591 module_exit (spiflash_exit);
592
593 MODULE_LICENSE("GPL");
594 MODULE_AUTHOR("Atheros Communications Inc");
595 MODULE_DESCRIPTION("MTD driver for SPI Flash on Atheros SOC");
596
Personal OpenWRT clone
This page took 0.080879 seconds and 3 git commands to generate.