1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Zoran zr36057/zr36067 PCI controller driver, for the |
4 | * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux |
5 | * Media Labs LML33/LML33R10. |
6 | * |
7 | * This part handles card-specific data and detection |
8 | * |
9 | * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx> |
10 | */ |
11 | |
12 | #include <linux/delay.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/module.h> |
15 | #include <linux/slab.h> |
16 | |
17 | #include <linux/i2c.h> |
18 | #include <linux/i2c-algo-bit.h> |
19 | #include <linux/videodev2.h> |
20 | #include <linux/spinlock.h> |
21 | |
22 | #include <linux/pci.h> |
23 | #include <linux/interrupt.h> |
24 | #include <linux/io.h> |
25 | #include <media/v4l2-common.h> |
26 | #include <media/i2c/bt819.h> |
27 | |
28 | #include "videocodec.h" |
29 | #include "zoran.h" |
30 | #include "zoran_card.h" |
31 | #include "zoran_device.h" |
32 | #include "zr36016.h" |
33 | #include "zr36050.h" |
34 | #include "zr36060.h" |
35 | |
36 | extern const struct zoran_format zoran_formats[]; |
37 | |
38 | static int card[BUZ_MAX] = { [0 ... (BUZ_MAX - 1)] = -1 }; |
39 | module_param_array(card, int, NULL, 0444); |
40 | MODULE_PARM_DESC(card, "Card type" ); |
41 | |
42 | /* Default input and video norm at startup of the driver. */ |
43 | |
44 | static unsigned int default_input; /* default 0 = Composite, 1 = S-Video */ |
45 | module_param(default_input, uint, 0444); |
46 | MODULE_PARM_DESC(default_input, |
47 | "Default input (0=Composite, 1=S-Video, 2=Internal)" ); |
48 | |
49 | static int default_mux = 1; /* 6 Eyes input selection */ |
50 | module_param(default_mux, int, 0644); |
51 | MODULE_PARM_DESC(default_mux, |
52 | "Default 6 Eyes mux setting (Input selection)" ); |
53 | |
54 | static int default_norm; /* default 0 = PAL, 1 = NTSC 2 = SECAM */ |
55 | module_param(default_norm, int, 0444); |
56 | MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)" ); |
57 | |
58 | /* /dev/videoN, -1 for autodetect */ |
59 | static int video_nr[BUZ_MAX] = { [0 ... (BUZ_MAX - 1)] = -1 }; |
60 | module_param_array(video_nr, int, NULL, 0444); |
61 | MODULE_PARM_DESC(video_nr, "Video device number (-1=Auto)" ); |
62 | |
63 | /* 1=Pass through TV signal when device is not used */ |
64 | /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */ |
65 | int pass_through; |
66 | module_param(pass_through, int, 0644); |
67 | MODULE_PARM_DESC(pass_through, |
68 | "Pass TV signal through to TV-out when idling" ); |
69 | |
70 | int zr36067_debug = 1; |
71 | module_param_named(debug, zr36067_debug, int, 0644); |
72 | MODULE_PARM_DESC(debug, "Debug level (0-5)" ); |
73 | |
74 | #define ZORAN_VERSION "0.10.1" |
75 | |
76 | MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver" ); |
77 | MODULE_AUTHOR("Serguei Miridonov" ); |
78 | MODULE_LICENSE("GPL" ); |
79 | MODULE_VERSION(ZORAN_VERSION); |
80 | |
81 | #define ZR_DEVICE(subven, subdev, data) { \ |
82 | .vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \ |
83 | .subvendor = (subven), .subdevice = (subdev), .driver_data = (data) } |
84 | |
85 | static const struct pci_device_id zr36067_pci_tbl[] = { |
86 | ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC10PLUS, DC10_PLUS), |
87 | ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC30PLUS, DC30_PLUS), |
88 | ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH, PCI_DEVICE_ID_LML_33R10, LML33R10), |
89 | ZR_DEVICE(PCI_VENDOR_ID_IOMEGA, PCI_DEVICE_ID_IOMEGA_BUZ, BUZ), |
90 | ZR_DEVICE(PCI_ANY_ID, PCI_ANY_ID, NUM_CARDS), |
91 | {0} |
92 | }; |
93 | MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl); |
94 | |
95 | static unsigned int zoran_num; /* number of cards found */ |
96 | |
97 | /* videocodec bus functions ZR36060 */ |
98 | static u32 zr36060_read(struct videocodec *codec, u16 reg) |
99 | { |
100 | struct zoran *zr = (struct zoran *)codec->master_data->data; |
101 | __u32 data; |
102 | |
103 | if (post_office_wait(zr) || post_office_write(zr, guest: 0, reg: 1, value: reg >> 8) || |
104 | post_office_write(zr, guest: 0, reg: 2, value: reg & 0xff)) |
105 | return -1; |
106 | |
107 | data = post_office_read(zr, guest: 0, reg: 3) & 0xff; |
108 | return data; |
109 | } |
110 | |
111 | static void zr36060_write(struct videocodec *codec, u16 reg, u32 val) |
112 | { |
113 | struct zoran *zr = (struct zoran *)codec->master_data->data; |
114 | |
115 | if (post_office_wait(zr) || post_office_write(zr, guest: 0, reg: 1, value: reg >> 8) || |
116 | post_office_write(zr, guest: 0, reg: 2, value: reg & 0xff)) |
117 | return; |
118 | |
119 | post_office_write(zr, guest: 0, reg: 3, value: val & 0xff); |
120 | } |
121 | |
122 | /* videocodec bus functions ZR36050 */ |
123 | static u32 zr36050_read(struct videocodec *codec, u16 reg) |
124 | { |
125 | struct zoran *zr = (struct zoran *)codec->master_data->data; |
126 | __u32 data; |
127 | |
128 | if (post_office_wait(zr) || post_office_write(zr, guest: 1, reg: 0, value: reg >> 2)) // reg. HIGHBYTES |
129 | return -1; |
130 | |
131 | data = post_office_read(zr, guest: 0, reg: reg & 0x03) & 0xff; // reg. LOWBYTES + read |
132 | return data; |
133 | } |
134 | |
135 | static void zr36050_write(struct videocodec *codec, u16 reg, u32 val) |
136 | { |
137 | struct zoran *zr = (struct zoran *)codec->master_data->data; |
138 | |
139 | if (post_office_wait(zr) || post_office_write(zr, guest: 1, reg: 0, value: reg >> 2)) // reg. HIGHBYTES |
140 | return; |
141 | |
142 | post_office_write(zr, guest: 0, reg: reg & 0x03, value: val & 0xff); // reg. LOWBYTES + wr. data |
143 | } |
144 | |
145 | /* videocodec bus functions ZR36016 */ |
146 | static u32 zr36016_read(struct videocodec *codec, u16 reg) |
147 | { |
148 | struct zoran *zr = (struct zoran *)codec->master_data->data; |
149 | __u32 data; |
150 | |
151 | if (post_office_wait(zr)) |
152 | return -1; |
153 | |
154 | data = post_office_read(zr, guest: 2, reg: reg & 0x03) & 0xff; // read |
155 | return data; |
156 | } |
157 | |
158 | /* hack for in zoran_device.c */ |
159 | void zr36016_write(struct videocodec *codec, u16 reg, u32 val) |
160 | { |
161 | struct zoran *zr = (struct zoran *)codec->master_data->data; |
162 | |
163 | if (post_office_wait(zr)) |
164 | return; |
165 | |
166 | post_office_write(zr, guest: 2, reg: reg & 0x03, value: val & 0x0ff); // wr. data |
167 | } |
168 | |
169 | /* |
170 | * Board specific information |
171 | */ |
172 | |
173 | static void dc10_init(struct zoran *zr) |
174 | { |
175 | /* Pixel clock selection */ |
176 | GPIO(zr, bit: 4, value: 0); |
177 | GPIO(zr, bit: 5, value: 1); |
178 | /* Enable the video bus sync signals */ |
179 | GPIO(zr, bit: 7, value: 0); |
180 | } |
181 | |
182 | static void dc10plus_init(struct zoran *zr) |
183 | { |
184 | } |
185 | |
186 | static void buz_init(struct zoran *zr) |
187 | { |
188 | /* some stuff from Iomega */ |
189 | pci_write_config_dword(dev: zr->pci_dev, where: 0xfc, val: 0x90680f15); |
190 | pci_write_config_dword(dev: zr->pci_dev, where: 0x0c, val: 0x00012020); |
191 | pci_write_config_dword(dev: zr->pci_dev, where: 0xe8, val: 0xc0200000); |
192 | } |
193 | |
194 | static void lml33_init(struct zoran *zr) |
195 | { |
196 | GPIO(zr, bit: 2, value: 1); // Set Composite input/output |
197 | } |
198 | |
199 | static void avs6eyes_init(struct zoran *zr) |
200 | { |
201 | // AverMedia 6-Eyes original driver by Christer Weinigel |
202 | |
203 | // Lifted straight from Christer's old driver and |
204 | // modified slightly by Martin Samuelsson. |
205 | |
206 | int mux = default_mux; /* 1 = BT866, 7 = VID1 */ |
207 | |
208 | GPIO(zr, bit: 4, value: 1); /* Bt866 SLEEP on */ |
209 | udelay(2); |
210 | |
211 | GPIO(zr, bit: 0, value: 1); /* ZR36060 /RESET on */ |
212 | GPIO(zr, bit: 1, value: 0); /* ZR36060 /SLEEP on */ |
213 | GPIO(zr, bit: 2, value: mux & 1); /* MUX S0 */ |
214 | GPIO(zr, bit: 3, value: 0); /* /FRAME on */ |
215 | GPIO(zr, bit: 4, value: 0); /* Bt866 SLEEP off */ |
216 | GPIO(zr, bit: 5, value: mux & 2); /* MUX S1 */ |
217 | GPIO(zr, bit: 6, value: 0); /* ? */ |
218 | GPIO(zr, bit: 7, value: mux & 4); /* MUX S2 */ |
219 | } |
220 | |
221 | static const char *codecid_to_modulename(u16 codecid) |
222 | { |
223 | const char *name = NULL; |
224 | |
225 | switch (codecid) { |
226 | case CODEC_TYPE_ZR36060: |
227 | name = "zr36060" ; |
228 | break; |
229 | case CODEC_TYPE_ZR36050: |
230 | name = "zr36050" ; |
231 | break; |
232 | case CODEC_TYPE_ZR36016: |
233 | name = "zr36016" ; |
234 | break; |
235 | } |
236 | |
237 | return name; |
238 | } |
239 | |
240 | static int codec_init(struct zoran *zr, u16 codecid) |
241 | { |
242 | switch (codecid) { |
243 | case CODEC_TYPE_ZR36060: |
244 | #ifdef CONFIG_VIDEO_ZORAN_ZR36060 |
245 | return zr36060_init_module(); |
246 | #else |
247 | pci_err(zr->pci_dev, "ZR36060 support is not enabled\n" ); |
248 | return -EINVAL; |
249 | #endif |
250 | break; |
251 | case CODEC_TYPE_ZR36050: |
252 | #ifdef CONFIG_VIDEO_ZORAN_DC30 |
253 | return zr36050_init_module(); |
254 | #else |
255 | pci_err(zr->pci_dev, "ZR36050 support is not enabled\n" ); |
256 | return -EINVAL; |
257 | #endif |
258 | break; |
259 | case CODEC_TYPE_ZR36016: |
260 | #ifdef CONFIG_VIDEO_ZORAN_DC30 |
261 | return zr36016_init_module(); |
262 | #else |
263 | pci_err(zr->pci_dev, "ZR36016 support is not enabled\n" ); |
264 | return -EINVAL; |
265 | #endif |
266 | break; |
267 | } |
268 | |
269 | pci_err(zr->pci_dev, "unknown codec id %x\n" , codecid); |
270 | return -EINVAL; |
271 | } |
272 | |
273 | static void codec_exit(struct zoran *zr, u16 codecid) |
274 | { |
275 | switch (codecid) { |
276 | case CODEC_TYPE_ZR36060: |
277 | #ifdef CONFIG_VIDEO_ZORAN_ZR36060 |
278 | zr36060_cleanup_module(); |
279 | #endif |
280 | break; |
281 | case CODEC_TYPE_ZR36050: |
282 | #ifdef CONFIG_VIDEO_ZORAN_DC30 |
283 | zr36050_cleanup_module(); |
284 | #endif |
285 | break; |
286 | case CODEC_TYPE_ZR36016: |
287 | #ifdef CONFIG_VIDEO_ZORAN_DC30 |
288 | zr36016_cleanup_module(); |
289 | #endif |
290 | break; |
291 | } |
292 | } |
293 | |
294 | static int videocodec_init(struct zoran *zr) |
295 | { |
296 | const char *codec_name, *vfe_name; |
297 | int result; |
298 | |
299 | codec_name = codecid_to_modulename(codecid: zr->card.video_codec); |
300 | if (codec_name) { |
301 | result = codec_init(zr, codecid: zr->card.video_codec); |
302 | if (result < 0) { |
303 | pci_err(zr->pci_dev, "failed to load video codec %s: %d\n" , |
304 | codec_name, result); |
305 | return result; |
306 | } |
307 | } |
308 | vfe_name = codecid_to_modulename(codecid: zr->card.video_vfe); |
309 | if (vfe_name) { |
310 | result = codec_init(zr, codecid: zr->card.video_vfe); |
311 | if (result < 0) { |
312 | pci_err(zr->pci_dev, "failed to load video vfe %s: %d\n" , |
313 | vfe_name, result); |
314 | if (codec_name) |
315 | codec_exit(zr, codecid: zr->card.video_codec); |
316 | return result; |
317 | } |
318 | } |
319 | return 0; |
320 | } |
321 | |
322 | static void videocodec_exit(struct zoran *zr) |
323 | { |
324 | if (zr->card.video_codec != CODEC_TYPE_NONE) |
325 | codec_exit(zr, codecid: zr->card.video_codec); |
326 | if (zr->card.video_vfe != CODEC_TYPE_NONE) |
327 | codec_exit(zr, codecid: zr->card.video_vfe); |
328 | } |
329 | |
330 | static const struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 }; |
331 | static const struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 }; |
332 | static const struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 }; |
333 | static const struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 }; |
334 | |
335 | static const struct tvnorm f50ccir601_lml33 = { 864, 720, 75 + 34, 804, 625, 576, 18 }; |
336 | static const struct tvnorm f60ccir601_lml33 = { 858, 720, 57 + 34, 788, 525, 480, 16 }; |
337 | |
338 | /* The DC10 (57/16/50) uses VActive as HSync, so h_start must be 0 */ |
339 | static const struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 }; |
340 | static const struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 }; |
341 | |
342 | /* |
343 | * FIXME: I cannot swap U and V in saa7114, so i do one pixel left shift in zoran (75 -> 74) |
344 | * (Maxim Yevtyushkin <max@linuxmedialabs.com>) |
345 | */ |
346 | static const struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74 + 54, 804, 625, 576, 18 }; |
347 | static const struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56 + 54, 788, 525, 480, 16 }; |
348 | |
349 | /* |
350 | * FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I copy Maxim's left |
351 | * shift hack for the 6 Eyes. |
352 | * |
353 | * Christer's driver used the unshifted norms, though... |
354 | * /Sam |
355 | */ |
356 | static const struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 }; |
357 | static const struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 }; |
358 | |
359 | static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END }; |
360 | static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END }; |
361 | static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END }; |
362 | static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END }; |
363 | static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END }; |
364 | static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END }; |
365 | static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END }; |
366 | static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END }; |
367 | static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END }; |
368 | static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END }; |
369 | |
370 | static struct card_info zoran_cards[NUM_CARDS] = { |
371 | { |
372 | .type = DC10_OLD, |
373 | .name = "DC10(old)" , |
374 | .i2c_decoder = "vpx3220a" , |
375 | .addrs_decoder = vpx3220_addrs, |
376 | .video_codec = CODEC_TYPE_ZR36050, |
377 | .video_vfe = CODEC_TYPE_ZR36016, |
378 | |
379 | .inputs = 3, |
380 | .input = { |
381 | { 1, "Composite" }, |
382 | { 2, "S-Video" }, |
383 | { 0, "Internal/comp" } |
384 | }, |
385 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, |
386 | .tvn = { |
387 | &f50sqpixel_dc10, |
388 | &f60sqpixel_dc10, |
389 | &f50sqpixel_dc10 |
390 | }, |
391 | .jpeg_int = 0, |
392 | .vsync_int = ZR36057_ISR_GIRQ1, |
393 | .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 }, |
394 | .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 }, |
395 | .gpcs = { -1, 0 }, |
396 | .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
397 | .gws_not_connected = 0, |
398 | .input_mux = 0, |
399 | .init = &dc10_init, |
400 | }, { |
401 | .type = DC10_NEW, |
402 | .name = "DC10(new)" , |
403 | .i2c_decoder = "saa7110" , |
404 | .addrs_decoder = saa7110_addrs, |
405 | .i2c_encoder = "adv7175" , |
406 | .addrs_encoder = adv717x_addrs, |
407 | .video_codec = CODEC_TYPE_ZR36060, |
408 | |
409 | .inputs = 3, |
410 | .input = { |
411 | { 0, "Composite" }, |
412 | { 7, "S-Video" }, |
413 | { 5, "Internal/comp" } |
414 | }, |
415 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, |
416 | .tvn = { |
417 | &f50sqpixel, |
418 | &f60sqpixel, |
419 | &f50sqpixel}, |
420 | .jpeg_int = ZR36057_ISR_GIRQ0, |
421 | .vsync_int = ZR36057_ISR_GIRQ1, |
422 | .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 }, |
423 | .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
424 | .gpcs = { -1, 1}, |
425 | .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 }, |
426 | .gws_not_connected = 0, |
427 | .input_mux = 0, |
428 | .init = &dc10plus_init, |
429 | }, { |
430 | .type = DC10_PLUS, |
431 | .name = "DC10_PLUS" , |
432 | .i2c_decoder = "saa7110" , |
433 | .addrs_decoder = saa7110_addrs, |
434 | .i2c_encoder = "adv7175" , |
435 | .addrs_encoder = adv717x_addrs, |
436 | .video_codec = CODEC_TYPE_ZR36060, |
437 | |
438 | .inputs = 3, |
439 | .input = { |
440 | { 0, "Composite" }, |
441 | { 7, "S-Video" }, |
442 | { 5, "Internal/comp" } |
443 | }, |
444 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, |
445 | .tvn = { |
446 | &f50sqpixel, |
447 | &f60sqpixel, |
448 | &f50sqpixel |
449 | }, |
450 | .jpeg_int = ZR36057_ISR_GIRQ0, |
451 | .vsync_int = ZR36057_ISR_GIRQ1, |
452 | .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 }, |
453 | .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
454 | .gpcs = { -1, 1 }, |
455 | .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 }, |
456 | .gws_not_connected = 0, |
457 | .input_mux = 0, |
458 | .init = &dc10plus_init, |
459 | }, { |
460 | .type = DC30, |
461 | .name = "DC30" , |
462 | .i2c_decoder = "vpx3220a" , |
463 | .addrs_decoder = vpx3220_addrs, |
464 | .i2c_encoder = "adv7175" , |
465 | .addrs_encoder = adv717x_addrs, |
466 | .video_codec = CODEC_TYPE_ZR36050, |
467 | .video_vfe = CODEC_TYPE_ZR36016, |
468 | |
469 | .inputs = 3, |
470 | .input = { |
471 | { 1, "Composite" }, |
472 | { 2, "S-Video" }, |
473 | { 0, "Internal/comp" } |
474 | }, |
475 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, |
476 | .tvn = { |
477 | &f50sqpixel_dc10, |
478 | &f60sqpixel_dc10, |
479 | &f50sqpixel_dc10 |
480 | }, |
481 | .jpeg_int = 0, |
482 | .vsync_int = ZR36057_ISR_GIRQ1, |
483 | .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 }, |
484 | .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 }, |
485 | .gpcs = { -1, 0 }, |
486 | .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
487 | .gws_not_connected = 0, |
488 | .input_mux = 0, |
489 | .init = &dc10_init, |
490 | }, { |
491 | .type = DC30_PLUS, |
492 | .name = "DC30_PLUS" , |
493 | .i2c_decoder = "vpx3220a" , |
494 | .addrs_decoder = vpx3220_addrs, |
495 | .i2c_encoder = "adv7175" , |
496 | .addrs_encoder = adv717x_addrs, |
497 | .video_codec = CODEC_TYPE_ZR36050, |
498 | .video_vfe = CODEC_TYPE_ZR36016, |
499 | |
500 | .inputs = 3, |
501 | .input = { |
502 | { 1, "Composite" }, |
503 | { 2, "S-Video" }, |
504 | { 0, "Internal/comp" } |
505 | }, |
506 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, |
507 | .tvn = { |
508 | &f50sqpixel_dc10, |
509 | &f60sqpixel_dc10, |
510 | &f50sqpixel_dc10 |
511 | }, |
512 | .jpeg_int = 0, |
513 | .vsync_int = ZR36057_ISR_GIRQ1, |
514 | .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 }, |
515 | .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 }, |
516 | .gpcs = { -1, 0 }, |
517 | .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
518 | .gws_not_connected = 0, |
519 | .input_mux = 0, |
520 | .init = &dc10_init, |
521 | }, { |
522 | .type = LML33, |
523 | .name = "LML33" , |
524 | .i2c_decoder = "bt819a" , |
525 | .addrs_decoder = bt819_addrs, |
526 | .i2c_encoder = "bt856" , |
527 | .addrs_encoder = bt856_addrs, |
528 | .video_codec = CODEC_TYPE_ZR36060, |
529 | |
530 | .inputs = 2, |
531 | .input = { |
532 | { 0, "Composite" }, |
533 | { 7, "S-Video" } |
534 | }, |
535 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL, |
536 | .tvn = { |
537 | &f50ccir601_lml33, |
538 | &f60ccir601_lml33, |
539 | NULL |
540 | }, |
541 | .jpeg_int = ZR36057_ISR_GIRQ1, |
542 | .vsync_int = ZR36057_ISR_GIRQ0, |
543 | .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 }, |
544 | .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 }, |
545 | .gpcs = { 3, 1 }, |
546 | .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 }, |
547 | .gws_not_connected = 1, |
548 | .input_mux = 0, |
549 | .init = &lml33_init, |
550 | }, { |
551 | .type = LML33R10, |
552 | .name = "LML33R10" , |
553 | .i2c_decoder = "saa7114" , |
554 | .addrs_decoder = saa7114_addrs, |
555 | .i2c_encoder = "adv7170" , |
556 | .addrs_encoder = adv717x_addrs, |
557 | .video_codec = CODEC_TYPE_ZR36060, |
558 | |
559 | .inputs = 2, |
560 | .input = { |
561 | { 0, "Composite" }, |
562 | { 7, "S-Video" } |
563 | }, |
564 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL, |
565 | .tvn = { |
566 | &f50ccir601_lm33r10, |
567 | &f60ccir601_lm33r10, |
568 | NULL |
569 | }, |
570 | .jpeg_int = ZR36057_ISR_GIRQ1, |
571 | .vsync_int = ZR36057_ISR_GIRQ0, |
572 | .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 }, |
573 | .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 }, |
574 | .gpcs = { 3, 1 }, |
575 | .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 }, |
576 | .gws_not_connected = 1, |
577 | .input_mux = 0, |
578 | .init = &lml33_init, |
579 | }, { |
580 | .type = BUZ, |
581 | .name = "Buz" , |
582 | .i2c_decoder = "saa7111" , |
583 | .addrs_decoder = saa7111_addrs, |
584 | .i2c_encoder = "saa7185" , |
585 | .addrs_encoder = saa7185_addrs, |
586 | .video_codec = CODEC_TYPE_ZR36060, |
587 | |
588 | .inputs = 2, |
589 | .input = { |
590 | { 3, "Composite" }, |
591 | { 7, "S-Video" } |
592 | }, |
593 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, |
594 | .tvn = { |
595 | &f50ccir601, |
596 | &f60ccir601, |
597 | &f50ccir601 |
598 | }, |
599 | .jpeg_int = ZR36057_ISR_GIRQ1, |
600 | .vsync_int = ZR36057_ISR_GIRQ0, |
601 | .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 }, |
602 | .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
603 | .gpcs = { 3, 1 }, |
604 | .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 }, |
605 | .gws_not_connected = 1, |
606 | .input_mux = 0, |
607 | .init = &buz_init, |
608 | }, { |
609 | .type = AVS6EYES, |
610 | .name = "6-Eyes" , |
611 | /* |
612 | * AverMedia chose not to brand the 6-Eyes. Thus it can't be |
613 | * autodetected, and requires card=x. |
614 | */ |
615 | .i2c_decoder = "ks0127" , |
616 | .addrs_decoder = ks0127_addrs, |
617 | .i2c_encoder = "bt866" , |
618 | .addrs_encoder = bt866_addrs, |
619 | .video_codec = CODEC_TYPE_ZR36060, |
620 | |
621 | .inputs = 10, |
622 | .input = { |
623 | { 0, "Composite 1" }, |
624 | { 1, "Composite 2" }, |
625 | { 2, "Composite 3" }, |
626 | { 4, "Composite 4" }, |
627 | { 5, "Composite 5" }, |
628 | { 6, "Composite 6" }, |
629 | { 8, "S-Video 1" }, |
630 | { 9, "S-Video 2" }, |
631 | {10, "S-Video 3" }, |
632 | {15, "YCbCr" } |
633 | }, |
634 | .norms = V4L2_STD_NTSC | V4L2_STD_PAL, |
635 | .tvn = { |
636 | &f50ccir601_avs6eyes, |
637 | &f60ccir601_avs6eyes, |
638 | NULL |
639 | }, |
640 | .jpeg_int = ZR36057_ISR_GIRQ1, |
641 | .vsync_int = ZR36057_ISR_GIRQ0, |
642 | .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam |
643 | .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam |
644 | .gpcs = { 3, 1 }, // Validity unknown /Sam |
645 | .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam |
646 | .gws_not_connected = 1, |
647 | .input_mux = 1, |
648 | .init = &avs6eyes_init, |
649 | } |
650 | |
651 | }; |
652 | |
653 | /* |
654 | * I2C functions |
655 | */ |
656 | /* software I2C functions */ |
657 | static int zoran_i2c_getsda(void *data) |
658 | { |
659 | struct zoran *zr = (struct zoran *)data; |
660 | |
661 | return (btread(ZR36057_I2CBR) >> 1) & 1; |
662 | } |
663 | |
664 | static int zoran_i2c_getscl(void *data) |
665 | { |
666 | struct zoran *zr = (struct zoran *)data; |
667 | |
668 | return btread(ZR36057_I2CBR) & 1; |
669 | } |
670 | |
671 | static void zoran_i2c_setsda(void *data, int state) |
672 | { |
673 | struct zoran *zr = (struct zoran *)data; |
674 | |
675 | if (state) |
676 | zr->i2cbr |= 2; |
677 | else |
678 | zr->i2cbr &= ~2; |
679 | btwrite(zr->i2cbr, ZR36057_I2CBR); |
680 | } |
681 | |
682 | static void zoran_i2c_setscl(void *data, int state) |
683 | { |
684 | struct zoran *zr = (struct zoran *)data; |
685 | |
686 | if (state) |
687 | zr->i2cbr |= 1; |
688 | else |
689 | zr->i2cbr &= ~1; |
690 | btwrite(zr->i2cbr, ZR36057_I2CBR); |
691 | } |
692 | |
693 | static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = { |
694 | .setsda = zoran_i2c_setsda, |
695 | .setscl = zoran_i2c_setscl, |
696 | .getsda = zoran_i2c_getsda, |
697 | .getscl = zoran_i2c_getscl, |
698 | .udelay = 10, |
699 | .timeout = 100, |
700 | }; |
701 | |
702 | static int zoran_register_i2c(struct zoran *zr) |
703 | { |
704 | zr->i2c_algo = zoran_i2c_bit_data_template; |
705 | zr->i2c_algo.data = zr; |
706 | strscpy(zr->i2c_adapter.name, ZR_DEVNAME(zr), |
707 | sizeof(zr->i2c_adapter.name)); |
708 | i2c_set_adapdata(adap: &zr->i2c_adapter, data: &zr->v4l2_dev); |
709 | zr->i2c_adapter.algo_data = &zr->i2c_algo; |
710 | zr->i2c_adapter.dev.parent = &zr->pci_dev->dev; |
711 | return i2c_bit_add_bus(&zr->i2c_adapter); |
712 | } |
713 | |
714 | static void zoran_unregister_i2c(struct zoran *zr) |
715 | { |
716 | i2c_del_adapter(adap: &zr->i2c_adapter); |
717 | } |
718 | |
719 | /* Check a zoran_params struct for correctness, insert default params */ |
720 | int zoran_check_jpg_settings(struct zoran *zr, |
721 | struct zoran_jpg_settings *settings, int try) |
722 | { |
723 | int err = 0, err0 = 0; |
724 | |
725 | pci_dbg(zr->pci_dev, "%s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n" , |
726 | __func__, settings->decimation, settings->hor_dcm, |
727 | settings->ver_dcm, settings->tmp_dcm); |
728 | pci_dbg(zr->pci_dev, "%s - x: %d, y: %d, w: %d, y: %d\n" , __func__, |
729 | settings->img_x, settings->img_y, |
730 | settings->img_width, settings->img_height); |
731 | /* Check decimation, set default values for decimation = 1, 2, 4 */ |
732 | switch (settings->decimation) { |
733 | case 1: |
734 | |
735 | settings->hor_dcm = 1; |
736 | settings->ver_dcm = 1; |
737 | settings->tmp_dcm = 1; |
738 | settings->field_per_buff = 2; |
739 | settings->img_x = 0; |
740 | settings->img_y = 0; |
741 | settings->img_width = BUZ_MAX_WIDTH; |
742 | settings->img_height = BUZ_MAX_HEIGHT / 2; |
743 | break; |
744 | case 2: |
745 | |
746 | settings->hor_dcm = 2; |
747 | settings->ver_dcm = 1; |
748 | settings->tmp_dcm = 2; |
749 | settings->field_per_buff = 1; |
750 | settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; |
751 | settings->img_y = 0; |
752 | settings->img_width = |
753 | (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; |
754 | settings->img_height = BUZ_MAX_HEIGHT / 2; |
755 | break; |
756 | case 4: |
757 | |
758 | if (zr->card.type == DC10_NEW) { |
759 | pci_dbg(zr->pci_dev, |
760 | "%s - HDec by 4 is not supported on the DC10\n" , |
761 | __func__); |
762 | err0++; |
763 | break; |
764 | } |
765 | |
766 | settings->hor_dcm = 4; |
767 | settings->ver_dcm = 2; |
768 | settings->tmp_dcm = 2; |
769 | settings->field_per_buff = 1; |
770 | settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; |
771 | settings->img_y = 0; |
772 | settings->img_width = |
773 | (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; |
774 | settings->img_height = BUZ_MAX_HEIGHT / 2; |
775 | break; |
776 | case 0: |
777 | |
778 | /* We have to check the data the user has set */ |
779 | |
780 | if (settings->hor_dcm != 1 && settings->hor_dcm != 2 && |
781 | (zr->card.type == DC10_NEW || settings->hor_dcm != 4)) { |
782 | settings->hor_dcm = clamp(settings->hor_dcm, 1, 2); |
783 | err0++; |
784 | } |
785 | if (settings->ver_dcm != 1 && settings->ver_dcm != 2) { |
786 | settings->ver_dcm = clamp(settings->ver_dcm, 1, 2); |
787 | err0++; |
788 | } |
789 | if (settings->tmp_dcm != 1 && settings->tmp_dcm != 2) { |
790 | settings->tmp_dcm = clamp(settings->tmp_dcm, 1, 2); |
791 | err0++; |
792 | } |
793 | if (settings->field_per_buff != 1 && |
794 | settings->field_per_buff != 2) { |
795 | settings->field_per_buff = clamp(settings->field_per_buff, 1, 2); |
796 | err0++; |
797 | } |
798 | if (settings->img_x < 0) { |
799 | settings->img_x = 0; |
800 | err0++; |
801 | } |
802 | if (settings->img_y < 0) { |
803 | settings->img_y = 0; |
804 | err0++; |
805 | } |
806 | if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) { |
807 | settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH); |
808 | err0++; |
809 | } |
810 | if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) { |
811 | settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2); |
812 | err0++; |
813 | } |
814 | if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) { |
815 | settings->img_x = BUZ_MAX_WIDTH - settings->img_width; |
816 | err0++; |
817 | } |
818 | if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) { |
819 | settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height; |
820 | err0++; |
821 | } |
822 | if (settings->img_width % (16 * settings->hor_dcm) != 0) { |
823 | settings->img_width -= settings->img_width % (16 * settings->hor_dcm); |
824 | if (settings->img_width == 0) |
825 | settings->img_width = 16 * settings->hor_dcm; |
826 | err0++; |
827 | } |
828 | if (settings->img_height % (8 * settings->ver_dcm) != 0) { |
829 | settings->img_height -= settings->img_height % (8 * settings->ver_dcm); |
830 | if (settings->img_height == 0) |
831 | settings->img_height = 8 * settings->ver_dcm; |
832 | err0++; |
833 | } |
834 | |
835 | if (!try && err0) { |
836 | pci_err(zr->pci_dev, "%s - error in params for decimation = 0\n" , __func__); |
837 | err++; |
838 | } |
839 | break; |
840 | default: |
841 | pci_err(zr->pci_dev, "%s - decimation = %d, must be 0, 1, 2 or 4\n" , |
842 | __func__, settings->decimation); |
843 | err++; |
844 | break; |
845 | } |
846 | |
847 | if (settings->jpg_comp.quality > 100) |
848 | settings->jpg_comp.quality = 100; |
849 | if (settings->jpg_comp.quality < 5) |
850 | settings->jpg_comp.quality = 5; |
851 | if (settings->jpg_comp.APPn < 0) |
852 | settings->jpg_comp.APPn = 0; |
853 | if (settings->jpg_comp.APPn > 15) |
854 | settings->jpg_comp.APPn = 15; |
855 | if (settings->jpg_comp.APP_len < 0) |
856 | settings->jpg_comp.APP_len = 0; |
857 | if (settings->jpg_comp.APP_len > 60) |
858 | settings->jpg_comp.APP_len = 60; |
859 | if (settings->jpg_comp.COM_len < 0) |
860 | settings->jpg_comp.COM_len = 0; |
861 | if (settings->jpg_comp.COM_len > 60) |
862 | settings->jpg_comp.COM_len = 60; |
863 | if (err) |
864 | return -EINVAL; |
865 | return 0; |
866 | } |
867 | |
868 | static int zoran_init_video_device(struct zoran *zr, struct video_device *video_dev, int dir) |
869 | { |
870 | int err; |
871 | |
872 | /* Now add the template and register the device unit. */ |
873 | *video_dev = zoran_template; |
874 | video_dev->v4l2_dev = &zr->v4l2_dev; |
875 | video_dev->lock = &zr->lock; |
876 | video_dev->device_caps = V4L2_CAP_STREAMING | dir; |
877 | |
878 | strscpy(video_dev->name, ZR_DEVNAME(zr), sizeof(video_dev->name)); |
879 | video_dev->vfl_dir = VFL_DIR_RX; |
880 | zoran_queue_init(zr, vq: &zr->vq, dir: V4L2_BUF_TYPE_VIDEO_CAPTURE); |
881 | |
882 | err = video_register_device(vdev: video_dev, type: VFL_TYPE_VIDEO, nr: video_nr[zr->id]); |
883 | if (err < 0) |
884 | return err; |
885 | video_set_drvdata(vdev: video_dev, data: zr); |
886 | return 0; |
887 | } |
888 | |
889 | static void zoran_exit_video_devices(struct zoran *zr) |
890 | { |
891 | video_unregister_device(vdev: zr->video_dev); |
892 | kfree(objp: zr->video_dev); |
893 | } |
894 | |
895 | static int zoran_init_video_devices(struct zoran *zr) |
896 | { |
897 | int err; |
898 | |
899 | zr->video_dev = video_device_alloc(); |
900 | if (!zr->video_dev) |
901 | return -ENOMEM; |
902 | |
903 | err = zoran_init_video_device(zr, video_dev: zr->video_dev, V4L2_CAP_VIDEO_CAPTURE); |
904 | if (err) |
905 | kfree(objp: zr->video_dev); |
906 | return err; |
907 | } |
908 | |
909 | /* |
910 | * v4l2_device_unregister() will care about removing zr->encoder/zr->decoder |
911 | * via v4l2_i2c_subdev_unregister() |
912 | */ |
913 | static int zoran_i2c_init(struct zoran *zr) |
914 | { |
915 | int err; |
916 | |
917 | pci_info(zr->pci_dev, "Initializing i2c bus...\n" ); |
918 | |
919 | err = zoran_register_i2c(zr); |
920 | if (err) { |
921 | pci_err(zr->pci_dev, "%s - cannot initialize i2c bus\n" , __func__); |
922 | return err; |
923 | } |
924 | |
925 | zr->decoder = v4l2_i2c_new_subdev(v4l2_dev: &zr->v4l2_dev, adapter: &zr->i2c_adapter, |
926 | client_type: zr->card.i2c_decoder, addr: 0, |
927 | probe_addrs: zr->card.addrs_decoder); |
928 | if (!zr->decoder) { |
929 | pci_err(zr->pci_dev, "Fail to get decoder %s\n" , zr->card.i2c_decoder); |
930 | err = -EINVAL; |
931 | goto error_decoder; |
932 | } |
933 | |
934 | if (zr->card.i2c_encoder) { |
935 | zr->encoder = v4l2_i2c_new_subdev(v4l2_dev: &zr->v4l2_dev, adapter: &zr->i2c_adapter, |
936 | client_type: zr->card.i2c_encoder, addr: 0, |
937 | probe_addrs: zr->card.addrs_encoder); |
938 | if (!zr->encoder) { |
939 | pci_err(zr->pci_dev, "Fail to get encoder %s\n" , zr->card.i2c_encoder); |
940 | err = -EINVAL; |
941 | goto error_decoder; |
942 | } |
943 | } |
944 | return 0; |
945 | |
946 | error_decoder: |
947 | zoran_unregister_i2c(zr); |
948 | return err; |
949 | } |
950 | |
951 | static void zoran_i2c_exit(struct zoran *zr) |
952 | { |
953 | zoran_unregister_i2c(zr); |
954 | } |
955 | |
956 | void zoran_open_init_params(struct zoran *zr) |
957 | { |
958 | int i; |
959 | |
960 | zr->v4l_settings.width = 192; |
961 | zr->v4l_settings.height = 144; |
962 | zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */ |
963 | zr->v4l_settings.bytesperline = zr->v4l_settings.width * |
964 | ((zr->v4l_settings.format->depth + 7) / 8); |
965 | |
966 | /* Set necessary params and call zoran_check_jpg_settings to set the defaults */ |
967 | zr->jpg_settings.decimation = 1; |
968 | zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */ |
969 | if (zr->card.type != BUZ) |
970 | zr->jpg_settings.odd_even = 1; |
971 | else |
972 | zr->jpg_settings.odd_even = 0; |
973 | zr->jpg_settings.jpg_comp.APPn = 0; |
974 | zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */ |
975 | memset(zr->jpg_settings.jpg_comp.APP_data, 0, |
976 | sizeof(zr->jpg_settings.jpg_comp.APP_data)); |
977 | zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */ |
978 | memset(zr->jpg_settings.jpg_comp.COM_data, 0, |
979 | sizeof(zr->jpg_settings.jpg_comp.COM_data)); |
980 | zr->jpg_settings.jpg_comp.jpeg_markers = |
981 | V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT; |
982 | i = zoran_check_jpg_settings(zr, settings: &zr->jpg_settings, try: 0); |
983 | if (i) |
984 | pci_err(zr->pci_dev, "%s internal error\n" , __func__); |
985 | |
986 | zr->buffer_size = zr->v4l_settings.bytesperline * zr->v4l_settings.height; |
987 | |
988 | clear_interrupt_counters(zr); |
989 | } |
990 | |
991 | static int zr36057_init(struct zoran *zr) |
992 | { |
993 | int j, err; |
994 | |
995 | pci_info(zr->pci_dev, "initializing card[%d]\n" , zr->id); |
996 | |
997 | /* Avoid nonsense settings from user for default input/norm */ |
998 | if (default_norm < 0 || default_norm > 2) |
999 | default_norm = 0; |
1000 | if (default_norm == 0) { |
1001 | zr->norm = V4L2_STD_PAL; |
1002 | zr->timing = zr->card.tvn[ZR_NORM_PAL]; |
1003 | } else if (default_norm == 1) { |
1004 | zr->norm = V4L2_STD_NTSC; |
1005 | zr->timing = zr->card.tvn[ZR_NORM_NTSC]; |
1006 | } else { |
1007 | zr->norm = V4L2_STD_SECAM; |
1008 | zr->timing = zr->card.tvn[ZR_NORM_SECAM]; |
1009 | } |
1010 | if (!zr->timing) { |
1011 | pci_warn(zr->pci_dev, |
1012 | "%s - default TV standard not supported by hardware. PAL will be used.\n" , |
1013 | __func__); |
1014 | zr->norm = V4L2_STD_PAL; |
1015 | zr->timing = zr->card.tvn[ZR_NORM_PAL]; |
1016 | } |
1017 | |
1018 | if (default_input > zr->card.inputs - 1) { |
1019 | pci_warn(zr->pci_dev, "default_input value %d out of range (0-%d)\n" , |
1020 | default_input, zr->card.inputs - 1); |
1021 | default_input = 0; |
1022 | } |
1023 | zr->input = default_input; |
1024 | |
1025 | /* default setup (will be repeated at every open) */ |
1026 | zoran_open_init_params(zr); |
1027 | |
1028 | /* allocate memory *before* doing anything to the hardware in case allocation fails */ |
1029 | zr->stat_com = dma_alloc_coherent(dev: &zr->pci_dev->dev, |
1030 | BUZ_NUM_STAT_COM * sizeof(u32), |
1031 | dma_handle: &zr->p_sc, GFP_KERNEL); |
1032 | if (!zr->stat_com) |
1033 | return -ENOMEM; |
1034 | |
1035 | for (j = 0; j < BUZ_NUM_STAT_COM; j++) |
1036 | zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */ |
1037 | |
1038 | zr->stat_comb = dma_alloc_coherent(dev: &zr->pci_dev->dev, |
1039 | BUZ_NUM_STAT_COM * sizeof(u32) * 2, |
1040 | dma_handle: &zr->p_scb, GFP_KERNEL); |
1041 | if (!zr->stat_comb) { |
1042 | err = -ENOMEM; |
1043 | goto exit_statcom; |
1044 | } |
1045 | |
1046 | err = zoran_init_video_devices(zr); |
1047 | if (err) |
1048 | goto exit_statcomb; |
1049 | |
1050 | zoran_init_hardware(zr); |
1051 | if (!pass_through) { |
1052 | decoder_call(zr, video, s_stream, 0); |
1053 | encoder_call(zr, video, s_routing, 2, 0, 0); |
1054 | } |
1055 | |
1056 | zr->initialized = 1; |
1057 | return 0; |
1058 | |
1059 | exit_statcomb: |
1060 | dma_free_coherent(dev: &zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2, |
1061 | cpu_addr: zr->stat_comb, dma_handle: zr->p_scb); |
1062 | exit_statcom: |
1063 | dma_free_coherent(dev: &zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32), |
1064 | cpu_addr: zr->stat_com, dma_handle: zr->p_sc); |
1065 | return err; |
1066 | } |
1067 | |
1068 | static void zoran_remove(struct pci_dev *pdev) |
1069 | { |
1070 | struct v4l2_device *v4l2_dev = dev_get_drvdata(dev: &pdev->dev); |
1071 | struct zoran *zr = to_zoran(v4l2_dev); |
1072 | |
1073 | if (!zr->initialized) |
1074 | goto exit_free; |
1075 | |
1076 | debugfs_remove_recursive(dentry: zr->dbgfs_dir); |
1077 | |
1078 | zoran_queue_exit(zr); |
1079 | |
1080 | /* unregister videocodec bus */ |
1081 | if (zr->codec) |
1082 | videocodec_detach(codec: zr->codec); |
1083 | if (zr->vfe) |
1084 | videocodec_detach(codec: zr->vfe); |
1085 | videocodec_exit(zr); |
1086 | |
1087 | /* unregister i2c bus */ |
1088 | zoran_i2c_exit(zr); |
1089 | /* disable PCI bus-mastering */ |
1090 | zoran_set_pci_master(zr, set_master: 0); |
1091 | /* put chip into reset */ |
1092 | btwrite(0, ZR36057_SPGPPCR); |
1093 | pci_free_irq(dev: zr->pci_dev, nr: 0, dev_id: zr); |
1094 | /* unmap and free memory */ |
1095 | dma_free_coherent(dev: &zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32), |
1096 | cpu_addr: zr->stat_com, dma_handle: zr->p_sc); |
1097 | dma_free_coherent(dev: &zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2, |
1098 | cpu_addr: zr->stat_comb, dma_handle: zr->p_scb); |
1099 | pci_release_regions(pdev); |
1100 | pci_disable_device(dev: zr->pci_dev); |
1101 | zoran_exit_video_devices(zr); |
1102 | exit_free: |
1103 | v4l2_ctrl_handler_free(hdl: &zr->hdl); |
1104 | v4l2_device_unregister(v4l2_dev: &zr->v4l2_dev); |
1105 | } |
1106 | |
1107 | void zoran_vdev_release(struct video_device *vdev) |
1108 | { |
1109 | kfree(objp: vdev); |
1110 | } |
1111 | |
1112 | static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr, |
1113 | int type) |
1114 | { |
1115 | struct videocodec_master *m = NULL; |
1116 | |
1117 | m = devm_kmalloc(dev: &zr->pci_dev->dev, size: sizeof(*m), GFP_KERNEL); |
1118 | if (!m) |
1119 | return m; |
1120 | |
1121 | /* |
1122 | * magic and type are unused for master struct. Makes sense only at codec structs. |
1123 | * In the past, .type were initialized to the old V4L1 .hardware value, |
1124 | * as VID_HARDWARE_ZR36067 |
1125 | */ |
1126 | m->magic = 0L; |
1127 | m->type = 0; |
1128 | |
1129 | m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER; |
1130 | strscpy(m->name, ZR_DEVNAME(zr), sizeof(m->name)); |
1131 | m->data = zr; |
1132 | |
1133 | switch (type) { |
1134 | case CODEC_TYPE_ZR36060: |
1135 | m->readreg = zr36060_read; |
1136 | m->writereg = zr36060_write; |
1137 | m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE; |
1138 | break; |
1139 | case CODEC_TYPE_ZR36050: |
1140 | m->readreg = zr36050_read; |
1141 | m->writereg = zr36050_write; |
1142 | m->flags |= CODEC_FLAG_JPEG; |
1143 | break; |
1144 | case CODEC_TYPE_ZR36016: |
1145 | m->readreg = zr36016_read; |
1146 | m->writereg = zr36016_write; |
1147 | m->flags |= CODEC_FLAG_VFE; |
1148 | break; |
1149 | } |
1150 | |
1151 | return m; |
1152 | } |
1153 | |
1154 | static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg) |
1155 | { |
1156 | struct zoran *zr = to_zoran(v4l2_dev: sd->v4l2_dev); |
1157 | |
1158 | /* |
1159 | * Bt819 needs to reset its FIFO buffer using #FRST pin and |
1160 | * LML33 card uses GPIO(7) for that. |
1161 | */ |
1162 | if (cmd == BT819_FIFO_RESET_LOW) |
1163 | GPIO(zr, bit: 7, value: 0); |
1164 | else if (cmd == BT819_FIFO_RESET_HIGH) |
1165 | GPIO(zr, bit: 7, value: 1); |
1166 | } |
1167 | |
1168 | static int zoran_video_set_ctrl(struct v4l2_ctrl *ctrl) |
1169 | { |
1170 | struct zoran *zr = container_of(ctrl->handler, struct zoran, hdl); |
1171 | |
1172 | switch (ctrl->id) { |
1173 | case V4L2_CID_JPEG_COMPRESSION_QUALITY: |
1174 | zr->jpg_settings.jpg_comp.quality = ctrl->val; |
1175 | return zoran_check_jpg_settings(zr, settings: &zr->jpg_settings, try: 0); |
1176 | default: |
1177 | return -EINVAL; |
1178 | } |
1179 | |
1180 | return 0; |
1181 | } |
1182 | |
1183 | static const struct v4l2_ctrl_ops zoran_video_ctrl_ops = { |
1184 | .s_ctrl = zoran_video_set_ctrl, |
1185 | }; |
1186 | |
1187 | static int zoran_debugfs_show(struct seq_file *seq, void *v) |
1188 | { |
1189 | struct zoran *zr = seq->private; |
1190 | |
1191 | seq_printf(m: seq, fmt: "Running mode %x\n" , zr->running); |
1192 | seq_printf(m: seq, fmt: "Codec mode %x\n" , zr->codec_mode); |
1193 | seq_printf(m: seq, fmt: "Norm %llx\n" , zr->norm); |
1194 | seq_printf(m: seq, fmt: "Input %d\n" , zr->input); |
1195 | seq_printf(m: seq, fmt: "Buffersize %d\n" , zr->buffer_size); |
1196 | |
1197 | seq_printf(m: seq, fmt: "V4L width %dx%d\n" , zr->v4l_settings.width, zr->v4l_settings.height); |
1198 | seq_printf(m: seq, fmt: "V4L bytesperline %d\n" , zr->v4l_settings.bytesperline); |
1199 | |
1200 | seq_printf(m: seq, fmt: "JPG decimation %u\n" , zr->jpg_settings.decimation); |
1201 | seq_printf(m: seq, fmt: "JPG hor_dcm %u\n" , zr->jpg_settings.hor_dcm); |
1202 | seq_printf(m: seq, fmt: "JPG ver_dcm %u\n" , zr->jpg_settings.ver_dcm); |
1203 | seq_printf(m: seq, fmt: "JPG tmp_dcm %u\n" , zr->jpg_settings.tmp_dcm); |
1204 | seq_printf(m: seq, fmt: "JPG odd_even %u\n" , zr->jpg_settings.odd_even); |
1205 | seq_printf(m: seq, fmt: "JPG crop %dx%d %d %d\n" , |
1206 | zr->jpg_settings.img_x, |
1207 | zr->jpg_settings.img_y, |
1208 | zr->jpg_settings.img_width, |
1209 | zr->jpg_settings.img_height); |
1210 | |
1211 | seq_printf(m: seq, fmt: "Prepared %u\n" , zr->prepared); |
1212 | seq_printf(m: seq, fmt: "Queued %u\n" , zr->queued); |
1213 | |
1214 | videocodec_debugfs_show(m: seq); |
1215 | return 0; |
1216 | } |
1217 | |
1218 | DEFINE_SHOW_ATTRIBUTE(zoran_debugfs); |
1219 | |
1220 | /* |
1221 | * Scan for a Buz card (actually for the PCI controller ZR36057), |
1222 | * request the irq and map the io memory |
1223 | */ |
1224 | static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent) |
1225 | { |
1226 | unsigned char latency, need_latency; |
1227 | struct zoran *zr; |
1228 | int result; |
1229 | struct videocodec_master *master_vfe = NULL; |
1230 | struct videocodec_master *master_codec = NULL; |
1231 | int card_num; |
1232 | unsigned int nr; |
1233 | int err; |
1234 | |
1235 | pci_info(pdev, "Zoran MJPEG board driver version %s\n" , ZORAN_VERSION); |
1236 | |
1237 | /* some mainboards might not do PCI-PCI data transfer well */ |
1238 | if (pci_pci_problems & (PCIPCI_FAIL | PCIAGP_FAIL | PCIPCI_ALIMAGIK)) |
1239 | pci_warn(pdev, "%s: chipset does not support reliable PCI-PCI DMA\n" , |
1240 | ZORAN_NAME); |
1241 | |
1242 | err = dma_set_mask_and_coherent(dev: &pdev->dev, DMA_BIT_MASK(32)); |
1243 | if (err) |
1244 | return err; |
1245 | err = vb2_dma_contig_set_max_seg_size(dev: &pdev->dev, U32_MAX); |
1246 | if (err) |
1247 | return err; |
1248 | |
1249 | nr = zoran_num++; |
1250 | if (nr >= BUZ_MAX) { |
1251 | pci_err(pdev, "driver limited to %d card(s) maximum\n" , BUZ_MAX); |
1252 | return -ENOENT; |
1253 | } |
1254 | |
1255 | zr = devm_kzalloc(dev: &pdev->dev, size: sizeof(*zr), GFP_KERNEL); |
1256 | if (!zr) |
1257 | return -ENOMEM; |
1258 | |
1259 | zr->v4l2_dev.notify = zoran_subdev_notify; |
1260 | if (v4l2_device_register(dev: &pdev->dev, v4l2_dev: &zr->v4l2_dev)) |
1261 | goto zr_free_mem; |
1262 | zr->pci_dev = pdev; |
1263 | zr->id = nr; |
1264 | snprintf(ZR_DEVNAME(zr), size: sizeof(ZR_DEVNAME(zr)), fmt: "MJPEG[%u]" , zr->id); |
1265 | if (v4l2_ctrl_handler_init(&zr->hdl, 10)) |
1266 | goto zr_unreg; |
1267 | zr->v4l2_dev.ctrl_handler = &zr->hdl; |
1268 | v4l2_ctrl_new_std(hdl: &zr->hdl, ops: &zoran_video_ctrl_ops, |
1269 | V4L2_CID_JPEG_COMPRESSION_QUALITY, min: 0, |
1270 | max: 100, step: 1, def: 50); |
1271 | spin_lock_init(&zr->spinlock); |
1272 | mutex_init(&zr->lock); |
1273 | if (pci_enable_device(dev: pdev)) |
1274 | goto zr_unreg; |
1275 | zr->revision = zr->pci_dev->revision; |
1276 | |
1277 | pci_info(zr->pci_dev, "Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n" , |
1278 | zr->revision < 2 ? '5' : '6', zr->revision, |
1279 | zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0)); |
1280 | if (zr->revision >= 2) |
1281 | pci_info(zr->pci_dev, "Subsystem vendor=0x%04x id=0x%04x\n" , |
1282 | zr->pci_dev->subsystem_vendor, zr->pci_dev->subsystem_device); |
1283 | |
1284 | /* Use auto-detected card type? */ |
1285 | if (card[nr] == -1) { |
1286 | if (zr->revision < 2) { |
1287 | pci_err(pdev, "No card type specified, please use the card=X module parameter\n" ); |
1288 | pci_err(pdev, "It is not possible to auto-detect ZR36057 based cards\n" ); |
1289 | goto zr_unreg; |
1290 | } |
1291 | |
1292 | card_num = ent->driver_data; |
1293 | if (card_num >= NUM_CARDS) { |
1294 | pci_err(pdev, "Unknown card, try specifying card=X module parameter\n" ); |
1295 | goto zr_unreg; |
1296 | } |
1297 | pci_info(zr->pci_dev, "%s() - card %s detected\n" , __func__, |
1298 | zoran_cards[card_num].name); |
1299 | } else { |
1300 | card_num = card[nr]; |
1301 | if (card_num >= NUM_CARDS || card_num < 0) { |
1302 | pci_err(pdev, "User specified card type %d out of range (0 .. %d)\n" , |
1303 | card_num, NUM_CARDS - 1); |
1304 | goto zr_unreg; |
1305 | } |
1306 | } |
1307 | |
1308 | /* |
1309 | * even though we make this a non pointer and thus |
1310 | * theoretically allow for making changes to this struct |
1311 | * on a per-individual card basis at runtime, this is |
1312 | * strongly discouraged. This structure is intended to |
1313 | * keep general card information, no settings or anything |
1314 | */ |
1315 | zr->card = zoran_cards[card_num]; |
1316 | snprintf(ZR_DEVNAME(zr), size: sizeof(ZR_DEVNAME(zr)), fmt: "%s[%u]" , |
1317 | zr->card.name, zr->id); |
1318 | |
1319 | err = pci_request_regions(pdev, ZR_DEVNAME(zr)); |
1320 | if (err) |
1321 | goto zr_unreg; |
1322 | |
1323 | zr->zr36057_mem = devm_ioremap(dev: &pdev->dev, pci_resource_start(pdev, 0), |
1324 | pci_resource_len(pdev, 0)); |
1325 | if (!zr->zr36057_mem) { |
1326 | pci_err(pdev, "%s() - ioremap failed\n" , __func__); |
1327 | goto zr_pci_release; |
1328 | } |
1329 | |
1330 | result = pci_request_irq(dev: pdev, nr: 0, handler: zoran_irq, NULL, dev_id: zr, ZR_DEVNAME(zr)); |
1331 | if (result < 0) { |
1332 | if (result == -EINVAL) { |
1333 | pci_err(pdev, "%s - bad IRQ number or handler\n" , __func__); |
1334 | } else if (result == -EBUSY) { |
1335 | pci_err(pdev, "%s - IRQ %d busy, change your PnP config in BIOS\n" , |
1336 | __func__, zr->pci_dev->irq); |
1337 | } else { |
1338 | pci_err(pdev, "%s - cannot assign IRQ, error code %d\n" , __func__, result); |
1339 | } |
1340 | goto zr_pci_release; |
1341 | } |
1342 | |
1343 | /* set PCI latency timer */ |
1344 | pci_read_config_byte(dev: zr->pci_dev, PCI_LATENCY_TIMER, |
1345 | val: &latency); |
1346 | need_latency = zr->revision > 1 ? 32 : 48; |
1347 | if (latency != need_latency) { |
1348 | pci_info(zr->pci_dev, "Changing PCI latency from %d to %d\n" , |
1349 | latency, need_latency); |
1350 | pci_write_config_byte(dev: zr->pci_dev, PCI_LATENCY_TIMER, val: need_latency); |
1351 | } |
1352 | |
1353 | zr36057_restart(zr); |
1354 | |
1355 | err = zoran_i2c_init(zr); |
1356 | if (err) |
1357 | goto zr_free_irq; |
1358 | |
1359 | pci_info(zr->pci_dev, "Initializing videocodec bus...\n" ); |
1360 | err = videocodec_init(zr); |
1361 | if (err) |
1362 | goto zr_unreg_i2c; |
1363 | |
1364 | /* reset JPEG codec */ |
1365 | jpeg_codec_sleep(zr, sleep: 1); |
1366 | jpeg_codec_reset(zr); |
1367 | /* video bus enabled */ |
1368 | /* display codec revision */ |
1369 | if (zr->card.video_codec != 0) { |
1370 | master_codec = zoran_setup_videocodec(zr, type: zr->card.video_codec); |
1371 | if (!master_codec) |
1372 | goto zr_unreg_videocodec; |
1373 | zr->codec = videocodec_attach(master: master_codec); |
1374 | if (!zr->codec) { |
1375 | pci_err(pdev, "%s - no codec found\n" , __func__); |
1376 | goto zr_unreg_videocodec; |
1377 | } |
1378 | if (zr->codec->type != zr->card.video_codec) { |
1379 | pci_err(pdev, "%s - wrong codec\n" , __func__); |
1380 | goto zr_unreg_videocodec; |
1381 | } |
1382 | } |
1383 | if (zr->card.video_vfe != 0) { |
1384 | master_vfe = zoran_setup_videocodec(zr, type: zr->card.video_vfe); |
1385 | if (!master_vfe) |
1386 | goto zr_detach_codec; |
1387 | zr->vfe = videocodec_attach(master: master_vfe); |
1388 | if (!zr->vfe) { |
1389 | pci_err(pdev, "%s - no VFE found\n" , __func__); |
1390 | goto zr_detach_codec; |
1391 | } |
1392 | if (zr->vfe->type != zr->card.video_vfe) { |
1393 | pci_err(pdev, "%s = wrong VFE\n" , __func__); |
1394 | goto zr_detach_vfe; |
1395 | } |
1396 | } |
1397 | |
1398 | /* take care of Natoma chipset and a revision 1 zr36057 */ |
1399 | if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) |
1400 | pci_info(zr->pci_dev, "ZR36057/Natoma bug, max. buffer size is 128K\n" ); |
1401 | |
1402 | if (zr36057_init(zr) < 0) |
1403 | goto zr_detach_vfe; |
1404 | |
1405 | zr->map_mode = ZORAN_MAP_MODE_RAW; |
1406 | |
1407 | zr->dbgfs_dir = debugfs_create_dir(ZR_DEVNAME(zr), NULL); |
1408 | debugfs_create_file(name: "debug" , mode: 0444, parent: zr->dbgfs_dir, data: zr, |
1409 | fops: &zoran_debugfs_fops); |
1410 | return 0; |
1411 | |
1412 | zr_detach_vfe: |
1413 | videocodec_detach(codec: zr->vfe); |
1414 | zr_detach_codec: |
1415 | videocodec_detach(codec: zr->codec); |
1416 | zr_unreg_videocodec: |
1417 | videocodec_exit(zr); |
1418 | zr_unreg_i2c: |
1419 | zoran_i2c_exit(zr); |
1420 | zr_free_irq: |
1421 | btwrite(0, ZR36057_SPGPPCR); |
1422 | pci_free_irq(dev: zr->pci_dev, nr: 0, dev_id: zr); |
1423 | zr_pci_release: |
1424 | pci_release_regions(pdev); |
1425 | zr_unreg: |
1426 | v4l2_ctrl_handler_free(hdl: &zr->hdl); |
1427 | v4l2_device_unregister(v4l2_dev: &zr->v4l2_dev); |
1428 | zr_free_mem: |
1429 | |
1430 | return -ENODEV; |
1431 | } |
1432 | |
1433 | static struct pci_driver zoran_driver = { |
1434 | .name = "zr36067" , |
1435 | .id_table = zr36067_pci_tbl, |
1436 | .probe = zoran_probe, |
1437 | .remove = zoran_remove, |
1438 | }; |
1439 | |
1440 | module_pci_driver(zoran_driver); |
1441 | |