PageRenderTime 52ms CodeModel.GetById 20ms app.highlight 26ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/mtd/nand/alauda.c

https://bitbucket.org/ndreys/linux-sunxi
C | 733 lines | 595 code | 109 blank | 29 comment | 83 complexity | d0e6fe036e4d0a0c2a8d15fc85eb0011 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  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
 52static 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};
 57MODULE_DEVICE_TABLE(usb, alauda_table);
 58
 59struct 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
 66struct 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
 82static 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
108static 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
118static void alauda_delete(struct kref *kref)
119{
120	struct alauda *al = container_of(kref, struct alauda, kref);
121
122	if (al->mtd) {
123		mtd_device_unregister(al->mtd);
124		kfree(al->mtd);
125	}
126	usb_put_dev(al->dev);
127	kfree(al);
128}
129
130static 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
141static 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
152static 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
163static 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
174static 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
190struct alauda_sg_request {
191	struct urb *urb[3];
192	struct completion comp;
193};
194
195static void alauda_complete(struct urb *urb)
196{
197	struct completion *comp = urb->context;
198
199	if (comp)
200		complete(comp);
201}
202
203static 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;
241cancel:
242		for (i=0; i<3; i++) {
243			usb_kill_urb(sg.urb[i]);
244		}
245	}
246	mutex_unlock(&al->card_mutex);
247
248out:
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
255static 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
268static 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;
306cancel:
307		for (i=0; i<3; i++) {
308			usb_kill_urb(sg.urb[i]);
309		}
310	}
311	mutex_unlock(&al->card_mutex);
312
313out:
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
320static 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;
355cancel:
356		for (i=0; i<2; i++) {
357			usb_kill_urb(sg.urb[i]);
358		}
359	}
360	mutex_unlock(&al->card_mutex);
361
362out:
363	usb_free_urb(sg.urb[0]);
364	usb_free_urb(sg.urb[1]);
365	return err;
366}
367
368static 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
375static 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
388static 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 = -EUCLEAN;
418	if (uncorrected)
419		err = -EBADMSG;
420out:
421	kfree(bounce_buf);
422	return err;
423}
424
425static 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 = -EUCLEAN;
450	if (uncorrected)
451		err = -EBADMSG;
452	return err;
453}
454
455static 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
491static 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
519static 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
529static 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
595	err = mtd_device_register(mtd, NULL, 0);
596	if (err) {
597		err = -ENFILE;
598		goto error;
599	}
600
601	al->mtd = mtd;
602	alauda_reset(al); /* no clue whether this is necessary */
603	return 0;
604error:
605	kfree(mtd);
606	return err;
607}
608
609static int alauda_check_media(struct alauda *al)
610{
611	u8 buf[2], *b0 = buf, *b1 = buf+1;
612	int err;
613
614	err = alauda_get_media_status(al, buf);
615	if (err < 0)
616		return err;
617
618	if ((*b1 & 0x01) == 0) {
619		/* door open */
620		return -EIO;
621	}
622	if ((*b0 & 0x80) || ((*b0 & 0x1F) == 0x10)) {
623		/* no media ? */
624		return -EIO;
625	}
626	if (*b0 & 0x08) {
627		/* media change ? */
628		return alauda_init_media(al);
629	}
630	return 0;
631}
632
633static int alauda_probe(struct usb_interface *interface,
634		const struct usb_device_id *id)
635{
636	struct alauda *al;
637	struct usb_host_interface *iface;
638	struct usb_endpoint_descriptor *ep,
639			*ep_in=NULL, *ep_out=NULL, *ep_wr=NULL;
640	int i, err = -ENOMEM;
641
642	al = kzalloc(2*sizeof(*al), GFP_KERNEL);
643	if (!al)
644		goto error;
645
646	kref_init(&al->kref);
647	usb_set_intfdata(interface, al);
648
649	al->dev = usb_get_dev(interface_to_usbdev(interface));
650	al->interface = interface;
651
652	iface = interface->cur_altsetting;
653	for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
654		ep = &iface->endpoint[i].desc;
655
656		if (usb_endpoint_is_bulk_in(ep)) {
657			ep_in = ep;
658		} else if (usb_endpoint_is_bulk_out(ep)) {
659			if (i==0)
660				ep_wr = ep;
661			else
662				ep_out = ep;
663		}
664	}
665	err = -EIO;
666	if (!ep_wr || !ep_in || !ep_out)
667		goto error;
668
669	al->write_out = usb_sndbulkpipe(al->dev,
670			usb_endpoint_num(ep_wr));
671	al->bulk_in = usb_rcvbulkpipe(al->dev,
672			usb_endpoint_num(ep_in));
673	al->bulk_out = usb_sndbulkpipe(al->dev,
674			usb_endpoint_num(ep_out));
675
676	/* second device is identical up to now */
677	memcpy(al+1, al, sizeof(*al));
678
679	mutex_init(&al[0].card_mutex);
680	mutex_init(&al[1].card_mutex);
681
682	al[0].port = ALAUDA_PORT_XD;
683	al[1].port = ALAUDA_PORT_SM;
684
685	dev_info(&interface->dev, "alauda probed\n");
686	alauda_check_media(al);
687	alauda_check_media(al+1);
688
689	return 0;
690
691error:
692	if (al)
693		kref_put(&al->kref, alauda_delete);
694	return err;
695}
696
697static void alauda_disconnect(struct usb_interface *interface)
698{
699	struct alauda *al;
700
701	al = usb_get_intfdata(interface);
702	usb_set_intfdata(interface, NULL);
703
704	/* FIXME: prevent more I/O from starting */
705
706	/* decrement our usage count */
707	if (al)
708		kref_put(&al->kref, alauda_delete);
709
710	dev_info(&interface->dev, "alauda gone");
711}
712
713static struct usb_driver alauda_driver = {
714	.name =		"alauda",
715	.probe =	alauda_probe,
716	.disconnect =	alauda_disconnect,
717	.id_table =	alauda_table,
718};
719
720static int __init alauda_init(void)
721{
722	return usb_register(&alauda_driver);
723}
724
725static void __exit alauda_exit(void)
726{
727	usb_deregister(&alauda_driver);
728}
729
730module_init(alauda_init);
731module_exit(alauda_exit);
732
733MODULE_LICENSE("GPL");