PageRenderTime 73ms CodeModel.GetById 23ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/media/video/bt8xx/bttv-driver.c

https://gitlab.com/TeamCarbonXtreme/android_kernel_samsung_msm7x27
C | 4686 lines | 3673 code | 648 blank | 365 comment | 526 complexity | 3ad34d4704e6da8f65252d4e13f90884 MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. /*
    2. 

    3. 

  3.     bttv - Bt848 frame grabber driver
    4. 

    5. 

  5.     Copyright (C) 1996,97,98 Ralph  Metzler <rjkm@thp.uni-koeln.de>
    6. 

  6. 			   & Marcus Metzler <mocm@thp.uni-koeln.de>
    7. 

  7.     (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
    8. 

    9. 

  9.     some v4l2 code lines are taken from Justin's bttv2 driver which is
    10. 

  10.     (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
    11. 

    12. 

  12.     V4L1 removal from:
    13. 

  13.     (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
    14. 

    15. 

  15.     Fixes to be fully V4L2 compliant by
    16. 

  16.     (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
    17. 

    18. 

  18.     Cropping and overscan support
    19. 

  19.     Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
    20. 

  20.     Sponsored by OPQ Systems AB
    21. 

    22. 

  22.     This program is free software; you can redistribute it and/or modify
    23. 

  23.     it under the terms of the GNU General Public License as published by
    24. 

  24.     the Free Software Foundation; either version 2 of the License, or
    25. 

  25.     (at your option) any later version.
    26. 

    27. 

  27.     This program is distributed in the hope that it will be useful,
    28. 

  28.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    29. 

  29.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    30. 

  30.     GNU General Public License for more details.
    31. 

    32. 

  32.     You should have received a copy of the GNU General Public License
    33. 

  33.     along with this program; if not, write to the Free Software
    34. 

  34.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    35. 

  35. */
    36. 

  36. 

  37. #include <linux/init.h>
    38. 

  38. #include <linux/module.h>
    39. 

  39. #include <linux/delay.h>
    40. 

  40. #include <linux/slab.h>
    41. 

  41. #include <linux/errno.h>
    42. 

  42. #include <linux/fs.h>
    43. 

  43. #include <linux/kernel.h>
    44. 

  44. #include <linux/sched.h>
    45. 

  45. #include <linux/smp_lock.h>
    46. 

  46. #include <linux/interrupt.h>
    47. 

  47. #include <linux/kdev_t.h>
    48. 

  48. #include "bttvp.h"
    49. 

  49. #include <media/v4l2-common.h>
    50. 

  50. #include <media/v4l2-ioctl.h>
    51. 

  51. #include <media/tvaudio.h>
    52. 

  52. #include <media/msp3400.h>
    53. 

  53. 

  54. #include <linux/dma-mapping.h>
    55. 

  55. 

  56. #include <asm/io.h>
    57. 

  57. #include <asm/byteorder.h>
    58. 

  58. 

  59. #include <media/rds.h>
    60. 

  60. 

  61. 

  62. unsigned int bttv_num;			/* number of Bt848s in use */
    63. 

  63. struct bttv *bttvs[BTTV_MAX];
    64. 

  64. 

  65. unsigned int bttv_debug;
    66. 

  66. unsigned int bttv_verbose = 1;
    67. 

  67. unsigned int bttv_gpio;
    68. 

  68. 

  69. /* config variables */
    70. 

  70. #ifdef __BIG_ENDIAN
    71. 

  71. static unsigned int bigendian=1;
    72. 

  72. #else
    73. 

  73. static unsigned int bigendian;
    74. 

  74. #endif
    75. 

  75. static unsigned int radio[BTTV_MAX];
    76. 

  76. static unsigned int irq_debug;
    77. 

  77. static unsigned int gbuffers = 8;
    78. 

  78. static unsigned int gbufsize = 0x208000;
    79. 

  79. static unsigned int reset_crop = 1;
    80. 

  80. 

  81. static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
    82. 

  82. static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
    83. 

  83. static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
    84. 

  84. static int debug_latency;
    85. 

  85. static int disable_ir;
    86. 

  86. 

  87. static unsigned int fdsr;
    88. 

  88. 

  89. /* options */
    90. 

  90. static unsigned int combfilter;
    91. 

  91. static unsigned int lumafilter;
    92. 

  92. static unsigned int automute    = 1;
    93. 

  93. static unsigned int chroma_agc;
    94. 

  94. static unsigned int adc_crush   = 1;
    95. 

  95. static unsigned int whitecrush_upper = 0xCF;
    96. 

  96. static unsigned int whitecrush_lower = 0x7F;
    97. 

  97. static unsigned int vcr_hack;
    98. 

  98. static unsigned int irq_iswitch;
    99. 

  99. static unsigned int uv_ratio    = 50;
    100. 

  100. static unsigned int full_luma_range;
    101. 

  101. static unsigned int coring;
    102. 

  102. 

  103. /* API features (turn on/off stuff for testing) */
    104. 

  104. static unsigned int v4l2        = 1;
    105. 

  105. 

  106. /* insmod args */
    107. 

  107. module_param(bttv_verbose,      int, 0644);
    108. 

  108. module_param(bttv_gpio,         int, 0644);
    109. 

  109. module_param(bttv_debug,        int, 0644);
    110. 

  110. module_param(irq_debug,         int, 0644);
    111. 

  111. module_param(debug_latency,     int, 0644);
    112. 

  112. module_param(disable_ir,        int, 0444);
    113. 

  113. 

  114. module_param(fdsr,              int, 0444);
    115. 

  115. module_param(gbuffers,          int, 0444);
    116. 

  116. module_param(gbufsize,          int, 0444);
    117. 

  117. module_param(reset_crop,        int, 0444);
    118. 

  118. 

  119. module_param(v4l2,              int, 0644);
    120. 

  120. module_param(bigendian,         int, 0644);
    121. 

  121. module_param(irq_iswitch,       int, 0644);
    122. 

  122. module_param(combfilter,        int, 0444);
    123. 

  123. module_param(lumafilter,        int, 0444);
    124. 

  124. module_param(automute,          int, 0444);
    125. 

  125. module_param(chroma_agc,        int, 0444);
    126. 

  126. module_param(adc_crush,         int, 0444);
    127. 

  127. module_param(whitecrush_upper,  int, 0444);
    128. 

  128. module_param(whitecrush_lower,  int, 0444);
    129. 

  129. module_param(vcr_hack,          int, 0444);
    130. 

  130. module_param(uv_ratio,          int, 0444);
    131. 

  131. module_param(full_luma_range,   int, 0444);
    132. 

  132. module_param(coring,            int, 0444);
    133. 

  133. 

  134. module_param_array(radio,       int, NULL, 0444);
    135. 

  135. module_param_array(video_nr,    int, NULL, 0444);
    136. 

  136. module_param_array(radio_nr,    int, NULL, 0444);
    137. 

  137. module_param_array(vbi_nr,      int, NULL, 0444);
    138. 

  138. 

  139. MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
    140. 

  140. MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
    141. 

  141. MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
    142. 

  142. MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
    143. 

  143. MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
    144. 

  144. MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
    145. 

  145. MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
    146. 

  146. MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
    147. 

  147. MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
    148. 

  148. MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
    149. 

  149. 		 "is 1 (yes) for compatibility with older applications");
    150. 

  150. MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
    151. 

  151. MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
    152. 

  152. MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
    153. 

  153. MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
    154. 

  154. MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
    155. 

  155. MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
    156. 

  156. MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
    157. 

  157. MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
    158. 

  158. MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
    159. 

  159. MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
    160. 

  160. MODULE_PARM_DESC(video_nr, "video device numbers");
    161. 

  161. MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
    162. 

  162. MODULE_PARM_DESC(radio_nr, "radio device numbers");
    163. 

  163. 

  164. MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
    165. 

  165. MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
    166. 

  166. MODULE_LICENSE("GPL");
    167. 

  167. 

  168. /* ----------------------------------------------------------------------- */
    169. 

  169. /* sysfs                                                                   */
    170. 

  170. 

  171. static ssize_t show_card(struct device *cd,
    172. 

  172. 			 struct device_attribute *attr, char *buf)
    173. 

  173. {
    174. 

  174. 	struct video_device *vfd = container_of(cd, struct video_device, dev);
    175. 

  175. 	struct bttv *btv = video_get_drvdata(vfd);
    176. 

  176. 	return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
    177. 

  177. }
    178. 

  178. static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
    179. 

  179. 

  180. /* ----------------------------------------------------------------------- */
    181. 

  181. /* dvb auto-load setup                                                     */
    182. 

  182. #if defined(CONFIG_MODULES) && defined(MODULE)
    183. 

  183. static void request_module_async(struct work_struct *work)
    184. 

  184. {
    185. 

  185. 	request_module("dvb-bt8xx");
    186. 

  186. }
    187. 

  187. 

  188. static void request_modules(struct bttv *dev)
    189. 

  189. {
    190. 

  190. 	INIT_WORK(&dev->request_module_wk, request_module_async);
    191. 

  191. 	schedule_work(&dev->request_module_wk);
    192. 

  192. }
    193. 

  193. #else
    194. 

  194. #define request_modules(dev)
    195. 

  195. #endif /* CONFIG_MODULES */
    196. 

  196. 

  197. 

  198. /* ----------------------------------------------------------------------- */
    199. 

  199. /* static data                                                             */
    200. 

  200. 

  201. /* special timing tables from conexant... */
    202. 

  202. static u8 SRAM_Table[][60] =
    203. 

  203. {
    204. 

  204. 	/* PAL digital input over GPIO[7:0] */
    205. 

  205. 	{
    206. 

  206. 		45, // 45 bytes following
    207. 

  207. 		0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
    208. 

  208. 		0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
    209. 

  209. 		0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
    210. 

  210. 		0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
    211. 

  211. 		0x37,0x00,0xAF,0x21,0x00
    212. 

  212. 	},
    213. 

  213. 	/* NTSC digital input over GPIO[7:0] */
    214. 

  214. 	{
    215. 

  215. 		51, // 51 bytes following
    216. 

  216. 		0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
    217. 

  217. 		0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
    218. 

  218. 		0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
    219. 

  219. 		0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
    220. 

  220. 		0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
    221. 

  221. 		0x00,
    222. 

  222. 	},
    223. 

  223. 	// TGB_NTSC392 // quartzsight
    224. 

  224. 	// This table has been modified to be used for Fusion Rev D
    225. 

  225. 	{
    226. 

  226. 		0x2A, // size of table = 42
    227. 

  227. 		0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
    228. 

  228. 		0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
    229. 

  229. 		0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
    230. 

  230. 		0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
    231. 

  231. 		0x20, 0x00
    232. 

  232. 	}
    233. 

  233. };
    234. 

  234. 

  235. /* minhdelayx1	first video pixel we can capture on a line and
    236. 

  236.    hdelayx1	start of active video, both relative to rising edge of
    237. 

  237. 		/HRESET pulse (0H) in 1 / fCLKx1.
    238. 

  238.    swidth	width of active video and
    239. 

  239.    totalwidth	total line width, both in 1 / fCLKx1.
    240. 

  240.    sqwidth	total line width in square pixels.
    241. 

  241.    vdelay	start of active video in 2 * field lines relative to
    242. 

  242. 		trailing edge of /VRESET pulse (VDELAY register).
    243. 

  243.    sheight	height of active video in 2 * field lines.
    244. 

  244.    videostart0	ITU-R frame line number of the line corresponding
    245. 

  245. 		to vdelay in the first field. */
    246. 

  246. #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth,	 \
    247. 

  247. 		vdelay, sheight, videostart0)				 \
    248. 

  248. 	.cropcap.bounds.left = minhdelayx1,				 \
    249. 

  249. 	/* * 2 because vertically we count field lines times two, */	 \
    250. 

  250. 	/* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */		 \
    251. 

  251. 	.cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
    252. 

  252. 	/* 4 is a safety margin at the end of the line. */		 \
    253. 

  253. 	.cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4,	 \
    254. 

  254. 	.cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY,	 \
    255. 

  255. 	.cropcap.defrect.left = hdelayx1,				 \
    256. 

  256. 	.cropcap.defrect.top = (videostart0) * 2,			 \
    257. 

  257. 	.cropcap.defrect.width = swidth,				 \
    258. 

  258. 	.cropcap.defrect.height = sheight,				 \
    259. 

  259. 	.cropcap.pixelaspect.numerator = totalwidth,			 \
    260. 

  260. 	.cropcap.pixelaspect.denominator = sqwidth,
    261. 

  261. 

  262. const struct bttv_tvnorm bttv_tvnorms[] = {
    263. 

  263. 	/* PAL-BDGHI */
    264. 

  264. 	/* max. active video is actually 922, but 924 is divisible by 4 and 3! */
    265. 

  265. 	/* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
    266. 

  266. 	{
    267. 

  267. 		.v4l2_id        = V4L2_STD_PAL,
    268. 

  268. 		.name           = "PAL",
    269. 

  269. 		.Fsc            = 35468950,
    270. 

  270. 		.swidth         = 924,
    271. 

  271. 		.sheight        = 576,
    272. 

  272. 		.totalwidth     = 1135,
    273. 

  273. 		.adelay         = 0x7f,
    274. 

  274. 		.bdelay         = 0x72,
    275. 

  275. 		.iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
    276. 

  276. 		.scaledtwidth   = 1135,
    277. 

  277. 		.hdelayx1       = 186,
    278. 

  278. 		.hactivex1      = 924,
    279. 

  279. 		.vdelay         = 0x20,
    280. 

  280. 		.vbipack        = 255, /* min (2048 / 4, 0x1ff) & 0xff */
    281. 

  281. 		.sram           = 0,
    282. 

  282. 		/* ITU-R frame line number of the first VBI line
    283. 

  283. 		   we can capture, of the first and second field.
    284. 

  284. 		   The last line is determined by cropcap.bounds. */
    285. 

  285. 		.vbistart       = { 7, 320 },
    286. 

  286. 		CROPCAP(/* minhdelayx1 */ 68,
    287. 

  287. 			/* hdelayx1 */ 186,
    288. 

  288. 			/* Should be (768 * 1135 + 944 / 2) / 944.
    289. 

  289. 			   cropcap.defrect is used for image width
    290. 

  290. 			   checks, so we keep the old value 924. */
    291. 

  291. 			/* swidth */ 924,
    292. 

  292. 			/* totalwidth */ 1135,
    293. 

  293. 			/* sqwidth */ 944,
    294. 

  294. 			/* vdelay */ 0x20,
    295. 

  295. 			/* sheight */ 576,
    296. 

  296. 			/* videostart0 */ 23)
    297. 

  297. 		/* bt878 (and bt848?) can capture another
    298. 

  298. 		   line below active video. */
    299. 

  299. 		.cropcap.bounds.height = (576 + 2) + 0x20 - 2,
    300. 

  300. 	},{
    301. 

  301. 		.v4l2_id        = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
    302. 

  302. 		.name           = "NTSC",
    303. 

  303. 		.Fsc            = 28636363,
    304. 

  304. 		.swidth         = 768,
    305. 

  305. 		.sheight        = 480,
    306. 

  306. 		.totalwidth     = 910,
    307. 

  307. 		.adelay         = 0x68,
    308. 

  308. 		.bdelay         = 0x5d,
    309. 

  309. 		.iform          = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
    310. 

  310. 		.scaledtwidth   = 910,
    311. 

  311. 		.hdelayx1       = 128,
    312. 

  312. 		.hactivex1      = 910,
    313. 

  313. 		.vdelay         = 0x1a,
    314. 

  314. 		.vbipack        = 144, /* min (1600 / 4, 0x1ff) & 0xff */
    315. 

  315. 		.sram           = 1,
    316. 

  316. 		.vbistart	= { 10, 273 },
    317. 

  317. 		CROPCAP(/* minhdelayx1 */ 68,
    318. 

  318. 			/* hdelayx1 */ 128,
    319. 

  319. 			/* Should be (640 * 910 + 780 / 2) / 780? */
    320. 

  320. 			/* swidth */ 768,
    321. 

  321. 			/* totalwidth */ 910,
    322. 

  322. 			/* sqwidth */ 780,
    323. 

  323. 			/* vdelay */ 0x1a,
    324. 

  324. 			/* sheight */ 480,
    325. 

  325. 			/* videostart0 */ 23)
    326. 

  326. 	},{
    327. 

  327. 		.v4l2_id        = V4L2_STD_SECAM,
    328. 

  328. 		.name           = "SECAM",
    329. 

  329. 		.Fsc            = 35468950,
    330. 

  330. 		.swidth         = 924,
    331. 

  331. 		.sheight        = 576,
    332. 

  332. 		.totalwidth     = 1135,
    333. 

  333. 		.adelay         = 0x7f,
    334. 

  334. 		.bdelay         = 0xb0,
    335. 

  335. 		.iform          = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
    336. 

  336. 		.scaledtwidth   = 1135,
    337. 

  337. 		.hdelayx1       = 186,
    338. 

  338. 		.hactivex1      = 922,
    339. 

  339. 		.vdelay         = 0x20,
    340. 

  340. 		.vbipack        = 255,
    341. 

  341. 		.sram           = 0, /* like PAL, correct? */
    342. 

  342. 		.vbistart	= { 7, 320 },
    343. 

  343. 		CROPCAP(/* minhdelayx1 */ 68,
    344. 

  344. 			/* hdelayx1 */ 186,
    345. 

  345. 			/* swidth */ 924,
    346. 

  346. 			/* totalwidth */ 1135,
    347. 

  347. 			/* sqwidth */ 944,
    348. 

  348. 			/* vdelay */ 0x20,
    349. 

  349. 			/* sheight */ 576,
    350. 

  350. 			/* videostart0 */ 23)
    351. 

  351. 	},{
    352. 

  352. 		.v4l2_id        = V4L2_STD_PAL_Nc,
    353. 

  353. 		.name           = "PAL-Nc",
    354. 

  354. 		.Fsc            = 28636363,
    355. 

  355. 		.swidth         = 640,
    356. 

  356. 		.sheight        = 576,
    357. 

  357. 		.totalwidth     = 910,
    358. 

  358. 		.adelay         = 0x68,
    359. 

  359. 		.bdelay         = 0x5d,
    360. 

  360. 		.iform          = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
    361. 

  361. 		.scaledtwidth   = 780,
    362. 

  362. 		.hdelayx1       = 130,
    363. 

  363. 		.hactivex1      = 734,
    364. 

  364. 		.vdelay         = 0x1a,
    365. 

  365. 		.vbipack        = 144,
    366. 

  366. 		.sram           = -1,
    367. 

  367. 		.vbistart	= { 7, 320 },
    368. 

  368. 		CROPCAP(/* minhdelayx1 */ 68,
    369. 

  369. 			/* hdelayx1 */ 130,
    370. 

  370. 			/* swidth */ (640 * 910 + 780 / 2) / 780,
    371. 

  371. 			/* totalwidth */ 910,
    372. 

  372. 			/* sqwidth */ 780,
    373. 

  373. 			/* vdelay */ 0x1a,
    374. 

  374. 			/* sheight */ 576,
    375. 

  375. 			/* videostart0 */ 23)
    376. 

  376. 	},{
    377. 

  377. 		.v4l2_id        = V4L2_STD_PAL_M,
    378. 

  378. 		.name           = "PAL-M",
    379. 

  379. 		.Fsc            = 28636363,
    380. 

  380. 		.swidth         = 640,
    381. 

  381. 		.sheight        = 480,
    382. 

  382. 		.totalwidth     = 910,
    383. 

  383. 		.adelay         = 0x68,
    384. 

  384. 		.bdelay         = 0x5d,
    385. 

  385. 		.iform          = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
    386. 

  386. 		.scaledtwidth   = 780,
    387. 

  387. 		.hdelayx1       = 135,
    388. 

  388. 		.hactivex1      = 754,
    389. 

  389. 		.vdelay         = 0x1a,
    390. 

  390. 		.vbipack        = 144,
    391. 

  391. 		.sram           = -1,
    392. 

  392. 		.vbistart	= { 10, 273 },
    393. 

  393. 		CROPCAP(/* minhdelayx1 */ 68,
    394. 

  394. 			/* hdelayx1 */ 135,
    395. 

  395. 			/* swidth */ (640 * 910 + 780 / 2) / 780,
    396. 

  396. 			/* totalwidth */ 910,
    397. 

  397. 			/* sqwidth */ 780,
    398. 

  398. 			/* vdelay */ 0x1a,
    399. 

  399. 			/* sheight */ 480,
    400. 

  400. 			/* videostart0 */ 23)
    401. 

  401. 	},{
    402. 

  402. 		.v4l2_id        = V4L2_STD_PAL_N,
    403. 

  403. 		.name           = "PAL-N",
    404. 

  404. 		.Fsc            = 35468950,
    405. 

  405. 		.swidth         = 768,
    406. 

  406. 		.sheight        = 576,
    407. 

  407. 		.totalwidth     = 1135,
    408. 

  408. 		.adelay         = 0x7f,
    409. 

  409. 		.bdelay         = 0x72,
    410. 

  410. 		.iform          = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
    411. 

  411. 		.scaledtwidth   = 944,
    412. 

  412. 		.hdelayx1       = 186,
    413. 

  413. 		.hactivex1      = 922,
    414. 

  414. 		.vdelay         = 0x20,
    415. 

  415. 		.vbipack        = 144,
    416. 

  416. 		.sram           = -1,
    417. 

  417. 		.vbistart       = { 7, 320 },
    418. 

  418. 		CROPCAP(/* minhdelayx1 */ 68,
    419. 

  419. 			/* hdelayx1 */ 186,
    420. 

  420. 			/* swidth */ (768 * 1135 + 944 / 2) / 944,
    421. 

  421. 			/* totalwidth */ 1135,
    422. 

  422. 			/* sqwidth */ 944,
    423. 

  423. 			/* vdelay */ 0x20,
    424. 

  424. 			/* sheight */ 576,
    425. 

  425. 			/* videostart0 */ 23)
    426. 

  426. 	},{
    427. 

  427. 		.v4l2_id        = V4L2_STD_NTSC_M_JP,
    428. 

  428. 		.name           = "NTSC-JP",
    429. 

  429. 		.Fsc            = 28636363,
    430. 

  430. 		.swidth         = 640,
    431. 

  431. 		.sheight        = 480,
    432. 

  432. 		.totalwidth     = 910,
    433. 

  433. 		.adelay         = 0x68,
    434. 

  434. 		.bdelay         = 0x5d,
    435. 

  435. 		.iform          = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
    436. 

  436. 		.scaledtwidth   = 780,
    437. 

  437. 		.hdelayx1       = 135,
    438. 

  438. 		.hactivex1      = 754,
    439. 

  439. 		.vdelay         = 0x16,
    440. 

  440. 		.vbipack        = 144,
    441. 

  441. 		.sram           = -1,
    442. 

  442. 		.vbistart       = { 10, 273 },
    443. 

  443. 		CROPCAP(/* minhdelayx1 */ 68,
    444. 

  444. 			/* hdelayx1 */ 135,
    445. 

  445. 			/* swidth */ (640 * 910 + 780 / 2) / 780,
    446. 

  446. 			/* totalwidth */ 910,
    447. 

  447. 			/* sqwidth */ 780,
    448. 

  448. 			/* vdelay */ 0x16,
    449. 

  449. 			/* sheight */ 480,
    450. 

  450. 			/* videostart0 */ 23)
    451. 

  451. 	},{
    452. 

  452. 		/* that one hopefully works with the strange timing
    453. 

  453. 		 * which video recorders produce when playing a NTSC
    454. 

  454. 		 * tape on a PAL TV ... */
    455. 

  455. 		.v4l2_id        = V4L2_STD_PAL_60,
    456. 

  456. 		.name           = "PAL-60",
    457. 

  457. 		.Fsc            = 35468950,
    458. 

  458. 		.swidth         = 924,
    459. 

  459. 		.sheight        = 480,
    460. 

  460. 		.totalwidth     = 1135,
    461. 

  461. 		.adelay         = 0x7f,
    462. 

  462. 		.bdelay         = 0x72,
    463. 

  463. 		.iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
    464. 

  464. 		.scaledtwidth   = 1135,
    465. 

  465. 		.hdelayx1       = 186,
    466. 

  466. 		.hactivex1      = 924,
    467. 

  467. 		.vdelay         = 0x1a,
    468. 

  468. 		.vbipack        = 255,
    469. 

  469. 		.vtotal         = 524,
    470. 

  470. 		.sram           = -1,
    471. 

  471. 		.vbistart	= { 10, 273 },
    472. 

  472. 		CROPCAP(/* minhdelayx1 */ 68,
    473. 

  473. 			/* hdelayx1 */ 186,
    474. 

  474. 			/* swidth */ 924,
    475. 

  475. 			/* totalwidth */ 1135,
    476. 

  476. 			/* sqwidth */ 944,
    477. 

  477. 			/* vdelay */ 0x1a,
    478. 

  478. 			/* sheight */ 480,
    479. 

  479. 			/* videostart0 */ 23)
    480. 

  480. 	}
    481. 

  481. };
    482. 

  482. static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
    483. 

  483. 

  484. /* ----------------------------------------------------------------------- */
    485. 

  485. /* bttv format list
    486. 

  486.    packed pixel formats must come first */
    487. 

  487. static const struct bttv_format formats[] = {
    488. 

  488. 	{
    489. 

  489. 		.name     = "8 bpp, gray",
    490. 

  490. 		.fourcc   = V4L2_PIX_FMT_GREY,
    491. 

  491. 		.btformat = BT848_COLOR_FMT_Y8,
    492. 

  492. 		.depth    = 8,
    493. 

  493. 		.flags    = FORMAT_FLAGS_PACKED,
    494. 

  494. 	},{
    495. 

  495. 		.name     = "8 bpp, dithered color",
    496. 

  496. 		.fourcc   = V4L2_PIX_FMT_HI240,
    497. 

  497. 		.btformat = BT848_COLOR_FMT_RGB8,
    498. 

  498. 		.depth    = 8,
    499. 

  499. 		.flags    = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
    500. 

  500. 	},{
    501. 

  501. 		.name     = "15 bpp RGB, le",
    502. 

  502. 		.fourcc   = V4L2_PIX_FMT_RGB555,
    503. 

  503. 		.btformat = BT848_COLOR_FMT_RGB15,
    504. 

  504. 		.depth    = 16,
    505. 

  505. 		.flags    = FORMAT_FLAGS_PACKED,
    506. 

  506. 	},{
    507. 

  507. 		.name     = "15 bpp RGB, be",
    508. 

  508. 		.fourcc   = V4L2_PIX_FMT_RGB555X,
    509. 

  509. 		.btformat = BT848_COLOR_FMT_RGB15,
    510. 

  510. 		.btswap   = 0x03, /* byteswap */
    511. 

  511. 		.depth    = 16,
    512. 

  512. 		.flags    = FORMAT_FLAGS_PACKED,
    513. 

  513. 	},{
    514. 

  514. 		.name     = "16 bpp RGB, le",
    515. 

  515. 		.fourcc   = V4L2_PIX_FMT_RGB565,
    516. 

  516. 		.btformat = BT848_COLOR_FMT_RGB16,
    517. 

  517. 		.depth    = 16,
    518. 

  518. 		.flags    = FORMAT_FLAGS_PACKED,
    519. 

  519. 	},{
    520. 

  520. 		.name     = "16 bpp RGB, be",
    521. 

  521. 		.fourcc   = V4L2_PIX_FMT_RGB565X,
    522. 

  522. 		.btformat = BT848_COLOR_FMT_RGB16,
    523. 

  523. 		.btswap   = 0x03, /* byteswap */
    524. 

  524. 		.depth    = 16,
    525. 

  525. 		.flags    = FORMAT_FLAGS_PACKED,
    526. 

  526. 	},{
    527. 

  527. 		.name     = "24 bpp RGB, le",
    528. 

  528. 		.fourcc   = V4L2_PIX_FMT_BGR24,
    529. 

  529. 		.btformat = BT848_COLOR_FMT_RGB24,
    530. 

  530. 		.depth    = 24,
    531. 

  531. 		.flags    = FORMAT_FLAGS_PACKED,
    532. 

  532. 	},{
    533. 

  533. 		.name     = "32 bpp RGB, le",
    534. 

  534. 		.fourcc   = V4L2_PIX_FMT_BGR32,
    535. 

  535. 		.btformat = BT848_COLOR_FMT_RGB32,
    536. 

  536. 		.depth    = 32,
    537. 

  537. 		.flags    = FORMAT_FLAGS_PACKED,
    538. 

  538. 	},{
    539. 

  539. 		.name     = "32 bpp RGB, be",
    540. 

  540. 		.fourcc   = V4L2_PIX_FMT_RGB32,
    541. 

  541. 		.btformat = BT848_COLOR_FMT_RGB32,
    542. 

  542. 		.btswap   = 0x0f, /* byte+word swap */
    543. 

  543. 		.depth    = 32,
    544. 

  544. 		.flags    = FORMAT_FLAGS_PACKED,
    545. 

  545. 	},{
    546. 

  546. 		.name     = "4:2:2, packed, YUYV",
    547. 

  547. 		.fourcc   = V4L2_PIX_FMT_YUYV,
    548. 

  548. 		.btformat = BT848_COLOR_FMT_YUY2,
    549. 

  549. 		.depth    = 16,
    550. 

  550. 		.flags    = FORMAT_FLAGS_PACKED,
    551. 

  551. 	},{
    552. 

  552. 		.name     = "4:2:2, packed, YUYV",
    553. 

  553. 		.fourcc   = V4L2_PIX_FMT_YUYV,
    554. 

  554. 		.btformat = BT848_COLOR_FMT_YUY2,
    555. 

  555. 		.depth    = 16,
    556. 

  556. 		.flags    = FORMAT_FLAGS_PACKED,
    557. 

  557. 	},{
    558. 

  558. 		.name     = "4:2:2, packed, UYVY",
    559. 

  559. 		.fourcc   = V4L2_PIX_FMT_UYVY,
    560. 

  560. 		.btformat = BT848_COLOR_FMT_YUY2,
    561. 

  561. 		.btswap   = 0x03, /* byteswap */
    562. 

  562. 		.depth    = 16,
    563. 

  563. 		.flags    = FORMAT_FLAGS_PACKED,
    564. 

  564. 	},{
    565. 

  565. 		.name     = "4:2:2, planar, Y-Cb-Cr",
    566. 

  566. 		.fourcc   = V4L2_PIX_FMT_YUV422P,
    567. 

  567. 		.btformat = BT848_COLOR_FMT_YCrCb422,
    568. 

  568. 		.depth    = 16,
    569. 

  569. 		.flags    = FORMAT_FLAGS_PLANAR,
    570. 

  570. 		.hshift   = 1,
    571. 

  571. 		.vshift   = 0,
    572. 

  572. 	},{
    573. 

  573. 		.name     = "4:2:0, planar, Y-Cb-Cr",
    574. 

  574. 		.fourcc   = V4L2_PIX_FMT_YUV420,
    575. 

  575. 		.btformat = BT848_COLOR_FMT_YCrCb422,
    576. 

  576. 		.depth    = 12,
    577. 

  577. 		.flags    = FORMAT_FLAGS_PLANAR,
    578. 

  578. 		.hshift   = 1,
    579. 

  579. 		.vshift   = 1,
    580. 

  580. 	},{
    581. 

  581. 		.name     = "4:2:0, planar, Y-Cr-Cb",
    582. 

  582. 		.fourcc   = V4L2_PIX_FMT_YVU420,
    583. 

  583. 		.btformat = BT848_COLOR_FMT_YCrCb422,
    584. 

  584. 		.depth    = 12,
    585. 

  585. 		.flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
    586. 

  586. 		.hshift   = 1,
    587. 

  587. 		.vshift   = 1,
    588. 

  588. 	},{
    589. 

  589. 		.name     = "4:1:1, planar, Y-Cb-Cr",
    590. 

  590. 		.fourcc   = V4L2_PIX_FMT_YUV411P,
    591. 

  591. 		.btformat = BT848_COLOR_FMT_YCrCb411,
    592. 

  592. 		.depth    = 12,
    593. 

  593. 		.flags    = FORMAT_FLAGS_PLANAR,
    594. 

  594. 		.hshift   = 2,
    595. 

  595. 		.vshift   = 0,
    596. 

  596. 	},{
    597. 

  597. 		.name     = "4:1:0, planar, Y-Cb-Cr",
    598. 

  598. 		.fourcc   = V4L2_PIX_FMT_YUV410,
    599. 

  599. 		.btformat = BT848_COLOR_FMT_YCrCb411,
    600. 

  600. 		.depth    = 9,
    601. 

  601. 		.flags    = FORMAT_FLAGS_PLANAR,
    602. 

  602. 		.hshift   = 2,
    603. 

  603. 		.vshift   = 2,
    604. 

  604. 	},{
    605. 

  605. 		.name     = "4:1:0, planar, Y-Cr-Cb",
    606. 

  606. 		.fourcc   = V4L2_PIX_FMT_YVU410,
    607. 

  607. 		.btformat = BT848_COLOR_FMT_YCrCb411,
    608. 

  608. 		.depth    = 9,
    609. 

  609. 		.flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
    610. 

  610. 		.hshift   = 2,
    611. 

  611. 		.vshift   = 2,
    612. 

  612. 	},{
    613. 

  613. 		.name     = "raw scanlines",
    614. 

  614. 		.fourcc   = -1,
    615. 

  615. 		.btformat = BT848_COLOR_FMT_RAW,
    616. 

  616. 		.depth    = 8,
    617. 

  617. 		.flags    = FORMAT_FLAGS_RAW,
    618. 

  618. 	}
    619. 

  619. };
    620. 

  620. static const unsigned int FORMATS = ARRAY_SIZE(formats);
    621. 

  621. 

  622. /* ----------------------------------------------------------------------- */
    623. 

  623. 

  624. #define V4L2_CID_PRIVATE_CHROMA_AGC  (V4L2_CID_PRIVATE_BASE + 0)
    625. 

  625. #define V4L2_CID_PRIVATE_COMBFILTER  (V4L2_CID_PRIVATE_BASE + 1)
    626. 

  626. #define V4L2_CID_PRIVATE_AUTOMUTE    (V4L2_CID_PRIVATE_BASE + 2)
    627. 

  627. #define V4L2_CID_PRIVATE_LUMAFILTER  (V4L2_CID_PRIVATE_BASE + 3)
    628. 

  628. #define V4L2_CID_PRIVATE_AGC_CRUSH   (V4L2_CID_PRIVATE_BASE + 4)
    629. 

  629. #define V4L2_CID_PRIVATE_VCR_HACK    (V4L2_CID_PRIVATE_BASE + 5)
    630. 

  630. #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER   (V4L2_CID_PRIVATE_BASE + 6)
    631. 

  631. #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER   (V4L2_CID_PRIVATE_BASE + 7)
    632. 

  632. #define V4L2_CID_PRIVATE_UV_RATIO    (V4L2_CID_PRIVATE_BASE + 8)
    633. 

  633. #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE    (V4L2_CID_PRIVATE_BASE + 9)
    634. 

  634. #define V4L2_CID_PRIVATE_CORING      (V4L2_CID_PRIVATE_BASE + 10)
    635. 

  635. #define V4L2_CID_PRIVATE_LASTP1      (V4L2_CID_PRIVATE_BASE + 11)
    636. 

  636. 

  637. static const struct v4l2_queryctrl no_ctl = {
    638. 

  638. 	.name  = "42",
    639. 

  639. 	.flags = V4L2_CTRL_FLAG_DISABLED,
    640. 

  640. };
    641. 

  641. static const struct v4l2_queryctrl bttv_ctls[] = {
    642. 

  642. 	/* --- video --- */
    643. 

  643. 	{
    644. 

  644. 		.id            = V4L2_CID_BRIGHTNESS,
    645. 

  645. 		.name          = "Brightness",
    646. 

  646. 		.minimum       = 0,
    647. 

  647. 		.maximum       = 65535,
    648. 

  648. 		.step          = 256,
    649. 

  649. 		.default_value = 32768,
    650. 

  650. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    651. 

  651. 	},{
    652. 

  652. 		.id            = V4L2_CID_CONTRAST,
    653. 

  653. 		.name          = "Contrast",
    654. 

  654. 		.minimum       = 0,
    655. 

  655. 		.maximum       = 65535,
    656. 

  656. 		.step          = 128,
    657. 

  657. 		.default_value = 32768,
    658. 

  658. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    659. 

  659. 	},{
    660. 

  660. 		.id            = V4L2_CID_SATURATION,
    661. 

  661. 		.name          = "Saturation",
    662. 

  662. 		.minimum       = 0,
    663. 

  663. 		.maximum       = 65535,
    664. 

  664. 		.step          = 128,
    665. 

  665. 		.default_value = 32768,
    666. 

  666. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    667. 

  667. 	},{
    668. 

  668. 		.id            = V4L2_CID_HUE,
    669. 

  669. 		.name          = "Hue",
    670. 

  670. 		.minimum       = 0,
    671. 

  671. 		.maximum       = 65535,
    672. 

  672. 		.step          = 256,
    673. 

  673. 		.default_value = 32768,
    674. 

  674. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    675. 

  675. 	},
    676. 

  676. 	/* --- audio --- */
    677. 

  677. 	{
    678. 

  678. 		.id            = V4L2_CID_AUDIO_MUTE,
    679. 

  679. 		.name          = "Mute",
    680. 

  680. 		.minimum       = 0,
    681. 

  681. 		.maximum       = 1,
    682. 

  682. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    683. 

  683. 	},{
    684. 

  684. 		.id            = V4L2_CID_AUDIO_VOLUME,
    685. 

  685. 		.name          = "Volume",
    686. 

  686. 		.minimum       = 0,
    687. 

  687. 		.maximum       = 65535,
    688. 

  688. 		.step          = 65535/100,
    689. 

  689. 		.default_value = 65535,
    690. 

  690. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    691. 

  691. 	},{
    692. 

  692. 		.id            = V4L2_CID_AUDIO_BALANCE,
    693. 

  693. 		.name          = "Balance",
    694. 

  694. 		.minimum       = 0,
    695. 

  695. 		.maximum       = 65535,
    696. 

  696. 		.step          = 65535/100,
    697. 

  697. 		.default_value = 32768,
    698. 

  698. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    699. 

  699. 	},{
    700. 

  700. 		.id            = V4L2_CID_AUDIO_BASS,
    701. 

  701. 		.name          = "Bass",
    702. 

  702. 		.minimum       = 0,
    703. 

  703. 		.maximum       = 65535,
    704. 

  704. 		.step          = 65535/100,
    705. 

  705. 		.default_value = 32768,
    706. 

  706. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    707. 

  707. 	},{
    708. 

  708. 		.id            = V4L2_CID_AUDIO_TREBLE,
    709. 

  709. 		.name          = "Treble",
    710. 

  710. 		.minimum       = 0,
    711. 

  711. 		.maximum       = 65535,
    712. 

  712. 		.step          = 65535/100,
    713. 

  713. 		.default_value = 32768,
    714. 

  714. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    715. 

  715. 	},
    716. 

  716. 	/* --- private --- */
    717. 

  717. 	{
    718. 

  718. 		.id            = V4L2_CID_PRIVATE_CHROMA_AGC,
    719. 

  719. 		.name          = "chroma agc",
    720. 

  720. 		.minimum       = 0,
    721. 

  721. 		.maximum       = 1,
    722. 

  722. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    723. 

  723. 	},{
    724. 

  724. 		.id            = V4L2_CID_PRIVATE_COMBFILTER,
    725. 

  725. 		.name          = "combfilter",
    726. 

  726. 		.minimum       = 0,
    727. 

  727. 		.maximum       = 1,
    728. 

  728. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    729. 

  729. 	},{
    730. 

  730. 		.id            = V4L2_CID_PRIVATE_AUTOMUTE,
    731. 

  731. 		.name          = "automute",
    732. 

  732. 		.minimum       = 0,
    733. 

  733. 		.maximum       = 1,
    734. 

  734. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    735. 

  735. 	},{
    736. 

  736. 		.id            = V4L2_CID_PRIVATE_LUMAFILTER,
    737. 

  737. 		.name          = "luma decimation filter",
    738. 

  738. 		.minimum       = 0,
    739. 

  739. 		.maximum       = 1,
    740. 

  740. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    741. 

  741. 	},{
    742. 

  742. 		.id            = V4L2_CID_PRIVATE_AGC_CRUSH,
    743. 

  743. 		.name          = "agc crush",
    744. 

  744. 		.minimum       = 0,
    745. 

  745. 		.maximum       = 1,
    746. 

  746. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    747. 

  747. 	},{
    748. 

  748. 		.id            = V4L2_CID_PRIVATE_VCR_HACK,
    749. 

  749. 		.name          = "vcr hack",
    750. 

  750. 		.minimum       = 0,
    751. 

  751. 		.maximum       = 1,
    752. 

  752. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    753. 

  753. 	},{
    754. 

  754. 		.id            = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
    755. 

  755. 		.name          = "whitecrush upper",
    756. 

  756. 		.minimum       = 0,
    757. 

  757. 		.maximum       = 255,
    758. 

  758. 		.step          = 1,
    759. 

  759. 		.default_value = 0xCF,
    760. 

  760. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    761. 

  761. 	},{
    762. 

  762. 		.id            = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
    763. 

  763. 		.name          = "whitecrush lower",
    764. 

  764. 		.minimum       = 0,
    765. 

  765. 		.maximum       = 255,
    766. 

  766. 		.step          = 1,
    767. 

  767. 		.default_value = 0x7F,
    768. 

  768. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    769. 

  769. 	},{
    770. 

  770. 		.id            = V4L2_CID_PRIVATE_UV_RATIO,
    771. 

  771. 		.name          = "uv ratio",
    772. 

  772. 		.minimum       = 0,
    773. 

  773. 		.maximum       = 100,
    774. 

  774. 		.step          = 1,
    775. 

  775. 		.default_value = 50,
    776. 

  776. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    777. 

  777. 	},{
    778. 

  778. 		.id            = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
    779. 

  779. 		.name          = "full luma range",
    780. 

  780. 		.minimum       = 0,
    781. 

  781. 		.maximum       = 1,
    782. 

  782. 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
    783. 

  783. 	},{
    784. 

  784. 		.id            = V4L2_CID_PRIVATE_CORING,
    785. 

  785. 		.name          = "coring",
    786. 

  786. 		.minimum       = 0,
    787. 

  787. 		.maximum       = 3,
    788. 

  788. 		.step          = 1,
    789. 

  789. 		.default_value = 0,
    790. 

  790. 		.type          = V4L2_CTRL_TYPE_INTEGER,
    791. 

  791. 	}
    792. 

  792. 

  793. 

  794. 

  795. };
    796. 

  796. 

  797. static const struct v4l2_queryctrl *ctrl_by_id(int id)
    798. 

  798. {
    799. 

  799. 	int i;
    800. 

  800. 

  801. 	for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
    802. 

  802. 		if (bttv_ctls[i].id == id)
    803. 

  803. 			return bttv_ctls+i;
    804. 

  804. 

  805. 	return NULL;
    806. 

  806. }
    807. 

  807. 

  808. /* ----------------------------------------------------------------------- */
    809. 

  809. /* resource management                                                     */
    810. 

  810. 

  811. /*
    812. 

  812.    RESOURCE_    allocated by                freed by
    813. 

    814. 

  814.    VIDEO_READ   bttv_read 1)                bttv_read 2)
    815. 

    816. 

  816.    VIDEO_STREAM VIDIOC_STREAMON             VIDIOC_STREAMOFF
    817. 

  817. 		 VIDIOC_QBUF 1)              bttv_release
    818. 

  818. 		 VIDIOCMCAPTURE 1)
    819. 

    820. 

  820.    OVERLAY	 VIDIOCCAPTURE on            VIDIOCCAPTURE off
    821. 

  821. 		 VIDIOC_OVERLAY on           VIDIOC_OVERLAY off
    822. 

  822. 		 3)                          bttv_release
    823. 

    824. 

  824.    VBI		 VIDIOC_STREAMON             VIDIOC_STREAMOFF
    825. 

  825. 		 VIDIOC_QBUF 1)              bttv_release
    826. 

  826. 		 bttv_read, bttv_poll 1) 4)
    827. 

    828. 

  828.    1) The resource must be allocated when we enter buffer prepare functions
    829. 

  829.       and remain allocated while buffers are in the DMA queue.
    830. 

  830.    2) This is a single frame read.
    831. 

  831.    3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
    832. 

  832.       RESOURCE_OVERLAY is allocated.
    833. 

  833.    4) This is a continuous read, implies VIDIOC_STREAMON.
    834. 

    835. 

  835.    Note this driver permits video input and standard changes regardless if
    836. 

  836.    resources are allocated.
    837. 

  837. */
    838. 

  838. 

  839. #define VBI_RESOURCES (RESOURCE_VBI)
    840. 

  840. #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
    841. 

  841. 			 RESOURCE_VIDEO_STREAM | \
    842. 

  842. 			 RESOURCE_OVERLAY)
    843. 

  843. 

  844. static
    845. 

  845. int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
    846. 

  846. {
    847. 

  847. 	int xbits; /* mutual exclusive resources */
    848. 

  848. 

  849. 	if (fh->resources & bit)
    850. 

  850. 		/* have it already allocated */
    851. 

  851. 		return 1;
    852. 

  852. 

  853. 	xbits = bit;
    854. 

  854. 	if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
    855. 

  855. 		xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
    856. 

  856. 

  857. 	/* is it free? */
    858. 

  858. 	mutex_lock(&btv->lock);
    859. 

  859. 	if (btv->resources & xbits) {
    860. 

  860. 		/* no, someone else uses it */
    861. 

  861. 		goto fail;
    862. 

  862. 	}
    863. 

  863. 

  864. 	if ((bit & VIDEO_RESOURCES)
    865. 

  865. 	    && 0 == (btv->resources & VIDEO_RESOURCES)) {
    866. 

  866. 		/* Do crop - use current, don't - use default parameters. */
    867. 

  867. 		__s32 top = btv->crop[!!fh->do_crop].rect.top;
    868. 

  868. 

  869. 		if (btv->vbi_end > top)
    870. 

  870. 			goto fail;
    871. 

  871. 

  872. 		/* We cannot capture the same line as video and VBI data.
    873. 

  873. 		   Claim scan lines crop[].rect.top to bottom. */
    874. 

  874. 		btv->crop_start = top;
    875. 

  875. 	} else if (bit & VBI_RESOURCES) {
    876. 

  876. 		__s32 end = fh->vbi_fmt.end;
    877. 

  877. 

  878. 		if (end > btv->crop_start)
    879. 

  879. 			goto fail;
    880. 

  880. 

  881. 		/* Claim scan lines above fh->vbi_fmt.end. */
    882. 

  882. 		btv->vbi_end = end;
    883. 

  883. 	}
    884. 

  884. 

  885. 	/* it's free, grab it */
    886. 

  886. 	fh->resources  |= bit;
    887. 

  887. 	btv->resources |= bit;
    888. 

  888. 	mutex_unlock(&btv->lock);
    889. 

  889. 	return 1;
    890. 

  890. 

  891.  fail:
    892. 

  892. 	mutex_unlock(&btv->lock);
    893. 

  893. 	return 0;
    894. 

  894. }
    895. 

  895. 

  896. static
    897. 

  897. int check_btres(struct bttv_fh *fh, int bit)
    898. 

  898. {
    899. 

  899. 	return (fh->resources & bit);
    900. 

  900. }
    901. 

  901. 

  902. static
    903. 

  903. int locked_btres(struct bttv *btv, int bit)
    904. 

  904. {
    905. 

  905. 	return (btv->resources & bit);
    906. 

  906. }
    907. 

  907. 

  908. /* Call with btv->lock down. */
    909. 

  909. static void
    910. 

  910. disclaim_vbi_lines(struct bttv *btv)
    911. 

  911. {
    912. 

  912. 	btv->vbi_end = 0;
    913. 

  913. }
    914. 

  914. 

  915. /* Call with btv->lock down. */
    916. 

  916. static void
    917. 

  917. disclaim_video_lines(struct bttv *btv)
    918. 

  918. {
    919. 

  919. 	const struct bttv_tvnorm *tvnorm;
    920. 

  920. 	u8 crop;
    921. 

  921. 

  922. 	tvnorm = &bttv_tvnorms[btv->tvnorm];
    923. 

  923. 	btv->crop_start = tvnorm->cropcap.bounds.top
    924. 

  924. 		+ tvnorm->cropcap.bounds.height;
    925. 

  925. 

  926. 	/* VBI capturing ends at VDELAY, start of video capturing, no
    927. 

  927. 	   matter how many lines the VBI RISC program expects. When video
    928. 

  928. 	   capturing is off, it shall no longer "preempt" VBI capturing,
    929. 

  929. 	   so we set VDELAY to maximum. */
    930. 

  930. 	crop = btread(BT848_E_CROP) | 0xc0;
    931. 

  931. 	btwrite(crop, BT848_E_CROP);
    932. 

  932. 	btwrite(0xfe, BT848_E_VDELAY_LO);
    933. 

  933. 	btwrite(crop, BT848_O_CROP);
    934. 

  934. 	btwrite(0xfe, BT848_O_VDELAY_LO);
    935. 

  935. }
    936. 

  936. 

  937. static
    938. 

  938. void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
    939. 

  939. {
    940. 

  940. 	if ((fh->resources & bits) != bits) {
    941. 

  941. 		/* trying to free ressources not allocated by us ... */
    942. 

  942. 		printk("bttv: BUG! (btres)\n");
    943. 

  943. 	}
    944. 

  944. 	mutex_lock(&btv->lock);
    945. 

  945. 	fh->resources  &= ~bits;
    946. 

  946. 	btv->resources &= ~bits;
    947. 

  947. 

  948. 	bits = btv->resources;
    949. 

  949. 

  950. 	if (0 == (bits & VIDEO_RESOURCES))
    951. 

  951. 		disclaim_video_lines(btv);
    952. 

  952. 

  953. 	if (0 == (bits & VBI_RESOURCES))
    954. 

  954. 		disclaim_vbi_lines(btv);
    955. 

  955. 

  956. 	mutex_unlock(&btv->lock);
    957. 

  957. }
    958. 

  958. 

  959. /* ----------------------------------------------------------------------- */
    960. 

  960. /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC          */
    961. 

  961. 

  962. /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
    963. 

  963.    PLL_X = Reference pre-divider (0=1, 1=2)
    964. 

  964.    PLL_C = Post divider (0=6, 1=4)
    965. 

  965.    PLL_I = Integer input
    966. 

  966.    PLL_F = Fractional input
    967. 

    968. 

  968.    F_input = 28.636363 MHz:
    969. 

  969.    PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
    970. 

  970. */
    971. 

  971. 

  972. static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
    973. 

  973. {
    974. 

  974. 	unsigned char fl, fh, fi;
    975. 

  975. 

  976. 	/* prevent overflows */
    977. 

  977. 	fin/=4;
    978. 

  978. 	fout/=4;
    979. 

  979. 

  980. 	fout*=12;
    981. 

  981. 	fi=fout/fin;
    982. 

  982. 

  983. 	fout=(fout%fin)*256;
    984. 

  984. 	fh=fout/fin;
    985. 

  985. 

  986. 	fout=(fout%fin)*256;
    987. 

  987. 	fl=fout/fin;
    988. 

  988. 

  989. 	btwrite(fl, BT848_PLL_F_LO);
    990. 

  990. 	btwrite(fh, BT848_PLL_F_HI);
    991. 

  991. 	btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
    992. 

  992. }
    993. 

  993. 

  994. static void set_pll(struct bttv *btv)
    995. 

  995. {
    996. 

  996. 	int i;
    997. 

  997. 

  998. 	if (!btv->pll.pll_crystal)
    999. 

  999. 		return;
    1000. 

  1000. 

  1001. 	if (btv->pll.pll_ofreq == btv->pll.pll_current) {
    1002. 

  1002. 		dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
    1003. 

  1003. 		return;
    1004. 

  1004. 	}
    1005. 

  1005. 

  1006. 	if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
    1007. 

  1007. 		/* no PLL needed */
    1008. 

  1008. 		if (btv->pll.pll_current == 0)
    1009. 

  1009. 			return;
    1010. 

  1010. 		bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
    1011. 

  1011. 			btv->c.nr,btv->pll.pll_ifreq);
    1012. 

  1012. 		btwrite(0x00,BT848_TGCTRL);
    1013. 

  1013. 		btwrite(0x00,BT848_PLL_XCI);
    1014. 

  1014. 		btv->pll.pll_current = 0;
    1015. 

  1015. 		return;
    1016. 

  1016. 	}
    1017. 

  1017. 

  1018. 	bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
    1019. 

  1019. 		btv->pll.pll_ifreq, btv->pll.pll_ofreq);
    1020. 

  1020. 	set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
    1021. 

  1021. 

  1022. 	for (i=0; i<10; i++) {
    1023. 

  1023. 		/*  Let other people run while the PLL stabilizes */
    1024. 

  1024. 		bttv_printk(".");
    1025. 

  1025. 		msleep(10);
    1026. 

  1026. 

  1027. 		if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
    1028. 

  1028. 			btwrite(0,BT848_DSTATUS);
    1029. 

  1029. 		} else {
    1030. 

  1030. 			btwrite(0x08,BT848_TGCTRL);
    1031. 

  1031. 			btv->pll.pll_current = btv->pll.pll_ofreq;
    1032. 

  1032. 			bttv_printk(" ok\n");
    1033. 

  1033. 			return;
    1034. 

  1034. 		}
    1035. 

  1035. 	}
    1036. 

  1036. 	btv->pll.pll_current = -1;
    1037. 

  1037. 	bttv_printk("failed\n");
    1038. 

  1038. 	return;
    1039. 

  1039. }
    1040. 

  1040. 

  1041. /* used to switch between the bt848's analog/digital video capture modes */
    1042. 

  1042. static void bt848A_set_timing(struct bttv *btv)
    1043. 

  1043. {
    1044. 

  1044. 	int i, len;
    1045. 

  1045. 	int table_idx = bttv_tvnorms[btv->tvnorm].sram;
    1046. 

  1046. 	int fsc       = bttv_tvnorms[btv->tvnorm].Fsc;
    1047. 

  1047. 

  1048. 	if (btv->input == btv->dig) {
    1049. 

  1049. 		dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
    1050. 

  1050. 			btv->c.nr,table_idx);
    1051. 

  1051. 

  1052. 		/* timing change...reset timing generator address */
    1053. 

  1053. 		btwrite(0x00, BT848_TGCTRL);
    1054. 

  1054. 		btwrite(0x02, BT848_TGCTRL);
    1055. 

  1055. 		btwrite(0x00, BT848_TGCTRL);
    1056. 

  1056. 

  1057. 		len=SRAM_Table[table_idx][0];
    1058. 

  1058. 		for(i = 1; i <= len; i++)
    1059. 

  1059. 			btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
    1060. 

  1060. 		btv->pll.pll_ofreq = 27000000;
    1061. 

  1061. 

  1062. 		set_pll(btv);
    1063. 

  1063. 		btwrite(0x11, BT848_TGCTRL);
    1064. 

  1064. 		btwrite(0x41, BT848_DVSIF);
    1065. 

  1065. 	} else {
    1066. 

  1066. 		btv->pll.pll_ofreq = fsc;
    1067. 

  1067. 		set_pll(btv);
    1068. 

  1068. 		btwrite(0x0, BT848_DVSIF);
    1069. 

  1069. 	}
    1070. 

  1070. }
    1071. 

  1071. 

  1072. /* ----------------------------------------------------------------------- */
    1073. 

  1073. 

  1074. static void bt848_bright(struct bttv *btv, int bright)
    1075. 

  1075. {
    1076. 

  1076. 	int value;
    1077. 

  1077. 

  1078. 	// printk("bttv: set bright: %d\n",bright); // DEBUG
    1079. 

  1079. 	btv->bright = bright;
    1080. 

  1080. 

  1081. 	/* We want -128 to 127 we get 0-65535 */
    1082. 

  1082. 	value = (bright >> 8) - 128;
    1083. 

  1083. 	btwrite(value & 0xff, BT848_BRIGHT);
    1084. 

  1084. }
    1085. 

  1085. 

  1086. static void bt848_hue(struct bttv *btv, int hue)
    1087. 

  1087. {
    1088. 

  1088. 	int value;
    1089. 

  1089. 

  1090. 	btv->hue = hue;
    1091. 

  1091. 

  1092. 	/* -128 to 127 */
    1093. 

  1093. 	value = (hue >> 8) - 128;
    1094. 

  1094. 	btwrite(value & 0xff, BT848_HUE);
    1095. 

  1095. }
    1096. 

  1096. 

  1097. static void bt848_contrast(struct bttv *btv, int cont)
    1098. 

  1098. {
    1099. 

  1099. 	int value,hibit;
    1100. 

  1100. 

  1101. 	btv->contrast = cont;
    1102. 

  1102. 

  1103. 	/* 0-511 */
    1104. 

  1104. 	value = (cont  >> 7);
    1105. 

  1105. 	hibit = (value >> 6) & 4;
    1106. 

  1106. 	btwrite(value & 0xff, BT848_CONTRAST_LO);
    1107. 

  1107. 	btaor(hibit, ~4, BT848_E_CONTROL);
    1108. 

  1108. 	btaor(hibit, ~4, BT848_O_CONTROL);
    1109. 

  1109. }
    1110. 

  1110. 

  1111. static void bt848_sat(struct bttv *btv, int color)
    1112. 

  1112. {
    1113. 

  1113. 	int val_u,val_v,hibits;
    1114. 

  1114. 

  1115. 	btv->saturation = color;
    1116. 

  1116. 

  1117. 	/* 0-511 for the color */
    1118. 

  1118. 	val_u   = ((color * btv->opt_uv_ratio) / 50) >> 7;
    1119. 

  1119. 	val_v   = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
    1120. 

  1120. 	hibits  = (val_u >> 7) & 2;
    1121. 

  1121. 	hibits |= (val_v >> 8) & 1;
    1122. 

  1122. 	btwrite(val_u & 0xff, BT848_SAT_U_LO);
    1123. 

  1123. 	btwrite(val_v & 0xff, BT848_SAT_V_LO);
    1124. 

  1124. 	btaor(hibits, ~3, BT848_E_CONTROL);
    1125. 

  1125. 	btaor(hibits, ~3, BT848_O_CONTROL);
    1126. 

  1126. }
    1127. 

  1127. 

  1128. /* ----------------------------------------------------------------------- */
    1129. 

  1129. 

  1130. static int
    1131. 

  1131. video_mux(struct bttv *btv, unsigned int input)
    1132. 

  1132. {
    1133. 

  1133. 	int mux,mask2;
    1134. 

  1134. 

  1135. 	if (input >= bttv_tvcards[btv->c.type].video_inputs)
    1136. 

  1136. 		return -EINVAL;
    1137. 

  1137. 

  1138. 	/* needed by RemoteVideo MX */
    1139. 

  1139. 	mask2 = bttv_tvcards[btv->c.type].gpiomask2;
    1140. 

  1140. 	if (mask2)
    1141. 

  1141. 		gpio_inout(mask2,mask2);
    1142. 

  1142. 

  1143. 	if (input == btv->svhs)  {
    1144. 

  1144. 		btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
    1145. 

  1145. 		btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
    1146. 

  1146. 	} else {
    1147. 

  1147. 		btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
    1148. 

  1148. 		btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
    1149. 

  1149. 	}
    1150. 

  1150. 	mux = bttv_muxsel(btv, input);
    1151. 

  1151. 	btaor(mux<<5, ~(3<<5), BT848_IFORM);
    1152. 

  1152. 	dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
    1153. 

  1153. 		btv->c.nr,input,mux);
    1154. 

  1154. 

  1155. 	/* card specific hook */
    1156. 

  1156. 	if(bttv_tvcards[btv->c.type].muxsel_hook)
    1157. 

  1157. 		bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
    1158. 

  1158. 	return 0;
    1159. 

  1159. }
    1160. 

  1160. 

  1161. static char *audio_modes[] = {
    1162. 

  1162. 	"audio: tuner", "audio: radio", "audio: extern",
    1163. 

  1163. 	"audio: intern", "audio: mute"
    1164. 

  1164. };
    1165. 

  1165. 

  1166. static int
    1167. 

  1167. audio_mux(struct bttv *btv, int input, int mute)
    1168. 

  1168. {
    1169. 

  1169. 	int gpio_val, signal;
    1170. 

  1170. 	struct v4l2_control ctrl;
    1171. 

  1171. 

  1172. 	gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
    1173. 

  1173. 		   bttv_tvcards[btv->c.type].gpiomask);
    1174. 

  1174. 	signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
    1175. 

  1175. 

  1176. 	btv->mute = mute;
    1177. 

  1177. 	btv->audio = input;
    1178. 

  1178. 

  1179. 	/* automute */
    1180. 

  1180. 	mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
    1181. 

  1181. 

  1182. 	if (mute)
    1183. 

  1183. 		gpio_val = bttv_tvcards[btv->c.type].gpiomute;
    1184. 

  1184. 	else
    1185. 

  1185. 		gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
    1186. 

  1186. 

  1187. 	switch (btv->c.type) {
    1188. 

  1188. 	case BTTV_BOARD_VOODOOTV_FM:
    1189. 

  1189. 	case BTTV_BOARD_VOODOOTV_200:
    1190. 

  1190. 		gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
    1191. 

  1191. 		break;
    1192. 

  1192. 

  1193. 	default:
    1194. 

  1194. 		gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
    1195. 

  1195. 	}
    1196. 

  1196. 

  1197. 	if (bttv_gpio)
    1198. 

  1198. 		bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
    1199. 

  1199. 	if (in_interrupt())
    1200. 

  1200. 		return 0;
    1201. 

  1201. 

  1202. 	ctrl.id = V4L2_CID_AUDIO_MUTE;
    1203. 

  1203. 	ctrl.value = btv->mute;
    1204. 

  1204. 	bttv_call_all(btv, core, s_ctrl, &ctrl);
    1205. 

  1205. 	if (btv->sd_msp34xx) {
    1206. 

  1206. 		u32 in;
    1207. 

  1207. 

  1208. 		/* Note: the inputs tuner/radio/extern/intern are translated
    1209. 

  1209. 		   to msp routings. This assumes common behavior for all msp3400
    1210. 

  1210. 		   based TV cards. When this assumption fails, then the
    1211. 

  1211. 		   specific MSP routing must be added to the card table.
    1212. 

  1212. 		   For now this is sufficient. */
    1213. 

  1213. 		switch (input) {
    1214. 

  1214. 		case TVAUDIO_INPUT_RADIO:
    1215. 

  1215. 			in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
    1216. 

  1216. 				    MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
    1217. 

  1217. 			break;
    1218. 

  1218. 		case TVAUDIO_INPUT_EXTERN:
    1219. 

  1219. 			in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
    1220. 

  1220. 				    MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
    1221. 

  1221. 			break;
    1222. 

  1222. 		case TVAUDIO_INPUT_INTERN:
    1223. 

  1223. 			/* Yes, this is the same input as for RADIO. I doubt
    1224. 

  1224. 			   if this is ever used. The only board with an INTERN
    1225. 

  1225. 			   input is the BTTV_BOARD_AVERMEDIA98. I wonder how
    1226. 

  1226. 			   that was tested. My guess is that the whole INTERN
    1227. 

  1227. 			   input does not work. */
    1228. 

  1228. 			in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
    1229. 

  1229. 				    MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
    1230. 

  1230. 			break;
    1231. 

  1231. 		case TVAUDIO_INPUT_TUNER:
    1232. 

  1232. 		default:
    1233. 

  1233. 			/* This is the only card that uses TUNER2, and afaik,
    1234. 

  1234. 			   is the only difference between the VOODOOTV_FM
    1235. 

  1235. 			   and VOODOOTV_200 */
    1236. 

  1236. 			if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
    1237. 

  1237. 				in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
    1238. 

  1238. 					MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
    1239. 

  1239. 			else
    1240. 

  1240. 				in = MSP_INPUT_DEFAULT;
    1241. 

  1241. 			break;
    1242. 

  1242. 		}
    1243. 

  1243. 		v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
    1244. 

  1244. 			       in, MSP_OUTPUT_DEFAULT, 0);
    1245. 

  1245. 	}
    1246. 

  1246. 	if (btv->sd_tvaudio) {
    1247. 

  1247. 		v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
    1248. 

  1248. 				input, 0, 0);
    1249. 

  1249. 	}
    1250. 

  1250. 	return 0;
    1251. 

  1251. }
    1252. 

  1252. 

  1253. static inline int
    1254. 

  1254. audio_mute(struct bttv *btv, int mute)
    1255. 

  1255. {
    1256. 

  1256. 	return audio_mux(btv, btv->audio, mute);
    1257. 

  1257. }
    1258. 

  1258. 

  1259. static inline int
    1260. 

  1260. audio_input(struct bttv *btv, int input)
    1261. 

  1261. {
    1262. 

  1262. 	return audio_mux(btv, input, btv->mute);
    1263. 

  1263. }
    1264. 

  1264. 

  1265. static void
    1266. 

  1266. bttv_crop_calc_limits(struct bttv_crop *c)
    1267. 

  1267. {
    1268. 

  1268. 	/* Scale factor min. 1:1, max. 16:1. Min. image size
    1269. 

  1269. 	   48 x 32. Scaled width must be a multiple of 4. */
    1270. 

  1270. 

  1271. 	if (1) {
    1272. 

  1272. 		/* For bug compatibility with VIDIOCGCAP and image
    1273. 

  1273. 		   size checks in earlier driver versions. */
    1274. 

  1274. 		c->min_scaled_width = 48;
    1275. 

  1275. 		c->min_scaled_height = 32;
    1276. 

  1276. 	} else {
    1277. 

  1277. 		c->min_scaled_width =
    1278. 

  1278. 			(max(48, c->rect.width >> 4) + 3) & ~3;
    1279. 

  1279. 		c->min_scaled_height =
    1280. 

  1280. 			max(32, c->rect.height >> 4);
    1281. 

  1281. 	}
    1282. 

  1282. 

  1283. 	c->max_scaled_width  = c->rect.width & ~3;
    1284. 

  1284. 	c->max_scaled_height = c->rect.height;
    1285. 

  1285. }
    1286. 

  1286. 

  1287. static void
    1288. 

  1288. bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
    1289. 

  1289. {
    1290. 

  1290. 	c->rect = bttv_tvnorms[norm].cropcap.defrect;
    1291. 

  1291. 	bttv_crop_calc_limits(c);
    1292. 

  1292. }
    1293. 

  1293. 

  1294. /* Call with btv->lock down. */
    1295. 

  1295. static int
    1296. 

  1296. set_tvnorm(struct bttv *btv, unsigned int norm)
    1297. 

  1297. {
    1298. 

  1298. 	const struct bttv_tvnorm *tvnorm;
    1299. 

  1299. 	v4l2_std_id id;
    1300. 

  1300. 

  1301. 	BUG_ON(norm >= BTTV_TVNORMS);
    1302. 

  1302. 	BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
    1303. 

  1303. 

  1304. 	tvnorm = &bttv_tvnorms[norm];
    1305. 

  1305. 

  1306. 	if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
    1307. 

  1307. 		    sizeof (tvnorm->cropcap))) {
    1308. 

  1308. 		bttv_crop_reset(&btv->crop[0], norm);
    1309. 

  1309. 		btv->crop[1] = btv->crop[0]; /* current = default */
    1310. 

  1310. 

  1311. 		if (0 == (btv->resources & VIDEO_RESOURCES)) {
    1312. 

  1312. 			btv->crop_start = tvnorm->cropcap.bounds.top
    1313. 

  1313. 				+ tvnorm->cropcap.bounds.height;
    1314. 

  1314. 		}
    1315. 

  1315. 	}
    1316. 

  1316. 

  1317. 	btv->tvnorm = norm;
    1318. 

  1318. 

  1319. 	btwrite(tvnorm->adelay, BT848_ADELAY);
    1320. 

  1320. 	btwrite(tvnorm->bdelay, BT848_BDELAY);
    1321. 

  1321. 	btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
    1322. 

  1322. 	      BT848_IFORM);
    1323. 

  1323. 	btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
    1324. 

  1324. 	btwrite(1, BT848_VBI_PACK_DEL);
    1325. 

  1325. 	bt848A_set_timing(btv);
    1326. 

  1326. 

  1327. 	switch (btv->c.type) {
    1328. 

  1328. 	case BTTV_BOARD_VOODOOTV_FM:
    1329. 

  1329. 	case BTTV_BOARD_VOODOOTV_200:
    1330. 

  1330. 		bttv_tda9880_setnorm(btv, gpio_read());
    1331. 

  1331. 		break;
    1332. 

  1332. 	}
    1333. 

  1333. 	id = tvnorm->v4l2_id;
    1334. 

  1334. 	bttv_call_all(btv, core, s_std, id);
    1335. 

  1335. 

  1336. 	return 0;
    1337. 

  1337. }
    1338. 

  1338. 

  1339. /* Call with btv->lock down. */
    1340. 

  1340. static void
    1341. 

  1341. set_input(struct bttv *btv, unsigned int input, unsigned int norm)
    1342. 

  1342. {
    1343. 

  1343. 	unsigned long flags;
    1344. 

  1344. 

  1345. 	btv->input = input;
    1346. 

  1346. 	if (irq_iswitch) {
    1347. 

  1347. 		spin_lock_irqsave(&btv->s_lock,flags);
    1348. 

  1348. 		if (btv->curr.frame_irq) {
    1349. 

  1349. 			/* active capture -> delayed input switch */
    1350. 

  1350. 			btv->new_input = input;
    1351. 

  1351. 		} else {
    1352. 

  1352. 			video_mux(btv,input);
    1353. 

  1353. 		}
    1354. 

  1354. 		spin_unlock_irqrestore(&btv->s_lock,flags);
    1355. 

  1355. 	} else {
    1356. 

  1356. 		video_mux(btv,input);
    1357. 

  1357. 	}
    1358. 

  1358. 	audio_input(btv, (btv->tuner_type != TUNER_ABSENT && input == 0) ?
    1359. 

  1359. 			 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN);
    1360. 

  1360. 	set_tvnorm(btv, norm);
    1361. 

  1361. }
    1362. 

  1362. 

  1363. static void init_irqreg(struct bttv *btv)
    1364. 

  1364. {
    1365. 

  1365. 	/* clear status */
    1366. 

  1366. 	btwrite(0xfffffUL, BT848_INT_STAT);
    1367. 

  1367. 

  1368. 	if (bttv_tvcards[btv->c.type].no_video) {
    1369. 

  1369. 		/* i2c only */
    1370. 

  1370. 		btwrite(BT848_INT_I2CDONE,
    1371. 

  1371. 			BT848_INT_MASK);
    1372. 

  1372. 	} else {
    1373. 

  1373. 		/* full video */
    1374. 

  1374. 		btwrite((btv->triton1)  |
    1375. 

  1375. 			(btv->gpioirq ? BT848_INT_GPINT : 0) |
    1376. 

  1376. 			BT848_INT_SCERR |
    1377. 

  1377. 			(fdsr ? BT848_INT_FDSR : 0) |
    1378. 

  1378. 			BT848_INT_RISCI | BT848_INT_OCERR |
    1379. 

  1379. 			BT848_INT_FMTCHG|BT848_INT_HLOCK|
    1380. 

  1380. 			BT848_INT_I2CDONE,
    1381. 

  1381. 			BT848_INT_MASK);
    1382. 

  1382. 	}
    1383. 

  1383. }
    1384. 

  1384. 

  1385. static void init_bt848(struct bttv *btv)
    1386. 

  1386. {
    1387. 

  1387. 	int val;
    1388. 

  1388. 

  1389. 	if (bttv_tvcards[btv->c.type].no_video) {
    1390. 

  1390. 		/* very basic init only */
    1391. 

  1391. 		init_irqreg(btv);
    1392. 

  1392. 		return;
    1393. 

  1393. 	}
    1394. 

  1394. 

  1395. 	btwrite(0x00, BT848_CAP_CTL);
    1396. 

  1396. 	btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
    1397. 

  1397. 	btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
    1398. 

  1398. 

  1399. 	/* set planar and packed mode trigger points and         */
    1400. 

  1400. 	/* set rising edge of inverted GPINTR pin as irq trigger */
    1401. 

  1401. 	btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
    1402. 

  1402. 		BT848_GPIO_DMA_CTL_PLTP1_16|
    1403. 

  1403. 		BT848_GPIO_DMA_CTL_PLTP23_16|
    1404. 

  1404. 		BT848_GPIO_DMA_CTL_GPINTC|
    1405. 

  1405. 		BT848_GPIO_DMA_CTL_GPINTI,
    1406. 

  1406. 		BT848_GPIO_DMA_CTL);
    1407. 

  1407. 

  1408. 	val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
    1409. 

  1409. 	btwrite(val, BT848_E_SCLOOP);
    1410. 

  1410. 	btwrite(val, BT848_O_SCLOOP);
    1411. 

  1411. 

  1412. 	btwrite(0x20, BT848_E_VSCALE_HI);
    1413. 

  1413. 	btwrite(0x20, BT848_O_VSCALE_HI);
    1414. 

  1414. 	btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
    1415. 

  1415. 		BT848_ADC);
    1416. 

  1416. 

  1417. 	btwrite(whitecrush_upper, BT848_WC_UP);
    1418. 

  1418. 	btwrite(whitecrush_lower, BT848_WC_DOWN);
    1419. 

  1419. 

  1420. 	if (btv->opt_lumafilter) {
    1421. 

  1421. 		btwrite(0, BT848_E_CONTROL);
    1422. 

  1422. 		btwrite(0, BT848_O_CONTROL);
    1423. 

  1423. 	} else {
    1424. 

  1424. 		btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
    1425. 

  1425. 		btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
    1426. 

  1426. 	}
    1427. 

  1427. 

  1428. 	bt848_bright(btv,   btv->bright);
    1429. 

  1429. 	bt848_hue(btv,      btv->hue);
    1430. 

  1430. 	bt848_contrast(btv, btv->contrast);
    1431. 

  1431. 	bt848_sat(btv,      btv->saturation);
    1432. 

  1432. 

  1433. 	/* interrupt */
    1434. 

  1434. 	init_irqreg(btv);
    1435. 

  1435. }
    1436. 

  1436. 

  1437. static void bttv_reinit_bt848(struct bttv *btv)
    1438. 

  1438. {
    1439. 

  1439. 	unsigned long flags;
    1440. 

  1440. 

  1441. 	if (bttv_verbose)
    1442. 

  1442. 		printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
    1443. 

  1443. 	spin_lock_irqsave(&btv->s_lock,flags);
    1444. 

  1444. 	btv->errors=0;
    1445. 

  1445. 	bttv_set_dma(btv,0);
    1446. 

  1446. 	spin_unlock_irqrestore(&btv->s_lock,flags);
    1447. 

  1447. 

  1448. 	init_bt848(btv);
    1449. 

  1449. 	btv->pll.pll_current = -1;
    1450. 

  1450. 	set_input(btv, btv->input, btv->tvnorm);
    1451. 

  1451. }
    1452. 

  1452. 

  1453. static int bttv_g_ctrl(struct file *file, void *priv,
    1454. 

  1454. 					struct v4l2_control *c)
    1455. 

  1455. {
    1456. 

  1456. 	struct bttv_fh *fh = priv;
    1457. 

  1457. 	struct bttv *btv = fh->btv;
    1458. 

  1458. 

  1459. 	switch (c->id) {
    1460. 

  1460. 	case V4L2_CID_BRIGHTNESS:
    1461. 

  1461. 		c->value = btv->bright;
    1462. 

  1462. 		break;
    1463. 

  1463. 	case V4L2_CID_HUE:
    1464. 

  1464. 		c->value = btv->hue;
    1465. 

  1465. 		break;
    1466. 

  1466. 	case V4L2_CID_CONTRAST:
    1467. 

  1467. 		c->value = btv->contrast;
    1468. 

  1468. 		break;
    1469. 

  1469. 	case V4L2_CID_SATURATION:
    1470. 

  1470. 		c->value = btv->saturation;
    1471. 

  1471. 		break;
    1472. 

  1472. 

  1473. 	case V4L2_CID_AUDIO_MUTE:
    1474. 

  1474. 	case V4L2_CID_AUDIO_VOLUME:
    1475. 

  1475. 	case V4L2_CID_AUDIO_BALANCE:
    1476. 

  1476. 	case V4L2_CID_AUDIO_BASS:
    1477. 

  1477. 	case V4L2_CID_AUDIO_TREBLE:
    1478. 

  1478. 		bttv_call_all(btv, core, g_ctrl, c);
    1479. 

  1479. 		break;
    1480. 

  1480. 

  1481. 	case V4L2_CID_PRIVATE_CHROMA_AGC:
    1482. 

  1482. 		c->value = btv->opt_chroma_agc;
    1483. 

  1483. 		break;
    1484. 

  1484. 	case V4L2_CID_PRIVATE_COMBFILTER:
    1485. 

  1485. 		c->value = btv->opt_combfilter;
    1486. 

  1486. 		break;
    1487. 

  1487. 	case V4L2_CID_PRIVATE_LUMAFILTER:
    1488. 

  1488. 		c->value = btv->opt_lumafilter;
    1489. 

  1489. 		break;
    1490. 

  1490. 	case V4L2_CID_PRIVATE_AUTOMUTE:
    1491. 

  1491. 		c->value = btv->opt_automute;
    1492. 

  1492. 		break;
    1493. 

  1493. 	case V4L2_CID_PRIVATE_AGC_CRUSH:
    1494. 

  1494. 		c->value = btv->opt_adc_crush;
    1495. 

  1495. 		break;
    1496. 

  1496. 	case V4L2_CID_PRIVATE_VCR_HACK:
    1497. 

  1497. 		c->value = btv->opt_vcr_hack;
    1498. 

  1498. 		break;
    1499. 

  1499. 	case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
    1500. 

  1500. 		c->value = btv->opt_whitecrush_upper;
    1501. 

  1501. 		break;
    1502. 

  1502. 	case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
    1503. 

  1503. 		c->value = btv->opt_whitecrush_lower;
    1504. 

  1504. 		break;
    1505. 

  1505. 	case V4L2_CID_PRIVATE_UV_RATIO:
    1506. 

  1506. 		c->value = btv->opt_uv_ratio;
    1507. 

  1507. 		break;
    1508. 

  1508. 	case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
    1509. 

  1509. 		c->value = btv->opt_full_luma_range;
    1510. 

  1510. 		break;
    1511. 

  1511. 	case V4L2_CID_PRIVATE_CORING:
    1512. 

  1512. 		c->value = btv->opt_coring;
    1513. 

  1513. 		break;
    1514. 

  1514. 	default:
    1515. 

  1515. 		return -EINVAL;
    1516. 

  1516. 	}
    1517. 

  1517. 	return 0;
    1518. 

  1518. }
    1519. 

  1519. 

  1520. static int bttv_s_ctrl(struct file *file, void *f,
    1521. 

  1521. 					struct v4l2_control *c)
    1522. 

  1522. {
    1523. 

  1523. 	int err;
    1524. 

  1524. 	int val;
    1525. 

  1525. 	struct bttv_fh *fh = f;
    1526. 

  1526. 	struct bttv *btv = fh->btv;
    1527. 

  1527. 

  1528. 	err = v4l2_prio_check(&btv->prio, fh->prio);
    1529. 

  1529. 	if (0 != err)
    1530. 

  1530. 		return err;
    1531. 

  1531. 

  1532. 	switch (c->id) {
    1533. 

  1533. 	case V4L2_CID_BRIGHTNESS:
    1534. 

  1534. 		bt848_bright(btv, c->value);
    1535. 

  1535. 		break;
    1536. 

  1536. 	case V4L2_CID_HUE:
    1537. 

  1537. 		bt848_hue(btv, c->value);
    1538. 

  1538. 		break;
    1539. 

  1539. 	case V4L2_CID_CONTRAST:
    1540. 

  1540. 		bt848_contrast(btv, c->value);
    1541. 

  1541. 		break;
    1542. 

  1542. 	case V4L2_CID_SATURATION:
    1543. 

  1543. 		bt848_sat(btv, c->value);
    1544. 

  1544. 		break;
    1545. 

  1545. 	case V4L2_CID_AUDIO_MUTE:
    1546. 

  1546. 		audio_mute(btv, c->value);
    1547. 

  1547. 		/* fall through */
    1548. 

  1548. 	case V4L2_CID_AUDIO_VOLUME:
    1549. 

  1549. 		if (btv->volume_gpio)
    1550. 

  1550. 			btv->volume_gpio(btv, c->value);
    1551. 

  1551. 

  1552. 		bttv_call_all(btv, core, s_ctrl, c);
    1553. 

  1553. 		break;
    1554. 

  1554. 	case V4L2_CID_AUDIO_BALANCE:
    1555. 

  1555. 	case V4L2_CID_AUDIO_BASS:
    1556. 

  1556. 	case V4L2_CID_AUDIO_TREBLE:
    1557. 

  1557. 		bttv_call_all(btv, core, s_ctrl, c);
    1558. 

  1558. 		break;
    1559. 

  1559. 

  1560. 	case V4L2_CID_PRIVATE_CHROMA_AGC:
    1561. 

  1561. 		btv->opt_chroma_agc = c->value;
    1562. 

  1562. 		val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
    1563. 

  1563. 		btwrite(val, BT848_E_SCLOOP);
    1564. 

  1564. 		btwrite(val, BT848_O_SCLOOP);
    1565. 

  1565. 		break;
    1566. 

  1566. 	case V4L2_CID_PRIVATE_COMBFILTER:
    1567. 

  1567. 		btv->opt_combfilter = c->value;
    1568. 

  1568. 		break;
    1569. 

  1569. 	case V4L2_CID_PRIVATE_LUMAFILTER:
    1570. 

  1570. 		btv->opt_lumafilter = c->value;
    1571. 

  1571. 		if (btv->opt_lumafilter) {
    1572. 

  1572. 			btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
    1573. 

  1573. 			btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
    1574. 

  1574. 		} else {
    1575. 

  1575. 			btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
    1576. 

  1576. 			btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
    1577. 

  1577. 		}
    1578. 

  1578. 		break;
    1579. 

  1579. 	case V4L2_CID_PRIVATE_AUTOMUTE:
    1580. 

  1580. 		btv->opt_automute = c->value;
    1581. 

  1581. 		break;
    1582. 

  1582. 	case V4L2_CID_PRIVATE_AGC_CRUSH:
    1583. 

  1583. 		btv->opt_adc_crush = c->value;
    1584. 

  1584. 		btwrite(BT848_ADC_RESERVED |
    1585. 

  1585. 				(btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
    1586. 

  1586. 				BT848_ADC);
    1587. 

  1587. 		break;
    1588. 

  1588. 	case V4L2_CID_PRIVATE_VCR_HACK:
    1589. 

  1589. 		btv->opt_vcr_hack = c->value;
    1590. 

  1590. 		break;
    1591. 

  1591. 	case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
    1592. 

  1592. 		btv->opt_whitecrush_upper = c->value;
    1593. 

  1593. 		btwrite(c->value, BT848_WC_UP);
    1594. 

  1594. 		break;
    1595. 

  1595. 	case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
    1596. 

  1596. 		btv->opt_whitecrush_lower = c->value;
    1597. 

  1597. 		btwrite(c->value, BT848_WC_DOWN);
    1598. 

  1598. 		break;
    1599. 

  1599. 	case V4L2_CID_PRIVATE_UV_RATIO:
    1600. 

  1600. 		btv->opt_uv_ratio = c->value;
    1601. 

  1601. 		bt848_sat(btv, btv->saturation);
    1602. 

  1602. 		break;
    1603. 

  1603. 	case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
    1604. 

  1604. 		btv->opt_full_luma_range = c->value;
    1605. 

  1605. 		btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
    1606. 

  1606. 		break;
    1607. 

  1607. 	case V4L2_CID_PRIVATE_CORING:
    1608. 

  1608. 		btv->opt_coring = c->value;
    1609. 

  1609. 		btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
    1610. 

  1610. 		break;
    1611. 

  1611. 	default:
    1612. 

  1612. 		return -EINVAL;
    1613. 

  1613. 	}
    1614. 

  1614. 	return 0;
    1615. 

  1615. }
    1616. 

  1616. 

  1617. /* ----------------------------------------------------------------------- */
    1618. 

  1618. 

  1619. void bttv_gpio_tracking(struct bttv *btv, char *comment)
    1620. 

  1620. {
    1621. 

  1621. 	unsigned int outbits, data;
    1622. 

  1622. 	outbits = btread(BT848_GPIO_OUT_EN);
    1623. 

  1623. 	data    = btread(BT848_GPIO_DATA);
    1624. 

  1624. 	printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
    1625. 

  1625. 	       btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
    1626. 

  1626. }
    1627. 

  1627. 

  1628. static void bttv_field_count(struct bttv *btv)
    1629. 

  1629. {
    1630. 

  1630. 	int need_count = 0;
    1631. 

  1631. 

  1632. 	if (btv->users)
    1633. 

  1633. 		need_count++;
    1634. 

  1634. 

  1635. 	if (need_count) {
    1636. 

  1636. 		/* start field counter */
    1637. 

  1637. 		btor(BT848_INT_VSYNC,BT848_INT_MASK);
    1638. 

  1638. 	} else {
    1639. 

  1639. 		/* stop field counter */
    1640. 

  1640. 		btand(~BT848_INT_VSYNC,BT848_INT_MASK);
    1641. 

  1641. 		btv->field_count = 0;
    1642. 

  1642. 	}
    1643. 

  1643. }
    1644. 

  1644. 

  1645. static const struct bttv_format*
    1646. 

  1646. format_by_fourcc(int fourcc)
    1647. 

  1647. {
    1648. 

  1648. 	unsigned int i;
    1649. 

  1649. 

  1650. 	for (i = 0; i < FORMATS; i++) {
    1651. 

  1651. 		if (-1 == formats[i].fourcc)
    1652. 

  1652. 			continue;
    1653. 

  1653. 		if (formats[i].fourcc == fourcc)
    1654. 

  1654. 			return formats+i;
    1655. 

  1655. 	}
    1656. 

  1656. 	return NULL;
    1657. 

  1657. }
    1658. 

  1658. 

  1659. /* ----------------------------------------------------------------------- */
    1660. 

  1660. /* misc helpers                                                            */
    1661. 

  1661. 

  1662. static int
    1663. 

  1663. bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
    1664. 

  1664. 		    struct bttv_buffer *new)
    1665. 

  1665. {
    1666. 

  1666. 	struct bttv_buffer *old;
    1667. 

  1667. 	unsigned long flags;
    1668. 

  1668. 	int retval = 0;
    1669. 

  1669. 

  1670. 	dprintk("switch_overlay: enter [new=%p]\n",new);
    1671. 

  1671. 	if (new)
    1672. 

  1672. 		new->vb.state = VIDEOBUF_DONE;
    1673. 

  1673. 	spin_lock_irqsave(&btv->s_lock,flags);
    1674. 

  1674. 	old = btv->screen;
    1675. 

  1675. 	btv->screen = new;
    1676. 

  1676. 	btv->loop_irq |= 1;
    1677. 

  1677. 	bttv_set_dma(btv, 0x03);
    1678. 

  1678. 	spin_unlock_irqrestore(&btv->s_lock,flags);
    1679. 

  1679. 	if (NULL != old) {
    1680. 

  1680. 		dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
    1681. 

  1681. 		bttv_dma_free(&fh->cap,btv, old);
    1682. 

  1682. 		kfree(old);
    1683. 

  1683. 	}
    1684. 

  1684. 	if (NULL == new)
    1685. 

  1685. 		free_btres(btv,fh,RESOURCE_OVERLAY);
    1686. 

  1686. 	dprintk("switch_overlay: done\n");
    1687. 

  1687. 	return retval;
    1688. 

  1688. }
    1689. 

  1689. 

  1690. /* ----------------------------------------------------------------------- */
    1691. 

  1691. /* video4linux (1) interface                                               */
    1692. 

  1692. 

  1693. static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
    1694. 

  1694. 			       struct bttv_buffer *buf,
    1695. 

  1695. 			       const struct bttv_format *fmt,
    1696. 

  1696. 			       unsigned int width, unsigned int height,
    1697. 

  1697. 			       enum v4l2_field field)
    1698. 

  1698. {
    1699. 

  1699. 	struct bttv_fh *fh = q->priv_data;
    1700. 

  1700. 	int redo_dma_risc = 0;
    1701. 

  1701. 	struct bttv_crop c;
    1702. 

  1702. 	int norm;
    1703. 

  1703. 	int rc;
    1704. 

  1704. 

  1705. 	/* check settings */
    1706. 

  1706. 	if (NULL == fmt)
    1707. 

  1707. 		return -EINVAL;
    1708. 

  1708. 	if (fmt->btformat == BT848_COLOR_FMT_RAW) {
    1709. 

  1709. 		width  = RAW_BPL;
    1710. 

  1710. 		height = RAW_LINES*2;
    1711. 

  1711. 		if (width*height > buf->vb.bsize)
    1712. 

  1712. 			return -EINVAL;
    1713. 

  1713. 		buf->vb.size = buf->vb.bsize;
    1714. 

  1714. 

  1715. 		/* Make sure tvnorm and vbi_end remain consistent
    1716. 

  1716. 		   until we're done. */
    1717. 

  1717. 		mutex_lock(&btv->lock);
    1718. 

  1718. 

  1719. 		norm = btv->tvnorm;
    1720. 

  1720. 

  1721. 		/* In this mode capturing always starts at defrect.top
    1722. 

  1722. 		   (default VDELAY), ignoring cropping parameters. */
    1723. 

  1723. 		if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
    1724. 

  1724. 			mutex_unlock(&btv->lock);
    1725. 

  1725. 			return -EINVAL;
    1726. 

  1726. 		}
    1727. 

  1727. 

  1728. 		mutex_unlock(&btv->lock);
    1729. 

  1729. 

  1730. 		c.rect = bttv_tvnorms[norm].cropcap.defrect;
    1731. 

  1731. 	} else {
    1732. 

  1732. 		mutex_lock(&btv->lock);
    1733. 

  1733. 

  1734. 		norm = btv->tvnorm;
    1735. 

  1735. 		c = btv->crop[!!fh->do_crop];
    1736. 

  1736. 

  1737. 		mutex_unlock(&btv->lock);
    1738. 

  1738. 

  1739. 		if (width < c.min_scaled_width ||
    1740. 

  1740. 		    width > c.max_scaled_width ||
    1741. 

  1741. 		    height < c.min_scaled_height)
    1742. 

  1742. 			return -EINVAL;
    1743. 

  1743. 

  1744. 		switch (field) {
    1745. 

  1745. 		case V4L2_FIELD_TOP:
    1746. 

  1746. 		case V4L2_FIELD_BOTTOM:
    1747. 

  1747. 		case V4L2_FIELD_ALTERNATE:
    1748. 

  1748. 			/* btv->crop counts frame lines. Max. scale
    1749. 

  1749. 			   factor is 16:1 for frames, 8:1 for fields. */
    1750. 

  1750. 			if (height * 2 > c.max_scaled_height)
    1751. 

  1751. 				return -EINVAL;
    1752. 

  1752. 			break;
    1753. 

  1753. 

  1754. 		default:
    1755. 

  1755. 			if (height > c.max_scaled_height)
    1756. 

  1756. 				return -EINVAL;
    1757. 

  1757. 			break;
    1758. 

  1758. 		}
    1759. 

  1759. 

  1760. 		buf->vb.size = (width * height * fmt->depth) >> 3;
    1761. 

  1761. 		if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
    1762. 

  1762. 			return -EINVAL;
    1763. 

  1763. 	}
    1764. 

  1764. 

  1765. 	/* alloc + fill struct bttv_buffer (if changed) */
    1766. 

  1766. 	if (buf->vb.width != width || buf->vb.height != height ||
    1767. 

  1767. 	    buf->vb.field != field ||
    1768. 

  1768. 	    buf->tvnorm != norm || buf->fmt != fmt ||
    1769. 

  1769. 	    buf->crop.top != c.rect.top ||
    1770. 

  1770. 	    buf->crop.left != c.rect.left ||
    1771. 

  1771. 	    buf->crop.width != c.rect.width ||
    1772. 

  1772. 	    buf->crop.height != c.rect.height) {
    1773. 

  1773. 		buf->vb.width  = width;
    1774. 

  1774. 		buf->vb.height = height;
    1775. 

  1775. 		buf->vb.field  = field;
    1776. 

  1776. 		buf->tvnorm    = norm;
    1777. 

  1777. 		buf->fmt       = fmt;
    1778. 

  1778. 		buf->crop      = c.rect;
    1779. 

  1779. 		redo_dma_risc = 1;
    1780. 

  1780. 	}
    1781. 

  1781. 

  1782. 	/* alloc risc memory */
    1783. 

  1783. 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
    1784. 

  1784. 		redo_dma_risc = 1;
    1785. 

  1785. 		if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
    1786. 

  1786. 			goto fail;
    1787. 

  1787. 	}
    1788. 

  1788. 

  1789. 	if (redo_dma_risc)
    1790. 

  1790. 		if (0 != (rc = bttv_buffer_risc(btv,buf)))
    1791. 

  1791. 			goto fail;
    1792. 

  1792. 

  1793. 	buf->vb.state = VIDEOBUF_PREPARED;
    1794. 

  1794. 	return 0;
    1795. 

  1795. 

  1796.  fail:
    1797. 

  1797. 	bttv_dma_free(q,btv,buf);
    1798. 

  1798. 	return rc;
    1799. 

  1799. }
    1800. 

  1800. 

  1801. static int
    1802. 

  1802. buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
    1803. 

  1803. {
    1804. 

  1804. 	struct bttv_fh *fh = q->priv_data;
    1805. 

  1805. 

  1806. 	*size = fh->fmt->depth*fh->width*fh->height >> 3;
    1807. 

  1807. 	if (0 == *count)
    1808. 

  1808. 		*count = gbuffers;
    1809. 

  1809. 	if (*size * *count > gbuffers * gbufsize)
    1810. 

  1810. 		*count = (gbuffers * gbufsize) / *size;
    1811. 

  1811. 	return 0;
    1812. 

  1812. }
    1813. 

  1813. 

  1814. static int
    1815. 

  1815. buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
    1816. 

  1816. 	       enum v4l2_field field)
    1817. 

  1817. {
    1818. 

  1818. 	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
    1819. 

  1819. 	struct bttv_fh *fh = q->priv_data;
    1820. 

  1820. 

  1821. 	return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
    1822. 

  1822. 				   fh->width, fh->height, field);
    1823. 

  1823. }
    1824. 

  1824. 

  1825. static void
    1826. 

  1826. buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
    1827. 

  1827. {
    1828. 

  1828. 	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
    1829. 

  1829. 	struct bttv_fh *fh = q->priv_data;
    1830. 

  1830. 	struct bttv    *btv = fh->btv;
    1831. 

  1831. 

  1832. 	buf->vb.state = VIDEOBUF_QUEUED;
    1833. 

  1833. 	list_add_tail(&buf->vb.queue,&btv->capture);
    1834. 

  1834. 	if (!btv->curr.frame_irq) {
    1835. 

  1835. 		btv->loop_irq |= 1;
    1836. 

  1836. 		bttv_set_dma(btv, 0x03);
    1837. 

  1837. 	}
    1838. 

  1838. }
    1839. 

  1839. 

  1840. static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
    1841. 

  1841. {
    1842. 

  1842. 	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
    1843. 

  1843. 	struct bttv_fh *fh = q->priv_data;
    1844. 

  1844. 

  1845. 	bttv_dma_free(q,fh->btv,buf);
    1846. 

  1846. }
    1847. 

  1847. 

  1848. static struct videobuf_queue_ops bttv_video_qops = {
    1849. 

  1849. 	.buf_setup    = buffer_setup,
    1850. 

  1850. 	.buf_prepare  = buffer_prepare,
    1851. 

  1851. 	.buf_queue    = buffer_queue,
    1852. 

  1852. 	.buf_release  = buffer_release,
    1853. 

  1853. };
    1854. 

  1854. 

  1855. static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
    1856. 

  1856. {
    1857. 

  1857. 	struct bttv_fh *fh  = priv;
    1858. 

  1858. 	struct bttv *btv = fh->btv;
    1859. 

  1859. 	unsigned int i;
    1860. 

  1860. 	int err;
    1861. 

  1861. 

  1862. 	err = v4l2_prio_check(&btv->prio, fh->prio);
    1863. 

  1863. 	if (0 != err)
    1864. 

  1864. 		return err;
    1865. 

  1865. 

  1866. 	for (i = 0; i < BTTV_TVNORMS; i++)
    1867. 

  1867. 		if (*id & bttv_tvnorms[i].v4l2_id)
    1868. 

  1868. 			break;
    1869. 

  1869. 	if (i == BTTV_TVNORMS)
    1870. 

  1870. 		return -EINVAL;
    1871. 

  1871. 

  1872. 	mutex_lock(&btv->lock);
    1873. 

  1873. 	set_tvnorm(btv, i);
    1874. 

  1874. 	mutex_unlock(&btv->lock);
    1875. 

  1875. 

  1876. 	return 0;
    1877. 

  1877. }
    1878. 

  1878. 

  1879. static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
    1880. 

  1880. {
    1881. 

  1881. 	struct bttv_fh *fh = f;
    1882. 

  1882. 	struct bttv *btv = fh->btv;
    1883. 

  1883. 

  1884. 	if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
    1885. 

  1885. 		*id = V4L2_STD_625_50;
    1886. 

  1886. 	else
    1887. 

  1887. 		*id = V4L2_STD_525_60;
    1888. 

  1888. 	return 0;
    1889. 

  1889. }
    1890. 

  1890. 

  1891. static int bttv_enum_input(struct file *file, void *priv,
    1892. 

  1892. 					struct v4l2_input *i)
    1893. 

  1893. {
    1894. 

  1894. 	struct bttv_fh *fh = priv;
    1895. 

  1895. 	struct bttv *btv = fh->btv;
    1896. 

  1896. 	int n;
    1897. 

  1897. 

  1898. 	if (i->index >= bttv_tvcards[btv->c.type].video_inputs)
    1899. 

  1899. 		return -EINVAL;
    1900. 

  1900. 

  1901. 	i->type     = V4L2_INPUT_TYPE_CAMERA;
    1902. 

  1902. 	i->audioset = 1;
    1903. 

  1903. 

  1904. 	if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
    1905. 

  1905. 		sprintf(i->name, "Television");
    1906. 

  1906. 		i->type  = V4L2_INPUT_TYPE_TUNER;
    1907. 

  1907. 		i->tuner = 0;
    1908. 

  1908. 	} else if (i->index == btv->svhs) {
    1909. 

  1909. 		sprintf(i->name, "S-Video");
    1910. 

  1910. 	} else {
    1911. 

  1911. 		sprintf(i->name, "Composite%d", i->index);
    1912. 

  1912. 	}
    1913. 

  1913. 

  1914. 	if (i->index == btv->input) {
    1915. 

  1915. 		__u32 dstatus = btread(BT848_DSTATUS);
    1916. 

  1916. 		if (0 == (dstatus & BT848_DSTATUS_PRES))
    1917. 

  1917. 			i->status |= V4L2_IN_ST_NO_SIGNAL;
    1918. 

  1918. 		if (0 == (dstatus & BT848_DSTATUS_HLOC))
    1919. 

  1919. 			i->status |= V4L2_IN_ST_NO_H_LOCK;
    1920. 

  1920. 	}
    1921. 

  1921. 

  1922. 	for (n = 0; n < BTTV_TVNORMS; n++)
    1923. 

  1923. 		i->std |= bttv_tvnorms[n].v4l2_id;
    1924. 

  1924. 

  1925. 	return 0;
    1926. 

  1926. }
    1927. 

  1927. 

  1928. static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
    1929. 

  1929. {
    1930. 

  1930. 	struct bttv_fh *fh = priv;
    1931. 

  1931. 	struct bttv *btv = fh->btv;
    1932. 

  1932. 

  1933. 	*i = btv->input;
    1934. 

  1934. 	return 0;
    1935. 

  1935. }
    1936. 

  1936. 

  1937. static int bttv_s_input(struct file *file, void *priv, unsigned int i)
    1938. 

  1938. {
    1939. 

  1939. 	struct bttv_fh *fh  = priv;
    1940. 

  1940. 	struct bttv *btv = fh->btv;
    1941. 

  1941. 

  1942. 	int err;
    1943. 

  1943. 

  1944. 	err = v4l2_prio_check(&btv->prio, fh->prio);
    1945. 

  1945. 	if (0 != err)
    1946. 

  1946. 		return err;
    1947. 

  1947. 

  1948. 	if (i > bttv_tvcards[btv->c.type].video_inputs)
    1949. 

  1949. 		return -EINVAL;
    1950. 

  1950. 

  1951. 	mutex_lock(&btv->lock);
    1952. 

  1952. 	set_input(btv, i, btv->tvnorm);
    1953. 

  1953. 	mutex_unlock(&btv->lock);
    1954. 

  1954. 	return 0;
    1955. 

  1955. }
    1956. 

  1956. 

  1957. static int bttv_s_tuner(struct file *file, void *priv,
    1958. 

  1958. 					struct v4l2_tuner *t)
    1959. 

  1959. {
    1960. 

  1960. 	struct bttv_fh *fh  = priv;
    1961. 

  1961. 	struct bttv *btv = fh->btv;
    1962. 

  1962. 	int err;
    1963. 

  1963. 

  1964. 	err = v4l2_prio_check(&btv->prio, fh->prio);
    1965. 

  1965. 	if (0 != err)
    1966. 

  1966. 		return err;
    1967. 

  1967. 

  1968. 	if (btv->tuner_type == TUNER_ABSENT)
    1969. 

  1969. 		return -EINVAL;
    1970. 

  1970. 

  1971. 	if (0 != t->index)
    1972. 

  1972. 		return -EINVAL;
    1973. 

  1973. 

  1974. 	mutex_lock(&btv->lock);
    1975. 

  1975. 	bttv_call_all(btv, tuner, s_tuner, t);
    1976. 

  1976. 

  1977. 	if (btv->audio_mode_gpio)
    1978. 

  1978. 		btv->audio_mode_gpio(btv, t, 1);
    1979. 

  1979. 

  1980. 	mutex_unlock(&btv->lock);
    1981. 

  1981. 

  1982. 	return 0;
    1983. 

  1983. }
    1984. 

  1984. 

  1985. static int bttv_g_frequency(struct file *file, void *priv,
    1986. 

  1986. 					struct v4l2_frequency *f)
    1987. 

  1987. {
    1988. 

  1988. 	struct bttv_fh *fh  = priv;
    1989. 

  1989. 	struct bttv *btv = fh->btv;
    1990. 

  1990. 

  1991. 	f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
    1992. 

  1992. 	f->frequency = btv->freq;
    1993. 

  1993. 

  1994. 	return 0;
    1995. 

  1995. }
    1996. 

  1996. 

  1997. static int bttv_s_frequency(struct file *file, void *priv,
    1998. 

  1998. 					struct v4l2_frequency *f)
    1999. 

  1999. {
    2000. 

  2000. 	struct bttv_fh *fh  = priv;
    2001. 

  2001. 	struct bttv *btv = fh->btv;
    2002. 

  2002. 	int err;
    2003. 

  2003. 

  2004. 	err = v4l2_prio_check(&btv->prio, fh->prio);
    2005. 

  2005. 	if (0 != err)
    2006. 

  2006. 		return err;
    2007. 

  2007. 

  2008. 	if (unlikely(f->tuner != 0))
    2009. 

  2009. 		return -EINVAL;
    2010. 

  2010. 	if (unlikely(f->type != (btv->radio_user
    2011. 

  2011. 		? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
    2012. 

  2012. 		return -EINVAL;
    2013. 

  2013. 	mutex_lock(&btv->lock);
    2014. 

  2014. 	btv->freq = f->frequency;
    2015. 

  2015. 	bttv_call_all(btv, tuner, s_frequency, f);
    2016. 

  2016. 	if (btv->has_matchbox && btv->radio_user)
    2017. 

  2017. 		tea5757_set_freq(btv, btv->freq);
    2018. 

  2018. 	mutex_unlock(&btv->lock);
    2019. 

  2019. 	return 0;
    2020. 

  2020. }
    2021. 

  2021. 

  2022. static int bttv_log_status(struct file *file, void *f)
    2023. 

  2023. {
    2024. 

  2024. 	struct bttv_fh *fh  = f;
    2025. 

  2025. 	struct bttv *btv = fh->btv;
    2026. 

  2026. 

  2027. 	printk(KERN_INFO "bttv%d: ========  START STATUS CARD #%d  ========\n",
    2028. 

  2028. 			btv->c.nr, btv->c.nr);
    2029. 

  2029. 	bttv_call_all(btv, core, log_status);
    2030. 

  2030. 	printk(KERN_INFO "bttv%d: ========  END STATUS CARD   #%d  ========\n",
    2031. 

  2031. 			btv->c.nr, btv->c.nr);
    2032. 

  2032. 	return 0;
    2033. 

  2033. }
    2034. 

  2034. 

  2035. #ifdef CONFIG_VIDEO_ADV_DEBUG
    2036. 

  2036. static int bttv_g_register(struct file *file, void *f,
    2037. 

  2037. 					struct v4l2_dbg_register *reg)
    2038. 

  2038. {
    2039. 

  2039. 	struct bttv_fh *fh = f;
    2040. 

  2040. 	struct bttv *btv = fh->btv;
    2041. 

  2041. 

  2042. 	if (!capable(CAP_SYS_ADMIN))
    2043. 

  2043. 		return -EPERM;
    2044. 

  2044. 

  2045. 	if (!v4l2_chip_match_host(&reg->match))
    2046. 

  2046. 		return -EINVAL;
    2047. 

  2047. 

  2048. 	/* bt848 has a 12-bit register space */
    2049. 

  2049. 	reg->reg &= 0xfff;
    2050. 

  2050. 	reg->val = btread(reg->reg);
    2051. 

  2051. 	reg->size = 1;
    2052. 

  2052. 

  2053. 	return 0;
    2054. 

  2054. }
    2055. 

  2055. 

  2056. static int bttv_s_register(struct file *file, void *f,
    2057. 

  2057. 					struct v4l2_dbg_register *reg)
    2058. 

  2058. {
    2059. 

  2059. 	struct bttv_fh *fh = f;
    2060. 

  2060. 	struct bttv *btv = fh->btv;
    2061. 

  2061. 

  2062. 	if (!capable(CAP_SYS_ADMIN))
    2063. 

  2063. 		return -EPERM;
    2064. 

  2064. 

  2065. 	if (!v4l2_chip_match_host(&reg->match))
    2066. 

  2066. 		return -EINVAL;
    2067. 

  2067. 

  2068. 	/* bt848 has a 12-bit register space */
    2069. 

  2069. 	reg->reg &= 0xfff;
    2070. 

  2070. 	btwrite(reg->val, reg->reg);
    2071. 

  2071. 

  2072. 	return 0;
    2073. 

  2073. }
    2074. 

  2074. #endif
    2075. 

  2075. 

  2076. /* Given cropping boundaries b and the scaled width and height of a
    2077. 

  2077.    single field or frame, which must not exceed hardware limits, this
    2078. 

  2078.    function adjusts the cropping parameters c. */
    2079. 

  2079. static void
    2080. 

  2080. bttv_crop_adjust	(struct bttv_crop *             c,
    2081. 

  2081. 			 const struct v4l2_rect *	b,
    2082. 

  2082. 			 __s32                          width,
    2083. 

  2083. 			 __s32                          height,
    2084. 

  2084. 			 enum v4l2_field                field)
    2085. 

  2085. {
    2086. 

  2086. 	__s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
    2087. 

  2087. 	__s32 max_left;
    2088. 

  2088. 	__s32 max_top;
    2089. 

  2089. 

  2090. 	if (width < c->min_scaled_width) {
    2091. 

  2091. 		/* Max. hor. scale factor 16:1. */
    2092. 

  2092. 		c->rect.width = width * 16;
    2093. 

  2093. 	} else if (width > c->max_scaled_width) {
    2094. 

  2094. 		/* Min. hor. scale factor 1:1. */
    2095. 

  2095. 		c->rect.width = width;
    2096. 

  2096. 

  2097. 		max_left = b->left + b->width - width;
    2098. 

  2098. 		max_left = min(max_left, (__s32) MAX_HDELAY);
    2099. 

  2099. 		if (c->rect.left > max_left)
    2100. 

  2100. 			c->rect.left = max_left;
    2101. 

  2101. 	}
    2102. 

  2102. 

  2103. 	if (height < c->min_scaled_height) {
    2104. 

  2104. 		/* Max. vert. scale factor 16:1, single fields 8:1. */
    2105. 

  2105. 		c->rect.height = height * 16;
    2106. 

  2106. 	} else if (frame_height > c->max_scaled_height) {
    2107. 

  2107. 		/* Min. vert. scale factor 1:1.
    2108. 

  2108. 		   Top and height count field lines times two. */
    2109. 

  2109. 		c->rect.height = (frame_height + 1) & ~1;
    2110. 

  2110. 

  2111. 		max_top = b->top + b->height - c->rect.height;
    2112. 

  2112. 		if (c->rect.top > max_top)
    2113. 

  2113. 			c->rect.top = max_top;
    2114. 

  2114. 	}
    2115. 

  2115. 

  2116. 	bttv_crop_calc_limits(c);
    2117. 

  2117. }
    2118. 

  2118. 

  2119. /* Returns an error if scaling to a frame or single field with the given
    2120. 

  2120.    width and height is not possible with the current cropping parameters
    2121. 

  2121.    and width aligned according to width_mask. If adjust_size is TRUE the
    2122. 

  2122.    function may adjust the width and/or height instead, rounding width
    2123. 

  2123.    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
    2124. 

  2124.    also adjust the current cropping parameters to get closer to the
    2125. 

  2125.    desired image size. */
    2126. 

  2126. static int
    2127. 

  2127. limit_scaled_size       (struct bttv_fh *               fh,
    2128. 

  2128. 			 __s32 *                        width,
    2129. 

  2129. 			 __s32 *                        height,
    2130. 

  2130. 			 enum v4l2_field                field,
    2131. 

  2131. 			 unsigned int			width_mask,
    2132. 

  2132. 			 unsigned int			width_bias,
    2133. 

  2133. 			 int                            adjust_size,
    2134. 

  2134. 			 int                            adjust_crop)
    2135. 

  2135. {
    2136. 

  2136. 	struct bttv *btv = fh->btv;
    2137. 

  2137. 	const struct v4l2_rect *b;
    2138. 

  2138. 	struct bttv_crop *c;
    2139. 

  2139. 	__s32 min_width;
    2140. 

  2140. 	__s32 min_height;
    2141. 

  2141. 	__s32 max_width;
    2142. 

  2142. 	__s32 max_height;
    2143. 

  2143. 	int rc;
    2144. 

  2144. 

  2145. 	BUG_ON((int) width_mask >= 0 ||
    2146. 

  2146. 	       width_bias >= (unsigned int) -width_mask);
    2147. 

  2147. 

  2148. 	/* Make sure tvnorm, vbi_end and the current cropping parameters
    2149. 

  2149. 	   remain consistent until we're done. */
    2150. 

  2150. 	mutex_lock(&btv->lock);
    2151. 

  2151. 

  2152. 	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
    2153. 

  2153. 

  2154. 	/* Do crop - use current, don't - use default parameters. */
    2155. 

  2155. 	c = &btv->crop[!!fh->do_crop];
    2156. 

  2156. 

  2157. 	if (fh->do_crop
    2158. 

  2158. 	    && adjust_size
    2159. 

  2159. 	    && adjust_crop
    2160. 

  2160. 	    && !locked_btres(btv, VIDEO_RESOURCES)) {
    2161. 

  2161. 		min_width = 48;
    2162. 

  2162. 		min_height = 32;
    2163. 

  2163. 

  2164. 		/* We cannot scale up. When the scaled image is larger
    2165. 

  2165. 		   than crop.rect we adjust the crop.rect as required
    2166. 

  2166. 		   by the V4L2 spec, hence cropcap.bounds are our limit. */
    2167. 

  2167. 		max_width = min(b->width, (__s32) MAX_HACTIVE);
    2168. 

  2168. 		max_height = b->height;
    2169. 

  2169. 

  2170. 		/* We cannot capture the same line as video and VBI data.
    2171. 

  2171. 		   Note btv->vbi_end is really a minimum, see
    2172. 

  2172. 		   bttv_vbi_try_fmt(). */
    2173. 

  2173. 		if (btv->vbi_end > b->top) {
    2174. 

  2174. 			max_height -= btv->vbi_end - b->top;
    2175. 

  2175. 			rc = -EBUSY;
    2176. 

  2176. 			if (min_height > max_height)
    2177. 

  2177. 				goto fail;
    2178. 

  2178. 		}
    2179. 

  2179. 	} else {
    2180. 

  2180. 		rc = -EBUSY;
    2181. 

  2181. 		if (btv->vbi_end > c->rect.top)
    2182. 

  2182. 			goto fail;
    2183. 

  2183. 

  2184. 		min_width  = c->min_scaled_width;
    2185. 

  2185. 		min_height = c->min_scaled_height;
    2186. 

  2186. 		max_width  = c->max_scaled_width;
    2187. 

  2187. 		max_height = c->max_scaled_height;
    2188. 

  2188. 

  2189. 		adjust_crop = 0;
    2190. 

  2190. 	}
    2191. 

  2191. 

  2192. 	min_width = (min_width - width_mask - 1) & width_mask;
    2193. 

  2193. 	max_width = max_width & width_mask;
    2194. 

  2194. 

  2195. 	/* Max. scale factor is 16:1 for frames, 8:1 for fields. */
    2196. 

  2196. 	min_height = min_height;
    2197. 

  2197. 	/* Min. scale factor is 1:1. */
    2198. 

  2198. 	max_height >>= !V4L2_FIELD_HAS_BOTH(field);
    2199. 

  2199. 

  2200. 	if (adjust_size) {
    2201. 

  2201. 		*width = clamp(*width, min_width, max_width);
    2202. 

  2202. 		*height = clamp(*height, min_height, max_height);
    2203. 

  2203. 

  2204. 		/* Round after clamping to avoid overflow. */
    2205. 

  2205. 		*width = (*width + width_bias) & width_mask;
    2206. 

  2206. 

  2207. 		if (adjust_crop) {
    2208. 

  2208. 			bttv_crop_adjust(c, b, *width, *height, field);
    2209. 

  2209. 

  2210. 			if (btv->vbi_end > c->rect.top) {
    2211. 

  2211. 				/* Move the crop window out of the way. */
    2212. 

  2212. 				c->rect.top = btv->vbi_end;
    2213. 

  2213. 			}
    2214. 

  2214. 		}
    2215. 

  2215. 	} else {
    2216. 

  2216. 		rc = -EINVAL;
    2217. 

  2217. 		if (*width  < min_width ||
    2218. 

  2218. 		    *height < min_height ||
    2219. 

  2219. 		    *width  > max_width ||
    2220. 

  2220. 		    *height > max_height ||
    2221. 

  2221. 		    0 != (*width & ~width_mask))
    2222. 

  2222. 			goto fail;
    2223. 

  2223. 	}
    2224. 

  2224. 

  2225. 	rc = 0; /* success */
    2226. 

  2226. 

  2227.  fail:
    2228. 

  2228. 	mutex_unlock(&btv->lock);
    2229. 

  2229. 

  2230. 	return rc;
    2231. 

  2231. }
    2232. 

  2232. 

  2233. /* Returns an error if the given overlay window dimensions are not
    2234. 

  2234.    possible with the current cropping parameters. If adjust_size is
    2235. 

  2235.    TRUE the function may adjust the window width and/or height
    2236. 

  2236.    instead, however it always rounds the horizontal position and
    2237. 

  2237.    width as btcx_align() does. If adjust_crop is TRUE the function
    2238. 

  2238.    may also adjust the current cropping parameters to get closer
    2239. 

  2239.    to the desired window size. */
    2240. 

  2240. static int
    2241. 

  2241. verify_window		(struct bttv_fh *               fh,
    2242. 

  2242. 			 struct v4l2_window *           win,
    2243. 

  2243. 			 int                            adjust_size,
    2244. 

  2244. 			 int                            adjust_crop)
    2245. 

  2245. {
    2246. 

  2246. 	enum v4l2_field field;
    2247. 

  2247. 	unsigned int width_mask;
    2248. 

  2248. 	int rc;
    2249. 

  2249. 

  2250. 	if (win->w.width  < 48 || win->w.height < 32)
    2251. 

  2251. 		return -EINVAL;
    2252. 

  2252. 	if (win->clipcount > 2048)
    2253. 

  2253. 		return -EINVAL;
    2254. 

  2254. 

  2255. 	field = win->field;
    2256. 

  2256. 

  2257. 	if (V4L2_FIELD_ANY == field) {
    2258. 

  2258. 		__s32 height2;
    2259. 

  2259. 

  2260. 		height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
    2261. 

  2261. 		field = (win->w.height > height2)
    2262. 

  2262. 			? V4L2_FIELD_INTERLACED
    2263. 

  2263. 			: V4L2_FIELD_TOP;
    2264. 

  2264. 	}
    2265. 

  2265. 	switch (field) {
    2266. 

  2266. 	case V4L2_FIELD_TOP:
    2267. 

  2267. 	case V4L2_FIELD_BOTTOM:
    2268. 

  2268. 	case V4L2_FIELD_INTERLACED:
    2269. 

  2269. 		break;
    2270. 

  2270. 	default:
    2271. 

  2271. 		return -EINVAL;
    2272. 

  2272. 	}
    2273. 

  2273. 

  2274. 	/* 4-byte alignment. */
    2275. 

  2275. 	if (NULL == fh->ovfmt)
    2276. 

  2276. 		return -EINVAL;
    2277. 

  2277. 	width_mask = ~0;
    2278. 

  2278. 	switch (fh->ovfmt->depth) {
    2279. 

  2279. 	case 8:
    2280. 

  2280. 	case 24:
    2281. 

  2281. 		width_mask = ~3;
    2282. 

  2282. 		break;
    2283. 

  2283. 	case 16:
    2284. 

  2284. 		width_mask = ~1;
    2285. 

  2285. 		break;
    2286. 

  2286. 	case 32:
    2287. 

  2287. 		break;
    2288. 

  2288. 	default:
    2289. 

  2289. 		BUG();
    2290. 

  2290. 	}
    2291. 

  2291. 

  2292. 	win->w.width -= win->w.left & ~width_mask;
    2293. 

  2293. 	win->w.left = (win->w.left - width_mask - 1) & width_mask;
    2294. 

  2294. 

  2295. 	rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
    2296. 

  2296. 			       field, width_mask,
    2297. 

  2297. 			       /* width_bias: round down */ 0,
    2298. 

  2298. 			       adjust_size, adjust_crop);
    2299. 

  2299. 	if (0 != rc)
    2300. 

  2300. 		return rc;
    2301. 

  2301. 

  2302. 	win->field = field;
    2303. 

  2303. 	return 0;
    2304. 

  2304. }
    2305. 

  2305. 

  2306. static int setup_window(struct bttv_fh *fh, struct bttv *btv,
    2307. 

  2307. 			struct v4l2_window *win, int fixup)
    2308. 

  2308. {
    2309. 

  2309. 	struct v4l2_clip *clips = NULL;
    2310. 

  2310. 	int n,size,retval = 0;
    2311. 

  2311. 

  2312. 	if (NULL == fh->ovfmt)
    2313. 

  2313. 		return -EINVAL;
    2314. 

  2314. 	if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
    2315. 

  2315. 		return -EINVAL;
    2316. 

  2316. 	retval = verify_window(fh, win,
    2317. 

  2317. 			       /* adjust_size */ fixup,
    2318. 

  2318. 			       /* adjust_crop */ fixup);
    2319. 

  2319. 	if (0 != retval)
    2320. 

  2320. 		return retval;
    2321. 

  2321. 

  2322. 	/* copy clips  --  luckily v4l1 + v4l2 are binary
    2323. 

  2323. 	   compatible here ...*/
    2324. 

  2324. 	n = win->clipcount;
    2325. 

  2325. 	size = sizeof(*clips)*(n+4);
    2326. 

  2326. 	clips = kmalloc(size,GFP_KERNEL);
    2327. 

  2327. 	if (NULL == clips)
    2328. 

  2328. 		return -ENOMEM;
    2329. 

  2329. 	if (n > 0) {
    2330. 

  2330. 		if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
    2331. 

  2331. 			kfree(clips);
    2332. 

  2332. 			return -EFAULT;
    2333. 

  2333. 		}
    2334. 

  2334. 	}
    2335. 

  2335. 	/* clip against screen */
    2336. 

  2336. 	if (NULL != btv->fbuf.base)
    2337. 

  2337. 		n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
    2338. 

  2338. 				      &win->w, clips, n);
    2339. 

  2339. 	btcx_sort_clips(clips,n);
    2340. 

  2340. 

  2341. 	/* 4-byte alignments */
    2342. 

  2342. 	switch (fh->ovfmt->depth) {
    2343. 

  2343. 	case 8:
    2344. 

  2344. 	case 24:
    2345. 

  2345. 		btcx_align(&win->w, clips, n, 3);
    2346. 

  2346. 		break;
    2347. 

  2347. 	case 16:
    2348. 

  2348. 		btcx_align(&win->w, clips, n, 1);
    2349. 

  2349. 		break;
    2350. 

  2350. 	case 32:
    2351. 

  2351. 		/* no alignment fixups needed */
    2352. 

  2352. 		break;
    2353. 

  2353. 	default:
    2354. 

  2354. 		BUG();
    2355. 

  2355. 	}
    2356. 

  2356. 

  2357. 	mutex_lock(&fh->cap.vb_lock);
    2358. 

  2358. 	kfree(fh->ov.clips);
    2359. 

  2359. 	fh->ov.clips    = clips;
    2360. 

  2360. 	fh->ov.nclips   = n;
    2361. 

  2361. 

  2362. 	fh->ov.w        = win->w;
    2363. 

  2363. 	fh->ov.field    = win->field;
    2364. 

  2364. 	fh->ov.setup_ok = 1;
    2365. 

  2365. 	btv->init.ov.w.width   = win->w.width;
    2366. 

  2366. 	btv->init.ov.w.height  = win->w.height;
    2367. 

  2367. 	btv->init.ov.field     = win->field;
    2368. 

  2368. 

  2369. 	/* update overlay if needed */
    2370. 

  2370. 	retval = 0;
    2371. 

  2371. 	if (check_btres(fh, RESOURCE_OVERLAY)) {
    2372. 

  2372. 		struct bttv_buffer *new;
    2373. 

  2373. 

  2374. 		new = videobuf_sg_alloc(sizeof(*new));
    2375. 

  2375. 		new->crop = btv->crop[!!fh->do_crop].rect;
    2376. 

  2376. 		bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
    2377. 

  2377. 		retval = bttv_switch_overlay(btv,fh,new);
    2378. 

  2378. 	}
    2379. 

  2379. 	mutex_unlock(&fh->cap.vb_lock);
    2380. 

  2380. 	return retval;
    2381. 

  2381. }
    2382. 

  2382. 

  2383. /* ----------------------------------------------------------------------- */
    2384. 

  2384. 

  2385. static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
    2386. 

  2386. {
    2387. 

  2387. 	struct videobuf_queue* q = NULL;
    2388. 

  2388. 

  2389. 	switch (fh->type) {
    2390. 

  2390. 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
    2391. 

  2391. 		q = &fh->cap;
    2392. 

  2392. 		break;
    2393. 

  2393. 	case V4L2_BUF_TYPE_VBI_CAPTURE:
    2394. 

  2394. 		q = &fh->vbi;
    2395. 

  2395. 		break;
    2396. 

  2396. 	default:
    2397. 

  2397. 		BUG();
    2398. 

  2398. 	}
    2399. 

  2399. 	return q;
    2400. 

  2400. }
    2401. 

  2401. 

  2402. static int bttv_resource(struct bttv_fh *fh)
    2403. 

  2403. {
    2404. 

  2404. 	int res = 0;
    2405. 

  2405. 

  2406. 	switch (fh->type) {
    2407. 

  2407. 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
    2408. 

  2408. 		res = RESOURCE_VIDEO_STREAM;
    2409. 

  2409. 		break;
    2410. 

  2410. 	case V4L2_BUF_TYPE_VBI_CAPTURE:
    2411. 

  2411. 		res = RESOURCE_VBI;
    2412. 

  2412. 		break;
    2413. 

  2413. 	default:
    2414. 

  2414. 		BUG();
    2415. 

  2415. 	}
    2416. 

  2416. 	return res;
    2417. 

  2417. }
    2418. 

  2418. 

  2419. static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
    2420. 

  2420. {
    2421. 

  2421. 	struct videobuf_queue *q = bttv_queue(fh);
    2422. 

  2422. 	int res = bttv_resource(fh);
    2423. 

  2423. 

  2424. 	if (check_btres(fh,res))
    2425. 

  2425. 		return -EBUSY;
    2426. 

  2426. 	if (videobuf_queue_is_busy(q))
    2427. 

  2427. 		return -EBUSY;
    2428. 

  2428. 	fh->type = type;
    2429. 

  2429. 	return 0;
    2430. 

  2430. }
    2431. 

  2431. 

  2432. static void
    2433. 

  2433. pix_format_set_size     (struct v4l2_pix_format *       f,
    2434. 

  2434. 			 const struct bttv_format *     fmt,
    2435. 

  2435. 			 unsigned int                   width,
    2436. 

  2436. 			 unsigned int                   height)
    2437. 

  2437. {
    2438. 

  2438. 	f->width = width;
    2439. 

  2439. 	f->height = height;
    2440. 

  2440. 

  2441. 	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
    2442. 

  2442. 		f->bytesperline = width; /* Y plane */
    2443. 

  2443. 		f->sizeimage = (width * height * fmt->depth) >> 3;
    2444. 

  2444. 	} else {
    2445. 

  2445. 		f->bytesperline = (width * fmt->depth) >> 3;
    2446. 

  2446. 		f->sizeimage = height * f->bytesperline;
    2447. 

  2447. 	}
    2448. 

  2448. }
    2449. 

  2449. 

  2450. static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
    2451. 

  2451. 					struct v4l2_format *f)
    2452. 

  2452. {
    2453. 

  2453. 	struct bttv_fh *fh  = priv;
    2454. 

  2454. 

  2455. 	pix_format_set_size(&f->fmt.pix, fh->fmt,
    2456. 

  2456. 				fh->width, fh->height);
    2457. 

  2457. 	f->fmt.pix.field        = fh->cap.field;
    2458. 

  2458. 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
    2459. 

  2459. 

  2460. 	return 0;
    2461. 

  2461. }
    2462. 

  2462. 

  2463. static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
    2464. 

  2464. 					struct v4l2_format *f)
    2465. 

  2465. {
    2466. 

  2466. 	struct bttv_fh *fh  = priv;
    2467. 

  2467. 

  2468. 	f->fmt.win.w     = fh->ov.w;
    2469. 

  2469. 	f->fmt.win.field = fh->ov.field;
    2470. 

  2470. 

  2471. 	return 0;
    2472. 

  2472. }
    2473. 

  2473. 

  2474. static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
    2475. 

  2475. 						struct v4l2_format *f)
    2476. 

  2476. {
    2477. 

  2477. 	const struct bttv_format *fmt;
    2478. 

  2478. 	struct bttv_fh *fh = priv;
    2479. 

  2479. 	struct bttv *btv = fh->btv;
    2480. 

  2480. 	enum v4l2_field field;
    2481. 

  2481. 	__s32 width, height;
    2482. 

  2482. 	int rc;
    2483. 

  2483. 

  2484. 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
    2485. 

  2485. 	if (NULL == fmt)
    2486. 

  2486. 		return -EINVAL;
    2487. 

  2487. 

  2488. 	field = f->fmt.pix.field;
    2489. 

  2489. 

  2490. 	if (V4L2_FIELD_ANY == field) {
    2491. 

  2491. 		__s32 height2;
    2492. 

  2492. 

  2493. 		height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
    2494. 

  2494. 		field = (f->fmt.pix.height > height2)
    2495. 

  2495. 			? V4L2_FIELD_INTERLACED
    2496. 

  2496. 			: V4L2_FIELD_BOTTOM;
    2497. 

  2497. 	}
    2498. 

  2498. 

  2499. 	if (V4L2_FIELD_SEQ_BT == field)
    2500. 

  2500. 		field = V4L2_FIELD_SEQ_TB;
    2501. 

  2501. 

  2502. 	switch (field) {
    2503. 

  2503. 	case V4L2_FIELD_TOP:
    2504. 

  2504. 	case V4L2_FIELD_BOTTOM:
    2505. 

  2505. 	case V4L2_FIELD_ALTERNATE:
    2506. 

  2506. 	case V4L2_FIELD_INTERLACED:
    2507. 

  2507. 		break;
    2508. 

  2508. 	case V4L2_FIELD_SEQ_TB:
    2509. 

  2509. 		if (fmt->flags & FORMAT_FLAGS_PLANAR)
    2510. 

  2510. 			return -EINVAL;
    2511. 

  2511. 		break;
    2512. 

  2512. 	default:
    2513. 

  2513. 		return -EINVAL;
    2514. 

  2514. 	}
    2515. 

  2515. 

  2516. 	width = f->fmt.pix.width;
    2517. 

  2517. 	height = f->fmt.pix.height;
    2518. 

  2518. 

  2519. 	rc = limit_scaled_size(fh, &width, &height, field,
    2520. 

  2520. 			       /* width_mask: 4 pixels */ ~3,
    2521. 

  2521. 			       /* width_bias: nearest */ 2,
    2522. 

  2522. 			       /* adjust_size */ 1,
    2523. 

  2523. 			       /* adjust_crop */ 0);
    2524. 

  2524. 	if (0 != rc)
    2525. 

  2525. 		return rc;
    2526. 

  2526. 

  2527. 	/* update data for the application */
    2528. 

  2528. 	f->fmt.pix.field = field;
    2529. 

  2529. 	pix_format_set_size(&f->fmt.pix, fmt, width, height);
    2530. 

  2530. 

  2531. 	return 0;
    2532. 

  2532. }
    2533. 

  2533. 

  2534. static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
    2535. 

  2535. 						struct v4l2_format *f)
    2536. 

  2536. {
    2537. 

  2537. 	struct bttv_fh *fh = priv;
    2538. 

  2538. 

  2539. 	return verify_window(fh, &f->fmt.win,
    2540. 

  2540. 			/* adjust_size */ 1,
    2541. 

  2541. 			/* adjust_crop */ 0);
    2542. 

  2542. }
    2543. 

  2543. 

  2544. static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
    2545. 

  2545. 				struct v4l2_format *f)
    2546. 

  2546. {
    2547. 

  2547. 	int retval;
    2548. 

  2548. 	const struct bttv_format *fmt;
    2549. 

  2549. 	struct bttv_fh *fh = priv;
    2550. 

  2550. 	struct bttv *btv = fh->btv;
    2551. 

  2551. 	__s32 width, height;
    2552. 

  2552. 	enum v4l2_field field;
    2553. 

  2553. 

  2554. 	retval = bttv_switch_type(fh, f->type);
    2555. 

  2555. 	if (0 != retval)
    2556. 

  2556. 		return retval;
    2557. 

  2557. 

  2558. 	retval = bttv_try_fmt_vid_cap(file, priv, f);
    2559. 

  2559. 	if (0 != retval)
    2560. 

  2560. 		return retval;
    2561. 

  2561. 

  2562. 	width = f->fmt.pix.width;
    2563. 

  2563. 	height = f->fmt.pix.height;
    2564. 

  2564. 	field = f->fmt.pix.field;
    2565. 

  2565. 

  2566. 	retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
    2567. 

  2567. 			       /* width_mask: 4 pixels */ ~3,
    2568. 

  2568. 			       /* width_bias: nearest */ 2,
    2569. 

  2569. 			       /* adjust_size */ 1,
    2570. 

  2570. 			       /* adjust_crop */ 1);
    2571. 

  2571. 	if (0 != retval)
    2572. 

  2572. 		return retval;
    2573. 

  2573. 

  2574. 	f->fmt.pix.field = field;
    2575. 

  2575. 

  2576. 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
    2577. 

  2577. 

  2578. 	/* update our state informations */
    2579. 

  2579. 	mutex_lock(&fh->cap.vb_lock);
    2580. 

  2580. 	fh->fmt              = fmt;
    2581. 

  2581. 	fh->cap.field        = f->fmt.pix.field;
    2582. 

  2582. 	fh->cap.last         = V4L2_FIELD_NONE;
    2583. 

  2583. 	fh->width            = f->fmt.pix.width;
    2584. 

  2584. 	fh->height           = f->fmt.pix.height;
    2585. 

  2585. 	btv->init.fmt        = fmt;
    2586. 

  2586. 	btv->init.width      = f->fmt.pix.width;
    2587. 

  2587. 	btv->init.height     = f->fmt.pix.height;
    2588. 

  2588. 	mutex_unlock(&fh->cap.vb_lock);
    2589. 

  2589. 

  2590. 	return 0;
    2591. 

  2591. }
    2592. 

  2592. 

  2593. static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
    2594. 

  2594. 				struct v4l2_format *f)
    2595. 

  2595. {
    2596. 

  2596. 	struct bttv_fh *fh = priv;
    2597. 

  2597. 	struct bttv *btv = fh->btv;
    2598. 

  2598. 

  2599. 	if (no_overlay > 0) {
    2600. 

  2600. 		printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
    2601. 

  2601. 		return -EINVAL;
    2602. 

  2602. 	}
    2603. 

  2603. 

  2604. 	return setup_window(fh, btv, &f->fmt.win, 1);
    2605. 

  2605. }
    2606. 

  2606. 

  2607. #ifdef CONFIG_VIDEO_V4L1_COMPAT
    2608. 

  2608. static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
    2609. 

  2609. {
    2610. 

  2610. 	int retval;
    2611. 

  2611. 	unsigned int i;
    2612. 

  2612. 	struct bttv_fh *fh = priv;
    2613. 

  2613. 

  2614. 	mutex_lock(&fh->cap.vb_lock);
    2615. 

  2615. 	retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
    2616. 

  2616. 				     V4L2_MEMORY_MMAP);
    2617. 

  2617. 	if (retval < 0) {
    2618. 

  2618. 		mutex_unlock(&fh->cap.vb_lock);
    2619. 

  2619. 		return retval;
    2620. 

  2620. 	}
    2621. 

  2621. 

  2622. 	gbuffers = retval;
    2623. 

  2623. 	memset(mbuf, 0, sizeof(*mbuf));
    2624. 

  2624. 	mbuf->frames = gbuffers;
    2625. 

  2625. 	mbuf->size   = gbuffers * gbufsize;
    2626. 

  2626. 

  2627. 	for (i = 0; i < gbuffers; i++)
    2628. 

  2628. 		mbuf->offsets[i] = i * gbufsize;
    2629. 

  2629. 

  2630. 	mutex_unlock(&fh->cap.vb_lock);
    2631. 

  2631. 	return 0;
    2632. 

  2632. }
    2633. 

  2633. #endif
    2634. 

  2634. 

  2635. static int bttv_querycap(struct file *file, void  *priv,
    2636. 

  2636. 				struct v4l2_capability *cap)
    2637. 

  2637. {
    2638. 

  2638. 	struct bttv_fh *fh = priv;
    2639. 

  2639. 	struct bttv *btv = fh->btv;
    2640. 

  2640. 

  2641. 	if (0 == v4l2)
    2642. 

  2642. 		return -EINVAL;
    2643. 

  2643. 

  2644. 	strlcpy(cap->driver, "bttv", sizeof(cap->driver));
    2645. 

  2645. 	strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
    2646. 

  2646. 	snprintf(cap->bus_info, sizeof(cap->bus_info),
    2647. 

  2647. 		 "PCI:%s", pci_name(btv->c.pci));
    2648. 

  2648. 	cap->version = BTTV_VERSION_CODE;
    2649. 

  2649. 	cap->capabilities =
    2650. 

  2650. 		V4L2_CAP_VIDEO_CAPTURE |
    2651. 

  2651. 		V4L2_CAP_VBI_CAPTURE |
    2652. 

  2652. 		V4L2_CAP_READWRITE |
    2653. 

  2653. 		V4L2_CAP_STREAMING;
    2654. 

  2654. 	if (btv->has_saa6588)
    2655. 

  2655. 		cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
    2656. 

  2656. 	if (no_overlay <= 0)
    2657. 

  2657. 		cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
    2658. 

  2658. 

  2659. 	if (btv->tuner_type != TUNER_ABSENT)
    2660. 

  2660. 		cap->capabilities |= V4L2_CAP_TUNER;
    2661. 

  2661. 	return 0;
    2662. 

  2662. }
    2663. 

  2663. 

  2664. static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
    2665. 

  2665. {
    2666. 

  2666. 	int index = -1, i;
    2667. 

  2667. 

  2668. 	for (i = 0; i < FORMATS; i++) {
    2669. 

  2669. 		if (formats[i].fourcc != -1)
    2670. 

  2670. 			index++;
    2671. 

  2671. 		if ((unsigned int)index == f->index)
    2672. 

  2672. 			break;
    2673. 

  2673. 	}
    2674. 

  2674. 	if (FORMATS == i)
    2675. 

  2675. 		return -EINVAL;
    2676. 

  2676. 

  2677. 	f->pixelformat = formats[i].fourcc;
    2678. 

  2678. 	strlcpy(f->description, formats[i].name, sizeof(f->description));
    2679. 

  2679. 

  2680. 	return i;
    2681. 

  2681. }
    2682. 

  2682. 

  2683. static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
    2684. 

  2684. 				struct v4l2_fmtdesc *f)
    2685. 

  2685. {
    2686. 

  2686. 	int rc = bttv_enum_fmt_cap_ovr(f);
    2687. 

  2687. 

  2688. 	if (rc < 0)
    2689. 

  2689. 		return rc;
    2690. 

  2690. 

  2691. 	return 0;
    2692. 

  2692. }
    2693. 

  2693. 

  2694. static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
    2695. 

  2695. 					struct v4l2_fmtdesc *f)
    2696. 

  2696. {
    2697. 

  2697. 	int rc;
    2698. 

  2698. 

  2699. 	if (no_overlay > 0) {
    2700. 

  2700. 		printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
    2701. 

  2701. 		return -EINVAL;
    2702. 

  2702. 	}
    2703. 

  2703. 

  2704. 	rc = bttv_enum_fmt_cap_ovr(f);
    2705. 

  2705. 

  2706. 	if (rc < 0)
    2707. 

  2707. 		return rc;
    2708. 

  2708. 

  2709. 	if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
    2710. 

  2710. 		return -EINVAL;
    2711. 

  2711. 

  2712. 	return 0;
    2713. 

  2713. }
    2714. 

  2714. 

  2715. static int bttv_g_fbuf(struct file *file, void *f,
    2716. 

  2716. 				struct v4l2_framebuffer *fb)
    2717. 

  2717. {
    2718. 

  2718. 	struct bttv_fh *fh = f;
    2719. 

  2719. 	struct bttv *btv = fh->btv;
    2720. 

  2720. 

  2721. 	*fb = btv->fbuf;
    2722. 

  2722. 	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
    2723. 

  2723. 	if (fh->ovfmt)
    2724. 

  2724. 		fb->fmt.pixelformat  = fh->ovfmt->fourcc;
    2725. 

  2725. 	return 0;
    2726. 

  2726. }
    2727. 

  2727. 

  2728. static int bttv_overlay(struct file *file, void *f, unsigned int on)
    2729. 

  2729. {
    2730. 

  2730. 	struct bttv_fh *fh = f;
    2731. 

  2731. 	struct bttv *btv = fh->btv;
    2732. 

  2732. 	struct bttv_buffer *new;
    2733. 

  2733. 	int retval;
    2734. 

  2734. 

  2735. 	if (on) {
    2736. 

  2736. 		/* verify args */
    2737. 

  2737. 		if (NULL == btv->fbuf.base)
    2738. 

  2738. 			return -EINVAL;
    2739. 

  2739. 		if (!fh->ov.setup_ok) {
    2740. 

  2740. 			dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
    2741. 

  2741. 			return -EINVAL;
    2742. 

  2742. 		}
    2743. 

  2743. 	}
    2744. 

  2744. 

  2745. 	if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
    2746. 

  2746. 		return -EBUSY;
    2747. 

  2747. 

  2748. 	mutex_lock(&fh->cap.vb_lock);
    2749. 

  2749. 	if (on) {
    2750. 

  2750. 		fh->ov.tvnorm = btv->tvnorm;
    2751. 

  2751. 		new = videobuf_sg_alloc(sizeof(*new));
    2752. 

  2752. 		new->crop = btv->crop[!!fh->do_crop].rect;
    2753. 

  2753. 		bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
    2754. 

  2754. 	} else {
    2755. 

  2755. 		new = NULL;
    2756. 

  2756. 	}
    2757. 

  2757. 

  2758. 	/* switch over */
    2759. 

  2759. 	retval = bttv_switch_overlay(btv, fh, new);
    2760. 

  2760. 	mutex_unlock(&fh->cap.vb_lock);
    2761. 

  2761. 	return retval;
    2762. 

  2762. }
    2763. 

  2763. 

  2764. static int bttv_s_fbuf(struct file *file, void *f,
    2765. 

  2765. 				struct v4l2_framebuffer *fb)
    2766. 

  2766. {
    2767. 

  2767. 	struct bttv_fh *fh = f;
    2768. 

  2768. 	struct bttv *btv = fh->btv;
    2769. 

  2769. 	const struct bttv_format *fmt;
    2770. 

  2770. 	int retval;
    2771. 

  2771. 

  2772. 	if (!capable(CAP_SYS_ADMIN) &&
    2773. 

  2773. 		!capable(CAP_SYS_RAWIO))
    2774. 

  2774. 		return -EPERM;
    2775. 

  2775. 

  2776. 	/* check args */
    2777. 

  2777. 	fmt = format_by_fourcc(fb->fmt.pixelformat);
    2778. 

  2778. 	if (NULL == fmt)
    2779. 

  2779. 		return -EINVAL;
    2780. 

  2780. 	if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
    2781. 

  2781. 		return -EINVAL;
    2782. 

  2782. 

  2783. 	retval = -EINVAL;
    2784. 

  2784. 	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
    2785. 

  2785. 		__s32 width = fb->fmt.width;
    2786. 

  2786. 		__s32 height = fb->fmt.height;
    2787. 

  2787. 

  2788. 		retval = limit_scaled_size(fh, &width, &height,
    2789. 

  2789. 					   V4L2_FIELD_INTERLACED,
    2790. 

  2790. 					   /* width_mask */ ~3,
    2791. 

  2791. 					   /* width_bias */ 2,
    2792. 

  2792. 					   /* adjust_size */ 0,
    2793. 

  2793. 					   /* adjust_crop */ 0);
    2794. 

  2794. 		if (0 != retval)
    2795. 

  2795. 			return retval;
    2796. 

  2796. 	}
    2797. 

  2797. 

  2798. 	/* ok, accept it */
    2799. 

  2799. 	mutex_lock(&fh->cap.vb_lock);
    2800. 

  2800. 	btv->fbuf.base       = fb->base;
    2801. 

  2801. 	btv->fbuf.fmt.width  = fb->fmt.width;
    2802. 

  2802. 	btv->fbuf.fmt.height = fb->fmt.height;
    2803. 

  2803. 	if (0 != fb->fmt.bytesperline)
    2804. 

  2804. 		btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
    2805. 

  2805. 	else
    2806. 

  2806. 		btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
    2807. 

  2807. 

  2808. 	retval = 0;
    2809. 

  2809. 	fh->ovfmt = fmt;
    2810. 

  2810. 	btv->init.ovfmt = fmt;
    2811. 

  2811. 	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
    2812. 

  2812. 		fh->ov.w.left   = 0;
    2813. 

  2813. 		fh->ov.w.top    = 0;
    2814. 

  2814. 		fh->ov.w.width  = fb->fmt.width;
    2815. 

  2815. 		fh->ov.w.height = fb->fmt.height;
    2816. 

  2816. 		btv->init.ov.w.width  = fb->fmt.width;
    2817. 

  2817. 		btv->init.ov.w.height = fb->fmt.height;
    2818. 

  2818. 			kfree(fh->ov.clips);
    2819. 

  2819. 		fh->ov.clips = NULL;
    2820. 

  2820. 		fh->ov.nclips = 0;
    2821. 

  2821. 

  2822. 		if (check_btres(fh, RESOURCE_OVERLAY)) {
    2823. 

  2823. 			struct bttv_buffer *new;
    2824. 

  2824. 

  2825. 			new = videobuf_sg_alloc(sizeof(*new));
    2826. 

  2826. 			new->crop = btv->crop[!!fh->do_crop].rect;
    2827. 

  2827. 			bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
    2828. 

  2828. 			retval = bttv_switch_overlay(btv, fh, new);
    2829. 

  2829. 		}
    2830. 

  2830. 	}
    2831. 

  2831. 	mutex_unlock(&fh->cap.vb_lock);
    2832. 

  2832. 	return retval;
    2833. 

  2833. }
    2834. 

  2834. 

  2835. static int bttv_reqbufs(struct file *file, void *priv,
    2836. 

  2836. 				struct v4l2_requestbuffers *p)
    2837. 

  2837. {
    2838. 

  2838. 	struct bttv_fh *fh = priv;
    2839. 

  2839. 	return videobuf_reqbufs(bttv_queue(fh), p);
    2840. 

  2840. }
    2841. 

  2841. 

  2842. static int bttv_querybuf(struct file *file, void *priv,
    2843. 

  2843. 				struct v4l2_buffer *b)
    2844. 

  2844. {
    2845. 

  2845. 	struct bttv_fh *fh = priv;
    2846. 

  2846. 	return videobuf_querybuf(bttv_queue(fh), b);
    2847. 

  2847. }
    2848. 

  2848. 

  2849. static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
    2850. 

  2850. {
    2851. 

  2851. 	struct bttv_fh *fh = priv;
    2852. 

  2852. 	struct bttv *btv = fh->btv;
    2853. 

  2853. 	int res = bttv_resource(fh);
    2854. 

  2854. 

  2855. 	if (!check_alloc_btres(btv, fh, res))
    2856. 

  2856. 		return -EBUSY;
    2857. 

  2857. 

  2858. 	return videobuf_qbuf(bttv_queue(fh), b);
    2859. 

  2859. }
    2860. 

  2860. 

  2861. static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
    2862. 

  2862. {
    2863. 

  2863. 	struct bttv_fh *fh = priv;
    2864. 

  2864. 	return videobuf_dqbuf(bttv_queue(fh), b,
    2865. 

  2865. 			file->f_flags & O_NONBLOCK);
    2866. 

  2866. }
    2867. 

  2867. 

  2868. static int bttv_streamon(struct file *file, void *priv,
    2869. 

  2869. 					enum v4l2_buf_type type)
    2870. 

  2870. {
    2871. 

  2871. 	struct bttv_fh *fh = priv;
    2872. 

  2872. 	struct bttv *btv = fh->btv;
    2873. 

  2873. 	int res = bttv_resource(fh);
    2874. 

  2874. 

  2875. 	if (!check_alloc_btres(btv, fh, res))
    2876. 

  2876. 		return -EBUSY;
    2877. 

  2877. 	return videobuf_streamon(bttv_queue(fh));
    2878. 

  2878. }
    2879. 

  2879. 

  2880. 

  2881. static int bttv_streamoff(struct file *file, void *priv,
    2882. 

  2882. 					enum v4l2_buf_type type)
    2883. 

  2883. {
    2884. 

  2884. 	struct bttv_fh *fh = priv;
    2885. 

  2885. 	struct bttv *btv = fh->btv;
    2886. 

  2886. 	int retval;
    2887. 

  2887. 	int res = bttv_resource(fh);
    2888. 

  2888. 

  2889. 

  2890. 	retval = videobuf_streamoff(bttv_queue(fh));
    2891. 

  2891. 	if (retval < 0)
    2892. 

  2892. 		return retval;
    2893. 

  2893. 	free_btres(btv, fh, res);
    2894. 

  2894. 	return 0;
    2895. 

  2895. }
    2896. 

  2896. 

  2897. static int bttv_queryctrl(struct file *file, void *priv,
    2898. 

  2898. 					struct v4l2_queryctrl *c)
    2899. 

  2899. {
    2900. 

  2900. 	struct bttv_fh *fh = priv;
    2901. 

  2901. 	struct bttv *btv = fh->btv;
    2902. 

  2902. 	const struct v4l2_queryctrl *ctrl;
    2903. 

  2903. 

  2904. 	if ((c->id <  V4L2_CID_BASE ||
    2905. 

  2905. 	     c->id >= V4L2_CID_LASTP1) &&
    2906. 

  2906. 	    (c->id <  V4L2_CID_PRIVATE_BASE ||
    2907. 

  2907. 	     c->id >= V4L2_CID_PRIVATE_LASTP1))
    2908. 

  2908. 		return -EINVAL;
    2909. 

  2909. 

  2910. 	if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
    2911. 

  2911. 		*c = no_ctl;
    2912. 

  2912. 	else {
    2913. 

  2913. 		ctrl = ctrl_by_id(c->id);
    2914. 

  2914. 

  2915. 		*c = (NULL != ctrl) ? *ctrl : no_ctl;
    2916. 

  2916. 	}
    2917. 

  2917. 

  2918. 	return 0;
    2919. 

  2919. }
    2920. 

  2920. 

  2921. static int bttv_g_parm(struct file *file, void *f,
    2922. 

  2922. 				struct v4l2_streamparm *parm)
    2923. 

  2923. {
    2924. 

  2924. 	struct bttv_fh *fh = f;
    2925. 

  2925. 	struct bttv *btv = fh->btv;
    2926. 

  2926. 

  2927. 	v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
    2928. 

  2928. 				    &parm->parm.capture.timeperframe);
    2929. 

  2929. 	return 0;
    2930. 

  2930. }
    2931. 

  2931. 

  2932. static int bttv_g_tuner(struct file *file, void *priv,
    2933. 

  2933. 				struct v4l2_tuner *t)
    2934. 

  2934. {
    2935. 

  2935. 	struct bttv_fh *fh = priv;
    2936. 

  2936. 	struct bttv *btv = fh->btv;
    2937. 

  2937. 

  2938. 	if (btv->tuner_type == TUNER_ABSENT)
    2939. 

  2939. 		return -EINVAL;
    2940. 

  2940. 	if (0 != t->index)
    2941. 

  2941. 		return -EINVAL;
    2942. 

  2942. 

  2943. 	mutex_lock(&btv->lock);
    2944. 

  2944. 	t->rxsubchans = V4L2_TUNER_SUB_MONO;
    2945. 

  2945. 	bttv_call_all(btv, tuner, g_tuner, t);
    2946. 

  2946. 	strcpy(t->name, "Television");
    2947. 

  2947. 	t->capability = V4L2_TUNER_CAP_NORM;
    2948. 

  2948. 	t->type       = V4L2_TUNER_ANALOG_TV;
    2949. 

  2949. 	if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
    2950. 

  2950. 		t->signal = 0xffff;
    2951. 

  2951. 

  2952. 	if (btv->audio_mode_gpio)
    2953. 

  2953. 		btv->audio_mode_gpio(btv, t, 0);
    2954. 

  2954. 

  2955. 	mutex_unlock(&btv->lock);
    2956. 

  2956. 	return 0;
    2957. 

  2957. }
    2958. 

  2958. 

  2959. static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
    2960. 

  2960. {
    2961. 

  2961. 	struct bttv_fh *fh = f;
    2962. 

  2962. 	struct bttv *btv = fh->btv;
    2963. 

  2963. 

  2964. 	*p = v4l2_prio_max(&btv->prio);
    2965. 

  2965. 

  2966. 	return 0;
    2967. 

  2967. }
    2968. 

  2968. 

  2969. static int bttv_s_priority(struct file *file, void *f,
    2970. 

  2970. 					enum v4l2_priority prio)
    2971. 

  2971. {
    2972. 

  2972. 	struct bttv_fh *fh = f;
    2973. 

  2973. 	struct bttv *btv = fh->btv;
    2974. 

  2974. 

  2975. 	return v4l2_prio_change(&btv->prio, &fh->prio, prio);
    2976. 

  2976. }
    2977. 

  2977. 

  2978. static int bttv_cropcap(struct file *file, void *priv,
    2979. 

  2979. 				struct v4l2_cropcap *cap)
    2980. 

  2980. {
    2981. 

  2981. 	struct bttv_fh *fh = priv;
    2982. 

  2982. 	struct bttv *btv = fh->btv;
    2983. 

  2983. 

  2984. 	if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
    2985. 

  2985. 	    cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
    2986. 

  2986. 		return -EINVAL;
    2987. 

  2987. 

  2988. 	*cap = bttv_tvnorms[btv->tvnorm].cropcap;
    2989. 

  2989. 

  2990. 	return 0;
    2991. 

  2991. }
    2992. 

  2992. 

  2993. static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
    2994. 

  2994. {
    2995. 

  2995. 	struct bttv_fh *fh = f;
    2996. 

  2996. 	struct bttv *btv = fh->btv;
    2997. 

  2997. 

  2998. 	if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
    2999. 

  2999. 	    crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
    3000. 

  3000. 		return -EINVAL;
    3001. 

  3001. 

  3002. 	/* No fh->do_crop = 1; because btv->crop[1] may be
    3003. 

  3003. 	   inconsistent with fh->width or fh->height and apps
    3004. 

  3004. 	   do not expect a change here. */
    3005. 

  3005. 

  3006. 	crop->c = btv->crop[!!fh->do_crop].rect;
    3007. 

  3007. 

  3008. 	return 0;
    3009. 

  3009. }
    3010. 

  3010. 

  3011. static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
    3012. 

  3012. {
    3013. 

  3013. 	struct bttv_fh *fh = f;
    3014. 

  3014. 	struct bttv *btv = fh->btv;
    3015. 

  3015. 	const struct v4l2_rect *b;
    3016. 

  3016. 	int retval;
    3017. 

  3017. 	struct bttv_crop c;
    3018. 

  3018. 	__s32 b_left;
    3019. 

  3019. 	__s32 b_top;
    3020. 

  3020. 	__s32 b_right;
    3021. 

  3021. 	__s32 b_bottom;
    3022. 

  3022. 

  3023. 	if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
    3024. 

  3024. 	    crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
    3025. 

  3025. 		return -EINVAL;
    3026. 

  3026. 

  3027. 	retval = v4l2_prio_check(&btv->prio, fh->prio);
    3028. 

  3028. 	if (0 != retval)
    3029. 

  3029. 		return retval;
    3030. 

  3030. 

  3031. 	/* Make sure tvnorm, vbi_end and the current cropping
    3032. 

  3032. 	   parameters remain consistent until we're done. Note
    3033. 

  3033. 	   read() may change vbi_end in check_alloc_btres(). */
    3034. 

  3034. 	mutex_lock(&btv->lock);
    3035. 

  3035. 

  3036. 	retval = -EBUSY;
    3037. 

  3037. 

  3038. 	if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
    3039. 

  3039. 		mutex_unlock(&btv->lock);
    3040. 

  3040. 		return retval;
    3041. 

  3041. 	}
    3042. 

  3042. 

  3043. 	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
    3044. 

  3044. 

  3045. 	b_left = b->left;
    3046. 

  3046. 	b_right = b_left + b->width;
    3047. 

  3047. 	b_bottom = b->top + b->height;
    3048. 

  3048. 

  3049. 	b_top = max(b->top, btv->vbi_end);
    3050. 

  3050. 	if (b_top + 32 >= b_bottom) {
    3051. 

  3051. 		mutex_unlock(&btv->lock);
    3052. 

  3052. 		return retval;
    3053. 

  3053. 	}
    3054. 

  3054. 

  3055. 	/* Min. scaled size 48 x 32. */
    3056. 

  3056. 	c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
    3057. 

  3057. 	c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
    3058. 

  3058. 

  3059. 	c.rect.width = clamp(crop->c.width,
    3060. 

  3060. 			     48, b_right - c.rect.left);
    3061. 

  3061. 

  3062. 	c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
    3063. 

  3063. 	/* Top and height must be a multiple of two. */
    3064. 

  3064. 	c.rect.top = (c.rect.top + 1) & ~1;
    3065. 

  3065. 

  3066. 	c.rect.height = clamp(crop->c.height,
    3067. 

  3067. 			      32, b_bottom - c.rect.top);
    3068. 

  3068. 	c.rect.height = (c.rect.height + 1) & ~1;
    3069. 

  3069. 

  3070. 	bttv_crop_calc_limits(&c);
    3071. 

  3071. 

  3072. 	btv->crop[1] = c;
    3073. 

  3073. 

  3074. 	mutex_unlock(&btv->lock);
    3075. 

  3075. 

  3076. 	fh->do_crop = 1;
    3077. 

  3077. 

  3078. 	mutex_lock(&fh->cap.vb_lock);
    3079. 

  3079. 

  3080. 	if (fh->width < c.min_scaled_width) {
    3081. 

  3081. 		fh->width = c.min_scaled_width;
    3082. 

  3082. 		btv->init.width = c.min_scaled_width;
    3083. 

  3083. 	} else if (fh->width > c.max_scaled_width) {
    3084. 

  3084. 		fh->width = c.max_scaled_width;
    3085. 

  3085. 		btv->init.width = c.max_scaled_width;
    3086. 

  3086. 	}
    3087. 

  3087. 

  3088. 	if (fh->height < c.min_scaled_height) {
    3089. 

  3089. 		fh->height = c.min_scaled_height;
    3090. 

  3090. 		btv->init.height = c.min_scaled_height;
    3091. 

  3091. 	} else if (fh->height > c.max_scaled_height) {
    3092. 

  3092. 		fh->height = c.max_scaled_height;
    3093. 

  3093. 		btv->init.height = c.max_scaled_height;
    3094. 

  3094. 	}
    3095. 

  3095. 

  3096. 	mutex_unlock(&fh->cap.vb_lock);
    3097. 

  3097. 

  3098. 	return 0;
    3099. 

  3099. }
    3100. 

  3100. 

  3101. static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
    3102. 

  3102. {
    3103. 

  3103. 	if (unlikely(a->index))
    3104. 

  3104. 		return -EINVAL;
    3105. 

  3105. 

  3106. 	strcpy(a->name, "audio");
    3107. 

  3107. 	return 0;
    3108. 

  3108. }
    3109. 

  3109. 

  3110. static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
    3111. 

  3111. {
    3112. 

  3112. 	if (unlikely(a->index))
    3113. 

  3113. 		return -EINVAL;
    3114. 

  3114. 

  3115. 	return 0;
    3116. 

  3116. }
    3117. 

  3117. 

  3118. static ssize_t bttv_read(struct file *file, char __user *data,
    3119. 

  3119. 			 size_t count, loff_t *ppos)
    3120. 

  3120. {
    3121. 

  3121. 	struct bttv_fh *fh = file->private_data;
    3122. 

  3122. 	int retval = 0;
    3123. 

  3123. 

  3124. 	if (fh->btv->errors)
    3125. 

  3125. 		bttv_reinit_bt848(fh->btv);
    3126. 

  3126. 	dprintk("bttv%d: read count=%d type=%s\n",
    3127. 

  3127. 		fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
    3128. 

  3128. 

  3129. 	switch (fh->type) {
    3130. 

  3130. 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
    3131. 

  3131. 		if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
    3132. 

  3132. 			/* VIDEO_READ in use by another fh,
    3133. 

  3133. 			   or VIDEO_STREAM by any fh. */
    3134. 

  3134. 			return -EBUSY;
    3135. 

  3135. 		}
    3136. 

  3136. 		retval = videobuf_read_one(&fh->cap, data, count, ppos,
    3137. 

  3137. 					   file->f_flags & O_NONBLOCK);
    3138. 

  3138. 		free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
    3139. 

  3139. 		break;
    3140. 

  3140. 	case V4L2_BUF_TYPE_VBI_CAPTURE:
    3141. 

  3141. 		if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
    3142. 

  3142. 			return -EBUSY;
    3143. 

  3143. 		retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
    3144. 

  3144. 					      file->f_flags & O_NONBLOCK);
    3145. 

  3145. 		break;
    3146. 

  3146. 	default:
    3147. 

  3147. 		BUG();
    3148. 

  3148. 	}
    3149. 

  3149. 	return retval;
    3150. 

  3150. }
    3151. 

  3151. 

  3152. static unsigned int bttv_poll(struct file *file, poll_table *wait)
    3153. 

  3153. {
    3154. 

  3154. 	struct bttv_fh *fh = file->private_data;
    3155. 

  3155. 	struct bttv_buffer *buf;
    3156. 

  3156. 	enum v4l2_field field;
    3157. 

  3157. 	unsigned int rc = POLLERR;
    3158. 

  3158. 

  3159. 	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
    3160. 

  3160. 		if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
    3161. 

  3161. 			return POLLERR;
    3162. 

  3162. 		return videobuf_poll_stream(file, &fh->vbi, wait);
    3163. 

  3163. 	}
    3164. 

  3164. 

  3165. 	if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
    3166. 

  3166. 		mutex_lock(&fh->cap.vb_lock);
    3167. 

  3167. 		/* streaming capture */
    3168. 

  3168. 		if (list_empty(&fh->cap.stream))
    3169. 

  3169. 			goto err;
    3170. 

  3170. 		buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
    3171. 

  3171. 	} else {
    3172. 

  3172. 		/* read() capture */
    3173. 

  3173. 		mutex_lock(&fh->cap.vb_lock);
    3174. 

  3174. 		if (NULL == fh->cap.read_buf) {
    3175. 

  3175. 			/* need to capture a new frame */
    3176. 

  3176. 			if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
    3177. 

  3177. 				goto err;
    3178. 

  3178. 			fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
    3179. 

  3179. 			if (NULL == fh->cap.read_buf)
    3180. 

  3180. 				goto err;
    3181. 

  3181. 			fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
    3182. 

  3182. 			field = videobuf_next_field(&fh->cap);
    3183. 

  3183. 			if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
    3184. 

  3184. 				kfree (fh->cap.read_buf);
    3185. 

  3185. 				fh->cap.read_buf = NULL;
    3186. 

  3186. 				goto err;
    3187. 

  3187. 			}
    3188. 

  3188. 			fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
    3189. 

  3189. 			fh->cap.read_off = 0;
    3190. 

  3190. 		}
    3191. 

  3191. 		mutex_unlock(&fh->cap.vb_lock);
    3192. 

  3192. 		buf = (struct bttv_buffer*)fh->cap.read_buf;
    3193. 

  3193. 	}
    3194. 

  3194. 

  3195. 	poll_wait(file, &buf->vb.done, wait);
    3196. 

  3196. 	if (buf->vb.state == VIDEOBUF_DONE ||
    3197. 

  3197. 	    buf->vb.state == VIDEOBUF_ERROR)
    3198. 

  3198. 		rc =  POLLIN|POLLRDNORM;
    3199. 

  3199. 	else
    3200. 

  3200. 		rc = 0;
    3201. 

  3201. err:
    3202. 

  3202. 	mutex_unlock(&fh->cap.vb_lock);
    3203. 

  3203. 	return rc;
    3204. 

  3204. }
    3205. 

  3205. 

  3206. static int bttv_open(struct file *file)
    3207. 

  3207. {
    3208. 

  3208. 	struct video_device *vdev = video_devdata(file);
    3209. 

  3209. 	struct bttv *btv = video_drvdata(file);
    3210. 

  3210. 	struct bttv_fh *fh;
    3211. 

  3211. 	enum v4l2_buf_type type = 0;
    3212. 

  3212. 

  3213. 	dprintk(KERN_DEBUG "bttv: open dev=%s\n", video_device_node_name(vdev));
    3214. 

  3214. 

  3215. 	if (vdev->vfl_type == VFL_TYPE_GRABBER) {
    3216. 

  3216. 		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    3217. 

  3217. 	} else if (vdev->vfl_type == VFL_TYPE_VBI) {
    3218. 

  3218. 		type = V4L2_BUF_TYPE_VBI_CAPTURE;
    3219. 

  3219. 	} else {
    3220. 

  3220. 		WARN_ON(1);
    3221. 

  3221. 		return -ENODEV;
    3222. 

  3222. 	}
    3223. 

  3223. 

  3224. 	lock_kernel();
    3225. 

  3225. 

  3226. 	dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
    3227. 

  3227. 		btv->c.nr,v4l2_type_names[type]);
    3228. 

  3228. 

  3229. 	/* allocate per filehandle data */
    3230. 

  3230. 	fh = kmalloc(sizeof(*fh),GFP_KERNEL);
    3231. 

  3231. 	if (NULL == fh) {
    3232. 

  3232. 		unlock_kernel();
    3233. 

  3233. 		return -ENOMEM;
    3234. 

  3234. 	}
    3235. 

  3235. 	file->private_data = fh;
    3236. 

  3236. 	*fh = btv->init;
    3237. 

  3237. 	fh->type = type;
    3238. 

  3238. 	fh->ov.setup_ok = 0;
    3239. 

  3239. 	v4l2_prio_open(&btv->prio, &fh->prio);
    3240. 

  3240. 

  3241. 	videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
    3242. 

  3242. 			    &btv->c.pci->dev, &btv->s_lock,
    3243. 

  3243. 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
    3244. 

  3244. 			    V4L2_FIELD_INTERLACED,
    3245. 

  3245. 			    sizeof(struct bttv_buffer),
    3246. 

  3246. 			    fh);
    3247. 

  3247. 	videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
    3248. 

  3248. 			    &btv->c.pci->dev, &btv->s_lock,
    3249. 

  3249. 			    V4L2_BUF_TYPE_VBI_CAPTURE,
    3250. 

  3250. 			    V4L2_FIELD_SEQ_TB,
    3251. 

  3251. 			    sizeof(struct bttv_buffer),
    3252. 

  3252. 			    fh);
    3253. 

  3253. 	set_tvnorm(btv,btv->tvnorm);
    3254. 

  3254. 	set_input(btv, btv->input, btv->tvnorm);
    3255. 

  3255. 

  3256. 	btv->users++;
    3257. 

  3257. 

  3258. 	/* The V4L2 spec requires one global set of cropping parameters
    3259. 

  3259. 	   which only change on request. These are stored in btv->crop[1].
    3260. 

  3260. 	   However for compatibility with V4L apps and cropping unaware
    3261. 

  3261. 	   V4L2 apps we now reset the cropping parameters as seen through
    3262. 

  3262. 	   this fh, which is to say VIDIOC_G_CROP and scaling limit checks
    3263. 

  3263. 	   will use btv->crop[0], the default cropping parameters for the
    3264. 

  3264. 	   current video standard, and VIDIOC_S_FMT will not implicitely
    3265. 

  3265. 	   change the cropping parameters until VIDIOC_S_CROP has been
    3266. 

  3266. 	   called. */
    3267. 

  3267. 	fh->do_crop = !reset_crop; /* module parameter */
    3268. 

  3268. 

  3269. 	/* Likewise there should be one global set of VBI capture
    3270. 

  3270. 	   parameters, but for compatibility with V4L apps and earlier
    3271. 

  3271. 	   driver versions each fh has its own parameters. */
    3272. 

  3272. 	bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
    3273. 

  3273. 

  3274. 	bttv_field_count(btv);
    3275. 

  3275. 	unlock_kernel();
    3276. 

  3276. 	return 0;
    3277. 

  3277. }
    3278. 

  3278. 

  3279. static int bttv_release(struct file *file)
    3280. 

  3280. {
    3281. 

  3281. 	struct bttv_fh *fh = file->private_data;
    3282. 

  3282. 	struct bttv *btv = fh->btv;
    3283. 

  3283. 

  3284. 	/* turn off overlay */
    3285. 

  3285. 	if (check_btres(fh, RESOURCE_OVERLAY))
    3286. 

  3286. 		bttv_switch_overlay(btv,fh,NULL);
    3287. 

  3287. 

  3288. 	/* stop video capture */
    3289. 

  3289. 	if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
    3290. 

  3290. 		videobuf_streamoff(&fh->cap);
    3291. 

  3291. 		free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
    3292. 

  3292. 	}
    3293. 

  3293. 	if (fh->cap.read_buf) {
    3294. 

  3294. 		buffer_release(&fh->cap,fh->cap.read_buf);
    3295. 

  3295. 		kfree(fh->cap.read_buf);
    3296. 

  3296. 	}
    3297. 

  3297. 	if (check_btres(fh, RESOURCE_VIDEO_READ)) {
    3298. 

  3298. 		free_btres(btv, fh, RESOURCE_VIDEO_READ);
    3299. 

  3299. 	}
    3300. 

  3300. 

  3301. 	/* stop vbi capture */
    3302. 

  3302. 	if (check_btres(fh, RESOURCE_VBI)) {
    3303. 

  3303. 		videobuf_stop(&fh->vbi);
    3304. 

  3304. 		free_btres(btv,fh,RESOURCE_VBI);
    3305. 

  3305. 	}
    3306. 

  3306. 

  3307. 	/* free stuff */
    3308. 

  3308. 	videobuf_mmap_free(&fh->cap);
    3309. 

  3309. 	videobuf_mmap_free(&fh->vbi);
    3310. 

  3310. 	v4l2_prio_close(&btv->prio, fh->prio);
    3311. 

  3311. 	file->private_data = NULL;
    3312. 

  3312. 	kfree(fh);
    3313. 

  3313. 

  3314. 	btv->users--;
    3315. 

  3315. 	bttv_field_count(btv);
    3316. 

  3316. 

  3317. 	if (!btv->users)
    3318. 

  3318. 		audio_mute(btv, 1);
    3319. 

  3319. 

  3320. 	return 0;
    3321. 

  3321. }
    3322. 

  3322. 

  3323. static int
    3324. 

  3324. bttv_mmap(struct file *file, struct vm_area_struct *vma)
    3325. 

  3325. {
    3326. 

  3326. 	struct bttv_fh *fh = file->private_data;
    3327. 

  3327. 

  3328. 	dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
    3329. 

  3329. 		fh->btv->c.nr, v4l2_type_names[fh->type],
    3330. 

  3330. 		vma->vm_start, vma->vm_end - vma->vm_start);
    3331. 

  3331. 	return videobuf_mmap_mapper(bttv_queue(fh),vma);
    3332. 

  3332. }
    3333. 

  3333. 

  3334. static const struct v4l2_file_operations bttv_fops =
    3335. 

  3335. {
    3336. 

  3336. 	.owner	  = THIS_MODULE,
    3337. 

  3337. 	.open	  = bttv_open,
    3338. 

  3338. 	.release  = bttv_release,
    3339. 

  3339. 	.ioctl	  = video_ioctl2,
    3340. 

  3340. 	.read	  = bttv_read,
    3341. 

  3341. 	.mmap	  = bttv_mmap,
    3342. 

  3342. 	.poll     = bttv_poll,
    3343. 

  3343. };
    3344. 

  3344. 

  3345. static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
    3346. 

  3346. 	.vidioc_querycap                = bttv_querycap,
    3347. 

  3347. 	.vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
    3348. 

  3348. 	.vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
    3349. 

  3349. 	.vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
    3350. 

  3350. 	.vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
    3351. 

  3351. 	.vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
    3352. 

  3352. 	.vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
    3353. 

  3353. 	.vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
    3354. 

  3354. 	.vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
    3355. 

  3355. 	.vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
    3356. 

  3356. 	.vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
    3357. 

  3357. 	.vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
    3358. 

  3358. 	.vidioc_g_audio                 = bttv_g_audio,
    3359. 

  3359. 	.vidioc_s_audio                 = bttv_s_audio,
    3360. 

  3360. 	.vidioc_cropcap                 = bttv_cropcap,
    3361. 

  3361. 	.vidioc_reqbufs                 = bttv_reqbufs,
    3362. 

  3362. 	.vidioc_querybuf                = bttv_querybuf,
    3363. 

  3363. 	.vidioc_qbuf                    = bttv_qbuf,
    3364. 

  3364. 	.vidioc_dqbuf                   = bttv_dqbuf,
    3365. 

  3365. 	.vidioc_s_std                   = bttv_s_std,
    3366. 

  3366. 	.vidioc_enum_input              = bttv_enum_input,
    3367. 

  3367. 	.vidioc_g_input                 = bttv_g_input,
    3368. 

  3368. 	.vidioc_s_input                 = bttv_s_input,
    3369. 

  3369. 	.vidioc_queryctrl               = bttv_queryctrl,
    3370. 

  3370. 	.vidioc_g_ctrl                  = bttv_g_ctrl,
    3371. 

  3371. 	.vidioc_s_ctrl                  = bttv_s_ctrl,
    3372. 

  3372. 	.vidioc_streamon                = bttv_streamon,
    3373. 

  3373. 	.vidioc_streamoff               = bttv_streamoff,
    3374. 

  3374. 	.vidioc_g_tuner                 = bttv_g_tuner,
    3375. 

  3375. 	.vidioc_s_tuner                 = bttv_s_tuner,
    3376. 

  3376. #ifdef CONFIG_VIDEO_V4L1_COMPAT
    3377. 

  3377. 	.vidiocgmbuf                    = vidiocgmbuf,
    3378. 

  3378. #endif
    3379. 

  3379. 	.vidioc_g_crop                  = bttv_g_crop,
    3380. 

  3380. 	.vidioc_s_crop                  = bttv_s_crop,
    3381. 

  3381. 	.vidioc_g_fbuf                  = bttv_g_fbuf,
    3382. 

  3382. 	.vidioc_s_fbuf                  = bttv_s_fbuf,
    3383. 

  3383. 	.vidioc_overlay                 = bttv_overlay,
    3384. 

  3384. 	.vidioc_g_priority              = bttv_g_priority,
    3385. 

  3385. 	.vidioc_s_priority              = bttv_s_priority,
    3386. 

  3386. 	.vidioc_g_parm                  = bttv_g_parm,
    3387. 

  3387. 	.vidioc_g_frequency             = bttv_g_frequency,
    3388. 

  3388. 	.vidioc_s_frequency             = bttv_s_frequency,
    3389. 

  3389. 	.vidioc_log_status		= bttv_log_status,
    3390. 

  3390. 	.vidioc_querystd		= bttv_querystd,
    3391. 

  3391. #ifdef CONFIG_VIDEO_ADV_DEBUG
    3392. 

  3392. 	.vidioc_g_register		= bttv_g_register,
    3393. 

  3393. 	.vidioc_s_register		= bttv_s_register,
    3394. 

  3394. #endif
    3395. 

  3395. };
    3396. 

  3396. 

  3397. static struct video_device bttv_video_template = {
    3398. 

  3398. 	.fops         = &bttv_fops,
    3399. 

  3399. 	.ioctl_ops    = &bttv_ioctl_ops,
    3400. 

  3400. 	.tvnorms      = BTTV_NORMS,
    3401. 

  3401. 	.current_norm = V4L2_STD_PAL,
    3402. 

  3402. };
    3403. 

  3403. 

  3404. /* ----------------------------------------------------------------------- */
    3405. 

  3405. /* radio interface                                                         */
    3406. 

  3406. 

  3407. static int radio_open(struct file *file)
    3408. 

  3408. {
    3409. 

  3409. 	struct video_device *vdev = video_devdata(file);
    3410. 

  3410. 	struct bttv *btv = video_drvdata(file);
    3411. 

  3411. 	struct bttv_fh *fh;
    3412. 

  3412. 

  3413. 	dprintk("bttv: open dev=%s\n", video_device_node_name(vdev));
    3414. 

  3414. 

  3415. 	lock_kernel();
    3416. 

  3416. 

  3417. 	dprintk("bttv%d: open called (radio)\n",btv->c.nr);
    3418. 

  3418. 

  3419. 	/* allocate per filehandle data */
    3420. 

  3420. 	fh = kmalloc(sizeof(*fh), GFP_KERNEL);
    3421. 

  3421. 	if (NULL == fh) {
    3422. 

  3422. 		unlock_kernel();
    3423. 

  3423. 		return -ENOMEM;
    3424. 

  3424. 	}
    3425. 

  3425. 	file->private_data = fh;
    3426. 

  3426. 	*fh = btv->init;
    3427. 

  3427. 	v4l2_prio_open(&btv->prio, &fh->prio);
    3428. 

  3428. 

  3429. 	mutex_lock(&btv->lock);
    3430. 

  3430. 

  3431. 	btv->radio_user++;
    3432. 

  3432. 

  3433. 	bttv_call_all(btv, tuner, s_radio);
    3434. 

  3434. 	audio_input(btv,TVAUDIO_INPUT_RADIO);
    3435. 

  3435. 

  3436. 	mutex_unlock(&btv->lock);
    3437. 

  3437. 	unlock_kernel();
    3438. 

  3438. 	return 0;
    3439. 

  3439. }
    3440. 

  3440. 

  3441. static int radio_release(struct file *file)
    3442. 

  3442. {
    3443. 

  3443. 	struct bttv_fh *fh = file->private_data;
    3444. 

  3444. 	struct bttv *btv = fh->btv;
    3445. 

  3445. 	struct rds_command cmd;
    3446. 

  3446. 

  3447. 	v4l2_prio_close(&btv->prio, fh->prio);
    3448. 

  3448. 	file->private_data = NULL;
    3449. 

  3449. 	kfree(fh);
    3450. 

  3450. 

  3451. 	btv->radio_user--;
    3452. 

  3452. 

  3453. 	bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
    3454. 

  3454. 

  3455. 	return 0;
    3456. 

  3456. }
    3457. 

  3457. 

  3458. static int radio_querycap(struct file *file, void *priv,
    3459. 

  3459. 					struct v4l2_capability *cap)
    3460. 

  3460. {
    3461. 

  3461. 	struct bttv_fh *fh = priv;
    3462. 

  3462. 	struct bttv *btv = fh->btv;
    3463. 

  3463. 

  3464. 	strcpy(cap->driver, "bttv");
    3465. 

  3465. 	strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
    3466. 

  3466. 	sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
    3467. 

  3467. 	cap->version = BTTV_VERSION_CODE;
    3468. 

  3468. 	cap->capabilities = V4L2_CAP_TUNER;
    3469. 

  3469. 

  3470. 	return 0;
    3471. 

  3471. }
    3472. 

  3472. 

  3473. static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
    3474. 

  3474. {
    3475. 

  3475. 	struct bttv_fh *fh = priv;
    3476. 

  3476. 	struct bttv *btv = fh->btv;
    3477. 

  3477. 

  3478. 	if (btv->tuner_type == TUNER_ABSENT)
    3479. 

  3479. 		return -EINVAL;
    3480. 

  3480. 	if (0 != t->index)
    3481. 

  3481. 		return -EINVAL;
    3482. 

  3482. 	mutex_lock(&btv->lock);
    3483. 

  3483. 	strcpy(t->name, "Radio");
    3484. 

  3484. 	t->type = V4L2_TUNER_RADIO;
    3485. 

  3485. 

  3486. 	bttv_call_all(btv, tuner, g_tuner, t);
    3487. 

  3487. 

  3488. 	if (btv->audio_mode_gpio)
    3489. 

  3489. 		btv->audio_mode_gpio(btv, t, 0);
    3490. 

  3490. 

  3491. 	mutex_unlock(&btv->lock);
    3492. 

  3492. 

  3493. 	return 0;
    3494. 

  3494. }
    3495. 

  3495. 

  3496. static int radio_enum_input(struct file *file, void *priv,
    3497. 

  3497. 				struct v4l2_input *i)
    3498. 

  3498. {
    3499. 

  3499. 	if (i->index != 0)
    3500. 

  3500. 		return -EINVAL;
    3501. 

  3501. 

  3502. 	strcpy(i->name, "Radio");
    3503. 

  3503. 	i->type = V4L2_INPUT_TYPE_TUNER;
    3504. 

  3504. 

  3505. 	return 0;
    3506. 

  3506. }
    3507. 

  3507. 

  3508. static int radio_g_audio(struct file *file, void *priv,
    3509. 

  3509. 					struct v4l2_audio *a)
    3510. 

  3510. {
    3511. 

  3511. 	if (unlikely(a->index))
    3512. 

  3512. 		return -EINVAL;
    3513. 

  3513. 

  3514. 	strcpy(a->name, "Radio");
    3515. 

  3515. 

  3516. 	return 0;
    3517. 

  3517. }
    3518. 

  3518. 

  3519. static int radio_s_tuner(struct file *file, void *priv,
    3520. 

  3520. 					struct v4l2_tuner *t)
    3521. 

  3521. {
    3522. 

  3522. 	struct bttv_fh *fh = priv;
    3523. 

  3523. 	struct bttv *btv = fh->btv;
    3524. 

  3524. 

  3525. 	if (0 != t->index)
    3526. 

  3526. 		return -EINVAL;
    3527. 

  3527. 

  3528. 	bttv_call_all(btv, tuner, g_tuner, t);
    3529. 

  3529. 	return 0;
    3530. 

  3530. }
    3531. 

  3531. 

  3532. static int radio_s_audio(struct file *file, void *priv,
    3533. 

  3533. 					struct v4l2_audio *a)
    3534. 

  3534. {
    3535. 

  3535. 	if (unlikely(a->index))
    3536. 

  3536. 		return -EINVAL;
    3537. 

  3537. 

  3538. 	return 0;
    3539. 

  3539. }
    3540. 

  3540. 

  3541. static int radio_s_input(struct file *filp, void *priv, unsigned int i)
    3542. 

  3542. {
    3543. 

  3543. 	if (unlikely(i))
    3544. 

  3544. 		return -EINVAL;
    3545. 

  3545. 

  3546. 	return 0;
    3547. 

  3547. }
    3548. 

  3548. 

  3549. static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
    3550. 

  3550. {
    3551. 

  3551. 	return 0;
    3552. 

  3552. }
    3553. 

  3553. 

  3554. static int radio_queryctrl(struct file *file, void *priv,
    3555. 

  3555. 					struct v4l2_queryctrl *c)
    3556. 

  3556. {
    3557. 

  3557. 	const struct v4l2_queryctrl *ctrl;
    3558. 

  3558. 

  3559. 	if (c->id <  V4L2_CID_BASE ||
    3560. 

  3560. 			c->id >= V4L2_CID_LASTP1)
    3561. 

  3561. 		return -EINVAL;
    3562. 

  3562. 

  3563. 	if (c->id == V4L2_CID_AUDIO_MUTE) {
    3564. 

  3564. 		ctrl = ctrl_by_id(c->id);
    3565. 

  3565. 		*c = *ctrl;
    3566. 

  3566. 	} else
    3567. 

  3567. 		*c = no_ctl;
    3568. 

  3568. 

  3569. 	return 0;
    3570. 

  3570. }
    3571. 

  3571. 

  3572. static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
    3573. 

  3573. {
    3574. 

  3574. 	*i = 0;
    3575. 

  3575. 	return 0;
    3576. 

  3576. }
    3577. 

  3577. 

  3578. static ssize_t radio_read(struct file *file, char __user *data,
    3579. 

  3579. 			 size_t count, loff_t *ppos)
    3580. 

  3580. {
    3581. 

  3581. 	struct bttv_fh *fh = file->private_data;
    3582. 

  3582. 	struct bttv *btv = fh->btv;
    3583. 

  3583. 	struct rds_command cmd;
    3584. 

  3584. 	cmd.block_count = count/3;
    3585. 

  3585. 	cmd.buffer = data;
    3586. 

  3586. 	cmd.instance = file;
    3587. 

  3587. 	cmd.result = -ENODEV;
    3588. 

  3588. 

  3589. 	bttv_call_all(btv, core, ioctl, RDS_CMD_READ, &cmd);
    3590. 

  3590. 

  3591. 	return cmd.result;
    3592. 

  3592. }
    3593. 

  3593. 

  3594. static unsigned int radio_poll(struct file *file, poll_table *wait)
    3595. 

  3595. {
    3596. 

  3596. 	struct bttv_fh *fh = file->private_data;
    3597. 

  3597. 	struct bttv *btv = fh->btv;
    3598. 

  3598. 	struct rds_command cmd;
    3599. 

  3599. 	cmd.instance = file;
    3600. 

  3600. 	cmd.event_list = wait;
    3601. 

  3601. 	cmd.result = -ENODEV;
    3602. 

  3602. 	bttv_call_all(btv, core, ioctl, RDS_CMD_POLL, &cmd);
    3603. 

  3603. 

  3604. 	return cmd.result;
    3605. 

  3605. }
    3606. 

  3606. 

  3607. static const struct v4l2_file_operations radio_fops =
    3608. 

  3608. {
    3609. 

  3609. 	.owner	  = THIS_MODULE,
    3610. 

  3610. 	.open	  = radio_open,
    3611. 

  3611. 	.read     = radio_read,
    3612. 

  3612. 	.release  = radio_release,
    3613. 

  3613. 	.ioctl	  = video_ioctl2,
    3614. 

  3614. 	.poll     = radio_poll,
    3615. 

  3615. };
    3616. 

  3616. 

  3617. static const struct v4l2_ioctl_ops radio_ioctl_ops = {
    3618. 

  3618. 	.vidioc_querycap        = radio_querycap,
    3619. 

  3619. 	.vidioc_g_tuner         = radio_g_tuner,
    3620. 

  3620. 	.vidioc_enum_input      = radio_enum_input,
    3621. 

  3621. 	.vidioc_g_audio         = radio_g_audio,
    3622. 

  3622. 	.vidioc_s_tuner         = radio_s_tuner,
    3623. 

  3623. 	.vidioc_s_audio         = radio_s_audio,
    3624. 

  3624. 	.vidioc_s_input         = radio_s_input,
    3625. 

  3625. 	.vidioc_s_std           = radio_s_std,
    3626. 

  3626. 	.vidioc_queryctrl       = radio_queryctrl,
    3627. 

  3627. 	.vidioc_g_input         = radio_g_input,
    3628. 

  3628. 	.vidioc_g_ctrl          = bttv_g_ctrl,
    3629. 

  3629. 	.vidioc_s_ctrl          = bttv_s_ctrl,
    3630. 

  3630. 	.vidioc_g_frequency     = bttv_g_frequency,
    3631. 

  3631. 	.vidioc_s_frequency     = bttv_s_frequency,
    3632. 

  3632. };
    3633. 

  3633. 

  3634. static struct video_device radio_template = {
    3635. 

  3635. 	.fops      = &radio_fops,
    3636. 

  3636. 	.ioctl_ops = &radio_ioctl_ops,
    3637. 

  3637. };
    3638. 

  3638. 

  3639. /* ----------------------------------------------------------------------- */
    3640. 

  3640. /* some debug code                                                         */
    3641. 

  3641. 

  3642. static int bttv_risc_decode(u32 risc)
    3643. 

  3643. {
    3644. 

  3644. 	static char *instr[16] = {
    3645. 

  3645. 		[ BT848_RISC_WRITE     >> 28 ] = "write",
    3646. 

  3646. 		[ BT848_RISC_SKIP      >> 28 ] = "skip",
    3647. 

  3647. 		[ BT848_RISC_WRITEC    >> 28 ] = "writec",
    3648. 

  3648. 		[ BT848_RISC_JUMP      >> 28 ] = "jump",
    3649. 

  3649. 		[ BT848_RISC_SYNC      >> 28 ] = "sync",
    3650. 

  3650. 		[ BT848_RISC_WRITE123  >> 28 ] = "write123",
    3651. 

  3651. 		[ BT848_RISC_SKIP123   >> 28 ] = "skip123",
    3652. 

  3652. 		[ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
    3653. 

  3653. 	};
    3654. 

  3654. 	static int incr[16] = {
    3655. 

  3655. 		[ BT848_RISC_WRITE     >> 28 ] = 2,
    3656. 

  3656. 		[ BT848_RISC_JUMP      >> 28 ] = 2,
    3657. 

  3657. 		[ BT848_RISC_SYNC      >> 28 ] = 2,
    3658. 

  3658. 		[ BT848_RISC_WRITE123  >> 28 ] = 5,
    3659. 

  3659. 		[ BT848_RISC_SKIP123   >> 28 ] = 2,
    3660. 

  3660. 		[ BT848_RISC_WRITE1S23 >> 28 ] = 3,
    3661. 

  3661. 	};
    3662. 

  3662. 	static char *bits[] = {
    3663. 

  3663. 		"be0",  "be1",  "be2",  "be3/resync",
    3664. 

  3664. 		"set0", "set1", "set2", "set3",
    3665. 

  3665. 		"clr0", "clr1", "clr2", "clr3",
    3666. 

  3666. 		"irq",  "res",  "eol",  "sol",
    3667. 

  3667. 	};
    3668. 

  3668. 	int i;
    3669. 

  3669. 

  3670. 	printk("0x%08x [ %s", risc,
    3671. 

  3671. 	       instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
    3672. 

  3672. 	for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
    3673. 

  3673. 		if (risc & (1 << (i + 12)))
    3674. 

  3674. 			printk(" %s",bits[i]);
    3675. 

  3675. 	printk(" count=%d ]\n", risc & 0xfff);
    3676. 

  3676. 	return incr[risc >> 28] ? incr[risc >> 28] : 1;
    3677. 

  3677. }
    3678. 

  3678. 

  3679. static void bttv_risc_disasm(struct bttv *btv,
    3680. 

  3680. 			     struct btcx_riscmem *risc)
    3681. 

  3681. {
    3682. 

  3682. 	unsigned int i,j,n;
    3683. 

  3683. 

  3684. 	printk("%s: risc disasm: %p [dma=0x%08lx]\n",
    3685. 

  3685. 	       btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
    3686. 

  3686. 	for (i = 0; i < (risc->size >> 2); i += n) {
    3687. 

  3687. 		printk("%s:   0x%lx: ", btv->c.v4l2_dev.name,
    3688. 

  3688. 		       (unsigned long)(risc->dma + (i<<2)));
    3689. 

  3689. 		n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
    3690. 

  3690. 		for (j = 1; j < n; j++)
    3691. 

  3691. 			printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
    3692. 

  3692. 			       btv->c.v4l2_dev.name, (unsigned long)(risc->dma + ((i+j)<<2)),
    3693. 

  3693. 			       risc->cpu[i+j], j);
    3694. 

  3694. 		if (0 == risc->cpu[i])
    3695. 

  3695. 			break;
    3696. 

  3696. 	}
    3697. 

  3697. }
    3698. 

  3698. 

  3699. static void bttv_print_riscaddr(struct bttv *btv)
    3700. 

  3700. {
    3701. 

  3701. 	printk("  main: %08Lx\n",
    3702. 

  3702. 	       (unsigned long long)btv->main.dma);
    3703. 

  3703. 	printk("  vbi : o=%08Lx e=%08Lx\n",
    3704. 

  3704. 	       btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
    3705. 

  3705. 	       btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
    3706. 

  3706. 	printk("  cap : o=%08Lx e=%08Lx\n",
    3707. 

  3707. 	       btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
    3708. 

  3708. 	       btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
    3709. 

  3709. 	printk("  scr : o=%08Lx e=%08Lx\n",
    3710. 

  3710. 	       btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
    3711. 

  3711. 	       btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
    3712. 

  3712. 	bttv_risc_disasm(btv, &btv->main);
    3713. 

  3713. }
    3714. 

  3714. 

  3715. /* ----------------------------------------------------------------------- */
    3716. 

  3716. /* irq handler                                                             */
    3717. 

  3717. 

  3718. static char *irq_name[] = {
    3719. 

  3719. 	"FMTCHG",  // format change detected (525 vs. 625)
    3720. 

  3720. 	"VSYNC",   // vertical sync (new field)
    3721. 

  3721. 	"HSYNC",   // horizontal sync
    3722. 

  3722. 	"OFLOW",   // chroma/luma AGC overflow
    3723. 

  3723. 	"HLOCK",   // horizontal lock changed
    3724. 

  3724. 	"VPRES",   // video presence changed
    3725. 

  3725. 	"6", "7",
    3726. 

  3726. 	"I2CDONE", // hw irc operation finished
    3727. 

  3727. 	"GPINT",   // gpio port triggered irq
    3728. 

  3728. 	"10",
    3729. 

  3729. 	"RISCI",   // risc instruction triggered irq
    3730. 

  3730. 	"FBUS",    // pixel data fifo dropped data (high pci bus latencies)
    3731. 

  3731. 	"FTRGT",   // pixel data fifo overrun
    3732. 

  3732. 	"FDSR",    // fifo data stream resyncronisation
    3733. 

  3733. 	"PPERR",   // parity error (data transfer)
    3734. 

  3734. 	"RIPERR",  // parity error (read risc instructions)
    3735. 

  3735. 	"PABORT",  // pci abort
    3736. 

  3736. 	"OCERR",   // risc instruction error
    3737. 

  3737. 	"SCERR",   // syncronisation error
    3738. 

  3738. };
    3739. 

  3739. 

  3740. static void bttv_print_irqbits(u32 print, u32 mark)
    3741. 

  3741. {
    3742. 

  3742. 	unsigned int i;
    3743. 

  3743. 

  3744. 	printk("bits:");
    3745. 

  3745. 	for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
    3746. 

  3746. 		if (print & (1 << i))
    3747. 

  3747. 			printk(" %s",irq_name[i]);
    3748. 

  3748. 		if (mark & (1 << i))
    3749. 

  3749. 			printk("*");
    3750. 

  3750. 	}
    3751. 

  3751. }
    3752. 

  3752. 

  3753. static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
    3754. 

  3754. {
    3755. 

  3755. 	printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
    3756. 

  3756. 	       btv->c.nr,
    3757. 

  3757. 	       (unsigned long)btv->main.dma,
    3758. 

  3758. 	       (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
    3759. 

  3759. 	       (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
    3760. 

  3760. 	       (unsigned long)rc);
    3761. 

  3761. 

  3762. 	if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
    3763. 

  3763. 		printk("bttv%d: Oh, there (temporarely?) is no input signal. "
    3764. 

  3764. 		       "Ok, then this is harmless, don't worry ;)\n",
    3765. 

  3765. 		       btv->c.nr);
    3766. 

  3766. 		return;
    3767. 

  3767. 	}
    3768. 

  3768. 	printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
    3769. 

  3769. 	       btv->c.nr);
    3770. 

  3770. 	printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
    3771. 

  3771. 	       btv->c.nr);
    3772. 

  3772. 	dump_stack();
    3773. 

  3773. }
    3774. 

  3774. 

  3775. static int
    3776. 

  3776. bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
    3777. 

  3777. {
    3778. 

  3778. 	struct bttv_buffer *item;
    3779. 

  3779. 

  3780. 	memset(set,0,sizeof(*set));
    3781. 

  3781. 

  3782. 	/* capture request ? */
    3783. 

  3783. 	if (!list_empty(&btv->capture)) {
    3784. 

  3784. 		set->frame_irq = 1;
    3785. 

  3785. 		item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
    3786. 

  3786. 		if (V4L2_FIELD_HAS_TOP(item->vb.field))
    3787. 

  3787. 			set->top    = item;
    3788. 

  3788. 		if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
    3789. 

  3789. 			set->bottom = item;
    3790. 

  3790. 

  3791. 		/* capture request for other field ? */
    3792. 

  3792. 		if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
    3793. 

  3793. 		    (item->vb.queue.next != &btv->capture)) {
    3794. 

  3794. 			item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
    3795. 

  3795. 			/* Mike Isely <isely@pobox.com> - Only check
    3796. 

  3796. 			 * and set up the bottom field in the logic
    3797. 

  3797. 			 * below.  Don't ever do the top field.  This
    3798. 

  3798. 			 * of course means that if we set up the
    3799. 

  3799. 			 * bottom field in the above code that we'll
    3800. 

  3800. 			 * actually skip a field.  But that's OK.
    3801. 

  3801. 			 * Having processed only a single buffer this
    3802. 

  3802. 			 * time, then the next time around the first
    3803. 

  3803. 			 * available buffer should be for a top field.
    3804. 

  3804. 			 * That will then cause us here to set up a
    3805. 

  3805. 			 * top then a bottom field in the normal way.
    3806. 

  3806. 			 * The alternative to this understanding is
    3807. 

  3807. 			 * that we set up the second available buffer
    3808. 

  3808. 			 * as a top field, but that's out of order
    3809. 

  3809. 			 * since this driver always processes the top
    3810. 

  3810. 			 * field first - the effect will be the two
    3811. 

  3811. 			 * buffers being returned in the wrong order,
    3812. 

  3812. 			 * with the second buffer also being delayed
    3813. 

  3813. 			 * by one field time (owing to the fifo nature
    3814. 

  3814. 			 * of videobuf).  Worse still, we'll be stuck
    3815. 

  3815. 			 * doing fields out of order now every time
    3816. 

  3816. 			 * until something else causes a field to be
    3817. 

  3817. 			 * dropped.  By effectively forcing a field to
    3818. 

  3818. 			 * drop this way then we always get back into
    3819. 

  3819. 			 * sync within a single frame time.  (Out of
    3820. 

  3820. 			 * order fields can screw up deinterlacing
    3821. 

  3821. 			 * algorithms.) */
    3822. 

  3822. 			if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
    3823. 

  3823. 				if (NULL == set->bottom &&
    3824. 

  3824. 				    V4L2_FIELD_BOTTOM == item->vb.field) {
    3825. 

  3825. 					set->bottom = item;
    3826. 

  3826. 				}
    3827. 

  3827. 				if (NULL != set->top  &&  NULL != set->bottom)
    3828. 

  3828. 					set->top_irq = 2;
    3829. 

  3829. 			}
    3830. 

  3830. 		}
    3831. 

  3831. 	}
    3832. 

  3832. 

  3833. 	/* screen overlay ? */
    3834. 

  3834. 	if (NULL != btv->screen) {
    3835. 

  3835. 		if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
    3836. 

  3836. 			if (NULL == set->top && NULL == set->bottom) {
    3837. 

  3837. 				set->top    = btv->screen;
    3838. 

  3838. 				set->bottom = btv->screen;
    3839. 

  3839. 			}
    3840. 

  3840. 		} else {
    3841. 

  3841. 			if (V4L2_FIELD_TOP == btv->screen->vb.field &&
    3842. 

  3842. 			    NULL == set->top) {
    3843. 

  3843. 				set->top = btv->screen;
    3844. 

  3844. 			}
    3845. 

  3845. 			if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
    3846. 

  3846. 			    NULL == set->bottom) {
    3847. 

  3847. 				set->bottom = btv->screen;
    3848. 

  3848. 			}
    3849. 

  3849. 		}
    3850. 

  3850. 	}
    3851. 

  3851. 

  3852. 	dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
    3853. 

  3853. 		btv->c.nr,set->top, set->bottom,
    3854. 

  3854. 		btv->screen,set->frame_irq,set->top_irq);
    3855. 

  3855. 	return 0;
    3856. 

  3856. }
    3857. 

  3857. 

  3858. static void
    3859. 

  3859. bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
    3860. 

  3860. 		      struct bttv_buffer_set *curr, unsigned int state)
    3861. 

  3861. {
    3862. 

  3862. 	struct timeval ts;
    3863. 

  3863. 

  3864. 	do_gettimeofday(&ts);
    3865. 

  3865. 

  3866. 	if (wakeup->top == wakeup->bottom) {
    3867. 

  3867. 		if (NULL != wakeup->top && curr->top != wakeup->top) {
    3868. 

  3868. 			if (irq_debug > 1)
    3869. 

  3869. 				printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
    3870. 

  3870. 			wakeup->top->vb.ts = ts;
    3871. 

  3871. 			wakeup->top->vb.field_count = btv->field_count;
    3872. 

  3872. 			wakeup->top->vb.state = state;
    3873. 

  3873. 			wake_up(&wakeup->top->vb.done);
    3874. 

  3874. 		}
    3875. 

  3875. 	} else {
    3876. 

  3876. 		if (NULL != wakeup->top && curr->top != wakeup->top) {
    3877. 

  3877. 			if (irq_debug > 1)
    3878. 

  3878. 				printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
    3879. 

  3879. 			wakeup->top->vb.ts = ts;
    3880. 

  3880. 			wakeup->top->vb.field_count = btv->field_count;
    3881. 

  3881. 			wakeup->top->vb.state = state;
    3882. 

  3882. 			wake_up(&wakeup->top->vb.done);
    3883. 

  3883. 		}
    3884. 

  3884. 		if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
    3885. 

  3885. 			if (irq_debug > 1)
    3886. 

  3886. 				printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
    3887. 

  3887. 			wakeup->bottom->vb.ts = ts;
    3888. 

  3888. 			wakeup->bottom->vb.field_count = btv->field_count;
    3889. 

  3889. 			wakeup->bottom->vb.state = state;
    3890. 

  3890. 			wake_up(&wakeup->bottom->vb.done);
    3891. 

  3891. 		}
    3892. 

  3892. 	}
    3893. 

  3893. }
    3894. 

  3894. 

  3895. static void
    3896. 

  3896. bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
    3897. 

  3897. 		    unsigned int state)
    3898. 

  3898. {
    3899. 

  3899. 	struct timeval ts;
    3900. 

  3900. 

  3901. 	if (NULL == wakeup)
    3902. 

  3902. 		return;
    3903. 

  3903. 

  3904. 	do_gettimeofday(&ts);
    3905. 

  3905. 	wakeup->vb.ts = ts;
    3906. 

  3906. 	wakeup->vb.field_count = btv->field_count;
    3907. 

  3907. 	wakeup->vb.state = state;
    3908. 

  3908. 	wake_up(&wakeup->vb.done);
    3909. 

  3909. }
    3910. 

  3910. 

  3911. static void bttv_irq_timeout(unsigned long data)
    3912. 

  3912. {
    3913. 

  3913. 	struct bttv *btv = (struct bttv *)data;
    3914. 

  3914. 	struct bttv_buffer_set old,new;
    3915. 

  3915. 	struct bttv_buffer *ovbi;
    3916. 

  3916. 	struct bttv_buffer *item;
    3917. 

  3917. 	unsigned long flags;
    3918. 

  3918. 

  3919. 	if (bttv_verbose) {
    3920. 

  3920. 		printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
    3921. 

  3921. 		       btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
    3922. 

  3922. 		       btread(BT848_RISC_COUNT));
    3923. 

  3923. 		bttv_print_irqbits(btread(BT848_INT_STAT),0);
    3924. 

  3924. 		printk("\n");
    3925. 

  3925. 	}
    3926. 

  3926. 

  3927. 	spin_lock_irqsave(&btv->s_lock,flags);
    3928. 

  3928. 

  3929. 	/* deactivate stuff */
    3930. 

  3930. 	memset(&new,0,sizeof(new));
    3931. 

  3931. 	old  = btv->curr;
    3932. 

  3932. 	ovbi = btv->cvbi;
    3933. 

  3933. 	btv->curr = new;
    3934. 

  3934. 	btv->cvbi = NULL;
    3935. 

  3935. 	btv->loop_irq = 0;
    3936. 

  3936. 	bttv_buffer_activate_video(btv, &new);
    3937. 

  3937. 	bttv_buffer_activate_vbi(btv,   NULL);
    3938. 

  3938. 	bttv_set_dma(btv, 0);
    3939. 

  3939. 

  3940. 	/* wake up */
    3941. 

  3941. 	bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
    3942. 

  3942. 	bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
    3943. 

  3943. 

  3944. 	/* cancel all outstanding capture / vbi requests */
    3945. 

  3945. 	while (!list_empty(&btv->capture)) {
    3946. 

  3946. 		item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
    3947. 

  3947. 		list_del(&item->vb.queue);
    3948. 

  3948. 		item->vb.state = VIDEOBUF_ERROR;
    3949. 

  3949. 		wake_up(&item->vb.done);
    3950. 

  3950. 	}
    3951. 

  3951. 	while (!list_empty(&btv->vcapture)) {
    3952. 

  3952. 		item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
    3953. 

  3953. 		list_del(&item->vb.queue);
    3954. 

  3954. 		item->vb.state = VIDEOBUF_ERROR;
    3955. 

  3955. 		wake_up(&item->vb.done);
    3956. 

  3956. 	}
    3957. 

  3957. 

  3958. 	btv->errors++;
    3959. 

  3959. 	spin_unlock_irqrestore(&btv->s_lock,flags);
    3960. 

  3960. }
    3961. 

  3961. 

  3962. static void
    3963. 

  3963. bttv_irq_wakeup_top(struct bttv *btv)
    3964. 

  3964. {
    3965. 

  3965. 	struct bttv_buffer *wakeup = btv->curr.top;
    3966. 

  3966. 

  3967. 	if (NULL == wakeup)
    3968. 

  3968. 		return;
    3969. 

  3969. 

  3970. 	spin_lock(&btv->s_lock);
    3971. 

  3971. 	btv->curr.top_irq = 0;
    3972. 

  3972. 	btv->curr.top = NULL;
    3973. 

  3973. 	bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
    3974. 

  3974. 

  3975. 	do_gettimeofday(&wakeup->vb.ts);
    3976. 

  3976. 	wakeup->vb.field_count = btv->field_count;
    3977. 

  3977. 	wakeup->vb.state = VIDEOBUF_DONE;
    3978. 

  3978. 	wake_up(&wakeup->vb.done);
    3979. 

  3979. 	spin_unlock(&btv->s_lock);
    3980. 

  3980. }
    3981. 

  3981. 

  3982. static inline int is_active(struct btcx_riscmem *risc, u32 rc)
    3983. 

  3983. {
    3984. 

  3984. 	if (rc < risc->dma)
    3985. 

  3985. 		return 0;
    3986. 

  3986. 	if (rc > risc->dma + risc->size)
    3987. 

  3987. 		return 0;
    3988. 

  3988. 	return 1;
    3989. 

  3989. }
    3990. 

  3990. 

  3991. static void
    3992. 

  3992. bttv_irq_switch_video(struct bttv *btv)
    3993. 

  3993. {
    3994. 

  3994. 	struct bttv_buffer_set new;
    3995. 

  3995. 	struct bttv_buffer_set old;
    3996. 

  3996. 	dma_addr_t rc;
    3997. 

  3997. 

  3998. 	spin_lock(&btv->s_lock);
    3999. 

  3999. 

  4000. 	/* new buffer set */
    4001. 

  4001. 	bttv_irq_next_video(btv, &new);
    4002. 

  4002. 	rc = btread(BT848_RISC_COUNT);
    4003. 

  4003. 	if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
    4004. 

  4004. 	    (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
    4005. 

  4005. 		btv->framedrop++;
    4006. 

  4006. 		if (debug_latency)
    4007. 

  4007. 			bttv_irq_debug_low_latency(btv, rc);
    4008. 

  4008. 		spin_unlock(&btv->s_lock);
    4009. 

  4009. 		return;
    4010. 

  4010. 	}
    4011. 

  4011. 

  4012. 	/* switch over */
    4013. 

  4013. 	old = btv->curr;
    4014. 

  4014. 	btv->curr = new;
    4015. 

  4015. 	btv->loop_irq &= ~1;
    4016. 

  4016. 	bttv_buffer_activate_video(btv, &new);
    4017. 

  4017. 	bttv_set_dma(btv, 0);
    4018. 

  4018. 

  4019. 	/* switch input */
    4020. 

  4020. 	if (UNSET != btv->new_input) {
    4021. 

  4021. 		video_mux(btv,btv->new_input);
    4022. 

  4022. 		btv->new_input = UNSET;
    4023. 

  4023. 	}
    4024. 

  4024. 

  4025. 	/* wake up finished buffers */
    4026. 

  4026. 	bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
    4027. 

  4027. 	spin_unlock(&btv->s_lock);
    4028. 

  4028. }
    4029. 

  4029. 

  4030. static void
    4031. 

  4031. bttv_irq_switch_vbi(struct bttv *btv)
    4032. 

  4032. {
    4033. 

  4033. 	struct bttv_buffer *new = NULL;
    4034. 

  4034. 	struct bttv_buffer *old;
    4035. 

  4035. 	u32 rc;
    4036. 

  4036. 

  4037. 	spin_lock(&btv->s_lock);
    4038. 

  4038. 

  4039. 	if (!list_empty(&btv->vcapture))
    4040. 

  4040. 		new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
    4041. 

  4041. 	old = btv->cvbi;
    4042. 

  4042. 

  4043. 	rc = btread(BT848_RISC_COUNT);
    4044. 

  4044. 	if (NULL != old && (is_active(&old->top,    rc) ||
    4045. 

  4045. 			    is_active(&old->bottom, rc))) {
    4046. 

  4046. 		btv->framedrop++;
    4047. 

  4047. 		if (debug_latency)
    4048. 

  4048. 			bttv_irq_debug_low_latency(btv, rc);
    4049. 

  4049. 		spin_unlock(&btv->s_lock);
    4050. 

  4050. 		return;
    4051. 

  4051. 	}
    4052. 

  4052. 

  4053. 	/* switch */
    4054. 

  4054. 	btv->cvbi = new;
    4055. 

  4055. 	btv->loop_irq &= ~4;
    4056. 

  4056. 	bttv_buffer_activate_vbi(btv, new);
    4057. 

  4057. 	bttv_set_dma(btv, 0);
    4058. 

  4058. 

  4059. 	bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
    4060. 

  4060. 	spin_unlock(&btv->s_lock);
    4061. 

  4061. }
    4062. 

  4062. 

  4063. static irqreturn_t bttv_irq(int irq, void *dev_id)
    4064. 

  4064. {
    4065. 

  4065. 	u32 stat,astat;
    4066. 

  4066. 	u32 dstat;
    4067. 

  4067. 	int count;
    4068. 

  4068. 	struct bttv *btv;
    4069. 

  4069. 	int handled = 0;
    4070. 

  4070. 

  4071. 	btv=(struct bttv *)dev_id;
    4072. 

  4072. 

  4073. 	if (btv->custom_irq)
    4074. 

  4074. 		handled = btv->custom_irq(btv);
    4075. 

  4075. 

  4076. 	count=0;
    4077. 

  4077. 	while (1) {
    4078. 

  4078. 		/* get/clear interrupt status bits */
    4079. 

  4079. 		stat=btread(BT848_INT_STAT);
    4080. 

  4080. 		astat=stat&btread(BT848_INT_MASK);
    4081. 

  4081. 		if (!astat)
    4082. 

  4082. 			break;
    4083. 

  4083. 		handled = 1;
    4084. 

  4084. 		btwrite(stat,BT848_INT_STAT);
    4085. 

  4085. 

  4086. 		/* get device status bits */
    4087. 

  4087. 		dstat=btread(BT848_DSTATUS);
    4088. 

  4088. 

  4089. 		if (irq_debug) {
    4090. 

  4090. 			printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
    4091. 

  4091. 			       "riscs=%x, riscc=%08x, ",
    4092. 

  4092. 			       btv->c.nr, count, btv->field_count,
    4093. 

  4093. 			       stat>>28, btread(BT848_RISC_COUNT));
    4094. 

  4094. 			bttv_print_irqbits(stat,astat);
    4095. 

  4095. 			if (stat & BT848_INT_HLOCK)
    4096. 

  4096. 				printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
    4097. 

  4097. 				       ? "yes" : "no");
    4098. 

  4098. 			if (stat & BT848_INT_VPRES)
    4099. 

  4099. 				printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
    4100. 

  4100. 				       ? "yes" : "no");
    4101. 

  4101. 			if (stat & BT848_INT_FMTCHG)
    4102. 

  4102. 				printk("   NUML => %s", (dstat & BT848_DSTATUS_NUML)
    4103. 

  4103. 				       ? "625" : "525");
    4104. 

  4104. 			printk("\n");
    4105. 

  4105. 		}
    4106. 

  4106. 

  4107. 		if (astat&BT848_INT_VSYNC)
    4108. 

  4108. 			btv->field_count++;
    4109. 

  4109. 

  4110. 		if ((astat & BT848_INT_GPINT) && btv->remote) {
    4111. 

  4111. 			wake_up(&btv->gpioq);
    4112. 

  4112. 			bttv_input_irq(btv);
    4113. 

  4113. 		}
    4114. 

  4114. 

  4115. 		if (astat & BT848_INT_I2CDONE) {
    4116. 

  4116. 			btv->i2c_done = stat;
    4117. 

  4117. 			wake_up(&btv->i2c_queue);
    4118. 

  4118. 		}
    4119. 

  4119. 

  4120. 		if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
    4121. 

  4121. 			bttv_irq_switch_vbi(btv);
    4122. 

  4122. 

  4123. 		if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
    4124. 

  4124. 			bttv_irq_wakeup_top(btv);
    4125. 

  4125. 

  4126. 		if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
    4127. 

  4127. 			bttv_irq_switch_video(btv);
    4128. 

  4128. 

  4129. 		if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
    4130. 

  4130. 			audio_mute(btv, btv->mute);  /* trigger automute */
    4131. 

  4131. 

  4132. 		if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
    4133. 

  4133. 			printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
    4134. 

  4134. 			       (astat & BT848_INT_SCERR) ? "SCERR" : "",
    4135. 

  4135. 			       (astat & BT848_INT_OCERR) ? "OCERR" : "",
    4136. 

  4136. 			       btread(BT848_RISC_COUNT));
    4137. 

  4137. 			bttv_print_irqbits(stat,astat);
    4138. 

  4138. 			printk("\n");
    4139. 

  4139. 			if (bttv_debug)
    4140. 

  4140. 				bttv_print_riscaddr(btv);
    4141. 

  4141. 		}
    4142. 

  4142. 		if (fdsr && astat & BT848_INT_FDSR) {
    4143. 

  4143. 			printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
    4144. 

  4144. 			       btv->c.nr,btread(BT848_RISC_COUNT));
    4145. 

  4145. 			if (bttv_debug)
    4146. 

  4146. 				bttv_print_riscaddr(btv);
    4147. 

  4147. 		}
    4148. 

  4148. 

  4149. 		count++;
    4150. 

  4150. 		if (count > 4) {
    4151. 

  4151. 

  4152. 			if (count > 8 || !(astat & BT848_INT_GPINT)) {
    4153. 

  4153. 				btwrite(0, BT848_INT_MASK);
    4154. 

  4154. 

  4155. 				printk(KERN_ERR
    4156. 

  4156. 					   "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
    4157. 

  4157. 			} else {
    4158. 

  4158. 				printk(KERN_ERR
    4159. 

  4159. 					   "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
    4160. 

  4160. 

  4161. 				btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
    4162. 

  4162. 						BT848_INT_MASK);
    4163. 

  4163. 			};
    4164. 

  4164. 

  4165. 			bttv_print_irqbits(stat,astat);
    4166. 

  4166. 

  4167. 			printk("]\n");
    4168. 

  4168. 		}
    4169. 

  4169. 	}
    4170. 

  4170. 	btv->irq_total++;
    4171. 

  4171. 	if (handled)
    4172. 

  4172. 		btv->irq_me++;
    4173. 

  4173. 	return IRQ_RETVAL(handled);
    4174. 

  4174. }
    4175. 

  4175. 

  4176. 

  4177. /* ----------------------------------------------------------------------- */
    4178. 

  4178. /* initialitation                                                          */
    4179. 

  4179. 

  4180. static struct video_device *vdev_init(struct bttv *btv,
    4181. 

  4181. 				      const struct video_device *template,
    4182. 

  4182. 				      const char *type_name)
    4183. 

  4183. {
    4184. 

  4184. 	struct video_device *vfd;
    4185. 

  4185. 

  4186. 	vfd = video_device_alloc();
    4187. 

  4187. 	if (NULL == vfd)
    4188. 

  4188. 		return NULL;
    4189. 

  4189. 	*vfd = *template;
    4190. 

  4190. 	vfd->v4l2_dev = &btv->c.v4l2_dev;
    4191. 

  4191. 	vfd->release = video_device_release;
    4192. 

  4192. 	vfd->debug   = bttv_debug;
    4193. 

  4193. 	video_set_drvdata(vfd, btv);
    4194. 

  4194. 	snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
    4195. 

  4195. 		 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
    4196. 

  4196. 		 type_name, bttv_tvcards[btv->c.type].name);
    4197. 

  4197. 	return vfd;
    4198. 

  4198. }
    4199. 

  4199. 

  4200. static void bttv_unregister_video(struct bttv *btv)
    4201. 

  4201. {
    4202. 

  4202. 	if (btv->video_dev) {
    4203. 

  4203. 		if (video_is_registered(btv->video_dev))
    4204. 

  4204. 			video_unregister_device(btv->video_dev);
    4205. 

  4205. 		else
    4206. 

  4206. 			video_device_release(btv->video_dev);
    4207. 

  4207. 		btv->video_dev = NULL;
    4208. 

  4208. 	}
    4209. 

  4209. 	if (btv->vbi_dev) {
    4210. 

  4210. 		if (video_is_registered(btv->vbi_dev))
    4211. 

  4211. 			video_unregister_device(btv->vbi_dev);
    4212. 

  4212. 		else
    4213. 

  4213. 			video_device_release(btv->vbi_dev);
    4214. 

  4214. 		btv->vbi_dev = NULL;
    4215. 

  4215. 	}
    4216. 

  4216. 	if (btv->radio_dev) {
    4217. 

  4217. 		if (video_is_registered(btv->radio_dev))
    4218. 

  4218. 			video_unregister_device(btv->radio_dev);
    4219. 

  4219. 		else
    4220. 

  4220. 			video_device_release(btv->radio_dev);
    4221. 

  4221. 		btv->radio_dev = NULL;
    4222. 

  4222. 	}
    4223. 

  4223. }
    4224. 

  4224. 

  4225. /* register video4linux devices */
    4226. 

  4226. static int __devinit bttv_register_video(struct bttv *btv)
    4227. 

  4227. {
    4228. 

  4228. 	if (no_overlay > 0)
    4229. 

  4229. 		printk("bttv: Overlay support disabled.\n");
    4230. 

  4230. 

  4231. 	/* video */
    4232. 

  4232. 	btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
    4233. 

  4233. 

  4234. 	if (NULL == btv->video_dev)
    4235. 

  4235. 		goto err;
    4236. 

  4236. 	if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
    4237. 

  4237. 				  video_nr[btv->c.nr]) < 0)
    4238. 

  4238. 		goto err;
    4239. 

  4239. 	printk(KERN_INFO "bttv%d: registered device %s\n",
    4240. 

  4240. 	       btv->c.nr, video_device_node_name(btv->video_dev));
    4241. 

  4241. 	if (device_create_file(&btv->video_dev->dev,
    4242. 

  4242. 				     &dev_attr_card)<0) {
    4243. 

  4243. 		printk(KERN_ERR "bttv%d: device_create_file 'card' "
    4244. 

  4244. 		       "failed\n", btv->c.nr);
    4245. 

  4245. 		goto err;
    4246. 

  4246. 	}
    4247. 

  4247. 

  4248. 	/* vbi */
    4249. 

  4249. 	btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
    4250. 

  4250. 

  4251. 	if (NULL == btv->vbi_dev)
    4252. 

  4252. 		goto err;
    4253. 

  4253. 	if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
    4254. 

  4254. 				  vbi_nr[btv->c.nr]) < 0)
    4255. 

  4255. 		goto err;
    4256. 

  4256. 	printk(KERN_INFO "bttv%d: registered device %s\n",
    4257. 

  4257. 	       btv->c.nr, video_device_node_name(btv->vbi_dev));
    4258. 

  4258. 

  4259. 	if (!btv->has_radio)
    4260. 

  4260. 		return 0;
    4261. 

  4261. 	/* radio */
    4262. 

  4262. 	btv->radio_dev = vdev_init(btv, &radio_template, "radio");
    4263. 

  4263. 	if (NULL == btv->radio_dev)
    4264. 

  4264. 		goto err;
    4265. 

  4265. 	if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
    4266. 

  4266. 				  radio_nr[btv->c.nr]) < 0)
    4267. 

  4267. 		goto err;
    4268. 

  4268. 	printk(KERN_INFO "bttv%d: registered device %s\n",
    4269. 

  4269. 	       btv->c.nr, video_device_node_name(btv->radio_dev));
    4270. 

  4270. 

  4271. 	/* all done */
    4272. 

  4272. 	return 0;
    4273. 

  4273. 

  4274.  err:
    4275. 

  4275. 	bttv_unregister_video(btv);
    4276. 

  4276. 	return -1;
    4277. 

  4277. }
    4278. 

  4278. 

  4279. 

  4280. /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
    4281. 

  4281. /* response on cards with no firmware is not enabled by OF */
    4282. 

  4282. static void pci_set_command(struct pci_dev *dev)
    4283. 

  4283. {
    4284. 

  4284. #if defined(__powerpc__)
    4285. 

  4285. 	unsigned int cmd;
    4286. 

  4286. 

  4287. 	pci_read_config_dword(dev, PCI_COMMAND, &cmd);
    4288. 

  4288. 	cmd = (cmd | PCI_COMMAND_MEMORY );
    4289. 

  4289. 	pci_write_config_dword(dev, PCI_COMMAND, cmd);
    4290. 

  4290. #endif
    4291. 

  4291. }
    4292. 

  4292. 

  4293. static int __devinit bttv_probe(struct pci_dev *dev,
    4294. 

  4294. 				const struct pci_device_id *pci_id)
    4295. 

  4295. {
    4296. 

  4296. 	int result;
    4297. 

  4297. 	unsigned char lat;
    4298. 

  4298. 	struct bttv *btv;
    4299. 

  4299. 

  4300. 	if (bttv_num == BTTV_MAX)
    4301. 

  4301. 		return -ENOMEM;
    4302. 

  4302. 	printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
    4303. 

  4303. 	bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
    4304. 

  4304. 	if (btv == NULL) {
    4305. 

  4305. 		printk(KERN_ERR "bttv: out of memory.\n");
    4306. 

  4306. 		return -ENOMEM;
    4307. 

  4307. 	}
    4308. 

  4308. 	btv->c.nr  = bttv_num;
    4309. 

  4309. 	snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
    4310. 

  4310. 			"bttv%d", btv->c.nr);
    4311. 

  4311. 

  4312. 	/* initialize structs / fill in defaults */
    4313. 

  4313. 	mutex_init(&btv->lock);
    4314. 

  4314. 	spin_lock_init(&btv->s_lock);
    4315. 

  4315. 	spin_lock_init(&btv->gpio_lock);
    4316. 

  4316. 	init_waitqueue_head(&btv->gpioq);
    4317. 

  4317. 	init_waitqueue_head(&btv->i2c_queue);
    4318. 

  4318. 	INIT_LIST_HEAD(&btv->c.subs);
    4319. 

  4319. 	INIT_LIST_HEAD(&btv->capture);
    4320. 

  4320. 	INIT_LIST_HEAD(&btv->vcapture);
    4321. 

  4321. 	v4l2_prio_init(&btv->prio);
    4322. 

  4322. 

  4323. 	init_timer(&btv->timeout);
    4324. 

  4324. 	btv->timeout.function = bttv_irq_timeout;
    4325. 

  4325. 	btv->timeout.data     = (unsigned long)btv;
    4326. 

  4326. 

  4327. 	btv->i2c_rc = -1;
    4328. 

  4328. 	btv->tuner_type  = UNSET;
    4329. 

  4329. 	btv->new_input   = UNSET;
    4330. 

  4330. 	btv->has_radio=radio[btv->c.nr];
    4331. 

  4331. 

  4332. 	/* pci stuff (init, get irq/mmio, ... */
    4333. 

  4333. 	btv->c.pci = dev;
    4334. 

  4334. 	btv->id  = dev->device;
    4335. 

  4335. 	if (pci_enable_device(dev)) {
    4336. 

  4336. 		printk(KERN_WARNING "bttv%d: Can't enable device.\n",
    4337. 

  4337. 		       btv->c.nr);
    4338. 

  4338. 		return -EIO;
    4339. 

  4339. 	}
    4340. 

  4340. 	if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
    4341. 

  4341. 		printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
    4342. 

  4342. 		       btv->c.nr);
    4343. 

  4343. 		return -EIO;
    4344. 

  4344. 	}
    4345. 

  4345. 	if (!request_mem_region(pci_resource_start(dev,0),
    4346. 

  4346. 				pci_resource_len(dev,0),
    4347. 

  4347. 				btv->c.v4l2_dev.name)) {
    4348. 

  4348. 		printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
    4349. 

  4349. 		       btv->c.nr,
    4350. 

  4350. 		       (unsigned long long)pci_resource_start(dev,0));
    4351. 

  4351. 		return -EBUSY;
    4352. 

  4352. 	}
    4353. 

  4353. 	pci_set_master(dev);
    4354. 

  4354. 	pci_set_command(dev);
    4355. 

  4355. 

  4356. 	result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
    4357. 

  4357. 	if (result < 0) {
    4358. 

  4358. 		printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
    4359. 

  4359. 		goto fail0;
    4360. 

  4360. 	}
    4361. 

  4361. 

  4362. 	pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
    4363. 

  4363. 	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
    4364. 

  4364. 	printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
    4365. 

  4365. 	       bttv_num,btv->id, btv->revision, pci_name(dev));
    4366. 

  4366. 	printk("irq: %d, latency: %d, mmio: 0x%llx\n",
    4367. 

  4367. 	       btv->c.pci->irq, lat,
    4368. 

  4368. 	       (unsigned long long)pci_resource_start(dev,0));
    4369. 

  4369. 	schedule();
    4370. 

  4370. 

  4371. 	btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
    4372. 

  4372. 	if (NULL == btv->bt848_mmio) {
    4373. 

  4373. 		printk("bttv%d: ioremap() failed\n", btv->c.nr);
    4374. 

  4374. 		result = -EIO;
    4375. 

  4375. 		goto fail1;
    4376. 

  4376. 	}
    4377. 

  4377. 

  4378. 	/* identify card */
    4379. 

  4379. 	bttv_idcard(btv);
    4380. 

  4380. 

  4381. 	/* disable irqs, register irq handler */
    4382. 

  4382. 	btwrite(0, BT848_INT_MASK);
    4383. 

  4383. 	result = request_irq(btv->c.pci->irq, bttv_irq,
    4384. 

  4384. 	    IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
    4385. 

  4385. 	if (result < 0) {
    4386. 

  4386. 		printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
    4387. 

  4387. 		       bttv_num,btv->c.pci->irq);
    4388. 

  4388. 		goto fail1;
    4389. 

  4389. 	}
    4390. 

  4390. 

  4391. 	if (0 != bttv_handle_chipset(btv)) {
    4392. 

  4392. 		result = -EIO;
    4393. 

  4393. 		goto fail2;
    4394. 

  4394. 	}
    4395. 

  4395. 

  4396. 	/* init options from insmod args */
    4397. 

  4397. 	btv->opt_combfilter = combfilter;
    4398. 

  4398. 	btv->opt_lumafilter = lumafilter;
    4399. 

  4399. 	btv->opt_automute   = automute;
    4400. 

  4400. 	btv->opt_chroma_agc = chroma_agc;
    4401. 

  4401. 	btv->opt_adc_crush  = adc_crush;
    4402. 

  4402. 	btv->opt_vcr_hack   = vcr_hack;
    4403. 

  4403. 	btv->opt_whitecrush_upper  = whitecrush_upper;
    4404. 

  4404. 	btv->opt_whitecrush_lower  = whitecrush_lower;
    4405. 

  4405. 	btv->opt_uv_ratio   = uv_ratio;
    4406. 

  4406. 	btv->opt_full_luma_range   = full_luma_range;
    4407. 

  4407. 	btv->opt_coring     = coring;
    4408. 

  4408. 

  4409. 	/* fill struct bttv with some useful defaults */
    4410. 

  4410. 	btv->init.btv         = btv;
    4411. 

  4411. 	btv->init.ov.w.width  = 320;
    4412. 

  4412. 	btv->init.ov.w.height = 240;
    4413. 

  4413. 	btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
    4414. 

  4414. 	btv->init.width       = 320;
    4415. 

  4415. 	btv->init.height      = 240;
    4416. 

  4416. 	btv->input = 0;
    4417. 

  4417. 

  4418. 	/* initialize hardware */
    4419. 

  4419. 	if (bttv_gpio)
    4420. 

  4420. 		bttv_gpio_tracking(btv,"pre-init");
    4421. 

  4421. 

  4422. 	bttv_risc_init_main(btv);
    4423. 

  4423. 	init_bt848(btv);
    4424. 

  4424. 

  4425. 	/* gpio */
    4426. 

  4426. 	btwrite(0x00, BT848_GPIO_REG_INP);
    4427. 

  4427. 	btwrite(0x00, BT848_GPIO_OUT_EN);
    4428. 

  4428. 	if (bttv_verbose)
    4429. 

  4429. 		bttv_gpio_tracking(btv,"init");
    4430. 

  4430. 

  4431. 	/* needs to be done before i2c is registered */
    4432. 

  4432. 	bttv_init_card1(btv);
    4433. 

  4433. 

  4434. 	/* register i2c + gpio */
    4435. 

  4435. 	init_bttv_i2c(btv);
    4436. 

  4436. 

  4437. 	/* some card-specific stuff (needs working i2c) */
    4438. 

  4438. 	bttv_init_card2(btv);
    4439. 

  4439. 	bttv_init_tuner(btv);
    4440. 

  4440. 	init_irqreg(btv);
    4441. 

  4441. 

  4442. 	/* register video4linux + input */
    4443. 

  4443. 	if (!bttv_tvcards[btv->c.type].no_video) {
    4444. 

  4444. 		bttv_register_video(btv);
    4445. 

  4445. 		bt848_bright(btv,32768);
    4446. 

  4446. 		bt848_contrast(btv,32768);
    4447. 

  4447. 		bt848_hue(btv,32768);
    4448. 

  4448. 		bt848_sat(btv,32768);
    4449. 

  4449. 		audio_mute(btv, 1);
    4450. 

  4450. 		set_input(btv, 0, btv->tvnorm);
    4451. 

  4451. 		bttv_crop_reset(&btv->crop[0], btv->tvnorm);
    4452. 

  4452. 		btv->crop[1] = btv->crop[0]; /* current = default */
    4453. 

  4453. 		disclaim_vbi_lines(btv);
    4454. 

  4454. 		disclaim_video_lines(btv);
    4455. 

  4455. 	}
    4456. 

  4456. 

  4457. 	/* add subdevices and autoload dvb-bt8xx if needed */
    4458. 

  4458. 	if (bttv_tvcards[btv->c.type].has_dvb) {
    4459. 

  4459. 		bttv_sub_add_device(&btv->c, "dvb");
    4460. 

  4460. 		request_modules(btv);
    4461. 

  4461. 	}
    4462. 

  4462. 

  4463. 	if (!disable_ir) {
    4464. 

  4464. 		init_bttv_i2c_ir(btv);
    4465. 

  4465. 		bttv_input_init(btv);
    4466. 

  4466. 	}
    4467. 

  4467. 

  4468. 	/* everything is fine */
    4469. 

  4469. 	bttv_num++;
    4470. 

  4470. 	return 0;
    4471. 

  4471. 

  4472. fail2:
    4473. 

  4473. 	free_irq(btv->c.pci->irq,btv);
    4474. 

  4474. 

  4475. fail1:
    4476. 

  4476. 	v4l2_device_unregister(&btv->c.v4l2_dev);
    4477. 

  4477. 

  4478. fail0:
    4479. 

  4479. 	if (btv->bt848_mmio)
    4480. 

  4480. 		iounmap(btv->bt848_mmio);
    4481. 

  4481. 	release_mem_region(pci_resource_start(btv->c.pci,0),
    4482. 

  4482. 			   pci_resource_len(btv->c.pci,0));
    4483. 

  4483. 	return result;
    4484. 

  4484. }
    4485. 

  4485. 

  4486. static void __devexit bttv_remove(struct pci_dev *pci_dev)
    4487. 

  4487. {
    4488. 

  4488. 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
    4489. 

  4489. 	struct bttv *btv = to_bttv(v4l2_dev);
    4490. 

  4490. 

  4491. 	if (bttv_verbose)
    4492. 

  4492. 		printk("bttv%d: unloading\n",btv->c.nr);
    4493. 

  4493. 

  4494. 	/* shutdown everything (DMA+IRQs) */
    4495. 

  4495. 	btand(~15, BT848_GPIO_DMA_CTL);
    4496. 

  4496. 	btwrite(0, BT848_INT_MASK);
    4497. 

  4497. 	btwrite(~0x0, BT848_INT_STAT);
    4498. 

  4498. 	btwrite(0x0, BT848_GPIO_OUT_EN);
    4499. 

  4499. 	if (bttv_gpio)
    4500. 

  4500. 		bttv_gpio_tracking(btv,"cleanup");
    4501. 

  4501. 

  4502. 	/* tell gpio modules we are leaving ... */
    4503. 

  4503. 	btv->shutdown=1;
    4504. 

  4504. 	wake_up(&btv->gpioq);
    4505. 

  4505. 	bttv_input_fini(btv);
    4506. 

  4506. 	bttv_sub_del_devices(&btv->c);
    4507. 

  4507. 

  4508. 	/* unregister i2c_bus + input */
    4509. 

  4509. 	fini_bttv_i2c(btv);
    4510. 

  4510. 

  4511. 	/* unregister video4linux */
    4512. 

  4512. 	bttv_unregister_video(btv);
    4513. 

  4513. 

  4514. 	/* free allocated memory */
    4515. 

  4515. 	btcx_riscmem_free(btv->c.pci,&btv->main);
    4516. 

  4516. 

  4517. 	/* free ressources */
    4518. 

  4518. 	free_irq(btv->c.pci->irq,btv);
    4519. 

  4519. 	iounmap(btv->bt848_mmio);
    4520. 

  4520. 	release_mem_region(pci_resource_start(btv->c.pci,0),
    4521. 

  4521. 			   pci_resource_len(btv->c.pci,0));
    4522. 

  4522. 

  4523. 	v4l2_device_unregister(&btv->c.v4l2_dev);
    4524. 

  4524. 	bttvs[btv->c.nr] = NULL;
    4525. 

  4525. 	kfree(btv);
    4526. 

  4526. 

  4527. 	return;
    4528. 

  4528. }
    4529. 

  4529. 

  4530. #ifdef CONFIG_PM
    4531. 

  4531. static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
    4532. 

  4532. {
    4533. 

  4533. 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
    4534. 

  4534. 	struct bttv *btv = to_bttv(v4l2_dev);
    4535. 

  4535. 	struct bttv_buffer_set idle;
    4536. 

  4536. 	unsigned long flags;
    4537. 

  4537. 

  4538. 	dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
    4539. 

  4539. 

  4540. 	/* stop dma + irqs */
    4541. 

  4541. 	spin_lock_irqsave(&btv->s_lock,flags);
    4542. 

  4542. 	memset(&idle, 0, sizeof(idle));
    4543. 

  4543. 	btv->state.video = btv->curr;
    4544. 

  4544. 	btv->state.vbi   = btv->cvbi;
    4545. 

  4545. 	btv->state.loop_irq = btv->loop_irq;
    4546. 

  4546. 	btv->curr = idle;
    4547. 

  4547. 	btv->loop_irq = 0;
    4548. 

  4548. 	bttv_buffer_activate_video(btv, &idle);
    4549. 

  4549. 	bttv_buffer_activate_vbi(btv, NULL);
    4550. 

  4550. 	bttv_set_dma(btv, 0);
    4551. 

  4551. 	btwrite(0, BT848_INT_MASK);
    4552. 

  4552. 	spin_unlock_irqrestore(&btv->s_lock,flags);
    4553. 

  4553. 

  4554. 	/* save bt878 state */
    4555. 

  4555. 	btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
    4556. 

  4556. 	btv->state.gpio_data   = gpio_read();
    4557. 

  4557. 

  4558. 	/* save pci state */
    4559. 

  4559. 	pci_save_state(pci_dev);
    4560. 

  4560. 	if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
    4561. 

  4561. 		pci_disable_device(pci_dev);
    4562. 

  4562. 		btv->state.disabled = 1;
    4563. 

  4563. 	}
    4564. 

  4564. 	return 0;
    4565. 

  4565. }
    4566. 

  4566. 

  4567. static int bttv_resume(struct pci_dev *pci_dev)
    4568. 

  4568. {
    4569. 

  4569. 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
    4570. 

  4570. 	struct bttv *btv = to_bttv(v4l2_dev);
    4571. 

  4571. 	unsigned long flags;
    4572. 

  4572. 	int err;
    4573. 

  4573. 

  4574. 	dprintk("bttv%d: resume\n", btv->c.nr);
    4575. 

  4575. 

  4576. 	/* restore pci state */
    4577. 

  4577. 	if (btv->state.disabled) {
    4578. 

  4578. 		err=pci_enable_device(pci_dev);
    4579. 

  4579. 		if (err) {
    4580. 

  4580. 			printk(KERN_WARNING "bttv%d: Can't enable device.\n",
    4581. 

  4581. 								btv->c.nr);
    4582. 

  4582. 			return err;
    4583. 

  4583. 		}
    4584. 

  4584. 		btv->state.disabled = 0;
    4585. 

  4585. 	}
    4586. 

  4586. 	err=pci_set_power_state(pci_dev, PCI_D0);
    4587. 

  4587. 	if (err) {
    4588. 

  4588. 		pci_disable_device(pci_dev);
    4589. 

  4589. 		printk(KERN_WARNING "bttv%d: Can't enable device.\n",
    4590. 

  4590. 							btv->c.nr);
    4591. 

  4591. 		btv->state.disabled = 1;
    4592. 

  4592. 		return err;
    4593. 

  4593. 	}
    4594. 

  4594. 

  4595. 	pci_restore_state(pci_dev);
    4596. 

  4596. 

  4597. 	/* restore bt878 state */
    4598. 

  4598. 	bttv_reinit_bt848(btv);
    4599. 

  4599. 	gpio_inout(0xffffff, btv->state.gpio_enable);
    4600. 

  4600. 	gpio_write(btv->state.gpio_data);
    4601. 

  4601. 

  4602. 	/* restart dma */
    4603. 

  4603. 	spin_lock_irqsave(&btv->s_lock,flags);
    4604. 

  4604. 	btv->curr = btv->state.video;
    4605. 

  4605. 	btv->cvbi = btv->state.vbi;
    4606. 

  4606. 	btv->loop_irq = btv->state.loop_irq;
    4607. 

  4607. 	bttv_buffer_activate_video(btv, &btv->curr);
    4608. 

  4608. 	bttv_buffer_activate_vbi(btv, btv->cvbi);
    4609. 

  4609. 	bttv_set_dma(btv, 0);
    4610. 

  4610. 	spin_unlock_irqrestore(&btv->s_lock,flags);
    4611. 

  4611. 	return 0;
    4612. 

  4612. }
    4613. 

  4613. #endif
    4614. 

  4614. 

  4615. static struct pci_device_id bttv_pci_tbl[] = {
    4616. 

  4616. 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
    4617. 

  4617. 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
    4618. 

  4618. 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
    4619. 

  4619. 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
    4620. 

  4620. 	{0,}
    4621. 

  4621. };
    4622. 

  4622. 

  4623. MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
    4624. 

  4624. 

  4625. static struct pci_driver bttv_pci_driver = {
    4626. 

  4626. 	.name     = "bttv",
    4627. 

  4627. 	.id_table = bttv_pci_tbl,
    4628. 

  4628. 	.probe    = bttv_probe,
    4629. 

  4629. 	.remove   = __devexit_p(bttv_remove),
    4630. 

  4630. #ifdef CONFIG_PM
    4631. 

  4631. 	.suspend  = bttv_suspend,
    4632. 

  4632. 	.resume   = bttv_resume,
    4633. 

  4633. #endif
    4634. 

  4634. };
    4635. 

  4635. 

  4636. static int __init bttv_init_module(void)
    4637. 

  4637. {
    4638. 

  4638. 	int ret;
    4639. 

  4639. 

  4640. 	bttv_num = 0;
    4641. 

  4641. 

  4642. 	printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
    4643. 

  4643. 	       (BTTV_VERSION_CODE >> 16) & 0xff,
    4644. 

  4644. 	       (BTTV_VERSION_CODE >> 8) & 0xff,
    4645. 

  4645. 	       BTTV_VERSION_CODE & 0xff);
    4646. 

  4646. #ifdef SNAPSHOT
    4647. 

  4647. 	printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
    4648. 

  4648. 	       SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
    4649. 

  4649. #endif
    4650. 

  4650. 	if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
    4651. 

  4651. 		gbuffers = 2;
    4652. 

  4652. 	if (gbufsize > BTTV_MAX_FBUF)
    4653. 

  4653. 		gbufsize = BTTV_MAX_FBUF;
    4654. 

  4654. 	gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
    4655. 

  4655. 	if (bttv_verbose)
    4656. 

  4656. 		printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
    4657. 

  4657. 		       gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
    4658. 

  4658. 

  4659. 	bttv_check_chipset();
    4660. 

  4660. 

  4661. 	ret = bus_register(&bttv_sub_bus_type);
    4662. 

  4662. 	if (ret < 0) {
    4663. 

  4663. 		printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
    4664. 

  4664. 		return ret;
    4665. 

  4665. 	}
    4666. 

  4666. 	ret = pci_register_driver(&bttv_pci_driver);
    4667. 

  4667. 	if (ret < 0)
    4668. 

  4668. 		bus_unregister(&bttv_sub_bus_type);
    4669. 

  4669. 

  4670. 	return ret;
    4671. 

  4671. }
    4672. 

  4672. 

  4673. static void __exit bttv_cleanup_module(void)
    4674. 

  4674. {
    4675. 

  4675. 	pci_unregister_driver(&bttv_pci_driver);
    4676. 

  4676. 	bus_unregister(&bttv_sub_bus_type);
    4677. 

  4677. }
    4678. 

  4678. 

  4679. module_init(bttv_init_module);
    4680. 

  4680. module_exit(bttv_cleanup_module);
    4681. 

  4681. 

  4682. /*
    4683. 

  4683.  * Local variables:
    4684. 

  4684.  * c-basic-offset: 8
    4685. 

  4685.  * End:
    4686. 

  4686.  */
    4687. 

  4687.