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