257937cd99bffb2f4a93ce88607ca11ca3e8c9a1
[linux-2.6.git] / drivers / mtd / nand / alauda.c
1 /*
2  * MTD driver for Alauda chips
3  *
4  * Copyright (C) 2007 Joern Engel <joern@logfs.org>
5  *
6  * Based on drivers/usb/usb-skeleton.c which is:
7  * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
8  * and on drivers/usb/storage/alauda.c, which is:
9  *   (c) 2005 Daniel Drake <dsd@gentoo.org>
10  *
11  * Idea and initial work by Arnd Bergmann <arnd@arndb.de>
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 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;
68         struct usb_interface    *interface;
69         struct mtd_info         *mtd;
70         struct alauda_card      *card;
71         struct mutex            card_mutex;
72         u32                     pagemask;
73         u32                     bytemask;
74         u32                     blockmask;
75         unsigned int            write_out;
76         unsigned int            bulk_in;
77         unsigned int            bulk_out;
78         u8                      port;
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) {
123                 del_mtd_device(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[] = {
166                 ALAUDA_BULK_CMD, ALAUDA_BULK_RESET_MEDIA, 0, 0,
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
190 struct alauda_sg_request {
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[] = {
211                 ALAUDA_BULK_CMD, ALAUDA_BULK_READ_PAGE, PBA_HI(pba),
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[] = {
276                 ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_PAGE, PBA_HI(pba),
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[] = {
326                 ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba),
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 popcount8(u8 c)
376 {
377         int ret = 0;
378
379         for ( ; c; c>>=1)
380                 ret += c & 1;
381         return ret;
382 }
383
384 static int alauda_isbad(struct mtd_info *mtd, loff_t ofs)
385 {
386         u8 oob[16];
387         int err;
388
389         err = alauda_read_oob(mtd, ofs, oob);
390         if (err)
391                 return err;
392
393         /* A block is marked bad if two or more bits are zero */
394         return popcount8(oob[5]) >= 7 ? 0 : 1;
395 }
396
397 static int alauda_bounce_read(struct mtd_info *mtd, loff_t from, size_t len,
398                 size_t *retlen, u_char *buf)
399 {
400         struct alauda *al = mtd->priv;
401         void *bounce_buf;
402         int err, corrected=0, uncorrected=0;
403
404         bounce_buf = kmalloc(mtd->writesize, GFP_KERNEL);
405         if (!bounce_buf)
406                 return -ENOMEM;
407
408         *retlen = len;
409         while (len) {
410                 u8 oob[16];
411                 size_t byte = from & al->bytemask;
412                 size_t cplen = min(len, mtd->writesize - byte);
413
414                 err = alauda_read_page(mtd, from, bounce_buf, oob,
415                                 &corrected, &uncorrected);
416                 if (err)
417                         goto out;
418
419                 memcpy(buf, bounce_buf + byte, cplen);
420                 buf += cplen;
421                 from += cplen;
422                 len -= cplen;
423         }
424         err = 0;
425         if (corrected)
426                 err = -EUCLEAN;
427         if (uncorrected)
428                 err = -EBADMSG;
429 out:
430         kfree(bounce_buf);
431         return err;
432 }
433
434 static int alauda_read(struct mtd_info *mtd, loff_t from, size_t len,
435                 size_t *retlen, u_char *buf)
436 {
437         struct alauda *al = mtd->priv;
438         int err, corrected=0, uncorrected=0;
439
440         if ((from & al->bytemask) || (len & al->bytemask))
441                 return alauda_bounce_read(mtd, from, len, retlen, buf);
442
443         *retlen = len;
444         while (len) {
445                 u8 oob[16];
446
447                 err = alauda_read_page(mtd, from, buf, oob,
448                                 &corrected, &uncorrected);
449                 if (err)
450                         return err;
451
452                 buf += mtd->writesize;
453                 from += mtd->writesize;
454                 len -= mtd->writesize;
455         }
456         err = 0;
457         if (corrected)
458                 err = -EUCLEAN;
459         if (uncorrected)
460                 err = -EBADMSG;
461         return err;
462 }
463
464 static int alauda_write(struct mtd_info *mtd, loff_t to, size_t len,
465                 size_t *retlen, const u_char *buf)
466 {
467         struct alauda *al = mtd->priv;
468         int err;
469
470         if ((to & al->bytemask) || (len & al->bytemask))
471                 return -EINVAL;
472
473         *retlen = len;
474         while (len) {
475                 u32 page = (to >> al->card->pageshift) & al->pagemask;
476                 u8 oob[16] = {  'h', 'e', 'l', 'l', 'o', 0xff, 0xff, 0xff,
477                                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
478
479                 /* don't write to bad blocks */
480                 if (page == 0) {
481                         err = alauda_isbad(mtd, to);
482                         if (err) {
483                                 return -EIO;
484                         }
485                 }
486                 nand_calculate_ecc(mtd, buf, &oob[13]);
487                 nand_calculate_ecc(mtd, buf+256, &oob[8]);
488
489                 err = alauda_write_page(mtd, to, (void*)buf, oob);
490                 if (err)
491                         return err;
492
493                 buf += mtd->writesize;
494                 to += mtd->writesize;
495                 len -= mtd->writesize;
496         }
497         return 0;
498 }
499
500 static int __alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
501 {
502         struct alauda *al = mtd->priv;
503         u32 ofs = instr->addr;
504         u32 len = instr->len;
505         int err;
506
507         if ((ofs & al->blockmask) || (len & al->blockmask))
508                 return -EINVAL;
509
510         while (len) {
511                 /* don't erase bad blocks */
512                 err = alauda_isbad(mtd, ofs);
513                 if (err > 0)
514                         err = -EIO;
515                 if (err < 0)
516                         return err;
517
518                 err = alauda_erase_block(mtd, ofs);
519                 if (err < 0)
520                         return err;
521
522                 ofs += mtd->erasesize;
523                 len -= mtd->erasesize;
524         }
525         return 0;
526 }
527
528 static int alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
529 {
530         int err;
531
532         err = __alauda_erase(mtd, instr);
533         instr->state = err ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
534         mtd_erase_callback(instr);
535         return err;
536 }
537
538 static int alauda_init_media(struct alauda *al)
539 {
540         u8 buf[4], *b0=buf, *b1=buf+1;
541         struct alauda_card *card;
542         struct mtd_info *mtd;
543         int err;
544
545         mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
546         if (!mtd)
547                 return -ENOMEM;
548
549         for (;;) {
550                 err = alauda_get_media_status(al, buf);
551                 if (err < 0)
552                         goto error;
553                 if (*b0 & 0x10)
554                         break;
555                 msleep(20);
556         }
557
558         err = alauda_ack_media(al);
559         if (err)
560                 goto error;
561
562         msleep(10);
563
564         err = alauda_get_media_status(al, buf);
565         if (err < 0)
566                 goto error;
567
568         if (*b0 != 0x14) {
569                 /* media not ready */
570                 err = -EIO;
571                 goto error;
572         }
573         err = alauda_get_media_signatures(al, buf);
574         if (err < 0)
575                 goto error;
576
577         card = get_card(*b1);
578         if (!card) {
579                 printk(KERN_ERR"Alauda: unknown card id %02x\n", *b1);
580                 err = -EIO;
581                 goto error;
582         }
583         printk(KERN_INFO"pagesize=%x\nerasesize=%x\nsize=%xMiB\n",
584                         1<<card->pageshift, 1<<card->blockshift,
585                         1<<(card->chipshift-20));
586         al->card = card;
587         al->pagemask = (1 << (card->blockshift - card->pageshift)) - 1;
588         al->bytemask = (1 << card->pageshift) - 1;
589         al->blockmask = (1 << card->blockshift) - 1;
590
591         mtd->name = "alauda";
592         mtd->size = 1<<card->chipshift;
593         mtd->erasesize = 1<<card->blockshift;
594         mtd->writesize = 1<<card->pageshift;
595         mtd->type = MTD_NANDFLASH;
596         mtd->flags = MTD_CAP_NANDFLASH;
597         mtd->read = alauda_read;
598         mtd->write = alauda_write;
599         mtd->erase = alauda_erase;
600         mtd->block_isbad = alauda_isbad;
601         mtd->priv = al;
602         mtd->owner = THIS_MODULE;
603
604         err = add_mtd_device(mtd);
605         if (err) {
606                 err = -ENFILE;
607                 goto error;
608         }
609
610         al->mtd = mtd;
611         alauda_reset(al); /* no clue whether this is necessary */
612         return 0;
613 error:
614         kfree(mtd);
615         return err;
616 }
617
618 static int alauda_check_media(struct alauda *al)
619 {
620         u8 buf[2], *b0 = buf, *b1 = buf+1;
621         int err;
622
623         err = alauda_get_media_status(al, buf);
624         if (err < 0)
625                 return err;
626
627         if ((*b1 & 0x01) == 0) {
628                 /* door open */
629                 return -EIO;
630         }
631         if ((*b0 & 0x80) || ((*b0 & 0x1F) == 0x10)) {
632                 /* no media ? */
633                 return -EIO;
634         }
635         if (*b0 & 0x08) {
636                 /* media change ? */
637                 return alauda_init_media(al);
638         }
639         return 0;
640 }
641
642 static int alauda_probe(struct usb_interface *interface,
643                 const struct usb_device_id *id)
644 {
645         struct alauda *al;
646         struct usb_host_interface *iface;
647         struct usb_endpoint_descriptor *ep,
648                         *ep_in=NULL, *ep_out=NULL, *ep_wr=NULL;
649         int i, err = -ENOMEM;
650
651         al = kzalloc(2*sizeof(*al), GFP_KERNEL);
652         if (!al)
653                 goto error;
654
655         kref_init(&al->kref);
656         usb_set_intfdata(interface, al);
657
658         al->dev = usb_get_dev(interface_to_usbdev(interface));
659         al->interface = interface;
660
661         iface = interface->cur_altsetting;
662         for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
663                 ep = &iface->endpoint[i].desc;
664
665                 if (usb_endpoint_is_bulk_in(ep)) {
666                         ep_in = ep;
667                 } else if (usb_endpoint_is_bulk_out(ep)) {
668                         if (i==0)
669                                 ep_wr = ep;
670                         else
671                                 ep_out = ep;
672                 }
673         }
674         err = -EIO;
675         if (!ep_wr || !ep_in || !ep_out)
676                 goto error;
677
678         al->write_out = usb_sndbulkpipe(al->dev,
679                         ep_wr->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
680         al->bulk_in = usb_rcvbulkpipe(al->dev,
681                         ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
682         al->bulk_out = usb_sndbulkpipe(al->dev,
683                         ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
684
685         /* second device is identical up to now */
686         memcpy(al+1, al, sizeof(*al));
687
688         mutex_init(&al[0].card_mutex);
689         mutex_init(&al[1].card_mutex);
690
691         al[0].port = ALAUDA_PORT_XD;
692         al[1].port = ALAUDA_PORT_SM;
693
694         info("alauda probed");
695         alauda_check_media(al);
696         alauda_check_media(al+1);
697
698         return 0;
699
700 error:
701         if (al)
702                 kref_put(&al->kref, alauda_delete);
703         return err;
704 }
705
706 static void alauda_disconnect(struct usb_interface *interface)
707 {
708         struct alauda *al;
709
710         al = usb_get_intfdata(interface);
711         usb_set_intfdata(interface, NULL);
712
713         /* FIXME: prevent more I/O from starting */
714
715         /* decrement our usage count */
716         if (al)
717                 kref_put(&al->kref, alauda_delete);
718
719         info("alauda gone");
720 }
721
722 static struct usb_driver alauda_driver = {
723         .name =         "alauda",
724         .probe =        alauda_probe,
725         .disconnect =   alauda_disconnect,
726         .id_table =     alauda_table,
727 };
728
729 static int __init alauda_init(void)
730 {
731         return usb_register(&alauda_driver);
732 }
733
734 static void __exit alauda_exit(void)
735 {
736         usb_deregister(&alauda_driver);
737 }
738
739 module_init(alauda_init);
740 module_exit(alauda_exit);
741
742 MODULE_LICENSE("GPL");