Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc
[linux-2.6] / drivers / net / sfc / mtd.c
1 /****************************************************************************
2  * Driver for Solarflare Solarstorm network controllers and boards
3  * Copyright 2005-2006 Fen Systems Ltd.
4  * Copyright 2006-2008 Solarflare Communications Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published
8  * by the Free Software Foundation, incorporated herein by reference.
9  */
10
11 #include <linux/module.h>
12 #include <linux/mtd/mtd.h>
13 #include <linux/delay.h>
14
15 #define EFX_DRIVER_NAME "sfc_mtd"
16 #include "net_driver.h"
17 #include "spi.h"
18 #include "efx.h"
19
20 #define EFX_SPI_VERIFY_BUF_LEN 16
21
22 struct efx_mtd {
23         const struct efx_spi_device *spi;
24         struct mtd_info mtd;
25         char name[IFNAMSIZ + 20];
26 };
27
28 /* SPI utilities */
29
30 static int efx_spi_slow_wait(struct efx_mtd *efx_mtd, bool uninterruptible)
31 {
32         const struct efx_spi_device *spi = efx_mtd->spi;
33         struct efx_nic *efx = spi->efx;
34         u8 status;
35         int rc, i;
36
37         /* Wait up to 4s for flash/EEPROM to finish a slow operation. */
38         for (i = 0; i < 40; i++) {
39                 __set_current_state(uninterruptible ?
40                                     TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
41                 schedule_timeout(HZ / 10);
42                 rc = falcon_spi_cmd(spi, SPI_RDSR, -1, NULL,
43                                     &status, sizeof(status));
44                 if (rc)
45                         return rc;
46                 if (!(status & SPI_STATUS_NRDY))
47                         return 0;
48                 if (signal_pending(current))
49                         return -EINTR;
50         }
51         EFX_ERR(efx, "timed out waiting for %s\n", efx_mtd->name);
52         return -ETIMEDOUT;
53 }
54
55 static int efx_spi_unlock(const struct efx_spi_device *spi)
56 {
57         const u8 unlock_mask = (SPI_STATUS_BP2 | SPI_STATUS_BP1 |
58                                 SPI_STATUS_BP0);
59         u8 status;
60         int rc;
61
62         rc = falcon_spi_cmd(spi, SPI_RDSR, -1, NULL, &status, sizeof(status));
63         if (rc)
64                 return rc;
65
66         if (!(status & unlock_mask))
67                 return 0; /* already unlocked */
68
69         rc = falcon_spi_cmd(spi, SPI_WREN, -1, NULL, NULL, 0);
70         if (rc)
71                 return rc;
72         rc = falcon_spi_cmd(spi, SPI_SST_EWSR, -1, NULL, NULL, 0);
73         if (rc)
74                 return rc;
75
76         status &= ~unlock_mask;
77         rc = falcon_spi_cmd(spi, SPI_WRSR, -1, &status, NULL, sizeof(status));
78         if (rc)
79                 return rc;
80         rc = falcon_spi_wait_write(spi);
81         if (rc)
82                 return rc;
83
84         return 0;
85 }
86
87 static int efx_spi_erase(struct efx_mtd *efx_mtd, loff_t start, size_t len)
88 {
89         const struct efx_spi_device *spi = efx_mtd->spi;
90         unsigned pos, block_len;
91         u8 empty[EFX_SPI_VERIFY_BUF_LEN];
92         u8 buffer[EFX_SPI_VERIFY_BUF_LEN];
93         int rc;
94
95         if (len != spi->erase_size)
96                 return -EINVAL;
97
98         if (spi->erase_command == 0)
99                 return -EOPNOTSUPP;
100
101         rc = efx_spi_unlock(spi);
102         if (rc)
103                 return rc;
104         rc = falcon_spi_cmd(spi, SPI_WREN, -1, NULL, NULL, 0);
105         if (rc)
106                 return rc;
107         rc = falcon_spi_cmd(spi, spi->erase_command, start, NULL, NULL, 0);
108         if (rc)
109                 return rc;
110         rc = efx_spi_slow_wait(efx_mtd, false);
111
112         /* Verify the entire region has been wiped */
113         memset(empty, 0xff, sizeof(empty));
114         for (pos = 0; pos < len; pos += block_len) {
115                 block_len = min(len - pos, sizeof(buffer));
116                 rc = falcon_spi_read(spi, start + pos, block_len, NULL, buffer);
117                 if (rc)
118                         return rc;
119                 if (memcmp(empty, buffer, block_len))
120                         return -EIO;
121
122                 /* Avoid locking up the system */
123                 cond_resched();
124                 if (signal_pending(current))
125                         return -EINTR;
126         }
127
128         return rc;
129 }
130
131 /* MTD interface */
132
133 static int efx_mtd_read(struct mtd_info *mtd, loff_t start, size_t len,
134                         size_t *retlen, u8 *buffer)
135 {
136         struct efx_mtd *efx_mtd = mtd->priv;
137         const struct efx_spi_device *spi = efx_mtd->spi;
138         struct efx_nic *efx = spi->efx;
139         int rc;
140
141         rc = mutex_lock_interruptible(&efx->spi_lock);
142         if (rc)
143                 return rc;
144         rc = falcon_spi_read(spi, FALCON_FLASH_BOOTCODE_START + start,
145                              len, retlen, buffer);
146         mutex_unlock(&efx->spi_lock);
147         return rc;
148 }
149
150 static int efx_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
151 {
152         struct efx_mtd *efx_mtd = mtd->priv;
153         struct efx_nic *efx = efx_mtd->spi->efx;
154         int rc;
155
156         rc = mutex_lock_interruptible(&efx->spi_lock);
157         if (rc)
158                 return rc;
159         rc = efx_spi_erase(efx_mtd, FALCON_FLASH_BOOTCODE_START + erase->addr,
160                            erase->len);
161         mutex_unlock(&efx->spi_lock);
162
163         if (rc == 0) {
164                 erase->state = MTD_ERASE_DONE;
165         } else {
166                 erase->state = MTD_ERASE_FAILED;
167                 erase->fail_addr = 0xffffffff;
168         }
169         mtd_erase_callback(erase);
170         return rc;
171 }
172
173 static int efx_mtd_write(struct mtd_info *mtd, loff_t start,
174                          size_t len, size_t *retlen, const u8 *buffer)
175 {
176         struct efx_mtd *efx_mtd = mtd->priv;
177         const struct efx_spi_device *spi = efx_mtd->spi;
178         struct efx_nic *efx = spi->efx;
179         int rc;
180
181         rc = mutex_lock_interruptible(&efx->spi_lock);
182         if (rc)
183                 return rc;
184         rc = falcon_spi_write(spi, FALCON_FLASH_BOOTCODE_START + start,
185                               len, retlen, buffer);
186         mutex_unlock(&efx->spi_lock);
187         return rc;
188 }
189
190 static void efx_mtd_sync(struct mtd_info *mtd)
191 {
192         struct efx_mtd *efx_mtd = mtd->priv;
193         struct efx_nic *efx = efx_mtd->spi->efx;
194         int rc;
195
196         mutex_lock(&efx->spi_lock);
197         rc = efx_spi_slow_wait(efx_mtd, true);
198         mutex_unlock(&efx->spi_lock);
199
200         if (rc)
201                 EFX_ERR(efx, "%s sync failed (%d)\n", efx_mtd->name, rc);
202         return;
203 }
204
205 void efx_mtd_remove(struct efx_nic *efx)
206 {
207         if (efx->spi_flash && efx->spi_flash->mtd) {
208                 struct efx_mtd *efx_mtd = efx->spi_flash->mtd;
209                 int rc;
210
211                 for (;;) {
212                         rc = del_mtd_device(&efx_mtd->mtd);
213                         if (rc != -EBUSY)
214                                 break;
215                         ssleep(1);
216                 }
217                 WARN_ON(rc);
218                 kfree(efx_mtd);
219         }
220 }
221
222 void efx_mtd_rename(struct efx_nic *efx)
223 {
224         if (efx->spi_flash && efx->spi_flash->mtd) {
225                 struct efx_mtd *efx_mtd = efx->spi_flash->mtd;
226                 snprintf(efx_mtd->name, sizeof(efx_mtd->name),
227                          "%s sfc_flash_bootrom", efx->name);
228         }
229 }
230
231 int efx_mtd_probe(struct efx_nic *efx)
232 {
233         struct efx_spi_device *spi = efx->spi_flash;
234         struct efx_mtd *efx_mtd;
235
236         if (!spi || spi->size <= FALCON_FLASH_BOOTCODE_START)
237                 return -ENODEV;
238
239         efx_mtd = kzalloc(sizeof(*efx_mtd), GFP_KERNEL);
240         if (!efx_mtd)
241                 return -ENOMEM;
242
243         efx_mtd->spi = spi;
244         spi->mtd = efx_mtd;
245
246         efx_mtd->mtd.type = MTD_NORFLASH;
247         efx_mtd->mtd.flags = MTD_CAP_NORFLASH;
248         efx_mtd->mtd.size = spi->size - FALCON_FLASH_BOOTCODE_START;
249         efx_mtd->mtd.erasesize = spi->erase_size;
250         efx_mtd->mtd.writesize = 1;
251         efx_mtd_rename(efx);
252
253         efx_mtd->mtd.owner = THIS_MODULE;
254         efx_mtd->mtd.priv = efx_mtd;
255         efx_mtd->mtd.name = efx_mtd->name;
256         efx_mtd->mtd.erase = efx_mtd_erase;
257         efx_mtd->mtd.read = efx_mtd_read;
258         efx_mtd->mtd.write = efx_mtd_write;
259         efx_mtd->mtd.sync = efx_mtd_sync;
260
261         if (add_mtd_device(&efx_mtd->mtd)) {
262                 kfree(efx_mtd);
263                 spi->mtd = NULL;
264                 /* add_mtd_device() returns 1 if the MTD table is full */
265                 return -ENOMEM;
266         }
267
268         return 0;
269 }