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