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  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21 
22 #include "au0828.h"
23 
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/videodev2.h>
27 #include <media/v4l2-common.h>
28 #include <linux/mutex.h>
29 
30 /* Due to enum tuner_pad_index */
31 #include <media/tuner.h>
32 
33 /*
34  * 1 = General debug messages
35  * 2 = USB handling
36  * 4 = I2C related
37  * 8 = Bridge related
38  * 16 = IR related
39  */
40 int au0828_debug;
41 module_param_named(debug, au0828_debug, int, 0644);
42 MODULE_PARM_DESC(debug,
43 		 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");
44 
45 static unsigned int disable_usb_speed_check;
46 module_param(disable_usb_speed_check, int, 0444);
47 MODULE_PARM_DESC(disable_usb_speed_check,
48 		 "override min bandwidth requirement of 480M bps");
49 
50 #define _AU0828_BULKPIPE 0x03
51 #define _BULKPIPESIZE 0xffff
52 
53 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
54 			    u16 index);
55 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
56 	u16 index, unsigned char *cp, u16 size);
57 
58 /* USB Direction */
59 #define CMD_REQUEST_IN		0x00
60 #define CMD_REQUEST_OUT		0x01
61 
62 u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
63 {
64 	u8 result = 0;
65 
66 	recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1);
67 	dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result);
68 
69 	return result;
70 }
71 
72 u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
73 {
74 	dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val);
75 	return send_control_msg(dev, CMD_REQUEST_OUT, val, reg);
76 }
77 
78 static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
79 	u16 index)
80 {
81 	int status = -ENODEV;
82 
83 	if (dev->usbdev) {
84 
85 		/* cp must be memory that has been allocated by kmalloc */
86 		status = usb_control_msg(dev->usbdev,
87 				usb_sndctrlpipe(dev->usbdev, 0),
88 				request,
89 				USB_DIR_OUT | USB_TYPE_VENDOR |
90 					USB_RECIP_DEVICE,
91 				value, index, NULL, 0, 1000);
92 
93 		status = min(status, 0);
94 
95 		if (status < 0) {
96 			pr_err("%s() Failed sending control message, error %d.\n",
97 				__func__, status);
98 		}
99 
100 	}
101 
102 	return status;
103 }
104 
105 static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
106 	u16 index, unsigned char *cp, u16 size)
107 {
108 	int status = -ENODEV;
109 	mutex_lock(&dev->mutex);
110 	if (dev->usbdev) {
111 		status = usb_control_msg(dev->usbdev,
112 				usb_rcvctrlpipe(dev->usbdev, 0),
113 				request,
114 				USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
115 				value, index,
116 				dev->ctrlmsg, size, 1000);
117 
118 		status = min(status, 0);
119 
120 		if (status < 0) {
121 			pr_err("%s() Failed receiving control message, error %d.\n",
122 				__func__, status);
123 		}
124 
125 		/* the host controller requires heap allocated memory, which
126 		   is why we didn't just pass "cp" into usb_control_msg */
127 		memcpy(cp, dev->ctrlmsg, size);
128 	}
129 	mutex_unlock(&dev->mutex);
130 	return status;
131 }
132 
133 static void au0828_unregister_media_device(struct au0828_dev *dev)
134 {
135 
136 #ifdef CONFIG_MEDIA_CONTROLLER
137 	if (dev->media_dev &&
138 		media_devnode_is_registered(&dev->media_dev->devnode)) {
139 		media_device_unregister(dev->media_dev);
140 		media_device_cleanup(dev->media_dev);
141 		dev->media_dev = NULL;
142 	}
143 #endif
144 }
145 
146 void au0828_usb_release(struct au0828_dev *dev)
147 {
148 	au0828_unregister_media_device(dev);
149 
150 	/* I2C */
151 	au0828_i2c_unregister(dev);
152 
153 	kfree(dev);
154 }
155 
156 static void au0828_usb_disconnect(struct usb_interface *interface)
157 {
158 	struct au0828_dev *dev = usb_get_intfdata(interface);
159 
160 	dprintk(1, "%s()\n", __func__);
161 
162 	/* there is a small window after disconnect, before
163 	   dev->usbdev is NULL, for poll (e.g: IR) try to access
164 	   the device and fill the dmesg with error messages.
165 	   Set the status so poll routines can check and avoid
166 	   access after disconnect.
167 	*/
168 	dev->dev_state = DEV_DISCONNECTED;
169 
170 	au0828_rc_unregister(dev);
171 	/* Digital TV */
172 	au0828_dvb_unregister(dev);
173 
174 	usb_set_intfdata(interface, NULL);
175 	mutex_lock(&dev->mutex);
176 	dev->usbdev = NULL;
177 	mutex_unlock(&dev->mutex);
178 	if (au0828_analog_unregister(dev)) {
179 		/*
180 		 * No need to call au0828_usb_release() if V4L2 is enabled,
181 		 * as this is already called via au0828_usb_v4l2_release()
182 		 */
183 		return;
184 	}
185 	au0828_usb_release(dev);
186 }
187 
188 static int au0828_media_device_init(struct au0828_dev *dev,
189 				    struct usb_device *udev)
190 {
191 #ifdef CONFIG_MEDIA_CONTROLLER
192 	struct media_device *mdev;
193 
194 	mdev = media_device_get_devres(&udev->dev);
195 	if (!mdev)
196 		return -ENOMEM;
197 
198 	media_device_usb_init(mdev, udev, udev->product);
199 
200 	dev->media_dev = mdev;
201 #endif
202 	return 0;
203 }
204 
205 
206 static int au0828_usb_probe(struct usb_interface *interface,
207 	const struct usb_device_id *id)
208 {
209 	int ifnum;
210 	int retval = 0;
211 
212 	struct au0828_dev *dev;
213 	struct usb_device *usbdev = interface_to_usbdev(interface);
214 
215 	ifnum = interface->altsetting->desc.bInterfaceNumber;
216 
217 	if (ifnum != 0)
218 		return -ENODEV;
219 
220 	dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
221 		le16_to_cpu(usbdev->descriptor.idVendor),
222 		le16_to_cpu(usbdev->descriptor.idProduct),
223 		ifnum);
224 
225 	/*
226 	 * Make sure we have 480 Mbps of bandwidth, otherwise things like
227 	 * video stream wouldn't likely work, since 12 Mbps is generally
228 	 * not enough even for most Digital TV streams.
229 	 */
230 	if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
231 		pr_err("au0828: Device initialization failed.\n");
232 		pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
233 		return -ENODEV;
234 	}
235 
236 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
237 	if (dev == NULL) {
238 		pr_err("%s() Unable to allocate memory\n", __func__);
239 		return -ENOMEM;
240 	}
241 
242 	mutex_init(&dev->lock);
243 	mutex_lock(&dev->lock);
244 	mutex_init(&dev->mutex);
245 	mutex_init(&dev->dvb.lock);
246 	dev->usbdev = usbdev;
247 	dev->boardnr = id->driver_info;
248 	dev->board = au0828_boards[dev->boardnr];
249 
250 	/* Initialize the media controller */
251 	retval = au0828_media_device_init(dev, usbdev);
252 	if (retval) {
253 		pr_err("%s() au0828_media_device_init failed\n",
254 		       __func__);
255 		mutex_unlock(&dev->lock);
256 		kfree(dev);
257 		return retval;
258 	}
259 
260 	retval = au0828_v4l2_device_register(interface, dev);
261 	if (retval) {
262 		au0828_usb_v4l2_media_release(dev);
263 		mutex_unlock(&dev->lock);
264 		kfree(dev);
265 		return retval;
266 	}
267 
268 	/* Power Up the bridge */
269 	au0828_write(dev, REG_600, 1 << 4);
270 
271 	/* Bring up the GPIO's and supporting devices */
272 	au0828_gpio_setup(dev);
273 
274 	/* I2C */
275 	au0828_i2c_register(dev);
276 
277 	/* Setup */
278 	au0828_card_setup(dev);
279 
280 	/* Analog TV */
281 	retval = au0828_analog_register(dev, interface);
282 	if (retval) {
283 		pr_err("%s() au0282_dev_register failed to register on V4L2\n",
284 			__func__);
285 		goto done;
286 	}
287 
288 	/* Digital TV */
289 	retval = au0828_dvb_register(dev);
290 	if (retval)
291 		pr_err("%s() au0282_dev_register failed\n",
292 		       __func__);
293 
294 	/* Remote controller */
295 	au0828_rc_register(dev);
296 
297 	/*
298 	 * Store the pointer to the au0828_dev so it can be accessed in
299 	 * au0828_usb_disconnect
300 	 */
301 	usb_set_intfdata(interface, dev);
302 
303 	pr_info("Registered device AU0828 [%s]\n",
304 		dev->board.name == NULL ? "Unset" : dev->board.name);
305 
306 	mutex_unlock(&dev->lock);
307 
308 #ifdef CONFIG_MEDIA_CONTROLLER
309 	retval = media_device_register(dev->media_dev);
310 #endif
311 
312 done:
313 	if (retval < 0)
314 		au0828_usb_disconnect(interface);
315 
316 	return retval;
317 }
318 
319 static int au0828_suspend(struct usb_interface *interface,
320 				pm_message_t message)
321 {
322 	struct au0828_dev *dev = usb_get_intfdata(interface);
323 
324 	if (!dev)
325 		return 0;
326 
327 	pr_info("Suspend\n");
328 
329 	au0828_rc_suspend(dev);
330 	au0828_v4l2_suspend(dev);
331 	au0828_dvb_suspend(dev);
332 
333 	/* FIXME: should suspend also ATV/DTV */
334 
335 	return 0;
336 }
337 
338 static int au0828_resume(struct usb_interface *interface)
339 {
340 	struct au0828_dev *dev = usb_get_intfdata(interface);
341 	if (!dev)
342 		return 0;
343 
344 	pr_info("Resume\n");
345 
346 	/* Power Up the bridge */
347 	au0828_write(dev, REG_600, 1 << 4);
348 
349 	/* Bring up the GPIO's and supporting devices */
350 	au0828_gpio_setup(dev);
351 
352 	au0828_rc_resume(dev);
353 	au0828_v4l2_resume(dev);
354 	au0828_dvb_resume(dev);
355 
356 	/* FIXME: should resume also ATV/DTV */
357 
358 	return 0;
359 }
360 
361 static struct usb_driver au0828_usb_driver = {
362 	.name		= KBUILD_MODNAME,
363 	.probe		= au0828_usb_probe,
364 	.disconnect	= au0828_usb_disconnect,
365 	.id_table	= au0828_usb_id_table,
366 	.suspend	= au0828_suspend,
367 	.resume		= au0828_resume,
368 	.reset_resume	= au0828_resume,
369 };
370 
371 static int __init au0828_init(void)
372 {
373 	int ret;
374 
375 	if (au0828_debug & 1)
376 		pr_info("%s() Debugging is enabled\n", __func__);
377 
378 	if (au0828_debug & 2)
379 		pr_info("%s() USB Debugging is enabled\n", __func__);
380 
381 	if (au0828_debug & 4)
382 		pr_info("%s() I2C Debugging is enabled\n", __func__);
383 
384 	if (au0828_debug & 8)
385 		pr_info("%s() Bridge Debugging is enabled\n",
386 		       __func__);
387 
388 	if (au0828_debug & 16)
389 		pr_info("%s() IR Debugging is enabled\n",
390 		       __func__);
391 
392 	pr_info("au0828 driver loaded\n");
393 
394 	ret = usb_register(&au0828_usb_driver);
395 	if (ret)
396 		pr_err("usb_register failed, error = %d\n", ret);
397 
398 	return ret;
399 }
400 
401 static void __exit au0828_exit(void)
402 {
403 	usb_deregister(&au0828_usb_driver);
404 }
405 
406 module_init(au0828_init);
407 module_exit(au0828_exit);
408 
409 MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
410 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
411 MODULE_LICENSE("GPL");
412 MODULE_VERSION("0.0.3");
413