3 * MTD driver for the SPI Flash Memory support.
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>
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.
16 /*===========================================================================
17 ** !!!! VERY IMPORTANT NOTICE !!!! FLASH DATA STORED IN LITTLE ENDIAN FORMAT
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.
28 ** The spiflash_write() routine performs byteswapping on all write
30 **===========================================================================*/
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>
48 /* #define SPIFLASH_DEBUG */
51 #error This driver currently only works with big endian CPU.
56 static char module_name[] = "spiflash";
58 #define MIN(a,b) ((a) < (b) ? (a) : (b))
62 #define ROOTFS_NAME "rootfs"
64 static __u32 spiflash_regread32(int reg);
65 static void spiflash_regwrite32(int reg, __u32 data);
66 static __u32 spiflash_sendcmd (int op);
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);
75 /* Flash configuration table */
81 } flashconfig_tbl[MAX_FLASH] =
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}
90 /* Mapping of generic opcodes to STM serial flash 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}
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 */
118 static struct spiflash_data *spidata;
120 extern int parse_redboot_partitions(struct mtd_info *master, struct mtd_partition **pparts);
122 /***************************************************************************************************/
125 spiflash_regread32(int reg)
127 volatile __u32 *data = (__u32 *)(spidata->spiflash_mmraddr + reg);
133 spiflash_regwrite32(int reg, __u32 data)
135 volatile __u32 *addr = (__u32 *)(spidata->spiflash_mmraddr + reg);
142 spiflash_sendcmd (int op)
146 struct opcodes *ptr_opcode;
148 ptr_opcode = &stm_opcodes[op];
151 reg = spiflash_regread32(SPI_FLASH_CTL);
152 } while (reg & SPI_CTL_BUSY);
154 spiflash_regwrite32(SPI_FLASH_OPCODE, ptr_opcode->code);
156 reg = (reg & ~SPI_CTL_TX_RX_CNT_MASK) | ptr_opcode->tx_cnt |
157 (ptr_opcode->rx_cnt << 4) | SPI_CTL_START;
159 spiflash_regwrite32(SPI_FLASH_CTL, reg);
161 if (ptr_opcode->rx_cnt > 0) {
163 reg = spiflash_regread32(SPI_FLASH_CTL);
164 } while (reg & SPI_CTL_BUSY);
166 reg = (__u32) spiflash_regread32(SPI_FLASH_DATA);
168 switch (ptr_opcode->rx_cnt) {
192 /* Probe SPI flash device
193 * Function returns 0 for failure.
194 * and flashconfig_tbl array index for success.
197 spiflash_probe_chip (void)
202 /* Read the signature on the flash device */
203 sig = spiflash_sendcmd(SPI_RD_SIG);
206 case STM_8MBIT_SIGNATURE:
207 flash_size = FLASH_1MB;
209 case STM_16MBIT_SIGNATURE:
210 flash_size = FLASH_2MB;
212 case STM_32MBIT_SIGNATURE:
213 flash_size = FLASH_4MB;
215 case STM_64MBIT_SIGNATURE:
216 flash_size = FLASH_8MB;
219 printk (KERN_WARNING "%s: Read of flash device signature failed!\n", module_name);
228 spiflash_erase (struct mtd_info *mtd,struct erase_info *instr)
230 struct opcodes *ptr_opcode;
232 int finished = FALSE;
234 #ifdef SPIFLASH_DEBUG
235 printk (KERN_DEBUG "%s(addr = 0x%.8x, len = %d)\n",__FUNCTION__,instr->addr,instr->len);
239 if (instr->addr + instr->len > mtd->size) return (-EINVAL);
241 ptr_opcode = &stm_opcodes[SPI_SECTOR_ERASE];
243 temp = ((__u32)instr->addr << 8) | (__u32)(ptr_opcode->code);
244 spin_lock(&spidata->mutex);
245 spiflash_sendcmd(SPI_WRITE_ENABLE);
248 reg = spiflash_regread32(SPI_FLASH_CTL);
249 } while (reg & SPI_CTL_BUSY);
251 spiflash_regwrite32(SPI_FLASH_OPCODE, temp);
253 reg = (reg & ~SPI_CTL_TX_RX_CNT_MASK) | ptr_opcode->tx_cnt | SPI_CTL_START;
254 spiflash_regwrite32(SPI_FLASH_CTL, reg);
258 reg = spiflash_sendcmd(SPI_RD_STATUS);
259 if (!(reg & SPI_STATUS_WIP)) {
263 spin_unlock(&spidata->mutex);
265 instr->state = MTD_ERASE_DONE;
266 if (instr->callback) instr->callback (instr);
268 #ifdef SPIFLASH_DEBUG
269 printk (KERN_DEBUG "%s return\n",__FUNCTION__);
275 spiflash_read (struct mtd_info *mtd, loff_t from,size_t len,size_t *retlen,u_char *buf)
279 #ifdef SPIFLASH_DEBUG
280 printk (KERN_DEBUG "%s(from = 0x%.8x, len = %d)\n",__FUNCTION__,(__u32) from,(int)len);
284 if (!len) return (0);
285 if (from + len > mtd->size) return (-EINVAL);
288 /* we always read len bytes */
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);
300 spiflash_write (struct mtd_info *mtd,loff_t to,size_t len,size_t *retlen,const u_char *buf)
302 int done = FALSE, page_offset, bytes_left, finished;
303 __u32 xact_len, spi_data = 0, opcode, reg;
305 #ifdef SPIFLASH_DEBUG
306 printk (KERN_DEBUG "%s(to = 0x%.8x, len = %d)\n",__FUNCTION__,(__u32) to,len);
312 if (!len) return (0);
313 if (to + len > mtd->size) return (-EINVAL);
315 opcode = stm_opcodes[SPI_PAGE_PROGRAM].code;
318 while (done == FALSE) {
319 xact_len = MIN(bytes_left, sizeof(__u32));
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.
327 page_offset = (to & (STM_PAGE_SIZE - 1)) + xact_len;
329 if (page_offset > STM_PAGE_SIZE) {
330 xact_len -= (page_offset - STM_PAGE_SIZE);
333 spin_lock(&spidata->mutex);
334 spiflash_sendcmd(SPI_WRITE_ENABLE);
338 reg = spiflash_regread32(SPI_FLASH_CTL);
339 } while (reg & SPI_CTL_BUSY);
343 spi_data = (u32) ((u8) *buf);
346 spi_data = (buf[1] << 8) | buf[0];
349 spi_data = (buf[2] << 16) | (buf[1] << 8) | buf[0];
352 spi_data = (buf[3] << 24) | (buf[2] << 16) |
353 (buf[1] << 8) | buf[0];
356 printk("spiflash_write: default case\n");
360 spiflash_regwrite32(SPI_FLASH_DATA, spi_data);
361 opcode = (opcode & SPI_OPCODE_MASK) | ((__u32)to << 8);
362 spiflash_regwrite32(SPI_FLASH_OPCODE, opcode);
364 reg = (reg & ~SPI_CTL_TX_RX_CNT_MASK) | (xact_len + 4) | SPI_CTL_START;
365 spiflash_regwrite32(SPI_FLASH_CTL, reg);
370 reg = spiflash_sendcmd(SPI_RD_STATUS);
371 if (!(reg & SPI_STATUS_WIP)) {
375 spin_unlock(&spidata->mutex);
377 bytes_left -= xact_len;
383 if (bytes_left == 0) {
392 #ifdef CONFIG_MTD_PARTITIONS
393 static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL };
397 static int spiflash_probe(struct platform_device *pdev)
399 int result = -1, i, j;
401 int index, num_parts;
402 struct mtd_info *mtd;
403 struct mtd_partition *mtd_parts;
405 struct mtd_partition *part;
406 struct squashfs_super_block *sb;
409 spidata->spiflash_mmraddr = ioremap_nocache(SPI_FLASH_MMR, SPI_FLASH_MMR_SIZE);
411 if (!spidata->spiflash_mmraddr) {
412 printk (KERN_WARNING "%s: Failed to map flash device\n", module_name);
417 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
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);
432 printk ("%s: Found SPI serial Flash.\n", module_name);
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);
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;
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;
455 #ifdef SPIFLASH_DEBUG
458 "mtd->size = 0x%.8x (%uM)\n"
459 "mtd->erasesize = 0x%.8x (%uK)\n"
460 "mtd->numeraseregions = %d\n",
462 mtd->size, mtd->size / (1024*1024),
463 mtd->erasesize, mtd->erasesize / 1024,
464 mtd->numeraseregions);
466 if (mtd->numeraseregions) {
467 for (result = 0; result < mtd->numeraseregions; result++) {
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);
480 /* parse redboot partitions */
481 num_parts = parse_mtd_partitions(mtd, part_probe_types, &spidata->parsed_parts, 0);
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));
490 if (!strcmp(part->name, ROOTFS_NAME)) {
491 /* create the root device */
492 ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, i);
494 part->size -= mtd->erasesize;
495 config_start = part->offset + part->size;
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)) {
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));
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);
511 if (len + mtd->erasesize > part->size)
514 part = &mtd_parts[++j];
519 part->name = kmalloc(10, GFP_KERNEL);
520 sprintf(part->name, "rootfs%d", j - i);
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));
527 part = &mtd_parts[j];
528 part->offset += part->size;
529 part->size = mtd->erasesize;
531 part->name = kmalloc(16, GFP_KERNEL);
532 sprintf(part->name, "board_config");
538 #ifdef SPIFLASH_DEBUG
539 printk (KERN_DEBUG "Found %d redboot partitions\n", num_parts);
542 result = add_mtd_partitions(mtd, mtd_parts, num_parts);
544 #ifdef SPIFLASH_DEBUG
545 printk (KERN_DEBUG "Did not find any redboot partitions\n");
557 static int spiflash_remove (struct platform_device *pdev)
559 del_mtd_partitions (spidata->mtd);
565 struct platform_driver spiflash_driver = {
566 .driver.name = "spiflash",
567 .probe = spiflash_probe,
568 .remove = spiflash_remove,
574 spidata = kmalloc(sizeof(struct spiflash_data), GFP_KERNEL);
578 spin_lock_init(&spidata->mutex);
579 platform_driver_register(&spiflash_driver);
590 module_init (spiflash_init);
591 module_exit (spiflash_exit);
593 MODULE_LICENSE("GPL");
594 MODULE_AUTHOR("Atheros Communications Inc");
595 MODULE_DESCRIPTION("MTD driver for SPI Flash on Atheros SOC");