Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/media/usb/stk1160/stk1160-core.c

  1 /*
  2  * STK1160 driver
  3  *
  4  * Copyright (C) 2012 Ezequiel Garcia
  5  * <elezegarcia--a.t--gmail.com>
  6  *
  7  * Based on Easycap driver by R.M. Thomas
  8  *      Copyright (C) 2010 R.M. Thomas
  9  *      <rmthomas--a.t--sciolus.org>
 10  *
 11  * This program is free software; you can redistribute it and/or modify
 12  * it under the terms of the GNU General Public License as published by
 13  * the Free Software Foundation; either version 2 of the License, or
 14  * (at your option) any later version.
 15  *
 16  * This program is distributed in the hope that it will be useful,
 17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19  * GNU General Public License for more details.
 20  *
 21  * TODO:
 22  *
 23  * 1. (Try to) detect if we must register ac97 mixer
 24  * 2. Support stream at lower speed: lower frame rate or lower frame size.
 25  *
 26  */
 27 
 28 #include <linux/module.h>
 29 #include <linux/init.h>
 30 #include <linux/kernel.h>
 31 #include <linux/errno.h>
 32 #include <linux/slab.h>
 33 
 34 #include <linux/usb.h>
 35 #include <linux/mm.h>
 36 #include <linux/vmalloc.h>
 37 #include <media/saa7115.h>
 38 
 39 #include "stk1160.h"
 40 #include "stk1160-reg.h"
 41 
 42 static unsigned int input;
 43 module_param(input, int, 0644);
 44 MODULE_PARM_DESC(input, "Set default input");
 45 
 46 MODULE_LICENSE("GPL");
 47 MODULE_AUTHOR("Ezequiel Garcia");
 48 MODULE_DESCRIPTION("STK1160 driver");
 49 
 50 /* Devices supported by this driver */
 51 static struct usb_device_id stk1160_id_table[] = {
 52         { USB_DEVICE(0x05e1, 0x0408) },
 53         { }
 54 };
 55 MODULE_DEVICE_TABLE(usb, stk1160_id_table);
 56 
 57 /* saa7113 I2C address */
 58 static unsigned short saa7113_addrs[] = {
 59         0x4a >> 1,
 60         I2C_CLIENT_END
 61 };
 62 
 63 /*
 64  * Read/Write stk registers
 65  */
 66 int stk1160_read_reg(struct stk1160 *dev, u16 reg, u8 *value)
 67 {
 68         int ret;
 69         int pipe = usb_rcvctrlpipe(dev->udev, 0);
 70         u8 *buf;
 71 
 72         *value = 0;
 73 
 74         buf = kmalloc(sizeof(u8), GFP_KERNEL);
 75         if (!buf)
 76                 return -ENOMEM;
 77         ret = usb_control_msg(dev->udev, pipe, 0x00,
 78                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 79                         0x00, reg, buf, sizeof(u8), HZ);
 80         if (ret < 0) {
 81                 stk1160_err("read failed on reg 0x%x (%d)\n",
 82                         reg, ret);
 83                 kfree(buf);
 84                 return ret;
 85         }
 86 
 87         *value = *buf;
 88         kfree(buf);
 89         return 0;
 90 }
 91 
 92 int stk1160_write_reg(struct stk1160 *dev, u16 reg, u16 value)
 93 {
 94         int ret;
 95         int pipe = usb_sndctrlpipe(dev->udev, 0);
 96 
 97         ret =  usb_control_msg(dev->udev, pipe, 0x01,
 98                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 99                         value, reg, NULL, 0, HZ);
100         if (ret < 0) {
101                 stk1160_err("write failed on reg 0x%x (%d)\n",
102                         reg, ret);
103                 return ret;
104         }
105 
106         return 0;
107 }
108 
109 void stk1160_select_input(struct stk1160 *dev)
110 {
111         int route;
112         static const u8 gctrl[] = {
113                 0x98, 0x90, 0x88, 0x80, 0x98
114         };
115 
116         if (dev->ctl_input == STK1160_SVIDEO_INPUT)
117                 route = SAA7115_SVIDEO3;
118         else
119                 route = SAA7115_COMPOSITE0;
120 
121         if (dev->ctl_input < ARRAY_SIZE(gctrl)) {
122                 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
123                                 route, 0, 0);
124                 stk1160_write_reg(dev, STK1160_GCTRL, gctrl[dev->ctl_input]);
125         }
126 }
127 
128 /* TODO: We should break this into pieces */
129 static void stk1160_reg_reset(struct stk1160 *dev)
130 {
131         int i;
132 
133         static const struct regval ctl[] = {
134                 {STK1160_GCTRL+2, 0x0078},
135 
136                 {STK1160_RMCTL+1, 0x0000},
137                 {STK1160_RMCTL+3, 0x0002},
138 
139                 {STK1160_PLLSO,   0x0010},
140                 {STK1160_PLLSO+1, 0x0000},
141                 {STK1160_PLLSO+2, 0x0014},
142                 {STK1160_PLLSO+3, 0x000E},
143 
144                 {STK1160_PLLFD,   0x0046},
145 
146                 /* Timing generator setup */
147                 {STK1160_TIGEN,   0x0012},
148                 {STK1160_TICTL,   0x002D},
149                 {STK1160_TICTL+1, 0x0001},
150                 {STK1160_TICTL+2, 0x0000},
151                 {STK1160_TICTL+3, 0x0000},
152                 {STK1160_TIGEN,   0x0080},
153 
154                 {0xffff, 0xffff}
155         };
156 
157         for (i = 0; ctl[i].reg != 0xffff; i++)
158                 stk1160_write_reg(dev, ctl[i].reg, ctl[i].val);
159 }
160 
161 static void stk1160_release(struct v4l2_device *v4l2_dev)
162 {
163         struct stk1160 *dev = container_of(v4l2_dev, struct stk1160, v4l2_dev);
164 
165         stk1160_info("releasing all resources\n");
166 
167         stk1160_i2c_unregister(dev);
168 
169         v4l2_ctrl_handler_free(&dev->ctrl_handler);
170         v4l2_device_unregister(&dev->v4l2_dev);
171         kfree(dev->alt_max_pkt_size);
172         kfree(dev);
173 }
174 
175 /* high bandwidth multiplier, as encoded in highspeed endpoint descriptors */
176 #define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03))
177 
178 /*
179  * Scan usb interface and populate max_pkt_size array
180  * with information on each alternate setting.
181  * The array should be allocated by the caller.
182  */
183 static int stk1160_scan_usb(struct usb_interface *intf, struct usb_device *udev,
184                 unsigned int *max_pkt_size)
185 {
186         int i, e, sizedescr, size, ifnum;
187         const struct usb_endpoint_descriptor *desc;
188 
189         bool has_video = false, has_audio = false;
190         const char *speed;
191 
192         ifnum = intf->altsetting[0].desc.bInterfaceNumber;
193 
194         /* Get endpoints */
195         for (i = 0; i < intf->num_altsetting; i++) {
196 
197                 for (e = 0; e < intf->altsetting[i].desc.bNumEndpoints; e++) {
198 
199                         /* This isn't clear enough, at least to me */
200                         desc = &intf->altsetting[i].endpoint[e].desc;
201                         sizedescr = le16_to_cpu(desc->wMaxPacketSize);
202                         size = sizedescr & 0x7ff;
203 
204                         if (udev->speed == USB_SPEED_HIGH)
205                                 size = size * hb_mult(sizedescr);
206 
207                         if (usb_endpoint_xfer_isoc(desc) &&
208                             usb_endpoint_dir_in(desc)) {
209                                 switch (desc->bEndpointAddress) {
210                                 case STK1160_EP_AUDIO:
211                                         has_audio = true;
212                                         break;
213                                 case STK1160_EP_VIDEO:
214                                         has_video = true;
215                                         max_pkt_size[i] = size;
216                                         break;
217                                 }
218                         }
219                 }
220         }
221 
222         /* Is this even possible? */
223         if (!(has_audio || has_video)) {
224                 dev_err(&udev->dev, "no audio or video endpoints found\n");
225                 return -ENODEV;
226         }
227 
228         switch (udev->speed) {
229         case USB_SPEED_LOW:
230                 speed = "1.5";
231                 break;
232         case USB_SPEED_FULL:
233                 speed = "12";
234                 break;
235         case USB_SPEED_HIGH:
236                 speed = "480";
237                 break;
238         default:
239                 speed = "unknown";
240         }
241 
242         dev_info(&udev->dev, "New device %s %s @ %s Mbps (%04x:%04x, interface %d, class %d)\n",
243                 udev->manufacturer ? udev->manufacturer : "",
244                 udev->product ? udev->product : "",
245                 speed,
246                 le16_to_cpu(udev->descriptor.idVendor),
247                 le16_to_cpu(udev->descriptor.idProduct),
248                 ifnum,
249                 intf->altsetting->desc.bInterfaceNumber);
250 
251         /* This should never happen, since we rejected audio interfaces */
252         if (has_audio)
253                 dev_warn(&udev->dev, "audio interface %d found.\n\
254                                 This is not implemented by this driver,\
255                                 you should use snd-usb-audio instead\n", ifnum);
256 
257         if (has_video)
258                 dev_info(&udev->dev, "video interface %d found\n",
259                                 ifnum);
260 
261         /*
262          * Make sure we have 480 Mbps of bandwidth, otherwise things like
263          * video stream wouldn't likely work, since 12 Mbps is generally
264          * not enough even for most streams.
265          */
266         if (udev->speed != USB_SPEED_HIGH)
267                 dev_warn(&udev->dev, "must be connected to a high-speed USB 2.0 port\n\
268                                 You may not be able to stream video smoothly\n");
269 
270         return 0;
271 }
272 
273 static int stk1160_probe(struct usb_interface *interface,
274                 const struct usb_device_id *id)
275 {
276         int rc = 0;
277 
278         unsigned int *alt_max_pkt_size; /* array of wMaxPacketSize */
279         struct usb_device *udev;
280         struct stk1160 *dev;
281 
282         udev = interface_to_usbdev(interface);
283 
284         /*
285          * Since usb audio class is supported by snd-usb-audio,
286          * we reject audio interface.
287          */
288         if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO)
289                 return -ENODEV;
290 
291         /* Alloc an array for all possible max_pkt_size */
292         alt_max_pkt_size = kmalloc(sizeof(alt_max_pkt_size[0]) *
293                         interface->num_altsetting, GFP_KERNEL);
294         if (alt_max_pkt_size == NULL)
295                 return -ENOMEM;
296 
297         /*
298          * Scan usb posibilities and populate alt_max_pkt_size array.
299          * Also, check if device speed is fast enough.
300          */
301         rc = stk1160_scan_usb(interface, udev, alt_max_pkt_size);
302         if (rc < 0) {
303                 kfree(alt_max_pkt_size);
304                 return rc;
305         }
306 
307         dev = kzalloc(sizeof(struct stk1160), GFP_KERNEL);
308         if (dev == NULL) {
309                 kfree(alt_max_pkt_size);
310                 return -ENOMEM;
311         }
312 
313         dev->alt_max_pkt_size = alt_max_pkt_size;
314         dev->udev = udev;
315         dev->num_alt = interface->num_altsetting;
316         dev->ctl_input = input;
317 
318         /* We save struct device for debug purposes only */
319         dev->dev = &interface->dev;
320 
321         usb_set_intfdata(interface, dev);
322 
323         /* initialize videobuf2 stuff */
324         rc = stk1160_vb2_setup(dev);
325         if (rc < 0)
326                 goto free_err;
327 
328         /*
329          * There is no need to take any locks here in probe
330          * because we register the device node as the *last* thing.
331          */
332         spin_lock_init(&dev->buf_lock);
333         mutex_init(&dev->v4l_lock);
334         mutex_init(&dev->vb_queue_lock);
335 
336         rc = v4l2_ctrl_handler_init(&dev->ctrl_handler, 0);
337         if (rc) {
338                 stk1160_err("v4l2_ctrl_handler_init failed (%d)\n", rc);
339                 goto free_err;
340         }
341 
342         /*
343          * We obtain a v4l2_dev but defer
344          * registration of video device node as the last thing.
345          * There is no need to set the name if we give a device struct
346          */
347         dev->v4l2_dev.release = stk1160_release;
348         dev->v4l2_dev.ctrl_handler = &dev->ctrl_handler;
349         rc = v4l2_device_register(dev->dev, &dev->v4l2_dev);
350         if (rc) {
351                 stk1160_err("v4l2_device_register failed (%d)\n", rc);
352                 goto free_ctrl;
353         }
354 
355         rc = stk1160_i2c_register(dev);
356         if (rc < 0)
357                 goto unreg_v4l2;
358 
359         /*
360          * To the best of my knowledge stk1160 boards only have
361          * saa7113, but it doesn't hurt to support them all.
362          */
363         dev->sd_saa7115 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
364                 "saa7115_auto", 0, saa7113_addrs);
365 
366         stk1160_info("driver ver %s successfully loaded\n",
367                 STK1160_VERSION);
368 
369         /* i2c reset saa711x */
370         v4l2_device_call_all(&dev->v4l2_dev, 0, core, reset, 0);
371         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
372 
373         /* reset stk1160 to default values */
374         stk1160_reg_reset(dev);
375 
376         /* select default input */
377         stk1160_select_input(dev);
378 
379         stk1160_ac97_register(dev);
380 
381         rc = stk1160_video_register(dev);
382         if (rc < 0)
383                 goto unreg_i2c;
384 
385         return 0;
386 
387 unreg_i2c:
388         stk1160_i2c_unregister(dev);
389 unreg_v4l2:
390         v4l2_device_unregister(&dev->v4l2_dev);
391 free_ctrl:
392         v4l2_ctrl_handler_free(&dev->ctrl_handler);
393 free_err:
394         kfree(alt_max_pkt_size);
395         kfree(dev);
396 
397         return rc;
398 }
399 
400 static void stk1160_disconnect(struct usb_interface *interface)
401 {
402         struct stk1160 *dev;
403 
404         dev = usb_get_intfdata(interface);
405         usb_set_intfdata(interface, NULL);
406 
407         /*
408          * Wait until all current v4l2 operation are finished
409          * then deallocate resources
410          */
411         mutex_lock(&dev->vb_queue_lock);
412         mutex_lock(&dev->v4l_lock);
413 
414         /* Here is the only place where isoc get released */
415         stk1160_uninit_isoc(dev);
416 
417         /* ac97 unregister needs to be done before usb_device is cleared */
418         stk1160_ac97_unregister(dev);
419 
420         stk1160_clear_queue(dev);
421 
422         video_unregister_device(&dev->vdev);
423         v4l2_device_disconnect(&dev->v4l2_dev);
424 
425         /* This way current users can detect device is gone */
426         dev->udev = NULL;
427 
428         mutex_unlock(&dev->v4l_lock);
429         mutex_unlock(&dev->vb_queue_lock);
430 
431         /*
432          * This calls stk1160_release if it's the last reference.
433          * therwise, release is posponed until there are no users left.
434          */
435         v4l2_device_put(&dev->v4l2_dev);
436 }
437 
438 static struct usb_driver stk1160_usb_driver = {
439         .name = "stk1160",
440         .id_table = stk1160_id_table,
441         .probe = stk1160_probe,
442         .disconnect = stk1160_disconnect,
443 };
444 
445 module_usb_driver(stk1160_usb_driver);
446 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us