Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
alauda.c
Go to the documentation of this file.
1 /*
2  * MTD driver for Alauda chips
3  *
4  * Copyright (C) 2007 Joern Engel <[email protected]>
5  *
6  * Based on drivers/usb/usb-skeleton.c which is:
7  * Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])
8  * and on drivers/usb/storage/alauda.c, which is:
9  * (c) 2005 Daniel Drake <[email protected]>
10  *
11  * Idea and initial work by Arnd Bergmann <[email protected]>
12  */
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/kref.h>
19 #include <linux/usb.h>
20 #include <linux/mutex.h>
21 #include <linux/mtd/mtd.h>
22 #include <linux/mtd/nand_ecc.h>
23 
24 /* Control commands */
25 #define ALAUDA_GET_XD_MEDIA_STATUS 0x08
26 #define ALAUDA_ACK_XD_MEDIA_CHANGE 0x0a
27 #define ALAUDA_GET_XD_MEDIA_SIG 0x86
28 
29 /* Common prefix */
30 #define ALAUDA_BULK_CMD 0x40
31 
32 /* The two ports */
33 #define ALAUDA_PORT_XD 0x00
34 #define ALAUDA_PORT_SM 0x01
35 
36 /* Bulk commands */
37 #define ALAUDA_BULK_READ_PAGE 0x84
38 #define ALAUDA_BULK_READ_OOB 0x85 /* don't use, there's a chip bug */
39 #define ALAUDA_BULK_READ_BLOCK 0x94
40 #define ALAUDA_BULK_ERASE_BLOCK 0xa3
41 #define ALAUDA_BULK_WRITE_PAGE 0xa4
42 #define ALAUDA_BULK_WRITE_BLOCK 0xb4
43 #define ALAUDA_BULK_RESET_MEDIA 0xe0
44 
45 /* Address shifting */
46 #define PBA_LO(pba) ((pba & 0xF) << 5)
47 #define PBA_HI(pba) (pba >> 3)
48 #define PBA_ZONE(pba) (pba >> 11)
49 
50 #define TIMEOUT HZ
51 
52 static const struct usb_device_id alauda_table[] = {
53  { USB_DEVICE(0x0584, 0x0008) }, /* Fujifilm DPC-R1 */
54  { USB_DEVICE(0x07b4, 0x010a) }, /* Olympus MAUSB-10 */
55  { }
56 };
57 MODULE_DEVICE_TABLE(usb, alauda_table);
58 
59 struct alauda_card {
60  u8 id; /* id byte */
61  u8 chipshift; /* 1<<chipshift total size */
62  u8 pageshift; /* 1<<pageshift page size */
63  u8 blockshift; /* 1<<blockshift block size */
64 };
65 
66 struct alauda {
67  struct usb_device *dev;
69  struct mtd_info *mtd;
70  struct alauda_card *card;
71  struct mutex card_mutex;
75  unsigned int write_out;
76  unsigned int bulk_in;
77  unsigned int bulk_out;
79  struct kref kref;
80 };
81 
82 static struct alauda_card alauda_card_ids[] = {
83  /* NAND flash */
84  { 0x6e, 20, 8, 12}, /* 1 MB */
85  { 0xe8, 20, 8, 12}, /* 1 MB */
86  { 0xec, 20, 8, 12}, /* 1 MB */
87  { 0x64, 21, 8, 12}, /* 2 MB */
88  { 0xea, 21, 8, 12}, /* 2 MB */
89  { 0x6b, 22, 9, 13}, /* 4 MB */
90  { 0xe3, 22, 9, 13}, /* 4 MB */
91  { 0xe5, 22, 9, 13}, /* 4 MB */
92  { 0xe6, 23, 9, 13}, /* 8 MB */
93  { 0x73, 24, 9, 14}, /* 16 MB */
94  { 0x75, 25, 9, 14}, /* 32 MB */
95  { 0x76, 26, 9, 14}, /* 64 MB */
96  { 0x79, 27, 9, 14}, /* 128 MB */
97  { 0x71, 28, 9, 14}, /* 256 MB */
98 
99  /* MASK ROM */
100  { 0x5d, 21, 9, 13}, /* 2 MB */
101  { 0xd5, 22, 9, 13}, /* 4 MB */
102  { 0xd6, 23, 9, 13}, /* 8 MB */
103  { 0x57, 24, 9, 13}, /* 16 MB */
104  { 0x58, 25, 9, 13}, /* 32 MB */
105  { }
106 };
107 
108 static struct alauda_card *get_card(u8 id)
109 {
110  struct alauda_card *card;
111 
112  for (card = alauda_card_ids; card->id; card++)
113  if (card->id == id)
114  return card;
115  return NULL;
116 }
117 
118 static void alauda_delete(struct kref *kref)
119 {
120  struct alauda *al = container_of(kref, struct alauda, kref);
121 
122  if (al->mtd) {
124  kfree(al->mtd);
125  }
126  usb_put_dev(al->dev);
127  kfree(al);
128 }
129 
130 static int alauda_get_media_status(struct alauda *al, void *buf)
131 {
132  int ret;
133 
134  mutex_lock(&al->card_mutex);
135  ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
136  ALAUDA_GET_XD_MEDIA_STATUS, 0xc0, 0, 1, buf, 2, HZ);
137  mutex_unlock(&al->card_mutex);
138  return ret;
139 }
140 
141 static int alauda_ack_media(struct alauda *al)
142 {
143  int ret;
144 
145  mutex_lock(&al->card_mutex);
146  ret = usb_control_msg(al->dev, usb_sndctrlpipe(al->dev, 0),
147  ALAUDA_ACK_XD_MEDIA_CHANGE, 0x40, 0, 1, NULL, 0, HZ);
148  mutex_unlock(&al->card_mutex);
149  return ret;
150 }
151 
152 static int alauda_get_media_signatures(struct alauda *al, void *buf)
153 {
154  int ret;
155 
156  mutex_lock(&al->card_mutex);
157  ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
158  ALAUDA_GET_XD_MEDIA_SIG, 0xc0, 0, 0, buf, 4, HZ);
159  mutex_unlock(&al->card_mutex);
160  return ret;
161 }
162 
163 static void alauda_reset(struct alauda *al)
164 {
165  u8 command[] = {
167  0, 0, 0, 0, al->port
168  };
169  mutex_lock(&al->card_mutex);
170  usb_bulk_msg(al->dev, al->bulk_out, command, 9, NULL, HZ);
171  mutex_unlock(&al->card_mutex);
172 }
173 
174 static void correct_data(void *buf, void *read_ecc,
175  int *corrected, int *uncorrected)
176 {
177  u8 calc_ecc[3];
178  int err;
179 
180  nand_calculate_ecc(NULL, buf, calc_ecc);
181  err = nand_correct_data(NULL, buf, read_ecc, calc_ecc);
182  if (err) {
183  if (err > 0)
184  (*corrected)++;
185  else
186  (*uncorrected)++;
187  }
188 }
189 
191  struct urb *urb[3];
192  struct completion comp;
193 };
194 
195 static void alauda_complete(struct urb *urb)
196 {
197  struct completion *comp = urb->context;
198 
199  if (comp)
200  complete(comp);
201 }
202 
203 static int __alauda_read_page(struct mtd_info *mtd, loff_t from, void *buf,
204  void *oob)
205 {
206  struct alauda_sg_request sg;
207  struct alauda *al = mtd->priv;
208  u32 pba = from >> al->card->blockshift;
209  u32 page = (from >> al->card->pageshift) & al->pagemask;
210  u8 command[] = {
212  PBA_ZONE(pba), 0, PBA_LO(pba) + page, 1, 0, al->port
213  };
214  int i, err;
215 
216  for (i=0; i<3; i++)
217  sg.urb[i] = NULL;
218 
219  err = -ENOMEM;
220  for (i=0; i<3; i++) {
221  sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
222  if (!sg.urb[i])
223  goto out;
224  }
225  init_completion(&sg.comp);
226  usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
227  alauda_complete, NULL);
228  usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, mtd->writesize,
229  alauda_complete, NULL);
230  usb_fill_bulk_urb(sg.urb[2], al->dev, al->bulk_in, oob, 16,
231  alauda_complete, &sg.comp);
232 
233  mutex_lock(&al->card_mutex);
234  for (i=0; i<3; i++) {
235  err = usb_submit_urb(sg.urb[i], GFP_NOIO);
236  if (err)
237  goto cancel;
238  }
239  if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
240  err = -ETIMEDOUT;
241 cancel:
242  for (i=0; i<3; i++) {
243  usb_kill_urb(sg.urb[i]);
244  }
245  }
246  mutex_unlock(&al->card_mutex);
247 
248 out:
249  usb_free_urb(sg.urb[0]);
250  usb_free_urb(sg.urb[1]);
251  usb_free_urb(sg.urb[2]);
252  return err;
253 }
254 
255 static int alauda_read_page(struct mtd_info *mtd, loff_t from,
256  void *buf, u8 *oob, int *corrected, int *uncorrected)
257 {
258  int err;
259 
260  err = __alauda_read_page(mtd, from, buf, oob);
261  if (err)
262  return err;
263  correct_data(buf, oob+13, corrected, uncorrected);
264  correct_data(buf+256, oob+8, corrected, uncorrected);
265  return 0;
266 }
267 
268 static int alauda_write_page(struct mtd_info *mtd, loff_t to, void *buf,
269  void *oob)
270 {
271  struct alauda_sg_request sg;
272  struct alauda *al = mtd->priv;
273  u32 pba = to >> al->card->blockshift;
274  u32 page = (to >> al->card->pageshift) & al->pagemask;
275  u8 command[] = {
277  PBA_ZONE(pba), 0, PBA_LO(pba) + page, 32, 0, al->port
278  };
279  int i, err;
280 
281  for (i=0; i<3; i++)
282  sg.urb[i] = NULL;
283 
284  err = -ENOMEM;
285  for (i=0; i<3; i++) {
286  sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
287  if (!sg.urb[i])
288  goto out;
289  }
290  init_completion(&sg.comp);
291  usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
292  alauda_complete, NULL);
293  usb_fill_bulk_urb(sg.urb[1], al->dev, al->write_out, buf,mtd->writesize,
294  alauda_complete, NULL);
295  usb_fill_bulk_urb(sg.urb[2], al->dev, al->write_out, oob, 16,
296  alauda_complete, &sg.comp);
297 
298  mutex_lock(&al->card_mutex);
299  for (i=0; i<3; i++) {
300  err = usb_submit_urb(sg.urb[i], GFP_NOIO);
301  if (err)
302  goto cancel;
303  }
304  if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
305  err = -ETIMEDOUT;
306 cancel:
307  for (i=0; i<3; i++) {
308  usb_kill_urb(sg.urb[i]);
309  }
310  }
311  mutex_unlock(&al->card_mutex);
312 
313 out:
314  usb_free_urb(sg.urb[0]);
315  usb_free_urb(sg.urb[1]);
316  usb_free_urb(sg.urb[2]);
317  return err;
318 }
319 
320 static int alauda_erase_block(struct mtd_info *mtd, loff_t ofs)
321 {
322  struct alauda_sg_request sg;
323  struct alauda *al = mtd->priv;
324  u32 pba = ofs >> al->card->blockshift;
325  u8 command[] = {
327  PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, al->port
328  };
329  u8 buf[2];
330  int i, err;
331 
332  for (i=0; i<2; i++)
333  sg.urb[i] = NULL;
334 
335  err = -ENOMEM;
336  for (i=0; i<2; i++) {
337  sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
338  if (!sg.urb[i])
339  goto out;
340  }
341  init_completion(&sg.comp);
342  usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
343  alauda_complete, NULL);
344  usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, 2,
345  alauda_complete, &sg.comp);
346 
347  mutex_lock(&al->card_mutex);
348  for (i=0; i<2; i++) {
349  err = usb_submit_urb(sg.urb[i], GFP_NOIO);
350  if (err)
351  goto cancel;
352  }
353  if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
354  err = -ETIMEDOUT;
355 cancel:
356  for (i=0; i<2; i++) {
357  usb_kill_urb(sg.urb[i]);
358  }
359  }
360  mutex_unlock(&al->card_mutex);
361 
362 out:
363  usb_free_urb(sg.urb[0]);
364  usb_free_urb(sg.urb[1]);
365  return err;
366 }
367 
368 static int alauda_read_oob(struct mtd_info *mtd, loff_t from, void *oob)
369 {
370  static u8 ignore_buf[512]; /* write only */
371 
372  return __alauda_read_page(mtd, from, ignore_buf, oob);
373 }
374 
375 static int alauda_isbad(struct mtd_info *mtd, loff_t ofs)
376 {
377  u8 oob[16];
378  int err;
379 
380  err = alauda_read_oob(mtd, ofs, oob);
381  if (err)
382  return err;
383 
384  /* A block is marked bad if two or more bits are zero */
385  return hweight8(oob[5]) >= 7 ? 0 : 1;
386 }
387 
388 static int alauda_bounce_read(struct mtd_info *mtd, loff_t from, size_t len,
389  size_t *retlen, u_char *buf)
390 {
391  struct alauda *al = mtd->priv;
392  void *bounce_buf;
393  int err, corrected=0, uncorrected=0;
394 
395  bounce_buf = kmalloc(mtd->writesize, GFP_KERNEL);
396  if (!bounce_buf)
397  return -ENOMEM;
398 
399  *retlen = len;
400  while (len) {
401  u8 oob[16];
402  size_t byte = from & al->bytemask;
403  size_t cplen = min(len, mtd->writesize - byte);
404 
405  err = alauda_read_page(mtd, from, bounce_buf, oob,
406  &corrected, &uncorrected);
407  if (err)
408  goto out;
409 
410  memcpy(buf, bounce_buf + byte, cplen);
411  buf += cplen;
412  from += cplen;
413  len -= cplen;
414  }
415  err = 0;
416  if (corrected)
417  err = 1; /* return max_bitflips per ecc step */
418  if (uncorrected)
419  err = -EBADMSG;
420 out:
421  kfree(bounce_buf);
422  return err;
423 }
424 
425 static int alauda_read(struct mtd_info *mtd, loff_t from, size_t len,
426  size_t *retlen, u_char *buf)
427 {
428  struct alauda *al = mtd->priv;
429  int err, corrected=0, uncorrected=0;
430 
431  if ((from & al->bytemask) || (len & al->bytemask))
432  return alauda_bounce_read(mtd, from, len, retlen, buf);
433 
434  *retlen = len;
435  while (len) {
436  u8 oob[16];
437 
438  err = alauda_read_page(mtd, from, buf, oob,
439  &corrected, &uncorrected);
440  if (err)
441  return err;
442 
443  buf += mtd->writesize;
444  from += mtd->writesize;
445  len -= mtd->writesize;
446  }
447  err = 0;
448  if (corrected)
449  err = 1; /* return max_bitflips per ecc step */
450  if (uncorrected)
451  err = -EBADMSG;
452  return err;
453 }
454 
455 static int alauda_write(struct mtd_info *mtd, loff_t to, size_t len,
456  size_t *retlen, const u_char *buf)
457 {
458  struct alauda *al = mtd->priv;
459  int err;
460 
461  if ((to & al->bytemask) || (len & al->bytemask))
462  return -EINVAL;
463 
464  *retlen = len;
465  while (len) {
466  u32 page = (to >> al->card->pageshift) & al->pagemask;
467  u8 oob[16] = { 'h', 'e', 'l', 'l', 'o', 0xff, 0xff, 0xff,
468  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
469 
470  /* don't write to bad blocks */
471  if (page == 0) {
472  err = alauda_isbad(mtd, to);
473  if (err) {
474  return -EIO;
475  }
476  }
477  nand_calculate_ecc(mtd, buf, &oob[13]);
478  nand_calculate_ecc(mtd, buf+256, &oob[8]);
479 
480  err = alauda_write_page(mtd, to, (void*)buf, oob);
481  if (err)
482  return err;
483 
484  buf += mtd->writesize;
485  to += mtd->writesize;
486  len -= mtd->writesize;
487  }
488  return 0;
489 }
490 
491 static int __alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
492 {
493  struct alauda *al = mtd->priv;
494  u32 ofs = instr->addr;
495  u32 len = instr->len;
496  int err;
497 
498  if ((ofs & al->blockmask) || (len & al->blockmask))
499  return -EINVAL;
500 
501  while (len) {
502  /* don't erase bad blocks */
503  err = alauda_isbad(mtd, ofs);
504  if (err > 0)
505  err = -EIO;
506  if (err < 0)
507  return err;
508 
509  err = alauda_erase_block(mtd, ofs);
510  if (err < 0)
511  return err;
512 
513  ofs += mtd->erasesize;
514  len -= mtd->erasesize;
515  }
516  return 0;
517 }
518 
519 static int alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
520 {
521  int err;
522 
523  err = __alauda_erase(mtd, instr);
524  instr->state = err ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
525  mtd_erase_callback(instr);
526  return err;
527 }
528 
529 static int alauda_init_media(struct alauda *al)
530 {
531  u8 buf[4], *b0=buf, *b1=buf+1;
532  struct alauda_card *card;
533  struct mtd_info *mtd;
534  int err;
535 
536  mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
537  if (!mtd)
538  return -ENOMEM;
539 
540  for (;;) {
541  err = alauda_get_media_status(al, buf);
542  if (err < 0)
543  goto error;
544  if (*b0 & 0x10)
545  break;
546  msleep(20);
547  }
548 
549  err = alauda_ack_media(al);
550  if (err)
551  goto error;
552 
553  msleep(10);
554 
555  err = alauda_get_media_status(al, buf);
556  if (err < 0)
557  goto error;
558 
559  if (*b0 != 0x14) {
560  /* media not ready */
561  err = -EIO;
562  goto error;
563  }
564  err = alauda_get_media_signatures(al, buf);
565  if (err < 0)
566  goto error;
567 
568  card = get_card(*b1);
569  if (!card) {
570  printk(KERN_ERR"Alauda: unknown card id %02x\n", *b1);
571  err = -EIO;
572  goto error;
573  }
574  printk(KERN_INFO"pagesize=%x\nerasesize=%x\nsize=%xMiB\n",
575  1<<card->pageshift, 1<<card->blockshift,
576  1<<(card->chipshift-20));
577  al->card = card;
578  al->pagemask = (1 << (card->blockshift - card->pageshift)) - 1;
579  al->bytemask = (1 << card->pageshift) - 1;
580  al->blockmask = (1 << card->blockshift) - 1;
581 
582  mtd->name = "alauda";
583  mtd->size = 1<<card->chipshift;
584  mtd->erasesize = 1<<card->blockshift;
585  mtd->writesize = 1<<card->pageshift;
586  mtd->type = MTD_NANDFLASH;
587  mtd->flags = MTD_CAP_NANDFLASH;
588  mtd->_read = alauda_read;
589  mtd->_write = alauda_write;
590  mtd->_erase = alauda_erase;
591  mtd->_block_isbad = alauda_isbad;
592  mtd->priv = al;
593  mtd->owner = THIS_MODULE;
594  mtd->ecc_strength = 1;
595 
596  err = mtd_device_register(mtd, NULL, 0);
597  if (err) {
598  err = -ENFILE;
599  goto error;
600  }
601 
602  al->mtd = mtd;
603  alauda_reset(al); /* no clue whether this is necessary */
604  return 0;
605 error:
606  kfree(mtd);
607  return err;
608 }
609 
610 static int alauda_check_media(struct alauda *al)
611 {
612  u8 buf[2], *b0 = buf, *b1 = buf+1;
613  int err;
614 
615  err = alauda_get_media_status(al, buf);
616  if (err < 0)
617  return err;
618 
619  if ((*b1 & 0x01) == 0) {
620  /* door open */
621  return -EIO;
622  }
623  if ((*b0 & 0x80) || ((*b0 & 0x1F) == 0x10)) {
624  /* no media ? */
625  return -EIO;
626  }
627  if (*b0 & 0x08) {
628  /* media change ? */
629  return alauda_init_media(al);
630  }
631  return 0;
632 }
633 
634 static int alauda_probe(struct usb_interface *interface,
635  const struct usb_device_id *id)
636 {
637  struct alauda *al;
638  struct usb_host_interface *iface;
639  struct usb_endpoint_descriptor *ep,
640  *ep_in=NULL, *ep_out=NULL, *ep_wr=NULL;
641  int i, err = -ENOMEM;
642 
643  al = kzalloc(2*sizeof(*al), GFP_KERNEL);
644  if (!al)
645  goto error;
646 
647  kref_init(&al->kref);
648  usb_set_intfdata(interface, al);
649 
650  al->dev = usb_get_dev(interface_to_usbdev(interface));
651  al->interface = interface;
652 
653  iface = interface->cur_altsetting;
654  for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
655  ep = &iface->endpoint[i].desc;
656 
657  if (usb_endpoint_is_bulk_in(ep)) {
658  ep_in = ep;
659  } else if (usb_endpoint_is_bulk_out(ep)) {
660  if (i==0)
661  ep_wr = ep;
662  else
663  ep_out = ep;
664  }
665  }
666  err = -EIO;
667  if (!ep_wr || !ep_in || !ep_out)
668  goto error;
669 
670  al->write_out = usb_sndbulkpipe(al->dev,
671  usb_endpoint_num(ep_wr));
672  al->bulk_in = usb_rcvbulkpipe(al->dev,
673  usb_endpoint_num(ep_in));
674  al->bulk_out = usb_sndbulkpipe(al->dev,
675  usb_endpoint_num(ep_out));
676 
677  /* second device is identical up to now */
678  memcpy(al+1, al, sizeof(*al));
679 
680  mutex_init(&al[0].card_mutex);
681  mutex_init(&al[1].card_mutex);
682 
683  al[0].port = ALAUDA_PORT_XD;
684  al[1].port = ALAUDA_PORT_SM;
685 
686  dev_info(&interface->dev, "alauda probed\n");
687  alauda_check_media(al);
688  alauda_check_media(al+1);
689 
690  return 0;
691 
692 error:
693  if (al)
694  kref_put(&al->kref, alauda_delete);
695  return err;
696 }
697 
698 static void alauda_disconnect(struct usb_interface *interface)
699 {
700  struct alauda *al;
701 
702  al = usb_get_intfdata(interface);
703  usb_set_intfdata(interface, NULL);
704 
705  /* FIXME: prevent more I/O from starting */
706 
707  /* decrement our usage count */
708  if (al)
709  kref_put(&al->kref, alauda_delete);
710 
711  dev_info(&interface->dev, "alauda gone");
712 }
713 
714 static struct usb_driver alauda_driver = {
715  .name = "alauda",
716  .probe = alauda_probe,
717  .disconnect = alauda_disconnect,
718  .id_table = alauda_table,
719 };
720 
721 module_usb_driver(alauda_driver);
722 
723 MODULE_LICENSE("GPL");