1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3
4	bttv - Bt848 frame grabber driver
5
6	Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
7	& Marcus Metzler <mocm@thp.uni-koeln.de>
8	(c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9
10	some v4l2 code lines are taken from Justin's bttv2 driver which is
11	(c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
12
13	V4L1 removal from:
14	(c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
15
16	Fixes to be fully V4L2 compliant by
17	(c) 2006 Mauro Carvalho Chehab <mchehab@kernel.org>
18
19	Cropping and overscan support
20	Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
21	Sponsored by OPQ Systems AB
22
23	*/
24
25	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27	#include <linux/init.h>
28	#include <linux/module.h>
29	#include <linux/delay.h>
30	#include <linux/slab.h>
31	#include <linux/errno.h>
32	#include <linux/fs.h>
33	#include <linux/kernel.h>
34	#include <linux/sched.h>
35	#include <linux/interrupt.h>
36	#include <linux/kdev_t.h>
37	#include "bttvp.h"
38	#include <media/v4l2-common.h>
39	#include <media/v4l2-ioctl.h>
40	#include <media/v4l2-event.h>
41	#include <media/i2c/tvaudio.h>
42	#include <media/drv-intf/msp3400.h>
43
44	#include <linux/dma-mapping.h>
45
46	#include <asm/io.h>
47	#include <asm/byteorder.h>
48
49	#include <media/i2c/saa6588.h>
50
51	#define BTTV_VERSION "0.9.19"
52
53	unsigned int bttv_num; /* number of Bt848s in use */
54	struct bttv *bttvs[BTTV_MAX];
55
56	unsigned int bttv_debug;
57	unsigned int bttv_verbose = 1;
58	unsigned int bttv_gpio;
59
60	/* config variables */
61	#ifdef __BIG_ENDIAN
62	static unsigned int bigendian=1;
63	#else
64	static unsigned int bigendian;
65	#endif
66	static unsigned int radio[BTTV_MAX];
67	static unsigned int irq_debug;
68	static unsigned int gbuffers = 8;
69	static unsigned int gbufsize = 0x208000;
70	static unsigned int reset_crop = 1;
71
72	static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
73	static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
74	static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
75	static int debug_latency;
76	static int disable_ir;
77
78	static unsigned int fdsr;
79
80	/* options */
81	static unsigned int combfilter;
82	static unsigned int lumafilter;
83	static unsigned int automute = 1;
84	static unsigned int chroma_agc;
85	static unsigned int agc_crush = 1;
86	static unsigned int whitecrush_upper = 0xCF;
87	static unsigned int whitecrush_lower = 0x7F;
88	static unsigned int vcr_hack;
89	static unsigned int irq_iswitch;
90	static unsigned int uv_ratio = 50;
91	static unsigned int full_luma_range;
92	static unsigned int coring;
93
94	/* API features (turn on/off stuff for testing) */
95	static unsigned int v4l2 = 1;
96
97	/* insmod args */
98	module_param(bttv_verbose, int, 0644);
99	module_param(bttv_gpio, int, 0644);
100	module_param(bttv_debug, int, 0644);
101	module_param(irq_debug, int, 0644);
102	module_param(debug_latency, int, 0644);
103	module_param(disable_ir, int, 0444);
104
105	module_param(fdsr, int, 0444);
106	module_param(gbuffers, int, 0444);
107	module_param(gbufsize, int, 0444);
108	module_param(reset_crop, int, 0444);
109
110	module_param(v4l2, int, 0644);
111	module_param(bigendian, int, 0644);
112	module_param(irq_iswitch, int, 0644);
113	module_param(combfilter, int, 0444);
114	module_param(lumafilter, int, 0444);
115	module_param(automute, int, 0444);
116	module_param(chroma_agc, int, 0444);
117	module_param(agc_crush, int, 0444);
118	module_param(whitecrush_upper, int, 0444);
119	module_param(whitecrush_lower, int, 0444);
120	module_param(vcr_hack, int, 0444);
121	module_param(uv_ratio, int, 0444);
122	module_param(full_luma_range, int, 0444);
123	module_param(coring, int, 0444);
124
125	module_param_array(radio, int, NULL, 0444);
126	module_param_array(video_nr, int, NULL, 0444);
127	module_param_array(radio_nr, int, NULL, 0444);
128	module_param_array(vbi_nr, int, NULL, 0444);
129
130	MODULE_PARM_DESC(radio, "The TV card supports radio, default is 0 (no)");
131	MODULE_PARM_DESC(bigendian, "byte order of the framebuffer, default is native endian");
132	MODULE_PARM_DESC(bttv_verbose, "verbose startup messages, default is 1 (yes)");
133	MODULE_PARM_DESC(bttv_gpio, "log gpio changes, default is 0 (no)");
134	MODULE_PARM_DESC(bttv_debug, "debug messages, default is 0 (no)");
135	MODULE_PARM_DESC(irq_debug, "irq handler debug messages, default is 0 (no)");
136	MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
137	MODULE_PARM_DESC(gbuffers, "number of capture buffers. range 2-32, default 8");
138	MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 0x208000");
139	MODULE_PARM_DESC(reset_crop, "reset cropping parameters at open(), default is 1 (yes) for compatibility with older applications");
140	MODULE_PARM_DESC(automute, "mute audio on bad/missing video signal, default is 1 (yes)");
141	MODULE_PARM_DESC(chroma_agc, "enables the AGC of chroma signal, default is 0 (no)");
142	MODULE_PARM_DESC(agc_crush, "enables the luminance AGC crush, default is 1 (yes)");
143	MODULE_PARM_DESC(whitecrush_upper, "sets the white crush upper value, default is 207");
144	MODULE_PARM_DESC(whitecrush_lower, "sets the white crush lower value, default is 127");
145	MODULE_PARM_DESC(vcr_hack, "enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
146	MODULE_PARM_DESC(irq_iswitch, "switch inputs in irq handler");
147	MODULE_PARM_DESC(uv_ratio, "ratio between u and v gains, default is 50");
148	MODULE_PARM_DESC(full_luma_range, "use the full luma range, default is 0 (no)");
149	MODULE_PARM_DESC(coring, "set the luma coring level, default is 0 (no)");
150	MODULE_PARM_DESC(video_nr, "video device numbers");
151	MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
152	MODULE_PARM_DESC(radio_nr, "radio device numbers");
153
154	MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
155	MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
156	MODULE_LICENSE("GPL");
157	MODULE_VERSION(BTTV_VERSION);
158
159	#define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_USER_BTTV_BASE + 0)
160	#define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_USER_BTTV_BASE + 1)
161	#define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_USER_BTTV_BASE + 2)
162	#define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_USER_BTTV_BASE + 3)
163	#define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_USER_BTTV_BASE + 4)
164	#define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_USER_BTTV_BASE + 5)
165	#define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_USER_BTTV_BASE + 6)
166	#define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_USER_BTTV_BASE + 7)
167	#define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_USER_BTTV_BASE + 8)
168	#define V4L2_CID_PRIVATE_CORING (V4L2_CID_USER_BTTV_BASE + 9)
169
170	/* ----------------------------------------------------------------------- */
171	/* sysfs */
172
173	static ssize_t card_show(struct device *cd,
174	struct device_attribute *attr, char *buf)
175	{
176	struct video_device *vfd = to_video_device(cd);
177	struct bttv *btv = video_get_drvdata(vdev: vfd);
178	return sprintf(buf, fmt: "%d\n", btv ? btv->c.type : UNSET);
179	}
180	static DEVICE_ATTR_RO(card);
181
182	/* ----------------------------------------------------------------------- */
183	/* dvb auto-load setup */
184	#if defined(CONFIG_MODULES) && defined(MODULE)
185	static void request_module_async(struct work_struct *work)
186	{
187	request_module("dvb-bt8xx");
188	}
189
190	static void request_modules(struct bttv *dev)
191	{
192	INIT_WORK(&dev->request_module_wk, request_module_async);
193	schedule_work(&dev->request_module_wk);
194	}
195
196	static void flush_request_modules(struct bttv *dev)
197	{
198	flush_work(&dev->request_module_wk);
199	}
200	#else
201	#define request_modules(dev)
202	#define flush_request_modules(dev) do {} while(0)
203	#endif /* CONFIG_MODULES */
204
205
206	/* ----------------------------------------------------------------------- */
207	/* static data */
208
209	/* special timing tables from conexant... */
210	static u8 SRAM_Table[][60] =
211	{
212	/* PAL digital input over GPIO[7:0] */
213	{
214	45, // 45 bytes following
215	0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
216	0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
217	0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
218	0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
219	0x37,0x00,0xAF,0x21,0x00
220	},
221	/* NTSC digital input over GPIO[7:0] */
222	{
223	51, // 51 bytes following
224	0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
225	0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
226	0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
227	0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
228	0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
229	0x00,
230	},
231	// TGB_NTSC392 // quartzsight
232	// This table has been modified to be used for Fusion Rev D
233	{
234	0x2A, // size of table = 42
235	0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
236	0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
237	0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
238	0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
239	0x20, 0x00
240	}
241	};
242
243	/* minhdelayx1 first video pixel we can capture on a line and
244	hdelayx1 start of active video, both relative to rising edge of
245	/HRESET pulse (0H) in 1 / fCLKx1.
246	swidth width of active video and
247	totalwidth total line width, both in 1 / fCLKx1.
248	sqwidth total line width in square pixels.
249	vdelay start of active video in 2 * field lines relative to
250	trailing edge of /VRESET pulse (VDELAY register).
251	sheight height of active video in 2 * field lines.
252	extraheight Added to sheight for cropcap.bounds.height only
253	videostart0 ITU-R frame line number of the line corresponding
254	to vdelay in the first field. */
255	#define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
256	vdelay, sheight, extraheight, videostart0) \
257	.cropcap.bounds.left = minhdelayx1, \
258	/* * 2 because vertically we count field lines times two, */ \
259	/* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
260	.cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
261	/* 4 is a safety margin at the end of the line. */ \
262	.cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
263	.cropcap.bounds.height = (sheight) + (extraheight) + (vdelay) - \
264	MIN_VDELAY, \
265	.cropcap.defrect.left = hdelayx1, \
266	.cropcap.defrect.top = (videostart0) * 2, \
267	.cropcap.defrect.width = swidth, \
268	.cropcap.defrect.height = sheight, \
269	.cropcap.pixelaspect.numerator = totalwidth, \
270	.cropcap.pixelaspect.denominator = sqwidth,
271
272	const struct bttv_tvnorm bttv_tvnorms[] = {
273	/* PAL-BDGHI */
274	/* max. active video is actually 922, but 924 is divisible by 4 and 3! */
275	/* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
276	{
277	.v4l2_id = V4L2_STD_PAL,
278	.name = "PAL",
279	.Fsc = 35468950,
280	.swidth = 924,
281	.sheight = 576,
282	.totalwidth = 1135,
283	.adelay = 0x7f,
284	.bdelay = 0x72,
285	.iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
286	.scaledtwidth = 1135,
287	.hdelayx1 = 186,
288	.hactivex1 = 924,
289	.vdelay = 0x20,
290	.vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */
291	.sram = 0,
292	/* ITU-R frame line number of the first VBI line
293	we can capture, of the first and second field.
294	The last line is determined by cropcap.bounds. */
295	.vbistart = { 7, 320 },
296	CROPCAP(/* minhdelayx1 */ 68,
297	/* hdelayx1 */ 186,
298	/* Should be (768 * 1135 + 944 / 2) / 944.
299	cropcap.defrect is used for image width
300	checks, so we keep the old value 924. */
301	/* swidth */ 924,
302	/* totalwidth */ 1135,
303	/* sqwidth */ 944,
304	/* vdelay */ 0x20,
305	/* sheight */ 576,
306	/* bt878 (and bt848?) can capture another
307	line below active video. */
308	/* extraheight */ 2,
309	/* videostart0 */ 23)
310	},{
311	.v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
312	.name = "NTSC",
313	.Fsc = 28636363,
314	.swidth = 768,
315	.sheight = 480,
316	.totalwidth = 910,
317	.adelay = 0x68,
318	.bdelay = 0x5d,
319	.iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
320	.scaledtwidth = 910,
321	.hdelayx1 = 128,
322	.hactivex1 = 910,
323	.vdelay = 0x1a,
324	.vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */
325	.sram = 1,
326	.vbistart = { 10, 273 },
327	CROPCAP(/* minhdelayx1 */ 68,
328	/* hdelayx1 */ 128,
329	/* Should be (640 * 910 + 780 / 2) / 780? */
330	/* swidth */ 768,
331	/* totalwidth */ 910,
332	/* sqwidth */ 780,
333	/* vdelay */ 0x1a,
334	/* sheight */ 480,
335	/* extraheight */ 0,
336	/* videostart0 */ 23)
337	},{
338	.v4l2_id = V4L2_STD_SECAM,
339	.name = "SECAM",
340	.Fsc = 35468950,
341	.swidth = 924,
342	.sheight = 576,
343	.totalwidth = 1135,
344	.adelay = 0x7f,
345	.bdelay = 0xb0,
346	.iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
347	.scaledtwidth = 1135,
348	.hdelayx1 = 186,
349	.hactivex1 = 922,
350	.vdelay = 0x20,
351	.vbipack = 255,
352	.sram = 0, /* like PAL, correct? */
353	.vbistart = { 7, 320 },
354	CROPCAP(/* minhdelayx1 */ 68,
355	/* hdelayx1 */ 186,
356	/* swidth */ 924,
357	/* totalwidth */ 1135,
358	/* sqwidth */ 944,
359	/* vdelay */ 0x20,
360	/* sheight */ 576,
361	/* extraheight */ 0,
362	/* videostart0 */ 23)
363	},{
364	.v4l2_id = V4L2_STD_PAL_Nc,
365	.name = "PAL-Nc",
366	.Fsc = 28636363,
367	.swidth = 640,
368	.sheight = 576,
369	.totalwidth = 910,
370	.adelay = 0x68,
371	.bdelay = 0x5d,
372	.iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
373	.scaledtwidth = 780,
374	.hdelayx1 = 130,
375	.hactivex1 = 734,
376	.vdelay = 0x1a,
377	.vbipack = 144,
378	.sram = -1,
379	.vbistart = { 7, 320 },
380	CROPCAP(/* minhdelayx1 */ 68,
381	/* hdelayx1 */ 130,
382	/* swidth */ (640 * 910 + 780 / 2) / 780,
383	/* totalwidth */ 910,
384	/* sqwidth */ 780,
385	/* vdelay */ 0x1a,
386	/* sheight */ 576,
387	/* extraheight */ 0,
388	/* videostart0 */ 23)
389	},{
390	.v4l2_id = V4L2_STD_PAL_M,
391	.name = "PAL-M",
392	.Fsc = 28636363,
393	.swidth = 640,
394	.sheight = 480,
395	.totalwidth = 910,
396	.adelay = 0x68,
397	.bdelay = 0x5d,
398	.iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
399	.scaledtwidth = 780,
400	.hdelayx1 = 135,
401	.hactivex1 = 754,
402	.vdelay = 0x1a,
403	.vbipack = 144,
404	.sram = -1,
405	.vbistart = { 10, 273 },
406	CROPCAP(/* minhdelayx1 */ 68,
407	/* hdelayx1 */ 135,
408	/* swidth */ (640 * 910 + 780 / 2) / 780,
409	/* totalwidth */ 910,
410	/* sqwidth */ 780,
411	/* vdelay */ 0x1a,
412	/* sheight */ 480,
413	/* extraheight */ 0,
414	/* videostart0 */ 23)
415	},{
416	.v4l2_id = V4L2_STD_PAL_N,
417	.name = "PAL-N",
418	.Fsc = 35468950,
419	.swidth = 768,
420	.sheight = 576,
421	.totalwidth = 1135,
422	.adelay = 0x7f,
423	.bdelay = 0x72,
424	.iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
425	.scaledtwidth = 944,
426	.hdelayx1 = 186,
427	.hactivex1 = 922,
428	.vdelay = 0x20,
429	.vbipack = 144,
430	.sram = -1,
431	.vbistart = { 7, 320 },
432	CROPCAP(/* minhdelayx1 */ 68,
433	/* hdelayx1 */ 186,
434	/* swidth */ (768 * 1135 + 944 / 2) / 944,
435	/* totalwidth */ 1135,
436	/* sqwidth */ 944,
437	/* vdelay */ 0x20,
438	/* sheight */ 576,
439	/* extraheight */ 0,
440	/* videostart0 */ 23)
441	},{
442	.v4l2_id = V4L2_STD_NTSC_M_JP,
443	.name = "NTSC-JP",
444	.Fsc = 28636363,
445	.swidth = 640,
446	.sheight = 480,
447	.totalwidth = 910,
448	.adelay = 0x68,
449	.bdelay = 0x5d,
450	.iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
451	.scaledtwidth = 780,
452	.hdelayx1 = 135,
453	.hactivex1 = 754,
454	.vdelay = 0x16,
455	.vbipack = 144,
456	.sram = -1,
457	.vbistart = { 10, 273 },
458	CROPCAP(/* minhdelayx1 */ 68,
459	/* hdelayx1 */ 135,
460	/* swidth */ (640 * 910 + 780 / 2) / 780,
461	/* totalwidth */ 910,
462	/* sqwidth */ 780,
463	/* vdelay */ 0x16,
464	/* sheight */ 480,
465	/* extraheight */ 0,
466	/* videostart0 */ 23)
467	},{
468	/* that one hopefully works with the strange timing
469	* which video recorders produce when playing a NTSC
470	* tape on a PAL TV ... */
471	.v4l2_id = V4L2_STD_PAL_60,
472	.name = "PAL-60",
473	.Fsc = 35468950,
474	.swidth = 924,
475	.sheight = 480,
476	.totalwidth = 1135,
477	.adelay = 0x7f,
478	.bdelay = 0x72,
479	.iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
480	.scaledtwidth = 1135,
481	.hdelayx1 = 186,
482	.hactivex1 = 924,
483	.vdelay = 0x1a,
484	.vbipack = 255,
485	.vtotal = 524,
486	.sram = -1,
487	.vbistart = { 10, 273 },
488	CROPCAP(/* minhdelayx1 */ 68,
489	/* hdelayx1 */ 186,
490	/* swidth */ 924,
491	/* totalwidth */ 1135,
492	/* sqwidth */ 944,
493	/* vdelay */ 0x1a,
494	/* sheight */ 480,
495	/* extraheight */ 0,
496	/* videostart0 */ 23)
497	}
498	};
499	static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
500
501	/* ----------------------------------------------------------------------- */
502	/* bttv format list
503	packed pixel formats must come first */
504	static const struct bttv_format formats[] = {
505	{
506	.fourcc = V4L2_PIX_FMT_GREY,
507	.btformat = BT848_COLOR_FMT_Y8,
508	.depth = 8,
509	.flags = FORMAT_FLAGS_PACKED,
510	},{
511	.fourcc = V4L2_PIX_FMT_HI240,
512	.btformat = BT848_COLOR_FMT_RGB8,
513	.depth = 8,
514	.flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
515	},{
516	.fourcc = V4L2_PIX_FMT_RGB555,
517	.btformat = BT848_COLOR_FMT_RGB15,
518	.depth = 16,
519	.flags = FORMAT_FLAGS_PACKED,
520	},{
521	.fourcc = V4L2_PIX_FMT_RGB555X,
522	.btformat = BT848_COLOR_FMT_RGB15,
523	.btswap = 0x03, /* byteswap */
524	.depth = 16,
525	.flags = FORMAT_FLAGS_PACKED,
526	},{
527	.fourcc = V4L2_PIX_FMT_RGB565,
528	.btformat = BT848_COLOR_FMT_RGB16,
529	.depth = 16,
530	.flags = FORMAT_FLAGS_PACKED,
531	},{
532	.fourcc = V4L2_PIX_FMT_RGB565X,
533	.btformat = BT848_COLOR_FMT_RGB16,
534	.btswap = 0x03, /* byteswap */
535	.depth = 16,
536	.flags = FORMAT_FLAGS_PACKED,
537	},{
538	.fourcc = V4L2_PIX_FMT_BGR24,
539	.btformat = BT848_COLOR_FMT_RGB24,
540	.depth = 24,
541	.flags = FORMAT_FLAGS_PACKED,
542	},{
543	.fourcc = V4L2_PIX_FMT_BGR32,
544	.btformat = BT848_COLOR_FMT_RGB32,
545	.depth = 32,
546	.flags = FORMAT_FLAGS_PACKED,
547	},{
548	.fourcc = V4L2_PIX_FMT_RGB32,
549	.btformat = BT848_COLOR_FMT_RGB32,
550	.btswap = 0x0f, /* byte+word swap */
551	.depth = 32,
552	.flags = FORMAT_FLAGS_PACKED,
553	},{
554	.fourcc = V4L2_PIX_FMT_YUYV,
555	.btformat = BT848_COLOR_FMT_YUY2,
556	.depth = 16,
557	.flags = FORMAT_FLAGS_PACKED,
558	},{
559	.fourcc = V4L2_PIX_FMT_UYVY,
560	.btformat = BT848_COLOR_FMT_YUY2,
561	.btswap = 0x03, /* byteswap */
562	.depth = 16,
563	.flags = FORMAT_FLAGS_PACKED,
564	},{
565	.fourcc = V4L2_PIX_FMT_YUV422P,
566	.btformat = BT848_COLOR_FMT_YCrCb422,
567	.depth = 16,
568	.flags = FORMAT_FLAGS_PLANAR,
569	.hshift = 1,
570	.vshift = 0,
571	},{
572	.fourcc = V4L2_PIX_FMT_YUV420,
573	.btformat = BT848_COLOR_FMT_YCrCb422,
574	.depth = 12,
575	.flags = FORMAT_FLAGS_PLANAR,
576	.hshift = 1,
577	.vshift = 1,
578	},{
579	.fourcc = V4L2_PIX_FMT_YVU420,
580	.btformat = BT848_COLOR_FMT_YCrCb422,
581	.depth = 12,
582	.flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
583	.hshift = 1,
584	.vshift = 1,
585	},{
586	.fourcc = V4L2_PIX_FMT_YUV411P,
587	.btformat = BT848_COLOR_FMT_YCrCb411,
588	.depth = 12,
589	.flags = FORMAT_FLAGS_PLANAR,
590	.hshift = 2,
591	.vshift = 0,
592	},{
593	.fourcc = V4L2_PIX_FMT_YUV410,
594	.btformat = BT848_COLOR_FMT_YCrCb411,
595	.depth = 9,
596	.flags = FORMAT_FLAGS_PLANAR,
597	.hshift = 2,
598	.vshift = 2,
599	},{
600	.fourcc = V4L2_PIX_FMT_YVU410,
601	.btformat = BT848_COLOR_FMT_YCrCb411,
602	.depth = 9,
603	.flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
604	.hshift = 2,
605	.vshift = 2,
606	},{
607	.fourcc = -1,
608	.btformat = BT848_COLOR_FMT_RAW,
609	.depth = 8,
610	.flags = FORMAT_FLAGS_RAW,
611	}
612	};
613	static const unsigned int FORMATS = ARRAY_SIZE(formats);
614
615	/* ----------------------------------------------------------------------- */
616	/* resource management */
617
618	/*
619	RESOURCE_ allocated by freed by
620
621	VIDEO_READ bttv_read 1) bttv_read 2)
622
623	VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
624	VIDIOC_QBUF 1) bttv_release
625	VIDIOCMCAPTURE 1)
626
627	VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
628	VIDIOC_QBUF 1) bttv_release
629	bttv_read, bttv_poll 1) 3)
630
631	1) The resource must be allocated when we enter buffer prepare functions
632	and remain allocated while buffers are in the DMA queue.
633	2) This is a single frame read.
634	3) This is a continuous read, implies VIDIOC_STREAMON.
635
636	Note this driver permits video input and standard changes regardless if
637	resources are allocated.
638	*/
639
640	#define VBI_RESOURCES (RESOURCE_VBI)
641	#define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
642	RESOURCE_VIDEO_STREAM)
643
644	int check_alloc_btres_lock(struct bttv *btv, int bit)
645	{
646	int xbits; /* mutual exclusive resources */
647
648	xbits = bit;
649	if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
650	xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
651
652	/* is it free? */
653	if (btv->resources & xbits) {
654	/* no, someone else uses it */
655	goto fail;
656	}
657
658	if ((bit & VIDEO_RESOURCES)
659	&& 0 == (btv->resources & VIDEO_RESOURCES)) {
660	/* Do crop - use current, don't - use default parameters. */
661	__s32 top = btv->crop[!!btv->do_crop].rect.top;
662
663	if (btv->vbi_end > top)
664	goto fail;
665
666	/* We cannot capture the same line as video and VBI data.
667	Claim scan lines crop[].rect.top to bottom. */
668	btv->crop_start = top;
669	} else if (bit & VBI_RESOURCES) {
670	__s32 end = btv->vbi_fmt.end;
671
672	if (end > btv->crop_start)
673	goto fail;
674
675	/* Claim scan lines above btv->vbi_fmt.end. */
676	btv->vbi_end = end;
677	}
678
679	/* it's free, grab it */
680	btv->resources |= bit;
681	return 1;
682
683	fail:
684	return 0;
685	}
686
687	static
688	int check_btres(struct bttv *btv, int bit)
689	{
690	return (btv->resources & bit);
691	}
692
693	static
694	int locked_btres(struct bttv *btv, int bit)
695	{
696	return (btv->resources & bit);
697	}
698
699	/* Call with btv->lock down. */
700	static void
701	disclaim_vbi_lines(struct bttv *btv)
702	{
703	btv->vbi_end = 0;
704	}
705
706	/* Call with btv->lock down. */
707	static void
708	disclaim_video_lines(struct bttv *btv)
709	{
710	const struct bttv_tvnorm *tvnorm;
711	u8 crop;
712
713	tvnorm = &bttv_tvnorms[btv->tvnorm];
714	btv->crop_start = tvnorm->cropcap.bounds.top
715	+ tvnorm->cropcap.bounds.height;
716
717	/* VBI capturing ends at VDELAY, start of video capturing, no
718	matter how many lines the VBI RISC program expects. When video
719	capturing is off, it shall no longer "preempt" VBI capturing,
720	so we set VDELAY to maximum. */
721	crop = btread(BT848_E_CROP) | 0xc0;
722	btwrite(crop, BT848_E_CROP);
723	btwrite(0xfe, BT848_E_VDELAY_LO);
724	btwrite(crop, BT848_O_CROP);
725	btwrite(0xfe, BT848_O_VDELAY_LO);
726	}
727
728	void free_btres_lock(struct bttv *btv, int bits)
729	{
730	if ((btv->resources & bits) != bits) {
731	/* trying to free resources not allocated by us ... */
732	pr_err("BUG! (btres)\n");
733	}
734	btv->resources &= ~bits;
735
736	bits = btv->resources;
737
738	if (0 == (bits & VIDEO_RESOURCES))
739	disclaim_video_lines(btv);
740
741	if (0 == (bits & VBI_RESOURCES))
742	disclaim_vbi_lines(btv);
743	}
744
745	/* ----------------------------------------------------------------------- */
746	/* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
747
748	/* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
749	PLL_X = Reference pre-divider (0=1, 1=2)
750	PLL_C = Post divider (0=6, 1=4)
751	PLL_I = Integer input
752	PLL_F = Fractional input
753
754	F_input = 28.636363 MHz:
755	PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
756	*/
757
758	static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
759	{
760	unsigned char fl, fh, fi;
761
762	/* prevent overflows */
763	fin/=4;
764	fout/=4;
765
766	fout*=12;
767	fi=fout/fin;
768
769	fout=(fout%fin)*256;
770	fh=fout/fin;
771
772	fout=(fout%fin)*256;
773	fl=fout/fin;
774
775	btwrite(fl, BT848_PLL_F_LO);
776	btwrite(fh, BT848_PLL_F_HI);
777	btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
778	}
779
780	static void set_pll(struct bttv *btv)
781	{
782	int i;
783
784	if (!btv->pll.pll_crystal)
785	return;
786
787	if (btv->pll.pll_ofreq == btv->pll.pll_current) {
788	dprintk("%d: PLL: no change required\n", btv->c.nr);
789	return;
790	}
791
792	if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
793	/* no PLL needed */
794	if (btv->pll.pll_current == 0)
795	return;
796	if (bttv_verbose)
797	pr_info("%d: PLL can sleep, using XTAL (%d)\n",
798	btv->c.nr, btv->pll.pll_ifreq);
799	btwrite(0x00,BT848_TGCTRL);
800	btwrite(0x00,BT848_PLL_XCI);
801	btv->pll.pll_current = 0;
802	return;
803	}
804
805	if (bttv_verbose)
806	pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n",
807	btv->c.nr,
808	btv->pll.pll_ifreq, btv->pll.pll_ofreq);
809	set_pll_freq(btv, fin: btv->pll.pll_ifreq, fout: btv->pll.pll_ofreq);
810
811	for (i=0; i<10; i++) {
812	/* Let other people run while the PLL stabilizes */
813	msleep(msecs: 10);
814
815	if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
816	btwrite(0,BT848_DSTATUS);
817	} else {
818	btwrite(0x08,BT848_TGCTRL);
819	btv->pll.pll_current = btv->pll.pll_ofreq;
820	if (bttv_verbose)
821	pr_info("PLL set ok\n");
822	return;
823	}
824	}
825	btv->pll.pll_current = -1;
826	if (bttv_verbose)
827	pr_info("Setting PLL failed\n");
828	return;
829	}
830
831	/* used to switch between the bt848's analog/digital video capture modes */
832	static void bt848A_set_timing(struct bttv *btv)
833	{
834	int i, len;
835	int table_idx = bttv_tvnorms[btv->tvnorm].sram;
836	int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
837
838	if (btv->input == btv->dig) {
839	dprintk("%d: load digital timing table (table_idx=%d)\n",
840	btv->c.nr,table_idx);
841
842	/* timing change...reset timing generator address */
843	btwrite(0x00, BT848_TGCTRL);
844	btwrite(0x02, BT848_TGCTRL);
845	btwrite(0x00, BT848_TGCTRL);
846
847	len=SRAM_Table[table_idx][0];
848	for(i = 1; i <= len; i++)
849	btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
850	btv->pll.pll_ofreq = 27000000;
851
852	set_pll(btv);
853	btwrite(0x11, BT848_TGCTRL);
854	btwrite(0x41, BT848_DVSIF);
855	} else {
856	btv->pll.pll_ofreq = fsc;
857	set_pll(btv);
858	btwrite(0x0, BT848_DVSIF);
859	}
860	}
861
862	/* ----------------------------------------------------------------------- */
863
864	static void bt848_bright(struct bttv *btv, int bright)
865	{
866	int value;
867
868	// printk("set bright: %d\n", bright); // DEBUG
869	btv->bright = bright;
870
871	/* We want -128 to 127 we get 0-65535 */
872	value = (bright >> 8) - 128;
873	btwrite(value & 0xff, BT848_BRIGHT);
874	}
875
876	static void bt848_hue(struct bttv *btv, int hue)
877	{
878	int value;
879
880	btv->hue = hue;
881
882	/* -128 to 127 */
883	value = (hue >> 8) - 128;
884	btwrite(value & 0xff, BT848_HUE);
885	}
886
887	static void bt848_contrast(struct bttv *btv, int cont)
888	{
889	int value,hibit;
890
891	btv->contrast = cont;
892
893	/* 0-511 */
894	value = (cont >> 7);
895	hibit = (value >> 6) & 4;
896	btwrite(value & 0xff, BT848_CONTRAST_LO);
897	btaor(hibit, ~4, BT848_E_CONTROL);
898	btaor(hibit, ~4, BT848_O_CONTROL);
899	}
900
901	static void bt848_sat(struct bttv *btv, int color)
902	{
903	int val_u,val_v,hibits;
904
905	btv->saturation = color;
906
907	/* 0-511 for the color */
908	val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
909	val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
910	hibits = (val_u >> 7) & 2;
911	hibits |= (val_v >> 8) & 1;
912	btwrite(val_u & 0xff, BT848_SAT_U_LO);
913	btwrite(val_v & 0xff, BT848_SAT_V_LO);
914	btaor(hibits, ~3, BT848_E_CONTROL);
915	btaor(hibits, ~3, BT848_O_CONTROL);
916	}
917
918	/* ----------------------------------------------------------------------- */
919
920	static int
921	video_mux(struct bttv *btv, unsigned int input)
922	{
923	int mux,mask2;
924
925	if (input >= bttv_tvcards[btv->c.type].video_inputs)
926	return -EINVAL;
927
928	/* needed by RemoteVideo MX */
929	mask2 = bttv_tvcards[btv->c.type].gpiomask2;
930	if (mask2)
931	gpio_inout(mask2,mask2);
932
933	if (input == btv->svhs) {
934	btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
935	btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
936	} else {
937	btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
938	btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
939	}
940	mux = bttv_muxsel(btv, input);
941	btaor(mux<<5, ~(3<<5), BT848_IFORM);
942	dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux);
943
944	/* card specific hook */
945	if(bttv_tvcards[btv->c.type].muxsel_hook)
946	bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
947	return 0;
948	}
949
950	static char *audio_modes[] = {
951	"audio: tuner", "audio: radio", "audio: extern",
952	"audio: intern", "audio: mute"
953	};
954
955	static void
956	audio_mux_gpio(struct bttv *btv, int input, int mute)
957	{
958	int gpio_val, signal, mute_gpio;
959
960	gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
961	bttv_tvcards[btv->c.type].gpiomask);
962	signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
963
964	/* automute */
965	mute_gpio = mute || (btv->opt_automute && (!signal || !btv->users)
966	&& !btv->has_radio_tuner);
967
968	if (mute_gpio)
969	gpio_val = bttv_tvcards[btv->c.type].gpiomute;
970	else
971	gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
972
973	switch (btv->c.type) {
974	case BTTV_BOARD_VOODOOTV_FM:
975	case BTTV_BOARD_VOODOOTV_200:
976	gpio_val = bttv_tda9880_setnorm(btv, gpiobits: gpio_val);
977	break;
978
979	default:
980	gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
981	}
982
983	if (bttv_gpio)
984	bttv_gpio_tracking(btv, comment: audio_modes[mute_gpio ? 4 : input]);
985	}
986
987	static int
988	audio_mute(struct bttv *btv, int mute)
989	{
990	struct v4l2_ctrl *ctrl;
991
992	audio_mux_gpio(btv, input: btv->audio_input, mute);
993
994	if (btv->sd_msp34xx) {
995	ctrl = v4l2_ctrl_find(hdl: btv->sd_msp34xx->ctrl_handler, V4L2_CID_AUDIO_MUTE);
996	if (ctrl)
997	v4l2_ctrl_s_ctrl(ctrl, val: mute);
998	}
999	if (btv->sd_tvaudio) {
1000	ctrl = v4l2_ctrl_find(hdl: btv->sd_tvaudio->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1001	if (ctrl)
1002	v4l2_ctrl_s_ctrl(ctrl, val: mute);
1003	}
1004	if (btv->sd_tda7432) {
1005	ctrl = v4l2_ctrl_find(hdl: btv->sd_tda7432->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1006	if (ctrl)
1007	v4l2_ctrl_s_ctrl(ctrl, val: mute);
1008	}
1009	return 0;
1010	}
1011
1012	static int
1013	audio_input(struct bttv *btv, int input)
1014	{
1015	audio_mux_gpio(btv, input, mute: btv->mute);
1016
1017	if (btv->sd_msp34xx) {
1018	u32 in;
1019
1020	/* Note: the inputs tuner/radio/extern/intern are translated
1021	to msp routings. This assumes common behavior for all msp3400
1022	based TV cards. When this assumption fails, then the
1023	specific MSP routing must be added to the card table.
1024	For now this is sufficient. */
1025	switch (input) {
1026	case TVAUDIO_INPUT_RADIO:
1027	/* Some boards need the msp do to the radio demod */
1028	if (btv->radio_uses_msp_demodulator) {
1029	in = MSP_INPUT_DEFAULT;
1030	break;
1031	}
1032	in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1033	MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1034	break;
1035	case TVAUDIO_INPUT_EXTERN:
1036	in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1037	MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1038	break;
1039	case TVAUDIO_INPUT_INTERN:
1040	/* Yes, this is the same input as for RADIO. I doubt
1041	if this is ever used. The only board with an INTERN
1042	input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1043	that was tested. My guess is that the whole INTERN
1044	input does not work. */
1045	in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1046	MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1047	break;
1048	case TVAUDIO_INPUT_TUNER:
1049	default:
1050	/* This is the only card that uses TUNER2, and afaik,
1051	is the only difference between the VOODOOTV_FM
1052	and VOODOOTV_200 */
1053	if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1054	in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1055	MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1056	else
1057	in = MSP_INPUT_DEFAULT;
1058	break;
1059	}
1060	v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1061	in, MSP_OUTPUT_DEFAULT, 0);
1062	}
1063	if (btv->sd_tvaudio) {
1064	v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1065	input, 0, 0);
1066	}
1067	return 0;
1068	}
1069
1070	static void
1071	bttv_crop_calc_limits(struct bttv_crop *c)
1072	{
1073	/* Scale factor min. 1:1, max. 16:1. Min. image size
1074	48 x 32. Scaled width must be a multiple of 4. */
1075
1076	if (1) {
1077	/* For bug compatibility with VIDIOCGCAP and image
1078	size checks in earlier driver versions. */
1079	c->min_scaled_width = 48;
1080	c->min_scaled_height = 32;
1081	} else {
1082	c->min_scaled_width =
1083	(max_t(unsigned int, 48, c->rect.width >> 4) + 3) & ~3;
1084	c->min_scaled_height =
1085	max_t(unsigned int, 32, c->rect.height >> 4);
1086	}
1087
1088	c->max_scaled_width = c->rect.width & ~3;
1089	c->max_scaled_height = c->rect.height;
1090	}
1091
1092	static void
1093	bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1094	{
1095	c->rect = bttv_tvnorms[norm].cropcap.defrect;
1096	bttv_crop_calc_limits(c);
1097	}
1098
1099	/* Call with btv->lock down. */
1100	static int
1101	set_tvnorm(struct bttv *btv, unsigned int norm)
1102	{
1103	const struct bttv_tvnorm *tvnorm;
1104	v4l2_std_id id;
1105
1106	WARN_ON(norm >= BTTV_TVNORMS);
1107	WARN_ON(btv->tvnorm >= BTTV_TVNORMS);
1108
1109	tvnorm = &bttv_tvnorms[norm];
1110
1111	if (memcmp(p: &bttv_tvnorms[btv->tvnorm].cropcap, q: &tvnorm->cropcap,
1112	size: sizeof (tvnorm->cropcap))) {
1113	bttv_crop_reset(c: &btv->crop[0], norm);
1114	btv->crop[1] = btv->crop[0]; /* current = default */
1115
1116	if (0 == (btv->resources & VIDEO_RESOURCES)) {
1117	btv->crop_start = tvnorm->cropcap.bounds.top
1118	+ tvnorm->cropcap.bounds.height;
1119	}
1120	}
1121
1122	btv->tvnorm = norm;
1123
1124	btwrite(tvnorm->adelay, BT848_ADELAY);
1125	btwrite(tvnorm->bdelay, BT848_BDELAY);
1126	btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1127	BT848_IFORM);
1128	btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1129	btwrite(1, BT848_VBI_PACK_DEL);
1130	bt848A_set_timing(btv);
1131
1132	switch (btv->c.type) {
1133	case BTTV_BOARD_VOODOOTV_FM:
1134	case BTTV_BOARD_VOODOOTV_200:
1135	bttv_tda9880_setnorm(btv, gpio_read());
1136	break;
1137	}
1138	id = tvnorm->v4l2_id;
1139	bttv_call_all(btv, video, s_std, id);
1140
1141	return 0;
1142	}
1143
1144	/* Call with btv->lock down. */
1145	static void
1146	set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1147	{
1148	unsigned long flags;
1149
1150	btv->input = input;
1151	if (irq_iswitch) {
1152	spin_lock_irqsave(&btv->s_lock,flags);
1153	if (btv->curr.frame_irq) {
1154	/* active capture -> delayed input switch */
1155	btv->new_input = input;
1156	} else {
1157	video_mux(btv,input);
1158	}
1159	spin_unlock_irqrestore(lock: &btv->s_lock,flags);
1160	} else {
1161	video_mux(btv,input);
1162	}
1163	btv->audio_input = (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1164	TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN;
1165	audio_input(btv, input: btv->audio_input);
1166	set_tvnorm(btv, norm);
1167	}
1168
1169	void init_irqreg(struct bttv *btv)
1170	{
1171	/* clear status */
1172	btwrite(0xfffffUL, BT848_INT_STAT);
1173
1174	if (bttv_tvcards[btv->c.type].no_video) {
1175	/* i2c only */
1176	btwrite(BT848_INT_I2CDONE,
1177	BT848_INT_MASK);
1178	} else {
1179	/* full video */
1180	btwrite((btv->triton1) |
1181	(btv->gpioirq ? BT848_INT_GPINT : 0) |
1182	BT848_INT_SCERR |
1183	(fdsr ? BT848_INT_FDSR : 0) |
1184	BT848_INT_RISCI | BT848_INT_OCERR |
1185	BT848_INT_FMTCHG|BT848_INT_HLOCK|
1186	BT848_INT_I2CDONE,
1187	BT848_INT_MASK);
1188	}
1189	}
1190
1191	static void init_bt848(struct bttv *btv)
1192	{
1193	if (bttv_tvcards[btv->c.type].no_video) {
1194	/* very basic init only */
1195	init_irqreg(btv);
1196	return;
1197	}
1198
1199	btwrite(0x00, BT848_CAP_CTL);
1200	btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1201	btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1202
1203	/* set planar and packed mode trigger points and */
1204	/* set rising edge of inverted GPINTR pin as irq trigger */
1205	btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1206	BT848_GPIO_DMA_CTL_PLTP1_16|
1207	BT848_GPIO_DMA_CTL_PLTP23_16|
1208	BT848_GPIO_DMA_CTL_GPINTC|
1209	BT848_GPIO_DMA_CTL_GPINTI,
1210	BT848_GPIO_DMA_CTL);
1211
1212	btwrite(0x20, BT848_E_VSCALE_HI);
1213	btwrite(0x20, BT848_O_VSCALE_HI);
1214
1215	v4l2_ctrl_handler_setup(hdl: &btv->ctrl_handler);
1216
1217	/* interrupt */
1218	init_irqreg(btv);
1219	}
1220
1221	static void bttv_reinit_bt848(struct bttv *btv)
1222	{
1223	unsigned long flags;
1224
1225	if (bttv_verbose)
1226	pr_info("%d: reset, reinitialize\n", btv->c.nr);
1227	spin_lock_irqsave(&btv->s_lock,flags);
1228	btv->errors=0;
1229	bttv_set_dma(btv,override: 0);
1230	spin_unlock_irqrestore(lock: &btv->s_lock,flags);
1231
1232	init_bt848(btv);
1233	btv->pll.pll_current = -1;
1234	set_input(btv, input: btv->input, norm: btv->tvnorm);
1235	}
1236
1237	static int bttv_s_ctrl(struct v4l2_ctrl *c)
1238	{
1239	struct bttv *btv = container_of(c->handler, struct bttv, ctrl_handler);
1240	int val;
1241
1242	switch (c->id) {
1243	case V4L2_CID_BRIGHTNESS:
1244	bt848_bright(btv, bright: c->val);
1245	break;
1246	case V4L2_CID_HUE:
1247	bt848_hue(btv, hue: c->val);
1248	break;
1249	case V4L2_CID_CONTRAST:
1250	bt848_contrast(btv, cont: c->val);
1251	break;
1252	case V4L2_CID_SATURATION:
1253	bt848_sat(btv, color: c->val);
1254	break;
1255	case V4L2_CID_COLOR_KILLER:
1256	if (c->val) {
1257	btor(BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1258	btor(BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1259	} else {
1260	btand(~BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1261	btand(~BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1262	}
1263	break;
1264	case V4L2_CID_AUDIO_MUTE:
1265	audio_mute(btv, mute: c->val);
1266	btv->mute = c->val;
1267	break;
1268	case V4L2_CID_AUDIO_VOLUME:
1269	btv->volume_gpio(btv, c->val);
1270	break;
1271
1272	case V4L2_CID_CHROMA_AGC:
1273	val = c->val ? BT848_SCLOOP_CAGC : 0;
1274	btwrite(val, BT848_E_SCLOOP);
1275	btwrite(val, BT848_O_SCLOOP);
1276	break;
1277	case V4L2_CID_PRIVATE_COMBFILTER:
1278	btv->opt_combfilter = c->val;
1279	break;
1280	case V4L2_CID_PRIVATE_LUMAFILTER:
1281	if (c->val) {
1282	btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1283	btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1284	} else {
1285	btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1286	btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1287	}
1288	break;
1289	case V4L2_CID_PRIVATE_AUTOMUTE:
1290	btv->opt_automute = c->val;
1291	break;
1292	case V4L2_CID_PRIVATE_AGC_CRUSH:
1293	btwrite(BT848_ADC_RESERVED |
1294	(c->val ? BT848_ADC_CRUSH : 0),
1295	BT848_ADC);
1296	break;
1297	case V4L2_CID_PRIVATE_VCR_HACK:
1298	btv->opt_vcr_hack = c->val;
1299	break;
1300	case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1301	btwrite(c->val, BT848_WC_UP);
1302	break;
1303	case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1304	btwrite(c->val, BT848_WC_DOWN);
1305	break;
1306	case V4L2_CID_PRIVATE_UV_RATIO:
1307	btv->opt_uv_ratio = c->val;
1308	bt848_sat(btv, color: btv->saturation);
1309	break;
1310	case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1311	btaor((c->val << 7), ~BT848_OFORM_RANGE, BT848_OFORM);
1312	break;
1313	case V4L2_CID_PRIVATE_CORING:
1314	btaor((c->val << 5), ~BT848_OFORM_CORE32, BT848_OFORM);
1315	break;
1316	default:
1317	return -EINVAL;
1318	}
1319	return 0;
1320	}
1321
1322	/* ----------------------------------------------------------------------- */
1323
1324	static const struct v4l2_ctrl_ops bttv_ctrl_ops = {
1325	.s_ctrl = bttv_s_ctrl,
1326	};
1327
1328	static struct v4l2_ctrl_config bttv_ctrl_combfilter = {
1329	.ops = &bttv_ctrl_ops,
1330	.id = V4L2_CID_PRIVATE_COMBFILTER,
1331	.name = "Comb Filter",
1332	.type = V4L2_CTRL_TYPE_BOOLEAN,
1333	.min = 0,
1334	.max = 1,
1335	.step = 1,
1336	.def = 1,
1337	};
1338
1339	static struct v4l2_ctrl_config bttv_ctrl_automute = {
1340	.ops = &bttv_ctrl_ops,
1341	.id = V4L2_CID_PRIVATE_AUTOMUTE,
1342	.name = "Auto Mute",
1343	.type = V4L2_CTRL_TYPE_BOOLEAN,
1344	.min = 0,
1345	.max = 1,
1346	.step = 1,
1347	.def = 1,
1348	};
1349
1350	static struct v4l2_ctrl_config bttv_ctrl_lumafilter = {
1351	.ops = &bttv_ctrl_ops,
1352	.id = V4L2_CID_PRIVATE_LUMAFILTER,
1353	.name = "Luma Decimation Filter",
1354	.type = V4L2_CTRL_TYPE_BOOLEAN,
1355	.min = 0,
1356	.max = 1,
1357	.step = 1,
1358	.def = 1,
1359	};
1360
1361	static struct v4l2_ctrl_config bttv_ctrl_agc_crush = {
1362	.ops = &bttv_ctrl_ops,
1363	.id = V4L2_CID_PRIVATE_AGC_CRUSH,
1364	.name = "AGC Crush",
1365	.type = V4L2_CTRL_TYPE_BOOLEAN,
1366	.min = 0,
1367	.max = 1,
1368	.step = 1,
1369	.def = 1,
1370	};
1371
1372	static struct v4l2_ctrl_config bttv_ctrl_vcr_hack = {
1373	.ops = &bttv_ctrl_ops,
1374	.id = V4L2_CID_PRIVATE_VCR_HACK,
1375	.name = "VCR Hack",
1376	.type = V4L2_CTRL_TYPE_BOOLEAN,
1377	.min = 0,
1378	.max = 1,
1379	.step = 1,
1380	.def = 1,
1381	};
1382
1383	static struct v4l2_ctrl_config bttv_ctrl_whitecrush_lower = {
1384	.ops = &bttv_ctrl_ops,
1385	.id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
1386	.name = "Whitecrush Lower",
1387	.type = V4L2_CTRL_TYPE_INTEGER,
1388	.min = 0,
1389	.max = 255,
1390	.step = 1,
1391	.def = 0x7f,
1392	};
1393
1394	static struct v4l2_ctrl_config bttv_ctrl_whitecrush_upper = {
1395	.ops = &bttv_ctrl_ops,
1396	.id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
1397	.name = "Whitecrush Upper",
1398	.type = V4L2_CTRL_TYPE_INTEGER,
1399	.min = 0,
1400	.max = 255,
1401	.step = 1,
1402	.def = 0xcf,
1403	};
1404
1405	static struct v4l2_ctrl_config bttv_ctrl_uv_ratio = {
1406	.ops = &bttv_ctrl_ops,
1407	.id = V4L2_CID_PRIVATE_UV_RATIO,
1408	.name = "UV Ratio",
1409	.type = V4L2_CTRL_TYPE_INTEGER,
1410	.min = 0,
1411	.max = 100,
1412	.step = 1,
1413	.def = 50,
1414	};
1415
1416	static struct v4l2_ctrl_config bttv_ctrl_full_luma = {
1417	.ops = &bttv_ctrl_ops,
1418	.id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
1419	.name = "Full Luma Range",
1420	.type = V4L2_CTRL_TYPE_BOOLEAN,
1421	.min = 0,
1422	.max = 1,
1423	.step = 1,
1424	};
1425
1426	static struct v4l2_ctrl_config bttv_ctrl_coring = {
1427	.ops = &bttv_ctrl_ops,
1428	.id = V4L2_CID_PRIVATE_CORING,
1429	.name = "Coring",
1430	.type = V4L2_CTRL_TYPE_INTEGER,
1431	.min = 0,
1432	.max = 3,
1433	.step = 1,
1434	};
1435
1436
1437	/* ----------------------------------------------------------------------- */
1438
1439	void bttv_gpio_tracking(struct bttv *btv, char *comment)
1440	{
1441	unsigned int outbits, data;
1442	outbits = btread(BT848_GPIO_OUT_EN);
1443	data = btread(BT848_GPIO_DATA);
1444	pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1445	btv->c.nr, outbits, data & outbits, data & ~outbits, comment);
1446	}
1447
1448	static const struct bttv_format*
1449	format_by_fourcc(int fourcc)
1450	{
1451	unsigned int i;
1452
1453	for (i = 0; i < FORMATS; i++) {
1454	if (-1 == formats[i].fourcc)
1455	continue;
1456	if (formats[i].fourcc == fourcc)
1457	return formats+i;
1458	}
1459	return NULL;
1460	}
1461
1462	/* ----------------------------------------------------------------------- */
1463	/* video4linux (1) interface */
1464
1465	static int queue_setup(struct vb2_queue *q, unsigned int *num_buffers,
1466	unsigned int *num_planes, unsigned int sizes[],
1467	struct device *alloc_devs[])
1468	{
1469	struct bttv *btv = vb2_get_drv_priv(q);
1470	unsigned int size = btv->fmt->depth * btv->width * btv->height >> 3;
1471
1472	if (*num_planes)
1473	return sizes[0] < size ? -EINVAL : 0;
1474	*num_planes = 1;
1475	sizes[0] = size;
1476
1477	return 0;
1478	}
1479
1480	static void buf_queue(struct vb2_buffer *vb)
1481	{
1482	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1483	struct vb2_queue *vq = vb->vb2_queue;
1484	struct bttv *btv = vb2_get_drv_priv(q: vq);
1485	struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
1486	unsigned long flags;
1487
1488	spin_lock_irqsave(&btv->s_lock, flags);
1489	if (list_empty(head: &btv->capture)) {
1490	btv->loop_irq = BT848_RISC_VIDEO;
1491	if (vb2_is_streaming(q: &btv->vbiq))
1492	btv->loop_irq |= BT848_RISC_VBI;
1493	bttv_set_dma(btv, BT848_CAP_CTL_CAPTURE_ODD |
1494	BT848_CAP_CTL_CAPTURE_EVEN);
1495	}
1496	list_add_tail(new: &buf->list, head: &btv->capture);
1497	spin_unlock_irqrestore(lock: &btv->s_lock, flags);
1498	}
1499
1500	static int buf_prepare(struct vb2_buffer *vb)
1501	{
1502	struct vb2_queue *vq = vb->vb2_queue;
1503	struct bttv *btv = vb2_get_drv_priv(q: vq);
1504	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1505	struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
1506	unsigned int size = (btv->fmt->depth * btv->width * btv->height) >> 3;
1507
1508	if (vb2_plane_size(vb, plane_no: 0) < size)
1509	return -EINVAL;
1510	vb2_set_plane_payload(vb, plane_no: 0, size);
1511
1512	if (btv->field != V4L2_FIELD_ALTERNATE) {
1513	buf->vbuf.field = btv->field;
1514	} else if (btv->field_last == V4L2_FIELD_TOP) {
1515	buf->vbuf.field = V4L2_FIELD_BOTTOM;
1516	btv->field_last = V4L2_FIELD_BOTTOM;
1517	} else {
1518	buf->vbuf.field = V4L2_FIELD_TOP;
1519	btv->field_last = V4L2_FIELD_TOP;
1520	}
1521
1522	/* Allocate memory for risc struct and create the risc program. */
1523	return bttv_buffer_risc(btv, buf);
1524	}
1525
1526	static void buf_cleanup(struct vb2_buffer *vb)
1527	{
1528	struct vb2_queue *vq = vb->vb2_queue;
1529	struct bttv *btv = vb2_get_drv_priv(q: vq);
1530	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1531	struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
1532
1533	btcx_riscmem_free(pci: btv->c.pci, risc: &buf->top);
1534	btcx_riscmem_free(pci: btv->c.pci, risc: &buf->bottom);
1535	}
1536
1537	static int start_streaming(struct vb2_queue *q, unsigned int count)
1538	{
1539	int seqnr = 0;
1540	struct bttv_buffer *buf;
1541	struct bttv *btv = vb2_get_drv_priv(q);
1542
1543	if (!check_alloc_btres_lock(btv, RESOURCE_VIDEO_STREAM)) {
1544	if (btv->field_count)
1545	seqnr++;
1546	while (!list_empty(head: &btv->capture)) {
1547	buf = list_entry(btv->capture.next,
1548	struct bttv_buffer, list);
1549	list_del(entry: &buf->list);
1550	buf->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
1551	vb2_buffer_done(vb: &buf->vbuf.vb2_buf,
1552	state: VB2_BUF_STATE_QUEUED);
1553	}
1554	return -EBUSY;
1555	}
1556	if (!vb2_is_streaming(q: &btv->vbiq)) {
1557	init_irqreg(btv);
1558	btv->field_count = 0;
1559	}
1560	btv->framedrop = 0;
1561
1562	return 0;
1563	}
1564
1565	static void stop_streaming(struct vb2_queue *q)
1566	{
1567	unsigned long flags;
1568	struct bttv *btv = vb2_get_drv_priv(q);
1569
1570	vb2_wait_for_all_buffers(q);
1571	spin_lock_irqsave(&btv->s_lock, flags);
1572	free_btres_lock(btv, RESOURCE_VIDEO_STREAM);
1573	if (!vb2_is_streaming(q: &btv->vbiq)) {
1574	/* stop field counter */
1575	btand(~BT848_INT_VSYNC, BT848_INT_MASK);
1576	}
1577	spin_unlock_irqrestore(lock: &btv->s_lock, flags);
1578	}
1579
1580	static const struct vb2_ops bttv_video_qops = {
1581	.queue_setup = queue_setup,
1582	.buf_queue = buf_queue,
1583	.buf_prepare = buf_prepare,
1584	.buf_cleanup = buf_cleanup,
1585	.start_streaming = start_streaming,
1586	.stop_streaming = stop_streaming,
1587	.wait_prepare = vb2_ops_wait_prepare,
1588	.wait_finish = vb2_ops_wait_finish,
1589	};
1590
1591	static void radio_enable(struct bttv *btv)
1592	{
1593	/* Switch to the radio tuner */
1594	if (!btv->has_radio_tuner) {
1595	btv->has_radio_tuner = 1;
1596	bttv_call_all(btv, tuner, s_radio);
1597	btv->audio_input = TVAUDIO_INPUT_RADIO;
1598	audio_input(btv, input: btv->audio_input);
1599	}
1600	}
1601
1602	static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id)
1603	{
1604	struct bttv *btv = video_drvdata(file);
1605	unsigned int i;
1606
1607	for (i = 0; i < BTTV_TVNORMS; i++)
1608	if (id & bttv_tvnorms[i].v4l2_id)
1609	break;
1610	if (i == BTTV_TVNORMS)
1611	return -EINVAL;
1612	btv->std = id;
1613	set_tvnorm(btv, norm: i);
1614	return 0;
1615	}
1616
1617	static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id)
1618	{
1619	struct bttv *btv = video_drvdata(file);
1620
1621	*id = btv->std;
1622	return 0;
1623	}
1624
1625	static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1626	{
1627	struct bttv *btv = video_drvdata(file);
1628
1629	if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1630	*id &= V4L2_STD_625_50;
1631	else
1632	*id &= V4L2_STD_525_60;
1633	return 0;
1634	}
1635
1636	static int bttv_enum_input(struct file *file, void *priv,
1637	struct v4l2_input *i)
1638	{
1639	struct bttv *btv = video_drvdata(file);
1640
1641	if (i->index >= bttv_tvcards[btv->c.type].video_inputs)
1642	return -EINVAL;
1643
1644	i->type = V4L2_INPUT_TYPE_CAMERA;
1645	i->audioset = 0;
1646
1647	if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1648	sprintf(buf: i->name, fmt: "Television");
1649	i->type = V4L2_INPUT_TYPE_TUNER;
1650	i->tuner = 0;
1651	} else if (i->index == btv->svhs) {
1652	sprintf(buf: i->name, fmt: "S-Video");
1653	} else {
1654	sprintf(buf: i->name, fmt: "Composite%d", i->index);
1655	}
1656
1657	if (i->index == btv->input) {
1658	__u32 dstatus = btread(BT848_DSTATUS);
1659	if (0 == (dstatus & BT848_DSTATUS_PRES))
1660	i->status |= V4L2_IN_ST_NO_SIGNAL;
1661	if (0 == (dstatus & BT848_DSTATUS_HLOC))
1662	i->status |= V4L2_IN_ST_NO_H_LOCK;
1663	}
1664
1665	i->std = BTTV_NORMS;
1666	return 0;
1667	}
1668
1669	static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1670	{
1671	struct bttv *btv = video_drvdata(file);
1672
1673	*i = btv->input;
1674
1675	return 0;
1676	}
1677
1678	static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1679	{
1680	struct bttv *btv = video_drvdata(file);
1681
1682	if (i >= bttv_tvcards[btv->c.type].video_inputs)
1683	return -EINVAL;
1684
1685	set_input(btv, input: i, norm: btv->tvnorm);
1686	return 0;
1687	}
1688
1689	static int bttv_s_tuner(struct file *file, void *priv,
1690	const struct v4l2_tuner *t)
1691	{
1692	struct bttv *btv = video_drvdata(file);
1693
1694	if (t->index)
1695	return -EINVAL;
1696
1697	bttv_call_all(btv, tuner, s_tuner, t);
1698
1699	if (btv->audio_mode_gpio) {
1700	struct v4l2_tuner copy = *t;
1701
1702	btv->audio_mode_gpio(btv, &copy, 1);
1703	}
1704	return 0;
1705	}
1706
1707	static int bttv_g_frequency(struct file *file, void *priv,
1708	struct v4l2_frequency *f)
1709	{
1710	struct bttv *btv = video_drvdata(file);
1711
1712	if (f->tuner)
1713	return -EINVAL;
1714
1715	if (f->type == V4L2_TUNER_RADIO)
1716	radio_enable(btv);
1717	f->frequency = f->type == V4L2_TUNER_RADIO ?
1718	btv->radio_freq : btv->tv_freq;
1719
1720	return 0;
1721	}
1722
1723	static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f)
1724	{
1725	struct v4l2_frequency new_freq = *f;
1726
1727	bttv_call_all(btv, tuner, s_frequency, f);
1728	/* s_frequency may clamp the frequency, so get the actual
1729	frequency before assigning radio/tv_freq. */
1730	bttv_call_all(btv, tuner, g_frequency, &new_freq);
1731	if (new_freq.type == V4L2_TUNER_RADIO) {
1732	radio_enable(btv);
1733	btv->radio_freq = new_freq.frequency;
1734	if (btv->has_tea575x) {
1735	btv->tea.freq = btv->radio_freq;
1736	snd_tea575x_set_freq(tea: &btv->tea);
1737	}
1738	} else {
1739	btv->tv_freq = new_freq.frequency;
1740	}
1741	}
1742
1743	static int bttv_s_frequency(struct file *file, void *priv,
1744	const struct v4l2_frequency *f)
1745	{
1746	struct bttv *btv = video_drvdata(file);
1747
1748	if (f->tuner)
1749	return -EINVAL;
1750
1751	bttv_set_frequency(btv, f);
1752	return 0;
1753	}
1754
1755	static int bttv_log_status(struct file *file, void *f)
1756	{
1757	struct video_device *vdev = video_devdata(file);
1758	struct bttv *btv = video_drvdata(file);
1759
1760	v4l2_ctrl_handler_log_status(hdl: vdev->ctrl_handler, prefix: btv->c.v4l2_dev.name);
1761	bttv_call_all(btv, core, log_status);
1762	return 0;
1763	}
1764
1765	#ifdef CONFIG_VIDEO_ADV_DEBUG
1766	static int bttv_g_register(struct file *file, void *f,
1767	struct v4l2_dbg_register *reg)
1768	{
1769	struct bttv *btv = video_drvdata(file);
1770
1771	/* bt848 has a 12-bit register space */
1772	reg->reg &= 0xfff;
1773	reg->val = btread(reg->reg);
1774	reg->size = 1;
1775
1776	return 0;
1777	}
1778
1779	static int bttv_s_register(struct file *file, void *f,
1780	const struct v4l2_dbg_register *reg)
1781	{
1782	struct bttv *btv = video_drvdata(file);
1783
1784	/* bt848 has a 12-bit register space */
1785	btwrite(reg->val, reg->reg & 0xfff);
1786
1787	return 0;
1788	}
1789	#endif
1790
1791	/* Given cropping boundaries b and the scaled width and height of a
1792	single field or frame, which must not exceed hardware limits, this
1793	function adjusts the cropping parameters c. */
1794	static void
1795	bttv_crop_adjust (struct bttv_crop * c,
1796	const struct v4l2_rect * b,
1797	__s32 width,
1798	__s32 height,
1799	enum v4l2_field field)
1800	{
1801	__s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
1802	__s32 max_left;
1803	__s32 max_top;
1804
1805	if (width < c->min_scaled_width) {
1806	/* Max. hor. scale factor 16:1. */
1807	c->rect.width = width * 16;
1808	} else if (width > c->max_scaled_width) {
1809	/* Min. hor. scale factor 1:1. */
1810	c->rect.width = width;
1811
1812	max_left = b->left + b->width - width;
1813	max_left = min(max_left, (__s32) MAX_HDELAY);
1814	if (c->rect.left > max_left)
1815	c->rect.left = max_left;
1816	}
1817
1818	if (height < c->min_scaled_height) {
1819	/* Max. vert. scale factor 16:1, single fields 8:1. */
1820	c->rect.height = height * 16;
1821	} else if (frame_height > c->max_scaled_height) {
1822	/* Min. vert. scale factor 1:1.
1823	Top and height count field lines times two. */
1824	c->rect.height = (frame_height + 1) & ~1;
1825
1826	max_top = b->top + b->height - c->rect.height;
1827	if (c->rect.top > max_top)
1828	c->rect.top = max_top;
1829	}
1830
1831	bttv_crop_calc_limits(c);
1832	}
1833
1834	/* Returns an error if scaling to a frame or single field with the given
1835	width and height is not possible with the current cropping parameters
1836	and width aligned according to width_mask. If adjust_size is TRUE the
1837	function may adjust the width and/or height instead, rounding width
1838	to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
1839	also adjust the current cropping parameters to get closer to the
1840	desired image size. */
1841	static int
1842	limit_scaled_size_lock(struct bttv *btv, __s32 *width, __s32 *height,
1843	enum v4l2_field field, unsigned int width_mask,
1844	unsigned int width_bias, int adjust_size,
1845	int adjust_crop)
1846	{
1847	const struct v4l2_rect *b;
1848	struct bttv_crop *c;
1849	__s32 min_width;
1850	__s32 min_height;
1851	__s32 max_width;
1852	__s32 max_height;
1853	int rc;
1854
1855	WARN_ON((int)width_mask >= 0 ||
1856	width_bias >= (unsigned int)(-width_mask));
1857
1858	/* Make sure tvnorm, vbi_end and the current cropping parameters
1859	remain consistent until we're done. */
1860
1861	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
1862
1863	/* Do crop - use current, don't - use default parameters. */
1864	c = &btv->crop[!!btv->do_crop];
1865
1866	if (btv->do_crop
1867	&& adjust_size
1868	&& adjust_crop
1869	&& !locked_btres(btv, VIDEO_RESOURCES)) {
1870	min_width = 48;
1871	min_height = 32;
1872
1873	/* We cannot scale up. When the scaled image is larger
1874	than crop.rect we adjust the crop.rect as required
1875	by the V4L2 spec, hence cropcap.bounds are our limit. */
1876	max_width = min_t(unsigned int, b->width, MAX_HACTIVE);
1877	max_height = b->height;
1878
1879	/* We cannot capture the same line as video and VBI data.
1880	Note btv->vbi_end is really a minimum, see
1881	bttv_vbi_try_fmt(). */
1882	if (btv->vbi_end > b->top) {
1883	max_height -= btv->vbi_end - b->top;
1884	rc = -EBUSY;
1885	if (min_height > max_height)
1886	goto fail;
1887	}
1888	} else {
1889	rc = -EBUSY;
1890	if (btv->vbi_end > c->rect.top)
1891	goto fail;
1892
1893	min_width = c->min_scaled_width;
1894	min_height = c->min_scaled_height;
1895	max_width = c->max_scaled_width;
1896	max_height = c->max_scaled_height;
1897
1898	adjust_crop = 0;
1899	}
1900
1901	min_width = (min_width - width_mask - 1) & width_mask;
1902	max_width = max_width & width_mask;
1903
1904	/* Max. scale factor is 16:1 for frames, 8:1 for fields. */
1905	/* Min. scale factor is 1:1. */
1906	max_height >>= !V4L2_FIELD_HAS_BOTH(field);
1907
1908	if (adjust_size) {
1909	*width = clamp(*width, min_width, max_width);
1910	*height = clamp(*height, min_height, max_height);
1911
1912	/* Round after clamping to avoid overflow. */
1913	*width = (*width + width_bias) & width_mask;
1914
1915	if (adjust_crop) {
1916	bttv_crop_adjust(c, b, width: *width, height: *height, field);
1917
1918	if (btv->vbi_end > c->rect.top) {
1919	/* Move the crop window out of the way. */
1920	c->rect.top = btv->vbi_end;
1921	}
1922	}
1923	} else {
1924	rc = -EINVAL;
1925	if (*width < min_width ||
1926	*height < min_height ||
1927	*width > max_width ||
1928	*height > max_height ||
1929	0 != (*width & ~width_mask))
1930	goto fail;
1931	}
1932
1933	rc = 0; /* success */
1934
1935	fail:
1936
1937	return rc;
1938	}
1939
1940	static int bttv_switch_type(struct bttv *btv, enum v4l2_buf_type type)
1941	{
1942	int res;
1943	struct vb2_queue *q;
1944
1945	switch (type) {
1946	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1947	q = &btv->capq;
1948	res = RESOURCE_VIDEO_STREAM;
1949	break;
1950	case V4L2_BUF_TYPE_VBI_CAPTURE:
1951	q = &btv->vbiq;
1952	res = RESOURCE_VBI;
1953	break;
1954	default:
1955	WARN_ON(1);
1956	return -EINVAL;
1957	}
1958
1959	if (check_btres(btv, bit: res))
1960	return -EBUSY;
1961	if (vb2_is_busy(q))
1962	return -EBUSY;
1963	btv->type = type;
1964
1965	return 0;
1966	}
1967
1968	static void
1969	pix_format_set_size (struct v4l2_pix_format * f,
1970	const struct bttv_format * fmt,
1971	unsigned int width,
1972	unsigned int height)
1973	{
1974	f->width = width;
1975	f->height = height;
1976
1977	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
1978	f->bytesperline = width; /* Y plane */
1979	f->sizeimage = (width * height * fmt->depth) >> 3;
1980	} else {
1981	f->bytesperline = (width * fmt->depth) >> 3;
1982	f->sizeimage = height * f->bytesperline;
1983	}
1984	}
1985
1986	static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
1987	struct v4l2_format *f)
1988	{
1989	struct bttv *btv = video_drvdata(file);
1990
1991	pix_format_set_size(f: &f->fmt.pix, fmt: btv->fmt, width: btv->width, height: btv->height);
1992	f->fmt.pix.field = btv->field;
1993	f->fmt.pix.pixelformat = btv->fmt->fourcc;
1994	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1995
1996	return 0;
1997	}
1998
1999	static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt,
2000	unsigned int *width_mask,
2001	unsigned int *width_bias)
2002	{
2003	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2004	*width_mask = ~15; /* width must be a multiple of 16 pixels */
2005	*width_bias = 8; /* nearest */
2006	} else {
2007	*width_mask = ~3; /* width must be a multiple of 4 pixels */
2008	*width_bias = 2; /* nearest */
2009	}
2010	}
2011
2012	static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2013	struct v4l2_format *f)
2014	{
2015	const struct bttv_format *fmt;
2016	struct bttv *btv = video_drvdata(file);
2017	enum v4l2_field field;
2018	__s32 width, height;
2019	__s32 height2;
2020	unsigned int width_mask, width_bias;
2021	int rc;
2022
2023	fmt = format_by_fourcc(fourcc: f->fmt.pix.pixelformat);
2024	if (NULL == fmt)
2025	return -EINVAL;
2026
2027	field = f->fmt.pix.field;
2028
2029	switch (field) {
2030	case V4L2_FIELD_TOP:
2031	case V4L2_FIELD_BOTTOM:
2032	case V4L2_FIELD_ALTERNATE:
2033	case V4L2_FIELD_INTERLACED:
2034	break;
2035	case V4L2_FIELD_SEQ_BT:
2036	case V4L2_FIELD_SEQ_TB:
2037	if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) {
2038	field = V4L2_FIELD_SEQ_TB;
2039	break;
2040	}
2041	fallthrough;
2042	default: /* FIELD_ANY case */
2043	height2 = btv->crop[!!btv->do_crop].rect.height >> 1;
2044	field = (f->fmt.pix.height > height2)
2045	? V4L2_FIELD_INTERLACED
2046	: V4L2_FIELD_BOTTOM;
2047	break;
2048	}
2049
2050	width = f->fmt.pix.width;
2051	height = f->fmt.pix.height;
2052
2053	bttv_get_width_mask_vid_cap(fmt, width_mask: &width_mask, width_bias: &width_bias);
2054	rc = limit_scaled_size_lock(btv, width: &width, height: &height, field, width_mask,
2055	width_bias, adjust_size: 1, adjust_crop: 0);
2056	if (0 != rc)
2057	return rc;
2058
2059	/* update data for the application */
2060	f->fmt.pix.field = field;
2061	pix_format_set_size(f: &f->fmt.pix, fmt, width, height);
2062	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2063
2064	return 0;
2065	}
2066
2067	static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2068	struct v4l2_format *f)
2069	{
2070	int retval;
2071	const struct bttv_format *fmt;
2072	struct bttv *btv = video_drvdata(file);
2073	__s32 width, height;
2074	unsigned int width_mask, width_bias;
2075	enum v4l2_field field;
2076
2077	retval = bttv_switch_type(btv, type: f->type);
2078	if (0 != retval)
2079	return retval;
2080
2081	retval = bttv_try_fmt_vid_cap(file, priv, f);
2082	if (0 != retval)
2083	return retval;
2084
2085	width = f->fmt.pix.width;
2086	height = f->fmt.pix.height;
2087	field = f->fmt.pix.field;
2088
2089	fmt = format_by_fourcc(fourcc: f->fmt.pix.pixelformat);
2090	bttv_get_width_mask_vid_cap(fmt, width_mask: &width_mask, width_bias: &width_bias);
2091	retval = limit_scaled_size_lock(btv, width: &width, height: &height, field: f->fmt.pix.field,
2092	width_mask, width_bias, adjust_size: 1, adjust_crop: 1);
2093	if (0 != retval)
2094	return retval;
2095
2096	f->fmt.pix.field = field;
2097
2098	/* update our state information */
2099	btv->fmt = fmt;
2100	btv->width = f->fmt.pix.width;
2101	btv->height = f->fmt.pix.height;
2102	btv->field = f->fmt.pix.field;
2103	/*
2104	* When field is V4L2_FIELD_ALTERNATE, buffers will be either
2105	* V4L2_FIELD_TOP or V4L2_FIELD_BOTTOM depending on the value of
2106	* field_last. Initialize field_last to V4L2_FIELD_BOTTOM so that
2107	* streaming starts with a V4L2_FIELD_TOP buffer.
2108	*/
2109	btv->field_last = V4L2_FIELD_BOTTOM;
2110
2111	return 0;
2112	}
2113
2114	static int bttv_querycap(struct file *file, void *priv,
2115	struct v4l2_capability *cap)
2116	{
2117	struct bttv *btv = video_drvdata(file);
2118
2119	if (0 == v4l2)
2120	return -EINVAL;
2121
2122	strscpy(cap->driver, "bttv", sizeof(cap->driver));
2123	strscpy(cap->card, btv->video_dev.name, sizeof(cap->card));
2124	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2125	V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
2126	if (video_is_registered(vdev: &btv->vbi_dev))
2127	cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
2128	if (video_is_registered(vdev: &btv->radio_dev)) {
2129	cap->capabilities |= V4L2_CAP_RADIO;
2130	if (btv->has_tea575x)
2131	cap->capabilities |= V4L2_CAP_HW_FREQ_SEEK;
2132	}
2133
2134	/*
2135	* No need to lock here: those vars are initialized during board
2136	* probe and remains untouched during the rest of the driver lifecycle
2137	*/
2138	if (btv->has_saa6588)
2139	cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2140	if (btv->tuner_type != TUNER_ABSENT)
2141	cap->capabilities |= V4L2_CAP_TUNER;
2142	return 0;
2143	}
2144
2145	static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
2146	struct v4l2_fmtdesc *f)
2147	{
2148	int index = -1, i;
2149
2150	for (i = 0; i < FORMATS; i++) {
2151	if (formats[i].fourcc != -1)
2152	index++;
2153	if ((unsigned int)index == f->index)
2154	break;
2155	}
2156	if (FORMATS == i)
2157	return -EINVAL;
2158
2159	f->pixelformat = formats[i].fourcc;
2160
2161	return 0;
2162	}
2163
2164	static int bttv_g_parm(struct file *file, void *f,
2165	struct v4l2_streamparm *parm)
2166	{
2167	struct bttv *btv = video_drvdata(file);
2168
2169	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2170	return -EINVAL;
2171	parm->parm.capture.readbuffers = gbuffers;
2172	v4l2_video_std_frame_period(id: bttv_tvnorms[btv->tvnorm].v4l2_id,
2173	frameperiod: &parm->parm.capture.timeperframe);
2174
2175	return 0;
2176	}
2177
2178	static int bttv_g_tuner(struct file *file, void *priv,
2179	struct v4l2_tuner *t)
2180	{
2181	struct bttv *btv = video_drvdata(file);
2182
2183	if (0 != t->index)
2184	return -EINVAL;
2185
2186	t->rxsubchans = V4L2_TUNER_SUB_MONO;
2187	t->capability = V4L2_TUNER_CAP_NORM;
2188	bttv_call_all(btv, tuner, g_tuner, t);
2189	strscpy(t->name, "Television", sizeof(t->name));
2190	t->type = V4L2_TUNER_ANALOG_TV;
2191	if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2192	t->signal = 0xffff;
2193
2194	if (btv->audio_mode_gpio)
2195	btv->audio_mode_gpio(btv, t, 0);
2196
2197	return 0;
2198	}
2199
2200	static int bttv_g_pixelaspect(struct file *file, void *priv,
2201	int type, struct v4l2_fract *f)
2202	{
2203	struct bttv *btv = video_drvdata(file);
2204
2205	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2206	return -EINVAL;
2207
2208	/* defrect and bounds are set via g_selection */
2209	*f = bttv_tvnorms[btv->tvnorm].cropcap.pixelaspect;
2210	return 0;
2211	}
2212
2213	static int bttv_g_selection(struct file *file, void *f, struct v4l2_selection *sel)
2214	{
2215	struct bttv *btv = video_drvdata(file);
2216
2217	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2218	return -EINVAL;
2219
2220	switch (sel->target) {
2221	case V4L2_SEL_TGT_CROP:
2222	sel->r = btv->crop[!!btv->do_crop].rect;
2223	break;
2224	case V4L2_SEL_TGT_CROP_DEFAULT:
2225	sel->r = bttv_tvnorms[btv->tvnorm].cropcap.defrect;
2226	break;
2227	case V4L2_SEL_TGT_CROP_BOUNDS:
2228	sel->r = bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2229	break;
2230	default:
2231	return -EINVAL;
2232	}
2233
2234	return 0;
2235	}
2236
2237	static int bttv_s_selection(struct file *file, void *f, struct v4l2_selection *sel)
2238	{
2239	struct bttv *btv = video_drvdata(file);
2240	const struct v4l2_rect *b;
2241	int retval;
2242	struct bttv_crop c;
2243	__s32 b_left;
2244	__s32 b_top;
2245	__s32 b_right;
2246	__s32 b_bottom;
2247
2248	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2249	return -EINVAL;
2250
2251	if (sel->target != V4L2_SEL_TGT_CROP)
2252	return -EINVAL;
2253
2254	/* Make sure tvnorm, vbi_end and the current cropping
2255	parameters remain consistent until we're done. Note
2256	read() may change vbi_end in check_alloc_btres_lock(). */
2257	retval = -EBUSY;
2258
2259	if (locked_btres(btv, VIDEO_RESOURCES))
2260	return retval;
2261
2262	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2263
2264	b_left = b->left;
2265	b_right = b_left + b->width;
2266	b_bottom = b->top + b->height;
2267
2268	b_top = max(b->top, btv->vbi_end);
2269	if (b_top + 32 >= b_bottom) {
2270	return retval;
2271	}
2272
2273	/* Min. scaled size 48 x 32. */
2274	c.rect.left = clamp_t(s32, sel->r.left, b_left, b_right - 48);
2275	c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
2276
2277	c.rect.width = clamp_t(s32, sel->r.width,
2278	48, b_right - c.rect.left);
2279
2280	c.rect.top = clamp_t(s32, sel->r.top, b_top, b_bottom - 32);
2281	/* Top and height must be a multiple of two. */
2282	c.rect.top = (c.rect.top + 1) & ~1;
2283
2284	c.rect.height = clamp_t(s32, sel->r.height,
2285	32, b_bottom - c.rect.top);
2286	c.rect.height = (c.rect.height + 1) & ~1;
2287
2288	bttv_crop_calc_limits(c: &c);
2289
2290	sel->r = c.rect;
2291
2292	btv->crop[1] = c;
2293
2294	btv->do_crop = 1;
2295
2296	if (btv->width < c.min_scaled_width)
2297	btv->width = c.min_scaled_width;
2298	else if (btv->width > c.max_scaled_width)
2299	btv->width = c.max_scaled_width;
2300
2301	if (btv->height < c.min_scaled_height)
2302	btv->height = c.min_scaled_height;
2303	else if (btv->height > c.max_scaled_height)
2304	btv->height = c.max_scaled_height;
2305
2306	return 0;
2307	}
2308
2309	static const struct v4l2_file_operations bttv_fops =
2310	{
2311	.owner = THIS_MODULE,
2312	.open = v4l2_fh_open,
2313	.release = vb2_fop_release,
2314	.unlocked_ioctl = video_ioctl2,
2315	.read = vb2_fop_read,
2316	.mmap = vb2_fop_mmap,
2317	.poll = vb2_fop_poll,
2318	};
2319
2320	static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
2321	.vidioc_querycap = bttv_querycap,
2322	.vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
2323	.vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
2324	.vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
2325	.vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
2326	.vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
2327	.vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
2328	.vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
2329	.vidioc_g_pixelaspect = bttv_g_pixelaspect,
2330	.vidioc_reqbufs = vb2_ioctl_reqbufs,
2331	.vidioc_create_bufs = vb2_ioctl_create_bufs,
2332	.vidioc_querybuf = vb2_ioctl_querybuf,
2333	.vidioc_qbuf = vb2_ioctl_qbuf,
2334	.vidioc_dqbuf = vb2_ioctl_dqbuf,
2335	.vidioc_streamon = vb2_ioctl_streamon,
2336	.vidioc_streamoff = vb2_ioctl_streamoff,
2337	.vidioc_s_std = bttv_s_std,
2338	.vidioc_g_std = bttv_g_std,
2339	.vidioc_enum_input = bttv_enum_input,
2340	.vidioc_g_input = bttv_g_input,
2341	.vidioc_s_input = bttv_s_input,
2342	.vidioc_g_tuner = bttv_g_tuner,
2343	.vidioc_s_tuner = bttv_s_tuner,
2344	.vidioc_g_selection = bttv_g_selection,
2345	.vidioc_s_selection = bttv_s_selection,
2346	.vidioc_g_parm = bttv_g_parm,
2347	.vidioc_g_frequency = bttv_g_frequency,
2348	.vidioc_s_frequency = bttv_s_frequency,
2349	.vidioc_log_status = bttv_log_status,
2350	.vidioc_querystd = bttv_querystd,
2351	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2352	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2353	#ifdef CONFIG_VIDEO_ADV_DEBUG
2354	.vidioc_g_register = bttv_g_register,
2355	.vidioc_s_register = bttv_s_register,
2356	#endif
2357	};
2358
2359	static struct video_device bttv_video_template = {
2360	.fops = &bttv_fops,
2361	.ioctl_ops = &bttv_ioctl_ops,
2362	.tvnorms = BTTV_NORMS,
2363	};
2364
2365	/* ----------------------------------------------------------------------- */
2366	/* radio interface */
2367
2368	static int radio_open(struct file *file)
2369	{
2370	struct video_device *vdev = video_devdata(file);
2371	struct bttv *btv = video_drvdata(file);
2372	int ret = v4l2_fh_open(filp: file);
2373
2374	if (ret)
2375	return ret;
2376
2377	dprintk("open dev=%s\n", video_device_node_name(vdev));
2378	dprintk("%d: open called (radio)\n", btv->c.nr);
2379
2380	btv->radio_user++;
2381	audio_mute(btv, mute: btv->mute);
2382
2383	return 0;
2384	}
2385
2386	static int radio_release(struct file *file)
2387	{
2388	struct bttv *btv = video_drvdata(file);
2389	struct saa6588_command cmd;
2390
2391	btv->radio_user--;
2392
2393	bttv_call_all(btv, core, command, SAA6588_CMD_CLOSE, &cmd);
2394
2395	if (btv->radio_user == 0)
2396	btv->has_radio_tuner = 0;
2397
2398	v4l2_fh_release(filp: file);
2399
2400	return 0;
2401	}
2402
2403	static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
2404	{
2405	struct bttv *btv = video_drvdata(file);
2406
2407	if (0 != t->index)
2408	return -EINVAL;
2409	strscpy(t->name, "Radio", sizeof(t->name));
2410	t->type = V4L2_TUNER_RADIO;
2411	radio_enable(btv);
2412
2413	bttv_call_all(btv, tuner, g_tuner, t);
2414
2415	if (btv->audio_mode_gpio)
2416	btv->audio_mode_gpio(btv, t, 0);
2417
2418	if (btv->has_tea575x)
2419	return snd_tea575x_g_tuner(tea: &btv->tea, v: t);
2420
2421	return 0;
2422	}
2423
2424	static int radio_s_tuner(struct file *file, void *priv,
2425	const struct v4l2_tuner *t)
2426	{
2427	struct bttv *btv = video_drvdata(file);
2428
2429	if (0 != t->index)
2430	return -EINVAL;
2431
2432	radio_enable(btv);
2433	bttv_call_all(btv, tuner, s_tuner, t);
2434	return 0;
2435	}
2436
2437	static int radio_s_hw_freq_seek(struct file *file, void *priv,
2438	const struct v4l2_hw_freq_seek *a)
2439	{
2440	struct bttv *btv = video_drvdata(file);
2441
2442	if (btv->has_tea575x)
2443	return snd_tea575x_s_hw_freq_seek(file, tea: &btv->tea, a);
2444
2445	return -ENOTTY;
2446	}
2447
2448	static int radio_enum_freq_bands(struct file *file, void *priv,
2449	struct v4l2_frequency_band *band)
2450	{
2451	struct bttv *btv = video_drvdata(file);
2452
2453	if (btv->has_tea575x)
2454	return snd_tea575x_enum_freq_bands(tea: &btv->tea, band);
2455
2456	return -ENOTTY;
2457	}
2458
2459	static ssize_t radio_read(struct file *file, char __user *data,
2460	size_t count, loff_t *ppos)
2461	{
2462	struct bttv *btv = video_drvdata(file);
2463	struct saa6588_command cmd;
2464
2465	cmd.block_count = count / 3;
2466	cmd.nonblocking = file->f_flags & O_NONBLOCK;
2467	cmd.buffer = data;
2468	cmd.instance = file;
2469	cmd.result = -ENODEV;
2470	radio_enable(btv);
2471
2472	bttv_call_all(btv, core, command, SAA6588_CMD_READ, &cmd);
2473
2474	return cmd.result;
2475	}
2476
2477	static __poll_t radio_poll(struct file *file, poll_table *wait)
2478	{
2479	struct bttv *btv = video_drvdata(file);
2480	struct saa6588_command cmd;
2481	__poll_t rc = v4l2_ctrl_poll(file, wait);
2482
2483	radio_enable(btv);
2484	cmd.instance = file;
2485	cmd.event_list = wait;
2486	cmd.poll_mask = 0;
2487	bttv_call_all(btv, core, command, SAA6588_CMD_POLL, &cmd);
2488
2489	return rc | cmd.poll_mask;
2490	}
2491
2492	static const struct v4l2_file_operations radio_fops =
2493	{
2494	.owner = THIS_MODULE,
2495	.open = radio_open,
2496	.read = radio_read,
2497	.release = radio_release,
2498	.unlocked_ioctl = video_ioctl2,
2499	.poll = radio_poll,
2500	};
2501
2502	static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2503	.vidioc_querycap = bttv_querycap,
2504	.vidioc_log_status = bttv_log_status,
2505	.vidioc_g_tuner = radio_g_tuner,
2506	.vidioc_s_tuner = radio_s_tuner,
2507	.vidioc_g_frequency = bttv_g_frequency,
2508	.vidioc_s_frequency = bttv_s_frequency,
2509	.vidioc_s_hw_freq_seek = radio_s_hw_freq_seek,
2510	.vidioc_enum_freq_bands = radio_enum_freq_bands,
2511	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2512	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2513	};
2514
2515	static struct video_device radio_template = {
2516	.fops = &radio_fops,
2517	.ioctl_ops = &radio_ioctl_ops,
2518	};
2519
2520	/* ----------------------------------------------------------------------- */
2521	/* some debug code */
2522
2523	static int bttv_risc_decode(u32 risc)
2524	{
2525	static char *instr[16] = {
2526	[ BT848_RISC_WRITE >> 28 ] = "write",
2527	[ BT848_RISC_SKIP >> 28 ] = "skip",
2528	[ BT848_RISC_WRITEC >> 28 ] = "writec",
2529	[ BT848_RISC_JUMP >> 28 ] = "jump",
2530	[ BT848_RISC_SYNC >> 28 ] = "sync",
2531	[ BT848_RISC_WRITE123 >> 28 ] = "write123",
2532	[ BT848_RISC_SKIP123 >> 28 ] = "skip123",
2533	[ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
2534	};
2535	static int incr[16] = {
2536	[ BT848_RISC_WRITE >> 28 ] = 2,
2537	[ BT848_RISC_JUMP >> 28 ] = 2,
2538	[ BT848_RISC_SYNC >> 28 ] = 2,
2539	[ BT848_RISC_WRITE123 >> 28 ] = 5,
2540	[ BT848_RISC_SKIP123 >> 28 ] = 2,
2541	[ BT848_RISC_WRITE1S23 >> 28 ] = 3,
2542	};
2543	static char *bits[] = {
2544	"be0", "be1", "be2", "be3/resync",
2545	"set0", "set1", "set2", "set3",
2546	"clr0", "clr1", "clr2", "clr3",
2547	"irq", "res", "eol", "sol",
2548	};
2549	int i;
2550
2551	pr_cont("0x%08x [ %s", risc,
2552	instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
2553	for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
2554	if (risc & (1 << (i + 12)))
2555	pr_cont(" %s", bits[i]);
2556	pr_cont(" count=%d ]\n", risc & 0xfff);
2557	return incr[risc >> 28] ? incr[risc >> 28] : 1;
2558	}
2559
2560	static void bttv_risc_disasm(struct bttv *btv,
2561	struct btcx_riscmem *risc)
2562	{
2563	unsigned int i,j,n;
2564
2565	pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
2566	btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
2567	for (i = 0; i < (risc->size >> 2); i += n) {
2568	pr_info("%s: 0x%lx: ",
2569	btv->c.v4l2_dev.name,
2570	(unsigned long)(risc->dma + (i<<2)));
2571	n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
2572	for (j = 1; j < n; j++)
2573	pr_info("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
2574	btv->c.v4l2_dev.name,
2575	(unsigned long)(risc->dma + ((i+j)<<2)),
2576	risc->cpu[i+j], j);
2577	if (0 == risc->cpu[i])
2578	break;
2579	}
2580	}
2581
2582	static void bttv_print_riscaddr(struct bttv *btv)
2583	{
2584	pr_info(" main: %08llx\n", (unsigned long long)btv->main.dma);
2585	pr_info(" vbi : o=%08llx e=%08llx\n",
2586	btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
2587	btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
2588	pr_info(" cap : o=%08llx e=%08llx\n",
2589	btv->curr.top
2590	? (unsigned long long)btv->curr.top->top.dma : 0,
2591	btv->curr.bottom
2592	? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
2593	bttv_risc_disasm(btv, risc: &btv->main);
2594	}
2595
2596	/* ----------------------------------------------------------------------- */
2597	/* irq handler */
2598
2599	static char *irq_name[] = {
2600	"FMTCHG", // format change detected (525 vs. 625)
2601	"VSYNC", // vertical sync (new field)
2602	"HSYNC", // horizontal sync
2603	"OFLOW", // chroma/luma AGC overflow
2604	"HLOCK", // horizontal lock changed
2605	"VPRES", // video presence changed
2606	"6", "7",
2607	"I2CDONE", // hw irc operation finished
2608	"GPINT", // gpio port triggered irq
2609	"10",
2610	"RISCI", // risc instruction triggered irq
2611	"FBUS", // pixel data fifo dropped data (high pci bus latencies)
2612	"FTRGT", // pixel data fifo overrun
2613	"FDSR", // fifo data stream resyncronisation
2614	"PPERR", // parity error (data transfer)
2615	"RIPERR", // parity error (read risc instructions)
2616	"PABORT", // pci abort
2617	"OCERR", // risc instruction error
2618	"SCERR", // syncronisation error
2619	};
2620
2621	static void bttv_print_irqbits(u32 print, u32 mark)
2622	{
2623	unsigned int i;
2624
2625	pr_cont("bits:");
2626	for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
2627	if (print & (1 << i))
2628	pr_cont(" %s", irq_name[i]);
2629	if (mark & (1 << i))
2630	pr_cont("*");
2631	}
2632	}
2633
2634	static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
2635	{
2636	pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
2637	btv->c.nr,
2638	(unsigned long)btv->main.dma,
2639	(unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
2640	(unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
2641	(unsigned long)rc);
2642
2643	if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
2644	pr_notice("%d: Oh, there (temporarily?) is no input signal. Ok, then this is harmless, don't worry ;)\n",
2645	btv->c.nr);
2646	return;
2647	}
2648	pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n",
2649	btv->c.nr);
2650	pr_notice("%d: Lets try to catch the culprit red-handed ...\n",
2651	btv->c.nr);
2652	dump_stack();
2653	}
2654
2655	static int
2656	bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
2657	{
2658	struct bttv_buffer *item;
2659
2660	memset(set,0,sizeof(*set));
2661
2662	/* capture request ? */
2663	if (!list_empty(head: &btv->capture)) {
2664	set->frame_irq = BT848_RISC_VIDEO;
2665	item = list_entry(btv->capture.next, struct bttv_buffer, list);
2666
2667	if (V4L2_FIELD_HAS_TOP(item->vbuf.field))
2668	set->top = item;
2669	if (V4L2_FIELD_HAS_BOTTOM(item->vbuf.field))
2670	set->bottom = item;
2671
2672	/* capture request for other field ? */
2673	if (!V4L2_FIELD_HAS_BOTH(item->vbuf.field) &&
2674	item->list.next != &btv->capture) {
2675	item = list_entry(item->list.next,
2676	struct bttv_buffer, list);
2677	/* Mike Isely <isely@pobox.com> - Only check
2678	* and set up the bottom field in the logic
2679	* below. Don't ever do the top field. This
2680	* of course means that if we set up the
2681	* bottom field in the above code that we'll
2682	* actually skip a field. But that's OK.
2683	* Having processed only a single buffer this
2684	* time, then the next time around the first
2685	* available buffer should be for a top field.
2686	* That will then cause us here to set up a
2687	* top then a bottom field in the normal way.
2688	* The alternative to this understanding is
2689	* that we set up the second available buffer
2690	* as a top field, but that's out of order
2691	* since this driver always processes the top
2692	* field first - the effect will be the two
2693	* buffers being returned in the wrong order,
2694	* with the second buffer also being delayed
2695	* by one field time (owing to the fifo nature
2696	* of videobuf). Worse still, we'll be stuck
2697	* doing fields out of order now every time
2698	* until something else causes a field to be
2699	* dropped. By effectively forcing a field to
2700	* drop this way then we always get back into
2701	* sync within a single frame time. (Out of
2702	* order fields can screw up deinterlacing
2703	* algorithms.) */
2704	if (!V4L2_FIELD_HAS_BOTH(item->vbuf.field)) {
2705	if (!set->bottom &&
2706	item->vbuf.field == V4L2_FIELD_BOTTOM)
2707	set->bottom = item;
2708	if (set->top && set->bottom) {
2709	/*
2710	* The buffer set has a top buffer and
2711	* a bottom buffer and they are not
2712	* copies of each other.
2713	*/
2714	set->top_irq = BT848_RISC_TOP;
2715	}
2716	}
2717	}
2718	}
2719
2720	dprintk("%d: next set: top=%p bottom=%p [irq=%d,%d]\n",
2721	btv->c.nr, set->top, set->bottom,
2722	set->frame_irq, set->top_irq);
2723	return 0;
2724	}
2725
2726	static void
2727	bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
2728	struct bttv_buffer_set *curr, unsigned int state)
2729	{
2730	u64 ts = ktime_get_ns();
2731
2732	if (wakeup->top == wakeup->bottom) {
2733	if (NULL != wakeup->top && curr->top != wakeup->top) {
2734	if (irq_debug > 1)
2735	pr_debug("%d: wakeup: both=%p\n",
2736	btv->c.nr, wakeup->top);
2737	wakeup->top->vbuf.vb2_buf.timestamp = ts;
2738	wakeup->top->vbuf.sequence = btv->field_count >> 1;
2739	vb2_buffer_done(vb: &wakeup->top->vbuf.vb2_buf, state);
2740	if (btv->field_count == 0)
2741	btor(BT848_INT_VSYNC, BT848_INT_MASK);
2742	}
2743	} else {
2744	if (NULL != wakeup->top && curr->top != wakeup->top) {
2745	if (irq_debug > 1)
2746	pr_debug("%d: wakeup: top=%p\n",
2747	btv->c.nr, wakeup->top);
2748	wakeup->top->vbuf.vb2_buf.timestamp = ts;
2749	wakeup->top->vbuf.sequence = btv->field_count >> 1;
2750	vb2_buffer_done(vb: &wakeup->top->vbuf.vb2_buf, state);
2751	if (btv->field_count == 0)
2752	btor(BT848_INT_VSYNC, BT848_INT_MASK);
2753	}
2754	if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
2755	if (irq_debug > 1)
2756	pr_debug("%d: wakeup: bottom=%p\n",
2757	btv->c.nr, wakeup->bottom);
2758	wakeup->bottom->vbuf.vb2_buf.timestamp = ts;
2759	wakeup->bottom->vbuf.sequence = btv->field_count >> 1;
2760	vb2_buffer_done(vb: &wakeup->bottom->vbuf.vb2_buf, state);
2761	if (btv->field_count == 0)
2762	btor(BT848_INT_VSYNC, BT848_INT_MASK);
2763	}
2764	}
2765	}
2766
2767	static void
2768	bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
2769	unsigned int state)
2770	{
2771	if (NULL == wakeup)
2772	return;
2773	wakeup->vbuf.vb2_buf.timestamp = ktime_get_ns();
2774	wakeup->vbuf.sequence = btv->field_count >> 1;
2775
2776	/*
2777	* Ugly hack for backwards compatibility.
2778	* Some applications expect that the last 4 bytes of
2779	* the VBI data contains the sequence number.
2780	*
2781	* This makes it possible to associate the VBI data
2782	* with the video frame if you use read() to get the
2783	* VBI data.
2784	*/
2785	if (vb2_fileio_is_active(q: wakeup->vbuf.vb2_buf.vb2_queue)) {
2786	u32 *vaddr = vb2_plane_vaddr(vb: &wakeup->vbuf.vb2_buf, plane_no: 0);
2787	unsigned long size =
2788	vb2_get_plane_payload(vb: &wakeup->vbuf.vb2_buf, plane_no: 0) / 4;
2789
2790	if (vaddr && size) {
2791	vaddr += size - 1;
2792	*vaddr = wakeup->vbuf.sequence;
2793	}
2794	}
2795
2796	vb2_buffer_done(vb: &wakeup->vbuf.vb2_buf, state);
2797	if (btv->field_count == 0)
2798	btor(BT848_INT_VSYNC, BT848_INT_MASK);
2799	}
2800
2801	static void bttv_irq_timeout(struct timer_list *t)
2802	{
2803	struct bttv *btv = from_timer(btv, t, timeout);
2804	struct bttv_buffer_set old,new;
2805	struct bttv_buffer *ovbi;
2806	struct bttv_buffer *item;
2807	unsigned long flags;
2808	int seqnr = 0;
2809
2810	if (bttv_verbose) {
2811	pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
2812	btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
2813	btread(BT848_RISC_COUNT));
2814	bttv_print_irqbits(btread(BT848_INT_STAT),mark: 0);
2815	pr_cont("\n");
2816	}
2817
2818	spin_lock_irqsave(&btv->s_lock,flags);
2819
2820	/* deactivate stuff */
2821	memset(&new,0,sizeof(new));
2822	old = btv->curr;
2823	ovbi = btv->cvbi;
2824	btv->curr = new;
2825	btv->cvbi = NULL;
2826	btv->loop_irq = 0;
2827	bttv_buffer_activate_video(btv, set: &new);
2828	bttv_buffer_activate_vbi(btv, NULL);
2829	bttv_set_dma(btv, override: 0);
2830
2831	/* wake up */
2832	bttv_irq_wakeup_video(btv, wakeup: &old, curr: &new, state: VB2_BUF_STATE_DONE);
2833	bttv_irq_wakeup_vbi(btv, wakeup: ovbi, state: VB2_BUF_STATE_DONE);
2834
2835	/* cancel all outstanding capture / vbi requests */
2836	if (btv->field_count)
2837	seqnr++;
2838	while (!list_empty(head: &btv->capture)) {
2839	item = list_entry(btv->capture.next, struct bttv_buffer, list);
2840	list_del(entry: &item->list);
2841	item->vbuf.vb2_buf.timestamp = ktime_get_ns();
2842	item->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
2843	vb2_buffer_done(vb: &item->vbuf.vb2_buf, state: VB2_BUF_STATE_ERROR);
2844	}
2845	while (!list_empty(head: &btv->vcapture)) {
2846	item = list_entry(btv->vcapture.next, struct bttv_buffer, list);
2847	list_del(entry: &item->list);
2848	item->vbuf.vb2_buf.timestamp = ktime_get_ns();
2849	item->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
2850	vb2_buffer_done(vb: &item->vbuf.vb2_buf, state: VB2_BUF_STATE_ERROR);
2851	}
2852
2853	btv->errors++;
2854	spin_unlock_irqrestore(lock: &btv->s_lock,flags);
2855	}
2856
2857	static void
2858	bttv_irq_wakeup_top(struct bttv *btv)
2859	{
2860	struct bttv_buffer *wakeup = btv->curr.top;
2861
2862	if (NULL == wakeup)
2863	return;
2864
2865	spin_lock(lock: &btv->s_lock);
2866	btv->curr.top_irq = 0;
2867	btv->curr.top = NULL;
2868	bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, irqflags: 0);
2869	wakeup->vbuf.vb2_buf.timestamp = ktime_get_ns();
2870	wakeup->vbuf.sequence = btv->field_count >> 1;
2871	vb2_buffer_done(vb: &wakeup->vbuf.vb2_buf, state: VB2_BUF_STATE_DONE);
2872	if (btv->field_count == 0)
2873	btor(BT848_INT_VSYNC, BT848_INT_MASK);
2874	spin_unlock(lock: &btv->s_lock);
2875	}
2876
2877	static inline int is_active(struct btcx_riscmem *risc, u32 rc)
2878	{
2879	if (rc < risc->dma)
2880	return 0;
2881	if (rc > risc->dma + risc->size)
2882	return 0;
2883	return 1;
2884	}
2885
2886	static void
2887	bttv_irq_switch_video(struct bttv *btv)
2888	{
2889	struct bttv_buffer_set new;
2890	struct bttv_buffer_set old;
2891	dma_addr_t rc;
2892
2893	spin_lock(lock: &btv->s_lock);
2894
2895	/* new buffer set */
2896	bttv_irq_next_video(btv, set: &new);
2897	rc = btread(BT848_RISC_COUNT);
2898	if ((btv->curr.top && is_active(risc: &btv->curr.top->top, rc)) ||
2899	(btv->curr.bottom && is_active(risc: &btv->curr.bottom->bottom, rc))) {
2900	btv->framedrop++;
2901	if (debug_latency)
2902	bttv_irq_debug_low_latency(btv, rc);
2903	spin_unlock(lock: &btv->s_lock);
2904	return;
2905	}
2906
2907	/* switch over */
2908	old = btv->curr;
2909	btv->curr = new;
2910	btv->loop_irq &= ~BT848_RISC_VIDEO;
2911	bttv_buffer_activate_video(btv, set: &new);
2912	bttv_set_dma(btv, override: 0);
2913
2914	/* switch input */
2915	if (UNSET != btv->new_input) {
2916	video_mux(btv,input: btv->new_input);
2917	btv->new_input = UNSET;
2918	}
2919
2920	/* wake up finished buffers */
2921	bttv_irq_wakeup_video(btv, wakeup: &old, curr: &new, state: VB2_BUF_STATE_DONE);
2922	spin_unlock(lock: &btv->s_lock);
2923	}
2924
2925	static void
2926	bttv_irq_switch_vbi(struct bttv *btv)
2927	{
2928	struct bttv_buffer *new = NULL;
2929	struct bttv_buffer *old;
2930	u32 rc;
2931
2932	spin_lock(lock: &btv->s_lock);
2933
2934	if (!list_empty(head: &btv->vcapture))
2935	new = list_entry(btv->vcapture.next, struct bttv_buffer, list);
2936	old = btv->cvbi;
2937
2938	rc = btread(BT848_RISC_COUNT);
2939	if (NULL != old && (is_active(risc: &old->top, rc) ||
2940	is_active(risc: &old->bottom, rc))) {
2941	btv->framedrop++;
2942	if (debug_latency)
2943	bttv_irq_debug_low_latency(btv, rc);
2944	spin_unlock(lock: &btv->s_lock);
2945	return;
2946	}
2947
2948	/* switch */
2949	btv->cvbi = new;
2950	btv->loop_irq &= ~BT848_RISC_VBI;
2951	bttv_buffer_activate_vbi(btv, vbi: new);
2952	bttv_set_dma(btv, override: 0);
2953
2954	bttv_irq_wakeup_vbi(btv, wakeup: old, state: VB2_BUF_STATE_DONE);
2955	spin_unlock(lock: &btv->s_lock);
2956	}
2957
2958	static irqreturn_t bttv_irq(int irq, void *dev_id)
2959	{
2960	u32 stat,astat;
2961	u32 dstat;
2962	int count;
2963	struct bttv *btv;
2964	int handled = 0;
2965
2966	btv=(struct bttv *)dev_id;
2967
2968	count=0;
2969	while (1) {
2970	/* get/clear interrupt status bits */
2971	stat=btread(BT848_INT_STAT);
2972	astat=stat&btread(BT848_INT_MASK);
2973	if (!astat)
2974	break;
2975	handled = 1;
2976	btwrite(stat,BT848_INT_STAT);
2977
2978	/* get device status bits */
2979	dstat=btread(BT848_DSTATUS);
2980
2981	if (irq_debug) {
2982	pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ",
2983	btv->c.nr, count, btv->field_count,
2984	stat>>28, btread(BT848_RISC_COUNT));
2985	bttv_print_irqbits(print: stat,mark: astat);
2986	if (stat & BT848_INT_HLOCK)
2987	pr_cont(" HLOC => %s",
2988	dstat & BT848_DSTATUS_HLOC
2989	? "yes" : "no");
2990	if (stat & BT848_INT_VPRES)
2991	pr_cont(" PRES => %s",
2992	dstat & BT848_DSTATUS_PRES
2993	? "yes" : "no");
2994	if (stat & BT848_INT_FMTCHG)
2995	pr_cont(" NUML => %s",
2996	dstat & BT848_DSTATUS_NUML
2997	? "625" : "525");
2998	pr_cont("\n");
2999	}
3000
3001	if (astat&BT848_INT_VSYNC)
3002	btv->field_count++;
3003
3004	if ((astat & BT848_INT_GPINT) && btv->remote) {
3005	bttv_input_irq(dev: btv);
3006	}
3007
3008	if (astat & BT848_INT_I2CDONE) {
3009	btv->i2c_done = stat;
3010	wake_up(&btv->i2c_queue);
3011	}
3012
3013	if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_VBI))
3014	bttv_irq_switch_vbi(btv);
3015
3016	if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_TOP))
3017	bttv_irq_wakeup_top(btv);
3018
3019	if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_VIDEO))
3020	bttv_irq_switch_video(btv);
3021
3022	if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
3023	/* trigger automute */
3024	audio_mux_gpio(btv, input: btv->audio_input, mute: btv->mute);
3025
3026	if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3027	pr_info("%d: %s%s @ %08x,",
3028	btv->c.nr,
3029	(astat & BT848_INT_SCERR) ? "SCERR" : "",
3030	(astat & BT848_INT_OCERR) ? "OCERR" : "",
3031	btread(BT848_RISC_COUNT));
3032	bttv_print_irqbits(print: stat,mark: astat);
3033	pr_cont("\n");
3034	if (bttv_debug)
3035	bttv_print_riscaddr(btv);
3036	}
3037	if (fdsr && astat & BT848_INT_FDSR) {
3038	pr_info("%d: FDSR @ %08x\n",
3039	btv->c.nr, btread(BT848_RISC_COUNT));
3040	if (bttv_debug)
3041	bttv_print_riscaddr(btv);
3042	}
3043
3044	count++;
3045	if (count > 4) {
3046
3047	if (count > 8 || !(astat & BT848_INT_GPINT)) {
3048	btwrite(0, BT848_INT_MASK);
3049
3050	pr_err("%d: IRQ lockup, cleared int mask [",
3051	btv->c.nr);
3052	} else {
3053	pr_err("%d: IRQ lockup, clearing GPINT from int mask [",
3054	btv->c.nr);
3055
3056	btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3057	BT848_INT_MASK);
3058	}
3059
3060	bttv_print_irqbits(print: stat,mark: astat);
3061
3062	pr_cont("]\n");
3063	}
3064	}
3065	btv->irq_total++;
3066	if (handled)
3067	btv->irq_me++;
3068	return IRQ_RETVAL(handled);
3069	}
3070
3071
3072	/* ----------------------------------------------------------------------- */
3073	/* initialization */
3074
3075	static int vdev_init(struct bttv *btv, struct video_device *vfd,
3076	const struct video_device *template,
3077	const char *type_name)
3078	{
3079	int err;
3080	struct vb2_queue *q;
3081	*vfd = *template;
3082	vfd->v4l2_dev = &btv->c.v4l2_dev;
3083	vfd->release = video_device_release_empty;
3084	video_set_drvdata(vdev: vfd, data: btv);
3085	snprintf(buf: vfd->name, size: sizeof(vfd->name), fmt: "BT%d%s %s (%s)",
3086	btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3087	type_name, bttv_tvcards[btv->c.type].name);
3088	if (btv->tuner_type == TUNER_ABSENT) {
3089	v4l2_disable_ioctl(vdev: vfd, VIDIOC_G_FREQUENCY);
3090	v4l2_disable_ioctl(vdev: vfd, VIDIOC_S_FREQUENCY);
3091	v4l2_disable_ioctl(vdev: vfd, VIDIOC_G_TUNER);
3092	v4l2_disable_ioctl(vdev: vfd, VIDIOC_S_TUNER);
3093	}
3094
3095	if (strcmp(type_name, "radio") == 0)
3096	return 0;
3097
3098	if (strcmp(type_name, "video") == 0) {
3099	q = &btv->capq;
3100	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3101	q->ops = &bttv_video_qops;
3102	} else if (strcmp(type_name, "vbi") == 0) {
3103	q = &btv->vbiq;
3104	q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
3105	q->ops = &bttv_vbi_qops;
3106	} else {
3107	return -EINVAL;
3108	}
3109	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
3110	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ | VB2_DMABUF;
3111	q->mem_ops = &vb2_dma_sg_memops;
3112	q->drv_priv = btv;
3113	q->gfp_flags = __GFP_DMA32;
3114	q->buf_struct_size = sizeof(struct bttv_buffer);
3115	q->lock = &btv->lock;
3116	q->min_queued_buffers = 2;
3117	q->dev = &btv->c.pci->dev;
3118	err = vb2_queue_init(q);
3119	if (err)
3120	return err;
3121	vfd->queue = q;
3122
3123	return 0;
3124	}
3125
3126	static void bttv_unregister_video(struct bttv *btv)
3127	{
3128	video_unregister_device(vdev: &btv->video_dev);
3129	video_unregister_device(vdev: &btv->vbi_dev);
3130	video_unregister_device(vdev: &btv->radio_dev);
3131	}
3132
3133	/* register video4linux devices */
3134	static int bttv_register_video(struct bttv *btv)
3135	{
3136	/* video */
3137	vdev_init(btv, vfd: &btv->video_dev, template: &bttv_video_template, type_name: "video");
3138	btv->video_dev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
3139	V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
3140	if (btv->tuner_type != TUNER_ABSENT)
3141	btv->video_dev.device_caps |= V4L2_CAP_TUNER;
3142
3143	if (video_register_device(vdev: &btv->video_dev, type: VFL_TYPE_VIDEO,
3144	nr: video_nr[btv->c.nr]) < 0)
3145	goto err;
3146	pr_info("%d: registered device %s\n",
3147	btv->c.nr, video_device_node_name(&btv->video_dev));
3148	if (device_create_file(device: &btv->video_dev.dev,
3149	entry: &dev_attr_card)<0) {
3150	pr_err("%d: device_create_file 'card' failed\n", btv->c.nr);
3151	goto err;
3152	}
3153
3154	/* vbi */
3155	vdev_init(btv, vfd: &btv->vbi_dev, template: &bttv_video_template, type_name: "vbi");
3156	btv->vbi_dev.device_caps = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE |
3157	V4L2_CAP_STREAMING;
3158	if (btv->tuner_type != TUNER_ABSENT)
3159	btv->vbi_dev.device_caps |= V4L2_CAP_TUNER;
3160
3161	if (video_register_device(vdev: &btv->vbi_dev, type: VFL_TYPE_VBI,
3162	nr: vbi_nr[btv->c.nr]) < 0)
3163	goto err;
3164	pr_info("%d: registered device %s\n",
3165	btv->c.nr, video_device_node_name(&btv->vbi_dev));
3166
3167	if (!btv->has_radio)
3168	return 0;
3169	/* radio */
3170	vdev_init(btv, vfd: &btv->radio_dev, template: &radio_template, type_name: "radio");
3171	btv->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
3172	if (btv->has_saa6588)
3173	btv->radio_dev.device_caps |= V4L2_CAP_READWRITE |
3174	V4L2_CAP_RDS_CAPTURE;
3175	if (btv->has_tea575x)
3176	btv->radio_dev.device_caps |= V4L2_CAP_HW_FREQ_SEEK;
3177	btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler;
3178	if (video_register_device(vdev: &btv->radio_dev, type: VFL_TYPE_RADIO,
3179	nr: radio_nr[btv->c.nr]) < 0)
3180	goto err;
3181	pr_info("%d: registered device %s\n",
3182	btv->c.nr, video_device_node_name(&btv->radio_dev));
3183
3184	/* all done */
3185	return 0;
3186
3187	err:
3188	bttv_unregister_video(btv);
3189	return -1;
3190	}
3191
3192
3193	/* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3194	/* response on cards with no firmware is not enabled by OF */
3195	static void pci_set_command(struct pci_dev *dev)
3196	{
3197	#if defined(__powerpc__)
3198	unsigned int cmd;
3199
3200	pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3201	cmd = (cmd | PCI_COMMAND_MEMORY );
3202	pci_write_config_dword(dev, PCI_COMMAND, cmd);
3203	#endif
3204	}
3205
3206	static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
3207	{
3208	struct v4l2_frequency init_freq = {
3209	.tuner = 0,
3210	.type = V4L2_TUNER_ANALOG_TV,
3211	.frequency = 980,
3212	};
3213	int result;
3214	unsigned char lat;
3215	struct bttv *btv;
3216	struct v4l2_ctrl_handler *hdl;
3217
3218	if (bttv_num == BTTV_MAX)
3219	return -ENOMEM;
3220	pr_info("Bt8xx card found (%d)\n", bttv_num);
3221	bttvs[bttv_num] = btv = kzalloc(size: sizeof(*btv), GFP_KERNEL);
3222	if (btv == NULL) {
3223	pr_err("out of memory\n");
3224	return -ENOMEM;
3225	}
3226	btv->c.nr = bttv_num;
3227	snprintf(buf: btv->c.v4l2_dev.name, size: sizeof(btv->c.v4l2_dev.name),
3228	fmt: "bttv%d", btv->c.nr);
3229
3230	/* initialize structs / fill in defaults */
3231	mutex_init(&btv->lock);
3232	spin_lock_init(&btv->s_lock);
3233	spin_lock_init(&btv->gpio_lock);
3234	init_waitqueue_head(&btv->i2c_queue);
3235	INIT_LIST_HEAD(list: &btv->c.subs);
3236	INIT_LIST_HEAD(list: &btv->capture);
3237	INIT_LIST_HEAD(list: &btv->vcapture);
3238
3239	timer_setup(&btv->timeout, bttv_irq_timeout, 0);
3240
3241	btv->i2c_rc = -1;
3242	btv->tuner_type = UNSET;
3243	btv->new_input = UNSET;
3244	btv->has_radio=radio[btv->c.nr];
3245
3246	/* pci stuff (init, get irq/mmio, ... */
3247	btv->c.pci = dev;
3248	btv->id = dev->device;
3249	if (pci_enable_device(dev)) {
3250	pr_warn("%d: Can't enable device\n", btv->c.nr);
3251	result = -EIO;
3252	goto free_mem;
3253	}
3254	if (dma_set_mask(dev: &dev->dev, DMA_BIT_MASK(32))) {
3255	pr_warn("%d: No suitable DMA available\n", btv->c.nr);
3256	result = -EIO;
3257	goto free_mem;
3258	}
3259	if (!request_mem_region(pci_resource_start(dev,0),
3260	pci_resource_len(dev,0),
3261	btv->c.v4l2_dev.name)) {
3262	pr_warn("%d: can't request iomem (0x%llx)\n",
3263	btv->c.nr,
3264	(unsigned long long)pci_resource_start(dev, 0));
3265	result = -EBUSY;
3266	goto free_mem;
3267	}
3268	pci_set_master(dev);
3269	pci_set_command(dev);
3270
3271	result = v4l2_device_register(dev: &dev->dev, v4l2_dev: &btv->c.v4l2_dev);
3272	if (result < 0) {
3273	pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr);
3274	goto fail0;
3275	}
3276	hdl = &btv->ctrl_handler;
3277	v4l2_ctrl_handler_init(hdl, 20);
3278	btv->c.v4l2_dev.ctrl_handler = hdl;
3279	v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6);
3280
3281	btv->revision = dev->revision;
3282	pci_read_config_byte(dev, PCI_LATENCY_TIMER, val: &lat);
3283	pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n",
3284	bttv_num, btv->id, btv->revision, pci_name(dev),
3285	btv->c.pci->irq, lat,
3286	(unsigned long long)pci_resource_start(dev, 0));
3287	schedule();
3288
3289	btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), size: 0x1000);
3290	if (NULL == btv->bt848_mmio) {
3291	pr_err("%d: ioremap() failed\n", btv->c.nr);
3292	result = -EIO;
3293	goto fail1;
3294	}
3295
3296	/* identify card */
3297	bttv_idcard(btv);
3298
3299	/* disable irqs, register irq handler */
3300	btwrite(0, BT848_INT_MASK);
3301	result = request_irq(irq: btv->c.pci->irq, handler: bttv_irq,
3302	IRQF_SHARED, name: btv->c.v4l2_dev.name, dev: (void *)btv);
3303	if (result < 0) {
3304	pr_err("%d: can't get IRQ %d\n",
3305	bttv_num, btv->c.pci->irq);
3306	goto fail1;
3307	}
3308
3309	if (0 != bttv_handle_chipset(btv)) {
3310	result = -EIO;
3311	goto fail2;
3312	}
3313
3314	/* init options from insmod args */
3315	btv->opt_combfilter = combfilter;
3316	bttv_ctrl_combfilter.def = combfilter;
3317	bttv_ctrl_lumafilter.def = lumafilter;
3318	btv->opt_automute = automute;
3319	bttv_ctrl_automute.def = automute;
3320	bttv_ctrl_agc_crush.def = agc_crush;
3321	btv->opt_vcr_hack = vcr_hack;
3322	bttv_ctrl_vcr_hack.def = vcr_hack;
3323	bttv_ctrl_whitecrush_upper.def = whitecrush_upper;
3324	bttv_ctrl_whitecrush_lower.def = whitecrush_lower;
3325	btv->opt_uv_ratio = uv_ratio;
3326	bttv_ctrl_uv_ratio.def = uv_ratio;
3327	bttv_ctrl_full_luma.def = full_luma_range;
3328	bttv_ctrl_coring.def = coring;
3329
3330	/* fill struct bttv with some useful defaults */
3331	btv->fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
3332	btv->width = 320;
3333	btv->height = 240;
3334	btv->field = V4L2_FIELD_INTERLACED;
3335	btv->input = 0;
3336	btv->tvnorm = 0; /* Index into bttv_tvnorms[] i.e. PAL. */
3337	bttv_vbi_fmt_reset(f: &btv->vbi_fmt, norm: btv->tvnorm);
3338	btv->vbi_count[0] = VBI_DEFLINES;
3339	btv->vbi_count[1] = VBI_DEFLINES;
3340	btv->do_crop = 0;
3341
3342	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3343	V4L2_CID_BRIGHTNESS, min: 0, max: 0xff00, step: 0x100, def: 32768);
3344	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3345	V4L2_CID_CONTRAST, min: 0, max: 0xff80, step: 0x80, def: 0x6c00);
3346	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3347	V4L2_CID_SATURATION, min: 0, max: 0xff80, step: 0x80, def: 32768);
3348	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3349	V4L2_CID_COLOR_KILLER, min: 0, max: 1, step: 1, def: 0);
3350	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3351	V4L2_CID_HUE, min: 0, max: 0xff00, step: 0x100, def: 32768);
3352	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3353	V4L2_CID_CHROMA_AGC, min: 0, max: 1, step: 1, def: !!chroma_agc);
3354	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3355	V4L2_CID_AUDIO_MUTE, min: 0, max: 1, step: 1, def: 0);
3356	if (btv->volume_gpio)
3357	v4l2_ctrl_new_std(hdl, ops: &bttv_ctrl_ops,
3358	V4L2_CID_AUDIO_VOLUME, min: 0, max: 0xff00, step: 0x100, def: 0xff00);
3359	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_combfilter, NULL);
3360	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_automute, NULL);
3361	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_lumafilter, NULL);
3362	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_agc_crush, NULL);
3363	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_vcr_hack, NULL);
3364	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_whitecrush_lower, NULL);
3365	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_whitecrush_upper, NULL);
3366	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_uv_ratio, NULL);
3367	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_full_luma, NULL);
3368	v4l2_ctrl_new_custom(hdl, cfg: &bttv_ctrl_coring, NULL);
3369
3370	/* initialize hardware */
3371	if (bttv_gpio)
3372	bttv_gpio_tracking(btv,comment: "pre-init");
3373
3374	bttv_risc_init_main(btv);
3375	init_bt848(btv);
3376
3377	/* gpio */
3378	btwrite(0x00, BT848_GPIO_REG_INP);
3379	btwrite(0x00, BT848_GPIO_OUT_EN);
3380	if (bttv_verbose)
3381	bttv_gpio_tracking(btv,comment: "init");
3382
3383	/* needs to be done before i2c is registered */
3384	bttv_init_card1(btv);
3385
3386	/* register i2c + gpio */
3387	init_bttv_i2c(btv);
3388
3389	/* some card-specific stuff (needs working i2c) */
3390	bttv_init_card2(btv);
3391	bttv_init_tuner(btv);
3392	if (btv->tuner_type != TUNER_ABSENT) {
3393	bttv_set_frequency(btv, f: &init_freq);
3394	btv->radio_freq = 90500 * 16; /* 90.5Mhz default */
3395	}
3396	btv->std = V4L2_STD_PAL;
3397	init_irqreg(btv);
3398	if (!bttv_tvcards[btv->c.type].no_video)
3399	v4l2_ctrl_handler_setup(hdl);
3400	if (hdl->error) {
3401	result = hdl->error;
3402	goto fail2;
3403	}
3404	/* mute device */
3405	audio_mute(btv, mute: 1);
3406
3407	/* register video4linux + input */
3408	if (!bttv_tvcards[btv->c.type].no_video) {
3409	v4l2_ctrl_add_handler(hdl: &btv->radio_ctrl_handler, add: hdl,
3410	filter: v4l2_ctrl_radio_filter, from_other_dev: false);
3411	if (btv->radio_ctrl_handler.error) {
3412	result = btv->radio_ctrl_handler.error;
3413	goto fail2;
3414	}
3415	set_input(btv, input: btv->input, norm: btv->tvnorm);
3416	bttv_crop_reset(c: &btv->crop[0], norm: btv->tvnorm);
3417	btv->crop[1] = btv->crop[0]; /* current = default */
3418	disclaim_vbi_lines(btv);
3419	disclaim_video_lines(btv);
3420	bttv_register_video(btv);
3421	}
3422
3423	/* add subdevices and autoload dvb-bt8xx if needed */
3424	if (bttv_tvcards[btv->c.type].has_dvb) {
3425	bttv_sub_add_device(core: &btv->c, name: "dvb");
3426	request_modules(btv);
3427	}
3428
3429	if (!disable_ir) {
3430	init_bttv_i2c_ir(btv);
3431	bttv_input_init(dev: btv);
3432	}
3433
3434	/* everything is fine */
3435	bttv_num++;
3436	return 0;
3437
3438	fail2:
3439	free_irq(btv->c.pci->irq,btv);
3440
3441	fail1:
3442	v4l2_ctrl_handler_free(hdl: &btv->ctrl_handler);
3443	v4l2_ctrl_handler_free(hdl: &btv->radio_ctrl_handler);
3444	v4l2_device_unregister(v4l2_dev: &btv->c.v4l2_dev);
3445
3446	fail0:
3447	if (btv->bt848_mmio)
3448	iounmap(addr: btv->bt848_mmio);
3449	release_mem_region(pci_resource_start(btv->c.pci,0),
3450	pci_resource_len(btv->c.pci,0));
3451	pci_disable_device(dev: btv->c.pci);
3452
3453	free_mem:
3454	bttvs[btv->c.nr] = NULL;
3455	kfree(objp: btv);
3456	return result;
3457	}
3458
3459	static void bttv_remove(struct pci_dev *pci_dev)
3460	{
3461	struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev: pci_dev);
3462	struct bttv *btv = to_bttv(v4l2_dev);
3463
3464	if (bttv_verbose)
3465	pr_info("%d: unloading\n", btv->c.nr);
3466
3467	if (bttv_tvcards[btv->c.type].has_dvb)
3468	flush_request_modules(btv);
3469
3470	/* shutdown everything (DMA+IRQs) */
3471	btand(~15, BT848_GPIO_DMA_CTL);
3472	btwrite(0, BT848_INT_MASK);
3473	btwrite(~0x0, BT848_INT_STAT);
3474	btwrite(0x0, BT848_GPIO_OUT_EN);
3475	if (bttv_gpio)
3476	bttv_gpio_tracking(btv,comment: "cleanup");
3477
3478	/* tell gpio modules we are leaving ... */
3479	btv->shutdown=1;
3480	bttv_input_fini(dev: btv);
3481	bttv_sub_del_devices(core: &btv->c);
3482
3483	/* unregister i2c_bus + input */
3484	fini_bttv_i2c(btv);
3485
3486	/* unregister video4linux */
3487	bttv_unregister_video(btv);
3488
3489	/* free allocated memory */
3490	v4l2_ctrl_handler_free(hdl: &btv->ctrl_handler);
3491	v4l2_ctrl_handler_free(hdl: &btv->radio_ctrl_handler);
3492	btcx_riscmem_free(pci: btv->c.pci,risc: &btv->main);
3493
3494	/* free resources */
3495	free_irq(btv->c.pci->irq,btv);
3496	del_timer_sync(timer: &btv->timeout);
3497	iounmap(addr: btv->bt848_mmio);
3498	release_mem_region(pci_resource_start(btv->c.pci,0),
3499	pci_resource_len(btv->c.pci,0));
3500	pci_disable_device(dev: btv->c.pci);
3501
3502	v4l2_device_unregister(v4l2_dev: &btv->c.v4l2_dev);
3503	bttvs[btv->c.nr] = NULL;
3504	kfree(objp: btv);
3505
3506	return;
3507	}
3508
3509	static int __maybe_unused bttv_suspend(struct device *dev)
3510	{
3511	struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
3512	struct bttv *btv = to_bttv(v4l2_dev);
3513	struct bttv_buffer_set idle;
3514	unsigned long flags;
3515
3516	dprintk("%d: suspend\n", btv->c.nr);
3517
3518	/* stop dma + irqs */
3519	spin_lock_irqsave(&btv->s_lock,flags);
3520	memset(&idle, 0, sizeof(idle));
3521	btv->state.video = btv->curr;
3522	btv->state.vbi = btv->cvbi;
3523	btv->state.loop_irq = btv->loop_irq;
3524	btv->curr = idle;
3525	btv->loop_irq = 0;
3526	bttv_buffer_activate_video(btv, set: &idle);
3527	bttv_buffer_activate_vbi(btv, NULL);
3528	bttv_set_dma(btv, override: 0);
3529	btwrite(0, BT848_INT_MASK);
3530	spin_unlock_irqrestore(lock: &btv->s_lock,flags);
3531
3532	/* save bt878 state */
3533	btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
3534	btv->state.gpio_data = gpio_read();
3535
3536	btv->state.disabled = 1;
3537	return 0;
3538	}
3539
3540	static int __maybe_unused bttv_resume(struct device *dev)
3541	{
3542	struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
3543	struct bttv *btv = to_bttv(v4l2_dev);
3544	unsigned long flags;
3545
3546	dprintk("%d: resume\n", btv->c.nr);
3547
3548	btv->state.disabled = 0;
3549
3550	/* restore bt878 state */
3551	bttv_reinit_bt848(btv);
3552	gpio_inout(0xffffff, btv->state.gpio_enable);
3553	gpio_write(btv->state.gpio_data);
3554
3555	/* restart dma */
3556	spin_lock_irqsave(&btv->s_lock,flags);
3557	btv->curr = btv->state.video;
3558	btv->cvbi = btv->state.vbi;
3559	btv->loop_irq = btv->state.loop_irq;
3560	bttv_buffer_activate_video(btv, set: &btv->curr);
3561	bttv_buffer_activate_vbi(btv, vbi: btv->cvbi);
3562	bttv_set_dma(btv, override: 0);
3563	spin_unlock_irqrestore(lock: &btv->s_lock,flags);
3564	return 0;
3565	}
3566
3567	static const struct pci_device_id bttv_pci_tbl[] = {
3568	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
3569	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
3570	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
3571	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
3572	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
3573	{0,}
3574	};
3575
3576	MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
3577
3578	static SIMPLE_DEV_PM_OPS(bttv_pm_ops,
3579	bttv_suspend,
3580	bttv_resume);
3581
3582	static struct pci_driver bttv_pci_driver = {
3583	.name = "bttv",
3584	.id_table = bttv_pci_tbl,
3585	.probe = bttv_probe,
3586	.remove = bttv_remove,
3587	.driver.pm = &bttv_pm_ops,
3588	};
3589
3590	static int __init bttv_init_module(void)
3591	{
3592	int ret;
3593
3594	bttv_num = 0;
3595
3596	pr_info("driver version %s loaded\n", BTTV_VERSION);
3597	if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
3598	gbuffers = 2;
3599	if (gbufsize > BTTV_MAX_FBUF)
3600	gbufsize = BTTV_MAX_FBUF;
3601	gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
3602	if (bttv_verbose)
3603	pr_info("using %d buffers with %dk (%d pages) each for capture\n",
3604	gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
3605
3606	bttv_check_chipset();
3607
3608	ret = bus_register(bus: &bttv_sub_bus_type);
3609	if (ret < 0) {
3610	pr_warn("bus_register error: %d\n", ret);
3611	return ret;
3612	}
3613	ret = pci_register_driver(&bttv_pci_driver);
3614	if (ret < 0)
3615	bus_unregister(bus: &bttv_sub_bus_type);
3616
3617	return ret;
3618	}
3619
3620	static void __exit bttv_cleanup_module(void)
3621	{
3622	pci_unregister_driver(dev: &bttv_pci_driver);
3623	bus_unregister(bus: &bttv_sub_bus_type);
3624	}
3625
3626	module_init(bttv_init_module);
3627	module_exit(bttv_cleanup_module);
3628