1 /*
2  *  Driver for the Auvitek USB bridge
3  *
4  *  Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *
15  *  GNU General Public License for more details.
16  */
17 
18 #include "au0828.h"
19 #include "au8522.h"
20 
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/videodev2.h>
24 #include <media/v4l2-common.h>
25 #include <linux/mutex.h>
26 
27 /* Due to enum tuner_pad_index */
28 #include <media/tuner.h>
29 
30 /*
31  * 1 = General debug messages
32  * 2 = USB handling
33  * 4 = I2C related
34  * 8 = Bridge related
35  * 16 = IR related
36  */
37 int au0828_debug;
38 module_param_named(debug, au0828_debug, int, 0644);
39 MODULE_PARM_DESC(debug,
40 		 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");
41 
42 static unsigned int disable_usb_speed_check;
43 module_param(disable_usb_speed_check, int, 0444);
44 MODULE_PARM_DESC(disable_usb_speed_check,
45 		 "override min bandwidth requirement of 480M bps");
46 
47 #define _AU0828_BULKPIPE 0x03
48 #define _BULKPIPESIZE 0xffff
49 
50 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
51 			    u16 index);
52 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
53 	u16 index, unsigned char *cp, u16 size);
54 
55 /* USB Direction */
56 #define CMD_REQUEST_IN		0x00
57 #define CMD_REQUEST_OUT		0x01
58 
59 u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
60 {
61 	u8 result = 0;
62 
63 	recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1);
64 	dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result);
65 
66 	return result;
67 }
68 
69 u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
70 {
71 	dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val);
72 	return send_control_msg(dev, CMD_REQUEST_OUT, val, reg);
73 }
74 
75 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
76 	u16 index)
77 {
78 	int status = -ENODEV;
79 
80 	if (dev->usbdev) {
81 
82 		/* cp must be memory that has been allocated by kmalloc */
83 		status = usb_control_msg(dev->usbdev,
84 				usb_sndctrlpipe(dev->usbdev, 0),
85 				request,
86 				USB_DIR_OUT | USB_TYPE_VENDOR |
87 					USB_RECIP_DEVICE,
88 				value, index, NULL, 0, 1000);
89 
90 		status = min(status, 0);
91 
92 		if (status < 0) {
93 			pr_err("%s() Failed sending control message, error %d.\n",
94 				__func__, status);
95 		}
96 
97 	}
98 
99 	return status;
100 }
101 
102 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
103 	u16 index, unsigned char *cp, u16 size)
104 {
105 	int status = -ENODEV;
106 	mutex_lock(&dev->mutex);
107 	if (dev->usbdev) {
108 		status = usb_control_msg(dev->usbdev,
109 				usb_rcvctrlpipe(dev->usbdev, 0),
110 				request,
111 				USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
112 				value, index,
113 				dev->ctrlmsg, size, 1000);
114 
115 		status = min(status, 0);
116 
117 		if (status < 0) {
118 			pr_err("%s() Failed receiving control message, error %d.\n",
119 				__func__, status);
120 		}
121 
122 		/* the host controller requires heap allocated memory, which
123 		   is why we didn't just pass "cp" into usb_control_msg */
124 		memcpy(cp, dev->ctrlmsg, size);
125 	}
126 	mutex_unlock(&dev->mutex);
127 	return status;
128 }
129 
130 #ifdef CONFIG_MEDIA_CONTROLLER
131 static void au0828_media_graph_notify(struct media_entity *new,
132 				      void *notify_data);
133 #endif
134 
135 static void au0828_unregister_media_device(struct au0828_dev *dev)
136 {
137 #ifdef CONFIG_MEDIA_CONTROLLER
138 	struct media_device *mdev = dev->media_dev;
139 	struct media_entity_notify *notify, *nextp;
140 
141 	if (!mdev || !media_devnode_is_registered(mdev->devnode))
142 		return;
143 
144 	/* Remove au0828 entity_notify callbacks */
145 	list_for_each_entry_safe(notify, nextp, &mdev->entity_notify, list) {
146 		if (notify->notify != au0828_media_graph_notify)
147 			continue;
148 		media_device_unregister_entity_notify(mdev, notify);
149 	}
150 
151 	/* clear enable_source, disable_source */
152 	mutex_lock(&mdev->graph_mutex);
153 	dev->media_dev->source_priv = NULL;
154 	dev->media_dev->enable_source = NULL;
155 	dev->media_dev->disable_source = NULL;
156 	mutex_unlock(&mdev->graph_mutex);
157 
158 	media_device_unregister(dev->media_dev);
159 	media_device_cleanup(dev->media_dev);
160 	kfree(dev->media_dev);
161 	dev->media_dev = NULL;
162 #endif
163 }
164 
165 void au0828_usb_release(struct au0828_dev *dev)
166 {
167 	au0828_unregister_media_device(dev);
168 
169 	/* I2C */
170 	au0828_i2c_unregister(dev);
171 
172 	kfree(dev);
173 }
174 
175 static void au0828_usb_disconnect(struct usb_interface *interface)
176 {
177 	struct au0828_dev *dev = usb_get_intfdata(interface);
178 
179 	dprintk(1, "%s()\n", __func__);
180 
181 	/* there is a small window after disconnect, before
182 	   dev->usbdev is NULL, for poll (e.g: IR) try to access
183 	   the device and fill the dmesg with error messages.
184 	   Set the status so poll routines can check and avoid
185 	   access after disconnect.
186 	*/
187 	set_bit(DEV_DISCONNECTED, &dev->dev_state);
188 
189 	au0828_rc_unregister(dev);
190 	/* Digital TV */
191 	au0828_dvb_unregister(dev);
192 
193 	usb_set_intfdata(interface, NULL);
194 	mutex_lock(&dev->mutex);
195 	dev->usbdev = NULL;
196 	mutex_unlock(&dev->mutex);
197 	if (au0828_analog_unregister(dev)) {
198 		/*
199 		 * No need to call au0828_usb_release() if V4L2 is enabled,
200 		 * as this is already called via au0828_usb_v4l2_release()
201 		 */
202 		return;
203 	}
204 	au0828_usb_release(dev);
205 }
206 
207 static int au0828_media_device_init(struct au0828_dev *dev,
208 				    struct usb_device *udev)
209 {
210 #ifdef CONFIG_MEDIA_CONTROLLER
211 	struct media_device *mdev;
212 
213 	mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
214 	if (!mdev)
215 		return -ENOMEM;
216 
217 	/* check if media device is already initialized */
218 	if (!mdev->dev)
219 		media_device_usb_init(mdev, udev, udev->product);
220 
221 	dev->media_dev = mdev;
222 #endif
223 	return 0;
224 }
225 
226 #ifdef CONFIG_MEDIA_CONTROLLER
227 static void au0828_media_graph_notify(struct media_entity *new,
228 				      void *notify_data)
229 {
230 	struct au0828_dev *dev = (struct au0828_dev *) notify_data;
231 	int ret;
232 	struct media_entity *entity, *mixer = NULL, *decoder = NULL;
233 
234 	if (!new) {
235 		/*
236 		 * Called during au0828 probe time to connect
237 		 * entites that were created prior to registering
238 		 * the notify handler. Find mixer and decoder.
239 		*/
240 		media_device_for_each_entity(entity, dev->media_dev) {
241 			if (entity->function == MEDIA_ENT_F_AUDIO_MIXER)
242 				mixer = entity;
243 			else if (entity->function == MEDIA_ENT_F_ATV_DECODER)
244 				decoder = entity;
245 		}
246 		goto create_link;
247 	}
248 
249 	switch (new->function) {
250 	case MEDIA_ENT_F_AUDIO_MIXER:
251 		mixer = new;
252 		if (dev->decoder)
253 			decoder = dev->decoder;
254 		break;
255 	case MEDIA_ENT_F_ATV_DECODER:
256 		/* In case, Mixer is added first, find mixer and create link */
257 		media_device_for_each_entity(entity, dev->media_dev) {
258 			if (entity->function == MEDIA_ENT_F_AUDIO_MIXER)
259 				mixer = entity;
260 		}
261 		decoder = new;
262 		break;
263 	default:
264 		break;
265 	}
266 
267 create_link:
268 	if (decoder && mixer) {
269 		ret = media_create_pad_link(decoder,
270 					    DEMOD_PAD_AUDIO_OUT,
271 					    mixer, 0,
272 					    MEDIA_LNK_FL_ENABLED);
273 		if (ret)
274 			dev_err(&dev->usbdev->dev,
275 				"Mixer Pad Link Create Error: %d\n", ret);
276 	}
277 }
278 
279 /* Callers should hold graph_mutex */
280 static int au0828_enable_source(struct media_entity *entity,
281 				struct media_pipeline *pipe)
282 {
283 	struct media_entity  *source, *find_source;
284 	struct media_entity *sink;
285 	struct media_link *link, *found_link = NULL;
286 	int ret = 0;
287 	struct media_device *mdev = entity->graph_obj.mdev;
288 	struct au0828_dev *dev;
289 
290 	if (!mdev)
291 		return -ENODEV;
292 
293 	dev = mdev->source_priv;
294 
295 	/*
296 	 * For Audio and V4L2 entity, find the link to which decoder
297 	 * is the sink. Look for an active link between decoder and
298 	 * source (tuner/s-video/Composite), if one exists, nothing
299 	 * to do. If not, look for any  active links between source
300 	 * and any other entity. If one exists, source is busy. If
301 	 * source is free, setup link and start pipeline from source.
302 	 * For DVB FE entity, the source for the link is the tuner.
303 	 * Check if tuner is available and setup link and start
304 	 * pipeline.
305 	*/
306 	if (entity->function == MEDIA_ENT_F_DTV_DEMOD) {
307 		sink = entity;
308 		find_source = dev->tuner;
309 	} else {
310 		/* Analog isn't configured or register failed */
311 		if (!dev->decoder) {
312 			ret = -ENODEV;
313 			goto end;
314 		}
315 
316 		sink = dev->decoder;
317 
318 		/*
319 		 * Default input is tuner and default input_type
320 		 * is AU0828_VMUX_TELEVISION.
321 		 * FIXME:
322 		 * There is a problem when s_input is called to
323 		 * change the default input. s_input will try to
324 		 * enable_source before attempting to change the
325 		 * input on the device, and will end up enabling
326 		 * default source which is tuner.
327 		 *
328 		 * Additional logic is necessary in au0828
329 		 * to detect that the input has changed and
330 		 * enable the right source.
331 		*/
332 
333 		if (dev->input_type == AU0828_VMUX_TELEVISION)
334 			find_source = dev->tuner;
335 		else if (dev->input_type == AU0828_VMUX_SVIDEO ||
336 			 dev->input_type == AU0828_VMUX_COMPOSITE)
337 			find_source = &dev->input_ent[dev->input_type];
338 		else {
339 			/* unknown input - let user select input */
340 			ret = 0;
341 			goto end;
342 		}
343 	}
344 
345 	/* Is an active link between sink and source */
346 	if (dev->active_link) {
347 		/*
348 		 * If DVB is using the tuner and calling entity is
349 		 * audio/video, the following check will be false,
350 		 * since sink is different. Result is Busy.
351 		 */
352 		if (dev->active_link->sink->entity == sink &&
353 		    dev->active_link->source->entity == find_source) {
354 			/*
355 			 * Either ALSA or Video own tuner. sink is
356 			 * the same for both. Prevent Video stepping
357 			 * on ALSA when ALSA owns the source.
358 			*/
359 			if (dev->active_link_owner != entity &&
360 			    dev->active_link_owner->function ==
361 						MEDIA_ENT_F_AUDIO_CAPTURE) {
362 				pr_debug("ALSA has the tuner\n");
363 				ret = -EBUSY;
364 				goto end;
365 			}
366 			ret = 0;
367 			goto end;
368 		} else {
369 			ret = -EBUSY;
370 			goto end;
371 		}
372 	}
373 
374 	list_for_each_entry(link, &sink->links, list) {
375 		/* Check sink, and source */
376 		if (link->sink->entity == sink &&
377 		    link->source->entity == find_source) {
378 			found_link = link;
379 			break;
380 		}
381 	}
382 
383 	if (!found_link) {
384 		ret = -ENODEV;
385 		goto end;
386 	}
387 
388 	/* activate link between source and sink and start pipeline */
389 	source = found_link->source->entity;
390 	ret = __media_entity_setup_link(found_link, MEDIA_LNK_FL_ENABLED);
391 	if (ret) {
392 		pr_err("Activate tuner link %s->%s. Error %d\n",
393 			source->name, sink->name, ret);
394 		goto end;
395 	}
396 
397 	ret = __media_pipeline_start(entity, pipe);
398 	if (ret) {
399 		pr_err("Start Pipeline: %s->%s Error %d\n",
400 			source->name, entity->name, ret);
401 		ret = __media_entity_setup_link(found_link, 0);
402 		pr_err("Deactivate link Error %d\n", ret);
403 		goto end;
404 	}
405 	/*
406 	 * save active link and active link owner to avoid audio
407 	 * deactivating video owned link from disable_source and
408 	 * vice versa
409 	*/
410 	dev->active_link = found_link;
411 	dev->active_link_owner = entity;
412 	dev->active_source = source;
413 	dev->active_sink = sink;
414 
415 	pr_debug("Enabled Source: %s->%s->%s Ret %d\n",
416 		 dev->active_source->name, dev->active_sink->name,
417 		 dev->active_link_owner->name, ret);
418 end:
419 	pr_debug("au0828_enable_source() end %s %d %d\n",
420 		 entity->name, entity->function, ret);
421 	return ret;
422 }
423 
424 /* Callers should hold graph_mutex */
425 static void au0828_disable_source(struct media_entity *entity)
426 {
427 	int ret = 0;
428 	struct media_device *mdev = entity->graph_obj.mdev;
429 	struct au0828_dev *dev;
430 
431 	if (!mdev)
432 		return;
433 
434 	dev = mdev->source_priv;
435 
436 	if (!dev->active_link)
437 		return;
438 
439 	/* link is active - stop pipeline from source (tuner) */
440 	if (dev->active_link->sink->entity == dev->active_sink &&
441 	    dev->active_link->source->entity == dev->active_source) {
442 		/*
443 		 * prevent video from deactivating link when audio
444 		 * has active pipeline
445 		*/
446 		if (dev->active_link_owner != entity)
447 			return;
448 		__media_pipeline_stop(entity);
449 		ret = __media_entity_setup_link(dev->active_link, 0);
450 		if (ret)
451 			pr_err("Deactivate link Error %d\n", ret);
452 
453 		pr_debug("Disabled Source: %s->%s->%s Ret %d\n",
454 			 dev->active_source->name, dev->active_sink->name,
455 			 dev->active_link_owner->name, ret);
456 
457 		dev->active_link = NULL;
458 		dev->active_link_owner = NULL;
459 		dev->active_source = NULL;
460 		dev->active_sink = NULL;
461 	}
462 }
463 #endif
464 
465 static int au0828_media_device_register(struct au0828_dev *dev,
466 					struct usb_device *udev)
467 {
468 #ifdef CONFIG_MEDIA_CONTROLLER
469 	int ret;
470 	struct media_entity *entity, *demod = NULL;
471 	struct media_link *link;
472 
473 	if (!dev->media_dev)
474 		return 0;
475 
476 	if (!media_devnode_is_registered(dev->media_dev->devnode)) {
477 
478 		/* register media device */
479 		ret = media_device_register(dev->media_dev);
480 		if (ret) {
481 			dev_err(&udev->dev,
482 				"Media Device Register Error: %d\n", ret);
483 			return ret;
484 		}
485 	} else {
486 		/*
487 		 * Call au0828_media_graph_notify() to connect
488 		 * audio graph to our graph. In this case, audio
489 		 * driver registered the device and there is no
490 		 * entity_notify to be called when new entities
491 		 * are added. Invoke it now.
492 		*/
493 		au0828_media_graph_notify(NULL, (void *) dev);
494 	}
495 
496 	/*
497 	 * Find tuner, decoder and demod.
498 	 *
499 	 * The tuner and decoder should be cached, as they'll be used by
500 	 *	au0828_enable_source.
501 	 *
502 	 * It also needs to disable the link between tuner and
503 	 * decoder/demod, to avoid disable step when tuner is requested
504 	 * by video or audio. Note that this step can't be done until dvb
505 	 * graph is created during dvb register.
506 	*/
507 	media_device_for_each_entity(entity, dev->media_dev) {
508 		switch (entity->function) {
509 		case MEDIA_ENT_F_TUNER:
510 			dev->tuner = entity;
511 			break;
512 		case MEDIA_ENT_F_ATV_DECODER:
513 			dev->decoder = entity;
514 			break;
515 		case MEDIA_ENT_F_DTV_DEMOD:
516 			demod = entity;
517 			break;
518 		}
519 	}
520 
521 	/* Disable link between tuner->demod and/or tuner->decoder */
522 	if (dev->tuner) {
523 		list_for_each_entry(link, &dev->tuner->links, list) {
524 			if (demod && link->sink->entity == demod)
525 				media_entity_setup_link(link, 0);
526 			if (dev->decoder && link->sink->entity == dev->decoder)
527 				media_entity_setup_link(link, 0);
528 		}
529 	}
530 
531 	/* register entity_notify callback */
532 	dev->entity_notify.notify_data = (void *) dev;
533 	dev->entity_notify.notify = (void *) au0828_media_graph_notify;
534 	ret = media_device_register_entity_notify(dev->media_dev,
535 						  &dev->entity_notify);
536 	if (ret) {
537 		dev_err(&udev->dev,
538 			"Media Device register entity_notify Error: %d\n",
539 			ret);
540 		return ret;
541 	}
542 	/* set enable_source */
543 	mutex_lock(&dev->media_dev->graph_mutex);
544 	dev->media_dev->source_priv = (void *) dev;
545 	dev->media_dev->enable_source = au0828_enable_source;
546 	dev->media_dev->disable_source = au0828_disable_source;
547 	mutex_unlock(&dev->media_dev->graph_mutex);
548 #endif
549 	return 0;
550 }
551 
552 static int au0828_usb_probe(struct usb_interface *interface,
553 	const struct usb_device_id *id)
554 {
555 	int ifnum;
556 	int retval = 0;
557 
558 	struct au0828_dev *dev;
559 	struct usb_device *usbdev = interface_to_usbdev(interface);
560 
561 	ifnum = interface->altsetting->desc.bInterfaceNumber;
562 
563 	if (ifnum != 0)
564 		return -ENODEV;
565 
566 	dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
567 		le16_to_cpu(usbdev->descriptor.idVendor),
568 		le16_to_cpu(usbdev->descriptor.idProduct),
569 		ifnum);
570 
571 	/*
572 	 * Make sure we have 480 Mbps of bandwidth, otherwise things like
573 	 * video stream wouldn't likely work, since 12 Mbps is generally
574 	 * not enough even for most Digital TV streams.
575 	 */
576 	if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
577 		pr_err("au0828: Device initialization failed.\n");
578 		pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
579 		return -ENODEV;
580 	}
581 
582 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
583 	if (dev == NULL) {
584 		pr_err("%s() Unable to allocate memory\n", __func__);
585 		return -ENOMEM;
586 	}
587 
588 	mutex_init(&dev->lock);
589 	mutex_lock(&dev->lock);
590 	mutex_init(&dev->mutex);
591 	mutex_init(&dev->dvb.lock);
592 	dev->usbdev = usbdev;
593 	dev->boardnr = id->driver_info;
594 	dev->board = au0828_boards[dev->boardnr];
595 
596 	/* Initialize the media controller */
597 	retval = au0828_media_device_init(dev, usbdev);
598 	if (retval) {
599 		pr_err("%s() au0828_media_device_init failed\n",
600 		       __func__);
601 		mutex_unlock(&dev->lock);
602 		kfree(dev);
603 		return retval;
604 	}
605 
606 	retval = au0828_v4l2_device_register(interface, dev);
607 	if (retval) {
608 		au0828_usb_v4l2_media_release(dev);
609 		mutex_unlock(&dev->lock);
610 		kfree(dev);
611 		return retval;
612 	}
613 
614 	/* Power Up the bridge */
615 	au0828_write(dev, REG_600, 1 << 4);
616 
617 	/* Bring up the GPIO's and supporting devices */
618 	au0828_gpio_setup(dev);
619 
620 	/* I2C */
621 	au0828_i2c_register(dev);
622 
623 	/* Setup */
624 	au0828_card_setup(dev);
625 
626 	/* Analog TV */
627 	retval = au0828_analog_register(dev, interface);
628 	if (retval) {
629 		pr_err("%s() au0282_dev_register failed to register on V4L2\n",
630 			__func__);
631 		goto done;
632 	}
633 
634 	/* Digital TV */
635 	retval = au0828_dvb_register(dev);
636 	if (retval)
637 		pr_err("%s() au0282_dev_register failed\n",
638 		       __func__);
639 
640 	/* Remote controller */
641 	au0828_rc_register(dev);
642 
643 	/*
644 	 * Store the pointer to the au0828_dev so it can be accessed in
645 	 * au0828_usb_disconnect
646 	 */
647 	usb_set_intfdata(interface, dev);
648 
649 	pr_info("Registered device AU0828 [%s]\n",
650 		dev->board.name == NULL ? "Unset" : dev->board.name);
651 
652 	mutex_unlock(&dev->lock);
653 
654 	retval = au0828_media_device_register(dev, usbdev);
655 
656 done:
657 	if (retval < 0)
658 		au0828_usb_disconnect(interface);
659 
660 	return retval;
661 }
662 
663 static int au0828_suspend(struct usb_interface *interface,
664 				pm_message_t message)
665 {
666 	struct au0828_dev *dev = usb_get_intfdata(interface);
667 
668 	if (!dev)
669 		return 0;
670 
671 	pr_info("Suspend\n");
672 
673 	au0828_rc_suspend(dev);
674 	au0828_v4l2_suspend(dev);
675 	au0828_dvb_suspend(dev);
676 
677 	/* FIXME: should suspend also ATV/DTV */
678 
679 	return 0;
680 }
681 
682 static int au0828_resume(struct usb_interface *interface)
683 {
684 	struct au0828_dev *dev = usb_get_intfdata(interface);
685 	if (!dev)
686 		return 0;
687 
688 	pr_info("Resume\n");
689 
690 	/* Power Up the bridge */
691 	au0828_write(dev, REG_600, 1 << 4);
692 
693 	/* Bring up the GPIO's and supporting devices */
694 	au0828_gpio_setup(dev);
695 
696 	au0828_rc_resume(dev);
697 	au0828_v4l2_resume(dev);
698 	au0828_dvb_resume(dev);
699 
700 	/* FIXME: should resume also ATV/DTV */
701 
702 	return 0;
703 }
704 
705 static struct usb_driver au0828_usb_driver = {
706 	.name		= KBUILD_MODNAME,
707 	.probe		= au0828_usb_probe,
708 	.disconnect	= au0828_usb_disconnect,
709 	.id_table	= au0828_usb_id_table,
710 	.suspend	= au0828_suspend,
711 	.resume		= au0828_resume,
712 	.reset_resume	= au0828_resume,
713 };
714 
715 static int __init au0828_init(void)
716 {
717 	int ret;
718 
719 	if (au0828_debug & 1)
720 		pr_info("%s() Debugging is enabled\n", __func__);
721 
722 	if (au0828_debug & 2)
723 		pr_info("%s() USB Debugging is enabled\n", __func__);
724 
725 	if (au0828_debug & 4)
726 		pr_info("%s() I2C Debugging is enabled\n", __func__);
727 
728 	if (au0828_debug & 8)
729 		pr_info("%s() Bridge Debugging is enabled\n",
730 		       __func__);
731 
732 	if (au0828_debug & 16)
733 		pr_info("%s() IR Debugging is enabled\n",
734 		       __func__);
735 
736 	pr_info("au0828 driver loaded\n");
737 
738 	ret = usb_register(&au0828_usb_driver);
739 	if (ret)
740 		pr_err("usb_register failed, error = %d\n", ret);
741 
742 	return ret;
743 }
744 
745 static void __exit au0828_exit(void)
746 {
747 	usb_deregister(&au0828_usb_driver);
748 }
749 
750 module_init(au0828_init);
751 module_exit(au0828_exit);
752 
753 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
754 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
755 MODULE_LICENSE("GPL");
756 MODULE_VERSION("0.0.3");
757