Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/staging/goldfish/goldfish_nand.c

  1 /*
  2  * drivers/mtd/devices/goldfish_nand.c
  3  *
  4  * Copyright (C) 2007 Google, Inc.
  5  * Copyright (C) 2012 Intel, Inc.
  6  * Copyright (C) 2013 Intel, Inc.
  7  *
  8  * This software is licensed under the terms of the GNU General Public
  9  * License version 2, as published by the Free Software Foundation, and
 10  * may be copied, distributed, and modified under those terms.
 11  *
 12  * This program is distributed in the hope that it will be useful,
 13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15  * GNU General Public License for more details.
 16  *
 17  */
 18 
 19 #include <linux/io.h>
 20 #include <linux/device.h>
 21 #include <linux/module.h>
 22 #include <linux/slab.h>
 23 #include <linux/ioport.h>
 24 #include <linux/vmalloc.h>
 25 #include <linux/mtd/mtd.h>
 26 #include <linux/platform_device.h>
 27 #include <linux/mutex.h>
 28 #include <linux/goldfish.h>
 29 #include <asm/div64.h>
 30 
 31 #include "goldfish_nand_reg.h"
 32 
 33 struct goldfish_nand {
 34         /* lock protects access to the device registers */
 35         struct mutex            lock;
 36         unsigned char __iomem  *base;
 37         struct cmd_params       *cmd_params;
 38         size_t                  mtd_count;
 39         struct mtd_info         mtd[0];
 40 };
 41 
 42 static u32 goldfish_nand_cmd_with_params(struct mtd_info *mtd,
 43                                          enum nand_cmd cmd, u64 addr, u32 len,
 44                                          void *ptr, u32 *rv)
 45 {
 46         u32 cmdp;
 47         struct goldfish_nand *nand = mtd->priv;
 48         struct cmd_params *cps = nand->cmd_params;
 49         unsigned char __iomem  *base = nand->base;
 50 
 51         if (cps == NULL)
 52                 return -1;
 53 
 54         switch (cmd) {
 55         case NAND_CMD_ERASE:
 56                 cmdp = NAND_CMD_ERASE_WITH_PARAMS;
 57                 break;
 58         case NAND_CMD_READ:
 59                 cmdp = NAND_CMD_READ_WITH_PARAMS;
 60                 break;
 61         case NAND_CMD_WRITE:
 62                 cmdp = NAND_CMD_WRITE_WITH_PARAMS;
 63                 break;
 64         default:
 65                 return -1;
 66         }
 67         cps->dev = mtd - nand->mtd;
 68         cps->addr_high = (u32)(addr >> 32);
 69         cps->addr_low = (u32)addr;
 70         cps->transfer_size = len;
 71         cps->data = (unsigned long)ptr;
 72         writel(cmdp, base + NAND_COMMAND);
 73         *rv = cps->result;
 74         return 0;
 75 }
 76 
 77 static u32 goldfish_nand_cmd(struct mtd_info *mtd, enum nand_cmd cmd,
 78                              u64 addr, u32 len, void *ptr)
 79 {
 80         struct goldfish_nand *nand = mtd->priv;
 81         u32 rv;
 82         unsigned char __iomem  *base = nand->base;
 83 
 84         mutex_lock(&nand->lock);
 85         if (goldfish_nand_cmd_with_params(mtd, cmd, addr, len, ptr, &rv)) {
 86                 writel(mtd - nand->mtd, base + NAND_DEV);
 87                 writel((u32)(addr >> 32), base + NAND_ADDR_HIGH);
 88                 writel((u32)addr, base + NAND_ADDR_LOW);
 89                 writel(len, base + NAND_TRANSFER_SIZE);
 90                 gf_write64((u64)ptr, base + NAND_DATA, base + NAND_DATA_HIGH);
 91                 writel(cmd, base + NAND_COMMAND);
 92                 rv = readl(base + NAND_RESULT);
 93         }
 94         mutex_unlock(&nand->lock);
 95         return rv;
 96 }
 97 
 98 static int goldfish_nand_erase(struct mtd_info *mtd, struct erase_info *instr)
 99 {
100         loff_t ofs = instr->addr;
101         u32 len = instr->len;
102         u32 rem;
103 
104         if (ofs + len > mtd->size)
105                 goto invalid_arg;
106         rem = do_div(ofs, mtd->writesize);
107         if (rem)
108                 goto invalid_arg;
109         ofs *= (mtd->writesize + mtd->oobsize);
110 
111         if (len % mtd->writesize)
112                 goto invalid_arg;
113         len = len / mtd->writesize * (mtd->writesize + mtd->oobsize);
114 
115         if (goldfish_nand_cmd(mtd, NAND_CMD_ERASE, ofs, len, NULL) != len) {
116                 pr_err("goldfish_nand_erase: erase failed, start %llx, len %x, dev_size %llx, erase_size %x\n",
117                        ofs, len, mtd->size, mtd->erasesize);
118                 return -EIO;
119         }
120 
121         instr->state = MTD_ERASE_DONE;
122         mtd_erase_callback(instr);
123 
124         return 0;
125 
126 invalid_arg:
127         pr_err("goldfish_nand_erase: invalid erase, start %llx, len %x, dev_size %llx, erase_size %x\n",
128                ofs, len, mtd->size, mtd->erasesize);
129         return -EINVAL;
130 }
131 
132 static int goldfish_nand_read_oob(struct mtd_info *mtd, loff_t ofs,
133                                   struct mtd_oob_ops *ops)
134 {
135         u32 rem;
136 
137         if (ofs + ops->len > mtd->size)
138                 goto invalid_arg;
139         if (ops->datbuf && ops->len && ops->len != mtd->writesize)
140                 goto invalid_arg;
141         if (ops->ooblen + ops->ooboffs > mtd->oobsize)
142                 goto invalid_arg;
143 
144         rem = do_div(ofs, mtd->writesize);
145         if (rem)
146                 goto invalid_arg;
147         ofs *= (mtd->writesize + mtd->oobsize);
148 
149         if (ops->datbuf)
150                 ops->retlen = goldfish_nand_cmd(mtd, NAND_CMD_READ, ofs,
151                                                 ops->len, ops->datbuf);
152         ofs += mtd->writesize + ops->ooboffs;
153         if (ops->oobbuf)
154                 ops->oobretlen = goldfish_nand_cmd(mtd, NAND_CMD_READ, ofs,
155                                                 ops->ooblen, ops->oobbuf);
156         return 0;
157 
158 invalid_arg:
159         pr_err("goldfish_nand_read_oob: invalid read, start %llx, len %zx, ooblen %zx, dev_size %llx, write_size %x\n",
160                ofs, ops->len, ops->ooblen, mtd->size, mtd->writesize);
161         return -EINVAL;
162 }
163 
164 static int goldfish_nand_write_oob(struct mtd_info *mtd, loff_t ofs,
165                                    struct mtd_oob_ops *ops)
166 {
167         u32 rem;
168 
169         if (ofs + ops->len > mtd->size)
170                 goto invalid_arg;
171         if (ops->len && ops->len != mtd->writesize)
172                 goto invalid_arg;
173         if (ops->ooblen + ops->ooboffs > mtd->oobsize)
174                 goto invalid_arg;
175 
176         rem = do_div(ofs, mtd->writesize);
177         if (rem)
178                 goto invalid_arg;
179         ofs *= (mtd->writesize + mtd->oobsize);
180 
181         if (ops->datbuf)
182                 ops->retlen = goldfish_nand_cmd(mtd, NAND_CMD_WRITE, ofs,
183                                                 ops->len, ops->datbuf);
184         ofs += mtd->writesize + ops->ooboffs;
185         if (ops->oobbuf)
186                 ops->oobretlen = goldfish_nand_cmd(mtd, NAND_CMD_WRITE, ofs,
187                                                 ops->ooblen, ops->oobbuf);
188         return 0;
189 
190 invalid_arg:
191         pr_err("goldfish_nand_write_oob: invalid write, start %llx, len %zx, ooblen %zx, dev_size %llx, write_size %x\n",
192                ofs, ops->len, ops->ooblen, mtd->size, mtd->writesize);
193         return -EINVAL;
194 }
195 
196 static int goldfish_nand_read(struct mtd_info *mtd, loff_t from, size_t len,
197                               size_t *retlen, u_char *buf)
198 {
199         u32 rem;
200 
201         if (from + len > mtd->size)
202                 goto invalid_arg;
203 
204         rem = do_div(from, mtd->writesize);
205         if (rem)
206                 goto invalid_arg;
207         from *= (mtd->writesize + mtd->oobsize);
208 
209         *retlen = goldfish_nand_cmd(mtd, NAND_CMD_READ, from, len, buf);
210         return 0;
211 
212 invalid_arg:
213         pr_err("goldfish_nand_read: invalid read, start %llx, len %zx, dev_size %llx, write_size %x\n",
214                from, len, mtd->size, mtd->writesize);
215         return -EINVAL;
216 }
217 
218 static int goldfish_nand_write(struct mtd_info *mtd, loff_t to, size_t len,
219                                size_t *retlen, const u_char *buf)
220 {
221         u32 rem;
222 
223         if (to + len > mtd->size)
224                 goto invalid_arg;
225 
226         rem = do_div(to, mtd->writesize);
227         if (rem)
228                 goto invalid_arg;
229         to *= (mtd->writesize + mtd->oobsize);
230 
231         *retlen = goldfish_nand_cmd(mtd, NAND_CMD_WRITE, to, len, (void *)buf);
232         return 0;
233 
234 invalid_arg:
235         pr_err("goldfish_nand_write: invalid write, start %llx, len %zx, dev_size %llx, write_size %x\n",
236                to, len, mtd->size, mtd->writesize);
237         return -EINVAL;
238 }
239 
240 static int goldfish_nand_block_isbad(struct mtd_info *mtd, loff_t ofs)
241 {
242         u32 rem;
243 
244         if (ofs >= mtd->size)
245                 goto invalid_arg;
246 
247         rem = do_div(ofs, mtd->erasesize);
248         if (rem)
249                 goto invalid_arg;
250         ofs *= mtd->erasesize / mtd->writesize;
251         ofs *= (mtd->writesize + mtd->oobsize);
252 
253         return goldfish_nand_cmd(mtd, NAND_CMD_BLOCK_BAD_GET, ofs, 0, NULL);
254 
255 invalid_arg:
256         pr_err("goldfish_nand_block_isbad: invalid arg, ofs %llx, dev_size %llx, write_size %x\n",
257                ofs, mtd->size, mtd->writesize);
258         return -EINVAL;
259 }
260 
261 static int goldfish_nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
262 {
263         u32 rem;
264 
265         if (ofs >= mtd->size)
266                 goto invalid_arg;
267 
268         rem = do_div(ofs, mtd->erasesize);
269         if (rem)
270                 goto invalid_arg;
271         ofs *= mtd->erasesize / mtd->writesize;
272         ofs *= (mtd->writesize + mtd->oobsize);
273 
274         if (goldfish_nand_cmd(mtd, NAND_CMD_BLOCK_BAD_SET, ofs, 0, NULL) != 1)
275                 return -EIO;
276         return 0;
277 
278 invalid_arg:
279         pr_err("goldfish_nand_block_markbad: invalid arg, ofs %llx, dev_size %llx, write_size %x\n",
280                ofs, mtd->size, mtd->writesize);
281         return -EINVAL;
282 }
283 
284 static int nand_setup_cmd_params(struct platform_device *pdev,
285                                  struct goldfish_nand *nand)
286 {
287         u64 paddr;
288         unsigned char __iomem  *base = nand->base;
289 
290         nand->cmd_params = devm_kzalloc(&pdev->dev,
291                                         sizeof(struct cmd_params), GFP_KERNEL);
292         if (!nand->cmd_params)
293                 return -1;
294 
295         paddr = __pa(nand->cmd_params);
296         writel((u32)(paddr >> 32), base + NAND_CMD_PARAMS_ADDR_HIGH);
297         writel((u32)paddr, base + NAND_CMD_PARAMS_ADDR_LOW);
298         return 0;
299 }
300 
301 static int goldfish_nand_init_device(struct platform_device *pdev,
302                                      struct goldfish_nand *nand, int id)
303 {
304         u32 name_len;
305         u32 result;
306         u32 flags;
307         unsigned char __iomem  *base = nand->base;
308         struct mtd_info *mtd = &nand->mtd[id];
309         char *name;
310 
311         mutex_lock(&nand->lock);
312         writel(id, base + NAND_DEV);
313         flags = readl(base + NAND_DEV_FLAGS);
314         name_len = readl(base + NAND_DEV_NAME_LEN);
315         mtd->writesize = readl(base + NAND_DEV_PAGE_SIZE);
316         mtd->size = readl(base + NAND_DEV_SIZE_LOW);
317         mtd->size |= (u64)readl(base + NAND_DEV_SIZE_HIGH) << 32;
318         mtd->oobsize = readl(base + NAND_DEV_EXTRA_SIZE);
319         mtd->oobavail = mtd->oobsize;
320         mtd->erasesize = readl(base + NAND_DEV_ERASE_SIZE) /
321                         (mtd->writesize + mtd->oobsize) * mtd->writesize;
322         do_div(mtd->size, mtd->writesize + mtd->oobsize);
323         mtd->size *= mtd->writesize;
324         dev_dbg(&pdev->dev,
325                 "goldfish nand dev%d: size %llx, page %d, extra %d, erase %d\n",
326                        id, mtd->size, mtd->writesize,
327                        mtd->oobsize, mtd->erasesize);
328         mutex_unlock(&nand->lock);
329 
330         mtd->priv = nand;
331 
332         name = devm_kzalloc(&pdev->dev, name_len + 1, GFP_KERNEL);
333         if (name == NULL)
334                 return -ENOMEM;
335         mtd->name = name;
336 
337         result = goldfish_nand_cmd(mtd, NAND_CMD_GET_DEV_NAME, 0, name_len,
338                                    name);
339         if (result != name_len) {
340                 dev_err(&pdev->dev,
341                         "goldfish_nand_init_device failed to get dev name %d != %d\n",
342                                result, name_len);
343                 return -ENODEV;
344         }
345         ((char *)mtd->name)[name_len] = '\0';
346 
347         /* Setup the MTD structure */
348         mtd->type = MTD_NANDFLASH;
349         mtd->flags = MTD_CAP_NANDFLASH;
350         if (flags & NAND_DEV_FLAG_READ_ONLY)
351                 mtd->flags &= ~MTD_WRITEABLE;
352         if (flags & NAND_DEV_FLAG_CMD_PARAMS_CAP)
353                 nand_setup_cmd_params(pdev, nand);
354 
355         mtd->owner = THIS_MODULE;
356         mtd->_erase = goldfish_nand_erase;
357         mtd->_read = goldfish_nand_read;
358         mtd->_write = goldfish_nand_write;
359         mtd->_read_oob = goldfish_nand_read_oob;
360         mtd->_write_oob = goldfish_nand_write_oob;
361         mtd->_block_isbad = goldfish_nand_block_isbad;
362         mtd->_block_markbad = goldfish_nand_block_markbad;
363 
364         if (mtd_device_register(mtd, NULL, 0))
365                 return -EIO;
366 
367         return 0;
368 }
369 
370 static int goldfish_nand_probe(struct platform_device *pdev)
371 {
372         u32 num_dev;
373         int i;
374         int err;
375         u32 num_dev_working;
376         u32 version;
377         struct resource *r;
378         struct goldfish_nand *nand;
379         unsigned char __iomem  *base;
380 
381         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
382         if (r == NULL)
383                 return -ENODEV;
384 
385         base = devm_ioremap(&pdev->dev, r->start, PAGE_SIZE);
386         if (base == NULL)
387                 return -ENOMEM;
388 
389         version = readl(base + NAND_VERSION);
390         if (version != NAND_VERSION_CURRENT) {
391                 dev_err(&pdev->dev,
392                         "goldfish_nand_init: version mismatch, got %d, expected %d\n",
393                                 version, NAND_VERSION_CURRENT);
394                 return -ENODEV;
395         }
396         num_dev = readl(base + NAND_NUM_DEV);
397         if (num_dev == 0)
398                 return -ENODEV;
399 
400         nand = devm_kzalloc(&pdev->dev, sizeof(*nand) +
401                                 sizeof(struct mtd_info) * num_dev, GFP_KERNEL);
402         if (nand == NULL)
403                 return -ENOMEM;
404 
405         mutex_init(&nand->lock);
406         nand->base = base;
407         nand->mtd_count = num_dev;
408         platform_set_drvdata(pdev, nand);
409 
410         num_dev_working = 0;
411         for (i = 0; i < num_dev; i++) {
412                 err = goldfish_nand_init_device(pdev, nand, i);
413                 if (err == 0)
414                         num_dev_working++;
415         }
416         if (num_dev_working == 0)
417                 return -ENODEV;
418         return 0;
419 }
420 
421 static int goldfish_nand_remove(struct platform_device *pdev)
422 {
423         struct goldfish_nand *nand = platform_get_drvdata(pdev);
424         int i;
425 
426         for (i = 0; i < nand->mtd_count; i++) {
427                 if (nand->mtd[i].name)
428                         mtd_device_unregister(&nand->mtd[i]);
429         }
430         return 0;
431 }
432 
433 static struct platform_driver goldfish_nand_driver = {
434         .probe          = goldfish_nand_probe,
435         .remove         = goldfish_nand_remove,
436         .driver = {
437                 .name = "goldfish_nand"
438         }
439 };
440 
441 module_platform_driver(goldfish_nand_driver);
442 MODULE_LICENSE("GPL");
443 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us