1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * STK1160 driver
4  *
5  * Copyright (C) 2012 Ezequiel Garcia
6  * <elezegarcia--a.t--gmail.com>
7  *
8  * Based on Easycap driver by R.M. Thomas
9  *	Copyright (C) 2010 R.M. Thomas
10  *	<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 
31 static unsigned int input;
32 module_param(input, int, 0644);
33 MODULE_PARM_DESC(input, "Set default input");
34 
35 MODULE_LICENSE("GPL");
36 MODULE_AUTHOR("Ezequiel Garcia");
37 MODULE_DESCRIPTION("STK1160 driver");
38 
39 /* Devices supported by this driver */
40 static const struct usb_device_id stk1160_id_table[] = {
41 	{ USB_DEVICE(0x05e1, 0x0408) },
42 	{ }
43 };
44 MODULE_DEVICE_TABLE(usb, stk1160_id_table);
45 
46 /* saa7113 I2C address */
47 static unsigned short saa7113_addrs[] = {
48 	0x4a >> 1,
49 	I2C_CLIENT_END
50 };
51 
52 /*
53  * Read/Write stk registers
54  */
55 int 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 
81 int 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 
98 void stk1160_select_input(struct stk1160 *dev)
99 {
100 	int route;
101 	static const u8 gctrl[] = {
102 		0x98, 0x90, 0x88, 0x80, 0x98
103 	};
104 
105 	if (dev->ctl_input == STK1160_SVIDEO_INPUT)
106 		route = SAA7115_SVIDEO3;
107 	else
108 		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 */
118 static 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 
150 static 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 array
171  * with information on each alternate setting.
172  * The array should be allocated by the caller.
173  */
174 static 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 like
254 	 * video stream wouldn't likely work, since 12 Mbps is generally
255 	 * 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 
264 static 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 probe
322 	 * 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 defer
336 	 * registration of video device node as the last thing.
337 	 * There is no need to set the name if we give a device struct
338 	 */
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 have
353 	 * 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 
376 unreg_i2c:
377 	stk1160_i2c_unregister(dev);
378 unreg_v4l2:
379 	v4l2_device_unregister(&dev->v4l2_dev);
380 free_ctrl:
381 	v4l2_ctrl_handler_free(&dev->ctrl_handler);
382 free_err:
383 	kfree(alt_max_pkt_size);
384 	kfree(dev);
385 
386 	return rc;
387 }
388 
389 static 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 finished
398 	 * then deallocate resources
399 	 */
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);
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 
424 static 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 
431 module_usb_driver(stk1160_usb_driver);
432