Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 1 | /* |
David Brownell | fa0a8c7 | 2007-06-24 15:12:35 -0700 | [diff] [blame] | 2 | * MTD SPI driver for ST M25Pxx (and similar) serial flash chips |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 3 | * |
| 4 | * Author: Mike Lavender, mike@steroidmicros.com |
| 5 | * |
| 6 | * Copyright (c) 2005, Intec Automation Inc. |
| 7 | * |
| 8 | * Some parts are based on lart.c by Abraham Van Der Merwe |
| 9 | * |
| 10 | * Cleaned up and generalized based on mtd_dataflash.c |
| 11 | * |
| 12 | * This code is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of the GNU General Public License version 2 as |
| 14 | * published by the Free Software Foundation. |
| 15 | * |
| 16 | */ |
| 17 | |
Anton Vorontsov | 9d2c4f3 | 2010-06-22 20:57:42 +0400 | [diff] [blame] | 18 | #include <linux/err.h> |
| 19 | #include <linux/errno.h> |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 20 | #include <linux/module.h> |
| 21 | #include <linux/device.h> |
David Brownell | 7d5230e | 2007-06-24 15:09:13 -0700 | [diff] [blame] | 22 | |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 23 | #include <linux/mtd/mtd.h> |
| 24 | #include <linux/mtd/partitions.h> |
David Brownell | 7d5230e | 2007-06-24 15:09:13 -0700 | [diff] [blame] | 25 | |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 26 | #include <linux/spi/spi.h> |
| 27 | #include <linux/spi/flash.h> |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 28 | #include <linux/mtd/spi-nor.h> |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 29 | |
Brian Norris | 778d226 | 2013-07-24 18:32:07 -0700 | [diff] [blame] | 30 | #define MAX_CMD_SIZE 6 |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 31 | struct m25p { |
| 32 | struct spi_device *spi; |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 33 | struct spi_nor spi_nor; |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 34 | u8 command[MAX_CMD_SIZE]; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 35 | }; |
| 36 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 37 | static int m25p80_read_reg(struct spi_nor *nor, u8 code, u8 *val, int len) |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 38 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 39 | struct m25p *flash = nor->priv; |
| 40 | struct spi_device *spi = flash->spi; |
Sourav Poddar | 3487a639 | 2013-11-06 20:05:35 +0530 | [diff] [blame] | 41 | int ret; |
Sourav Poddar | 3487a639 | 2013-11-06 20:05:35 +0530 | [diff] [blame] | 42 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 43 | ret = spi_write_then_read(spi, &code, 1, val, len); |
| 44 | if (ret < 0) |
| 45 | dev_err(&spi->dev, "error %d reading %x\n", ret, code); |
Sourav Poddar | 3487a639 | 2013-11-06 20:05:35 +0530 | [diff] [blame] | 46 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 47 | return ret; |
Sourav Poddar | 3487a639 | 2013-11-06 20:05:35 +0530 | [diff] [blame] | 48 | } |
| 49 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 50 | static void m25p_addr2cmd(struct spi_nor *nor, unsigned int addr, u8 *cmd) |
Anton Vorontsov | 837479d | 2009-10-12 20:24:40 +0400 | [diff] [blame] | 51 | { |
| 52 | /* opcode is in cmd[0] */ |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 53 | cmd[1] = addr >> (nor->addr_width * 8 - 8); |
| 54 | cmd[2] = addr >> (nor->addr_width * 8 - 16); |
| 55 | cmd[3] = addr >> (nor->addr_width * 8 - 24); |
| 56 | cmd[4] = addr >> (nor->addr_width * 8 - 32); |
Anton Vorontsov | 837479d | 2009-10-12 20:24:40 +0400 | [diff] [blame] | 57 | } |
| 58 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 59 | static int m25p_cmdsz(struct spi_nor *nor) |
Anton Vorontsov | 837479d | 2009-10-12 20:24:40 +0400 | [diff] [blame] | 60 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 61 | return 1 + nor->addr_width; |
Anton Vorontsov | 837479d | 2009-10-12 20:24:40 +0400 | [diff] [blame] | 62 | } |
| 63 | |
Jagan Teki | f9f3ce8 | 2015-08-19 15:26:44 +0530 | [diff] [blame] | 64 | static int m25p80_write_reg(struct spi_nor *nor, u8 opcode, u8 *buf, int len) |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 65 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 66 | struct m25p *flash = nor->priv; |
| 67 | struct spi_device *spi = flash->spi; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 68 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 69 | flash->command[0] = opcode; |
| 70 | if (buf) |
| 71 | memcpy(&flash->command[1], buf, len); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 72 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 73 | return spi_write(spi, flash->command, len + 1); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 74 | } |
| 75 | |
Michal Suchanek | 59451e1 | 2016-05-05 17:31:47 -0700 | [diff] [blame] | 76 | static ssize_t m25p80_write(struct spi_nor *nor, loff_t to, size_t len, |
Michal Suchanek | 2dd087b | 2016-05-05 17:31:53 -0700 | [diff] [blame] | 77 | const u_char *buf) |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 78 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 79 | struct m25p *flash = nor->priv; |
| 80 | struct spi_device *spi = flash->spi; |
| 81 | struct spi_transfer t[2] = {}; |
| 82 | struct spi_message m; |
| 83 | int cmd_sz = m25p_cmdsz(nor); |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 84 | ssize_t ret; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 85 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 86 | spi_message_init(&m); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 87 | |
Brian Norris | b02e7f3 | 2014-04-08 18:15:31 -0700 | [diff] [blame] | 88 | if (nor->program_opcode == SPINOR_OP_AAI_WP && nor->sst_write_second) |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 89 | cmd_sz = 1; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 90 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 91 | flash->command[0] = nor->program_opcode; |
| 92 | m25p_addr2cmd(nor, to, flash->command); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 93 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 94 | t[0].tx_buf = flash->command; |
| 95 | t[0].len = cmd_sz; |
| 96 | spi_message_add_tail(&t[0], &m); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 97 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 98 | t[1].tx_buf = buf; |
| 99 | t[1].len = len; |
| 100 | spi_message_add_tail(&t[1], &m); |
Chen Gong | 7854643 | 2008-11-26 10:23:57 +0000 | [diff] [blame] | 101 | |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 102 | ret = spi_sync(spi, &m); |
| 103 | if (ret) |
| 104 | return ret; |
Chen Gong | 7854643 | 2008-11-26 10:23:57 +0000 | [diff] [blame] | 105 | |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 106 | ret = m.actual_length - cmd_sz; |
| 107 | if (ret < 0) |
| 108 | return -EIO; |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 109 | return ret; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 110 | } |
| 111 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 112 | static inline unsigned int m25p80_rx_nbits(struct spi_nor *nor) |
Sourav Poddar | 8552b43 | 2013-11-06 20:05:34 +0530 | [diff] [blame] | 113 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 114 | switch (nor->flash_read) { |
| 115 | case SPI_NOR_DUAL: |
Geert Uytterhoeven | dbbafb7 | 2014-01-21 13:59:18 +0100 | [diff] [blame] | 116 | return 2; |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 117 | case SPI_NOR_QUAD: |
Geert Uytterhoeven | 464e906 | 2014-01-21 13:59:17 +0100 | [diff] [blame] | 118 | return 4; |
| 119 | default: |
| 120 | return 0; |
| 121 | } |
| 122 | } |
| 123 | |
Sourav Poddar | 8552b43 | 2013-11-06 20:05:34 +0530 | [diff] [blame] | 124 | /* |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 125 | * Read an address range from the nor chip. The address range |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 126 | * may be any size provided it is within the physical boundaries. |
| 127 | */ |
Michal Suchanek | 59451e1 | 2016-05-05 17:31:47 -0700 | [diff] [blame] | 128 | static ssize_t m25p80_read(struct spi_nor *nor, loff_t from, size_t len, |
Michal Suchanek | 2dd087b | 2016-05-05 17:31:53 -0700 | [diff] [blame] | 129 | u_char *buf) |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 130 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 131 | struct m25p *flash = nor->priv; |
| 132 | struct spi_device *spi = flash->spi; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 133 | struct spi_transfer t[2]; |
| 134 | struct spi_message m; |
Huang Shijie | 0b78a2c | 2014-04-28 11:53:38 +0800 | [diff] [blame] | 135 | unsigned int dummy = nor->read_dummy; |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 136 | ssize_t ret; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 137 | |
Huang Shijie | 0b78a2c | 2014-04-28 11:53:38 +0800 | [diff] [blame] | 138 | /* convert the dummy cycles to the number of bytes */ |
| 139 | dummy /= 8; |
| 140 | |
Vignesh R | 08922f6 | 2016-03-29 11:16:17 +0530 | [diff] [blame] | 141 | if (spi_flash_read_supported(spi)) { |
| 142 | struct spi_flash_read_message msg; |
Vignesh R | 08922f6 | 2016-03-29 11:16:17 +0530 | [diff] [blame] | 143 | |
| 144 | memset(&msg, 0, sizeof(msg)); |
| 145 | |
| 146 | msg.buf = buf; |
| 147 | msg.from = from; |
| 148 | msg.len = len; |
| 149 | msg.read_opcode = nor->read_opcode; |
| 150 | msg.addr_width = nor->addr_width; |
| 151 | msg.dummy_bytes = dummy; |
| 152 | /* TODO: Support other combinations */ |
| 153 | msg.opcode_nbits = SPI_NBITS_SINGLE; |
| 154 | msg.addr_nbits = SPI_NBITS_SINGLE; |
| 155 | msg.data_nbits = m25p80_rx_nbits(nor); |
| 156 | |
| 157 | ret = spi_flash_read(spi, &msg); |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 158 | if (ret < 0) |
| 159 | return ret; |
| 160 | return msg.retlen; |
Vignesh R | 08922f6 | 2016-03-29 11:16:17 +0530 | [diff] [blame] | 161 | } |
| 162 | |
Vitaly Wool | 8275c64 | 2006-01-08 13:34:28 -0800 | [diff] [blame] | 163 | spi_message_init(&m); |
| 164 | memset(t, 0, (sizeof t)); |
| 165 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 166 | flash->command[0] = nor->read_opcode; |
| 167 | m25p_addr2cmd(nor, from, flash->command); |
Sourav Poddar | 8552b43 | 2013-11-06 20:05:34 +0530 | [diff] [blame] | 168 | |
Vitaly Wool | 8275c64 | 2006-01-08 13:34:28 -0800 | [diff] [blame] | 169 | t[0].tx_buf = flash->command; |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 170 | t[0].len = m25p_cmdsz(nor) + dummy; |
Vitaly Wool | 8275c64 | 2006-01-08 13:34:28 -0800 | [diff] [blame] | 171 | spi_message_add_tail(&t[0], &m); |
| 172 | |
| 173 | t[1].rx_buf = buf; |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 174 | t[1].rx_nbits = m25p80_rx_nbits(nor); |
Michal Suchanek | 9519379 | 2016-05-05 17:31:56 -0700 | [diff] [blame] | 175 | t[1].len = min(len, spi_max_transfer_size(spi)); |
Vitaly Wool | 8275c64 | 2006-01-08 13:34:28 -0800 | [diff] [blame] | 176 | spi_message_add_tail(&t[1], &m); |
| 177 | |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 178 | ret = spi_sync(spi, &m); |
| 179 | if (ret) |
| 180 | return ret; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 181 | |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 182 | ret = m.actual_length - m25p_cmdsz(nor) - dummy; |
| 183 | if (ret < 0) |
| 184 | return -EIO; |
Michal Suchanek | 1992297b | 2016-05-05 17:31:48 -0700 | [diff] [blame] | 185 | return ret; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 186 | } |
| 187 | |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 188 | /* |
| 189 | * board specific setup should have ensured the SPI clock used here |
| 190 | * matches what the READ command supports, at least until this driver |
| 191 | * understands FAST_READ (for clocks over 25 MHz). |
| 192 | */ |
Bill Pemberton | 06f2551 | 2012-11-19 13:23:07 -0500 | [diff] [blame] | 193 | static int m25p_probe(struct spi_device *spi) |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 194 | { |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 195 | struct flash_platform_data *data; |
| 196 | struct m25p *flash; |
| 197 | struct spi_nor *nor; |
| 198 | enum read_mode mode = SPI_NOR_NORMAL; |
Brian Norris | de57732 | 2015-11-16 14:34:50 -0800 | [diff] [blame] | 199 | char *flash_name; |
Sourav Poddar | 3487a639 | 2013-11-06 20:05:35 +0530 | [diff] [blame] | 200 | int ret; |
Shaohui Xie | 5f94913 | 2011-10-14 15:49:00 +0800 | [diff] [blame] | 201 | |
Rafał Miłecki | 32f1b7c | 2014-09-28 22:36:54 +0200 | [diff] [blame] | 202 | data = dev_get_platdata(&spi->dev); |
| 203 | |
Brian Norris | 778d226 | 2013-07-24 18:32:07 -0700 | [diff] [blame] | 204 | flash = devm_kzalloc(&spi->dev, sizeof(*flash), GFP_KERNEL); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 205 | if (!flash) |
| 206 | return -ENOMEM; |
Brian Norris | 778d226 | 2013-07-24 18:32:07 -0700 | [diff] [blame] | 207 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 208 | nor = &flash->spi_nor; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 209 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 210 | /* install the hooks */ |
| 211 | nor->read = m25p80_read; |
| 212 | nor->write = m25p80_write; |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 213 | nor->write_reg = m25p80_write_reg; |
| 214 | nor->read_reg = m25p80_read_reg; |
| 215 | |
| 216 | nor->dev = &spi->dev; |
Brian Norris | 9c7d787 | 2015-10-30 20:33:24 -0700 | [diff] [blame] | 217 | spi_nor_set_flash_node(nor, spi->dev.of_node); |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 218 | nor->priv = flash; |
| 219 | |
Jingoo Han | 975aefc | 2013-04-06 15:41:32 +0900 | [diff] [blame] | 220 | spi_set_drvdata(spi, flash); |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 221 | flash->spi = spi; |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 222 | |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 223 | if (spi->mode & SPI_RX_QUAD) |
| 224 | mode = SPI_NOR_QUAD; |
Geert Uytterhoeven | 8848e16 | 2014-04-22 14:45:31 +0200 | [diff] [blame] | 225 | else if (spi->mode & SPI_RX_DUAL) |
| 226 | mode = SPI_NOR_DUAL; |
Rafał Miłecki | 32f1b7c | 2014-09-28 22:36:54 +0200 | [diff] [blame] | 227 | |
| 228 | if (data && data->name) |
Brian Norris | 1976367 | 2015-08-13 15:46:05 -0700 | [diff] [blame] | 229 | nor->mtd.name = data->name; |
Rafał Miłecki | 32f1b7c | 2014-09-28 22:36:54 +0200 | [diff] [blame] | 230 | |
| 231 | /* For some (historical?) reason many platforms provide two different |
| 232 | * names in flash_platform_data: "name" and "type". Quite often name is |
| 233 | * set to "m25p80" and then "type" provides a real chip name. |
| 234 | * If that's the case, respect "type" and ignore a "name". |
| 235 | */ |
| 236 | if (data && data->type) |
Rafał Miłecki | 90e55b3 | 2014-09-29 11:47:53 +0200 | [diff] [blame] | 237 | flash_name = data->type; |
Brian Norris | de57732 | 2015-11-16 14:34:50 -0800 | [diff] [blame] | 238 | else if (!strcmp(spi->modalias, "spi-nor")) |
| 239 | flash_name = NULL; /* auto-detect */ |
Rafał Miłecki | 90e55b3 | 2014-09-29 11:47:53 +0200 | [diff] [blame] | 240 | else |
| 241 | flash_name = spi->modalias; |
Rafał Miłecki | 32f1b7c | 2014-09-28 22:36:54 +0200 | [diff] [blame] | 242 | |
Ben Hutchings | 70f3ce0 | 2014-09-29 11:47:54 +0200 | [diff] [blame] | 243 | ret = spi_nor_scan(nor, flash_name, mode); |
Brian Norris | 03e296f | 2014-03-20 05:00:12 -0700 | [diff] [blame] | 244 | if (ret) |
| 245 | return ret; |
Michael Hennerich | 7228982 | 2008-07-03 23:54:42 -0700 | [diff] [blame] | 246 | |
Brian Norris | df02c88 | 2015-10-30 20:33:26 -0700 | [diff] [blame] | 247 | return mtd_device_register(&nor->mtd, data ? data->parts : NULL, |
| 248 | data ? data->nr_parts : 0); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | |
Bill Pemberton | 810b7e0 | 2012-11-19 13:26:04 -0500 | [diff] [blame] | 252 | static int m25p_remove(struct spi_device *spi) |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 253 | { |
Jingoo Han | 975aefc | 2013-04-06 15:41:32 +0900 | [diff] [blame] | 254 | struct m25p *flash = spi_get_drvdata(spi); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 255 | |
| 256 | /* Clean up MTD stuff. */ |
Brian Norris | 1976367 | 2015-08-13 15:46:05 -0700 | [diff] [blame] | 257 | return mtd_device_unregister(&flash->spi_nor.mtd); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 258 | } |
| 259 | |
Ben Hutchings | a5b7616 | 2014-09-30 03:14:55 +0100 | [diff] [blame] | 260 | /* |
Brian Norris | 1103b85 | 2015-03-27 10:29:50 -0700 | [diff] [blame] | 261 | * Do NOT add to this array without reading the following: |
| 262 | * |
| 263 | * Historically, many flash devices are bound to this driver by their name. But |
| 264 | * since most of these flash are compatible to some extent, and their |
| 265 | * differences can often be differentiated by the JEDEC read-ID command, we |
| 266 | * encourage new users to add support to the spi-nor library, and simply bind |
Brian Norris | 8947e39 | 2015-05-14 10:32:53 -0700 | [diff] [blame] | 267 | * against a generic string here (e.g., "jedec,spi-nor"). |
Brian Norris | 1103b85 | 2015-03-27 10:29:50 -0700 | [diff] [blame] | 268 | * |
| 269 | * Many flash names are kept here in this list (as well as in spi-nor.c) to |
| 270 | * keep them available as module aliases for existing platforms. |
Ben Hutchings | a5b7616 | 2014-09-30 03:14:55 +0100 | [diff] [blame] | 271 | */ |
| 272 | static const struct spi_device_id m25p_ids[] = { |
Rafał Miłecki | 3094fe1 | 2015-04-07 10:39:41 +0200 | [diff] [blame] | 273 | /* |
Brian Norris | de57732 | 2015-11-16 14:34:50 -0800 | [diff] [blame] | 274 | * Allow non-DT platform devices to bind to the "spi-nor" modalias, and |
| 275 | * hack around the fact that the SPI core does not provide uevent |
| 276 | * matching for .of_match_table |
| 277 | */ |
| 278 | {"spi-nor"}, |
| 279 | |
| 280 | /* |
Rafał Miłecki | 3094fe1 | 2015-04-07 10:39:41 +0200 | [diff] [blame] | 281 | * Entries not used in DTs that should be safe to drop after replacing |
Brian Norris | c1711b2 | 2015-11-16 14:34:51 -0800 | [diff] [blame] | 282 | * them with "spi-nor" in platform data. |
Rafał Miłecki | 3094fe1 | 2015-04-07 10:39:41 +0200 | [diff] [blame] | 283 | */ |
| 284 | {"s25sl064a"}, {"w25x16"}, {"m25p10"}, {"m25px64"}, |
| 285 | |
| 286 | /* |
Brian Norris | c1711b2 | 2015-11-16 14:34:51 -0800 | [diff] [blame] | 287 | * Entries that were used in DTs without "jedec,spi-nor" fallback and |
| 288 | * should be kept for backward compatibility. |
Rafał Miłecki | 3094fe1 | 2015-04-07 10:39:41 +0200 | [diff] [blame] | 289 | */ |
| 290 | {"at25df321a"}, {"at25df641"}, {"at26df081a"}, |
| 291 | {"mr25h256"}, |
| 292 | {"mx25l4005a"}, {"mx25l1606e"}, {"mx25l6405d"}, {"mx25l12805d"}, |
| 293 | {"mx25l25635e"},{"mx66l51235l"}, |
| 294 | {"n25q064"}, {"n25q128a11"}, {"n25q128a13"}, {"n25q512a"}, |
| 295 | {"s25fl256s1"}, {"s25fl512s"}, {"s25sl12801"}, {"s25fl008k"}, |
| 296 | {"s25fl064k"}, |
| 297 | {"sst25vf040b"},{"sst25vf016b"},{"sst25vf032b"},{"sst25wf040"}, |
| 298 | {"m25p40"}, {"m25p80"}, {"m25p16"}, {"m25p32"}, |
| 299 | {"m25p64"}, {"m25p128"}, |
| 300 | {"w25x80"}, {"w25x32"}, {"w25q32"}, {"w25q32dw"}, |
| 301 | {"w25q80bl"}, {"w25q128"}, {"w25q256"}, |
| 302 | |
| 303 | /* Flashes that can't be detected using JEDEC */ |
Ben Hutchings | a5b7616 | 2014-09-30 03:14:55 +0100 | [diff] [blame] | 304 | {"m25p05-nonjedec"}, {"m25p10-nonjedec"}, {"m25p20-nonjedec"}, |
| 305 | {"m25p40-nonjedec"}, {"m25p80-nonjedec"}, {"m25p16-nonjedec"}, |
| 306 | {"m25p32-nonjedec"}, {"m25p64-nonjedec"}, {"m25p128-nonjedec"}, |
Brian Norris | 1103b85 | 2015-03-27 10:29:50 -0700 | [diff] [blame] | 307 | |
Ben Hutchings | a5b7616 | 2014-09-30 03:14:55 +0100 | [diff] [blame] | 308 | { }, |
| 309 | }; |
| 310 | MODULE_DEVICE_TABLE(spi, m25p_ids); |
| 311 | |
Brian Norris | 4316302 | 2015-05-19 14:38:22 -0700 | [diff] [blame] | 312 | static const struct of_device_id m25p_of_table[] = { |
| 313 | /* |
| 314 | * Generic compatibility for SPI NOR that can be identified by the |
| 315 | * JEDEC READ ID opcode (0x9F). Use this, if possible. |
| 316 | */ |
| 317 | { .compatible = "jedec,spi-nor" }, |
| 318 | {} |
| 319 | }; |
| 320 | MODULE_DEVICE_TABLE(of, m25p_of_table); |
| 321 | |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 322 | static struct spi_driver m25p80_driver = { |
| 323 | .driver = { |
| 324 | .name = "m25p80", |
Brian Norris | 4316302 | 2015-05-19 14:38:22 -0700 | [diff] [blame] | 325 | .of_match_table = m25p_of_table, |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 326 | }, |
Ben Hutchings | a5b7616 | 2014-09-30 03:14:55 +0100 | [diff] [blame] | 327 | .id_table = m25p_ids, |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 328 | .probe = m25p_probe, |
Bill Pemberton | 5153b88 | 2012-11-19 13:21:24 -0500 | [diff] [blame] | 329 | .remove = m25p_remove, |
David Brownell | fa0a8c7 | 2007-06-24 15:12:35 -0700 | [diff] [blame] | 330 | |
| 331 | /* REVISIT: many of these chips have deep power-down modes, which |
| 332 | * should clearly be entered on suspend() to minimize power use. |
| 333 | * And also when they're otherwise idle... |
| 334 | */ |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 335 | }; |
| 336 | |
Axel Lin | c9d1b75 | 2012-01-27 15:45:20 +0800 | [diff] [blame] | 337 | module_spi_driver(m25p80_driver); |
Mike Lavender | 2f9f762 | 2006-01-08 13:34:27 -0800 | [diff] [blame] | 338 | |
| 339 | MODULE_LICENSE("GPL"); |
| 340 | MODULE_AUTHOR("Mike Lavender"); |
| 341 | MODULE_DESCRIPTION("MTD SPI driver for ST M25Pxx flash chips"); |