]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blame - drivers/media/video/cx18/cx18-driver.c
projects / mirror_ubuntu-focal-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (9506): ivtv/cx18: fix test whether modules should be loaded or not.
[mirror_ubuntu-focal-kernel.git] / drivers / media / video / cx18 / cx18-driver.c
CommitLineData
1c1e45d1
HV		 1/*
2 * cx18 driver initialization and card probing
3 *
4 * Derived from ivtv-driver.c
5 *
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
c641d09c 7 * Copyright (C) 2008 Andy Walls <awalls@radix.net>
1c1e45d1
HV		 8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22 * 02111-1307 USA
23 */
24
25#include "cx18-driver.h"
b1526421 26#include "cx18-io.h"
1c1e45d1
HV		 27#include "cx18-version.h"
28#include "cx18-cards.h"
29#include "cx18-i2c.h"
30#include "cx18-irq.h"
31#include "cx18-gpio.h"
32#include "cx18-firmware.h"
33#include "cx18-streams.h"
34#include "cx18-av-core.h"
35#include "cx18-scb.h"
36#include "cx18-mailbox.h"
37#include "cx18-ioctl.h"
38#include "tuner-xc2028.h"
39
40#include <media/tveeprom.h>
41
42
43/* var to keep track of the number of array elements in use */
44int cx18_cards_active;
45
46/* If you have already X v4l cards, then set this to X. This way
47 the device numbers stay matched. Example: you have a WinTV card
48 without radio and a Compro H900 with. Normally this would give a
49 video1 device together with a radio0 device for the Compro. By
50 setting this to 1 you ensure that radio0 is now also radio1. */
51int cx18_first_minor;
52
53/* Master variable for all cx18 info */
54struct cx18 *cx18_cards[CX18_MAX_CARDS];
55
56/* Protects cx18_cards_active */
57DEFINE_SPINLOCK(cx18_cards_lock);
58
59/* add your revision and whatnot here */
60static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
61 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
62 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
63 {0,}
64};
65
66MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
67
68/* Parameter declarations */
69static int cardtype[CX18_MAX_CARDS];
70static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
71 -1, -1, -1, -1, -1, -1, -1, -1,
72 -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1 };
74static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
75 -1, -1, -1, -1, -1, -1, -1, -1,
76 -1, -1, -1, -1, -1, -1, -1, -1,
77 -1, -1, -1, -1, -1, -1, -1, -1 };
c641d09c
AW		 78static int mmio_ndelay[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
79 -1, -1, -1, -1, -1, -1, -1, -1,
80 -1, -1, -1, -1, -1, -1, -1, -1,
81 -1, -1, -1, -1, -1, -1, -1, -1 };
c6eb8eaf
HV		 82static unsigned cardtype_c = 1;
83static unsigned tuner_c = 1;
84static unsigned radio_c = 1;
2796073a 85static unsigned mmio_ndelay_c = 1;
1c1e45d1
HV		 86static char pal[] = "--";
87static char secam[] = "--";
88static char ntsc[] = "-";
89
90/* Buffers */
91static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
92static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
93static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
94static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
95static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
96
97static int cx18_pci_latency = 1;
98
d267d851 99int cx18_retry_mmio = 1;
1c1e45d1
HV		 100int cx18_debug;
101
102module_param_array(tuner, int, &tuner_c, 0644);
103module_param_array(radio, bool, &radio_c, 0644);
104module_param_array(cardtype, int, &cardtype_c, 0644);
c641d09c 105module_param_array(mmio_ndelay, int, &mmio_ndelay_c, 0644);
1c1e45d1
HV		 106module_param_string(pal, pal, sizeof(pal), 0644);
107module_param_string(secam, secam, sizeof(secam), 0644);
108module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
109module_param_named(debug, cx18_debug, int, 0644);
d267d851 110module_param_named(retry_mmio, cx18_retry_mmio, int, 0644);
1c1e45d1
HV		 111module_param(cx18_pci_latency, int, 0644);
112module_param(cx18_first_minor, int, 0644);
113
114module_param(enc_mpg_buffers, int, 0644);
115module_param(enc_ts_buffers, int, 0644);
116module_param(enc_yuv_buffers, int, 0644);
117module_param(enc_vbi_buffers, int, 0644);
118module_param(enc_pcm_buffers, int, 0644);
119
120MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
121 "\t\t\tsee tuner.h for values");
122MODULE_PARM_DESC(radio,
123 "Enable or disable the radio. Use only if autodetection\n"
124 "\t\t\tfails. 0 = disable, 1 = enable");
125MODULE_PARM_DESC(cardtype,
126 "Only use this option if your card is not detected properly.\n"
127 "\t\tSpecify card type:\n"
128 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
129 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
130 "\t\t\t 3 = Compro VideoMate H900\n"
131 "\t\t\t 4 = Yuan MPC718\n"
03c28085 132 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
9eee4fb6
AW		 133 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
134 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
1c1e45d1
HV		 135 "\t\t\t 0 = Autodetect (default)\n"
136 "\t\t\t-1 = Ignore this card\n\t\t");
137MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
138MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
139MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
140MODULE_PARM_DESC(debug,
141 "Debug level (bitmask). Default: 0\n"
142 "\t\t\t 1/0x0001: warning\n"
143 "\t\t\t 2/0x0002: info\n"
144 "\t\t\t 4/0x0004: mailbox\n"
145 "\t\t\t 8/0x0008: dma\n"
146 "\t\t\t 16/0x0010: ioctl\n"
147 "\t\t\t 32/0x0020: file\n"
148 "\t\t\t 64/0x0040: i2c\n"
149 "\t\t\t128/0x0080: irq\n"
150 "\t\t\t256/0x0100: high volume\n");
151MODULE_PARM_DESC(cx18_pci_latency,
152 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
153 "\t\t\tDefault: Yes");
d267d851
AW		 154MODULE_PARM_DESC(retry_mmio,
155 "Check and retry memory mapped IO accesses\n"
156 "\t\t\tDefault: 1 [Yes]");
c641d09c
AW		 157MODULE_PARM_DESC(mmio_ndelay,
158 "Delay (ns) for each CX23418 memory mapped IO access.\n"
159 "\t\t\tTry larger values that are close to a multiple of the\n"
160 "\t\t\tPCI clock period, 30.3 ns, if your card doesn't work.\n"
161 "\t\t\tDefault: " __stringify(CX18_DEFAULT_MMIO_NDELAY));
1c1e45d1
HV		 162MODULE_PARM_DESC(enc_mpg_buffers,
163 "Encoder MPG Buffers (in MB)\n"
164 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
165MODULE_PARM_DESC(enc_ts_buffers,
166 "Encoder TS Buffers (in MB)\n"
167 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
168MODULE_PARM_DESC(enc_yuv_buffers,
169 "Encoder YUV Buffers (in MB)\n"
170 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
171MODULE_PARM_DESC(enc_vbi_buffers,
172 "Encoder VBI Buffers (in MB)\n"
173 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
174MODULE_PARM_DESC(enc_pcm_buffers,
175 "Encoder PCM buffers (in MB)\n"
176 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
177
dd89601d 178MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
1c1e45d1
HV		 179
180MODULE_AUTHOR("Hans Verkuil");
181MODULE_DESCRIPTION("CX23418 driver");
182MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
183MODULE_LICENSE("GPL");
184
185MODULE_VERSION(CX18_VERSION);
186
1c1e45d1
HV		 187/* Generic utility functions */
188int cx18_msleep_timeout(unsigned int msecs, int intr)
189{
190 int timeout = msecs_to_jiffies(msecs);
191 int sig;
192
193 do {
194 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
195 timeout = schedule_timeout(timeout);
196 sig = intr ? signal_pending(current) : 0;
197 } while (!sig && timeout);
198 return sig;
199}
200
201/* Release ioremapped memory */
202static void cx18_iounmap(struct cx18 *cx)
203{
204 if (cx == NULL)
205 return;
206
207 /* Release io memory */
208 if (cx->enc_mem != NULL) {
209 CX18_DEBUG_INFO("releasing enc_mem\n");
210 iounmap(cx->enc_mem);
211 cx->enc_mem = NULL;
212 }
213}
214
215/* Hauppauge card? get values from tveeprom */
216void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
217{
218 u8 eedata[256];
219
220 cx->i2c_client[0].addr = 0xA0 >> 1;
221 tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
222 tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
223}
224
225static void cx18_process_eeprom(struct cx18 *cx)
226{
227 struct tveeprom tv;
228
229 cx18_read_eeprom(cx, &tv);
230
231 /* Many thanks to Steven Toth from Hauppauge for providing the
232 model numbers */
1d081601
HV		 233 /* Note: the Samsung memory models cannot be reliably determined
234 from the model number. Use the cardtype module option if you
235 have one of these preproduction models. */
1c1e45d1 236 switch (tv.model) {
1d081601 237 case 74000 ... 74999:
1c1e45d1
HV		 238 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
239 break;
1c1e45d1
HV		 240 case 0:
241 CX18_ERR("Invalid EEPROM\n");
242 return;
243 default:
244 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
245 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
246 break;
247 }
248
249 cx->v4l2_cap = cx->card->v4l2_capabilities;
250 cx->card_name = cx->card->name;
251 cx->card_i2c = cx->card->i2c;
252
253 CX18_INFO("Autodetected %s\n", cx->card_name);
254
255 if (tv.tuner_type == TUNER_ABSENT)
256 CX18_ERR("tveeprom cannot autodetect tuner!");
257
258 if (cx->options.tuner == -1)
259 cx->options.tuner = tv.tuner_type;
260 if (cx->options.radio == -1)
261 cx->options.radio = (tv.has_radio != 0);
262
263 if (cx->std != 0)
264 /* user specified tuner standard */
265 return;
266
267 /* autodetect tuner standard */
268 if (tv.tuner_formats & V4L2_STD_PAL) {
269 CX18_DEBUG_INFO("PAL tuner detected\n");
270 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
271 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
272 CX18_DEBUG_INFO("NTSC tuner detected\n");
273 cx->std |= V4L2_STD_NTSC_M;
274 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
275 CX18_DEBUG_INFO("SECAM tuner detected\n");
276 cx->std |= V4L2_STD_SECAM_L;
277 } else {
278 CX18_INFO("No tuner detected, default to NTSC-M\n");
279 cx->std |= V4L2_STD_NTSC_M;
280 }
281}
282
283static v4l2_std_id cx18_parse_std(struct cx18 *cx)
284{
285 switch (pal[0]) {
286 case '6':
287 return V4L2_STD_PAL_60;
288 case 'b':
289 case 'B':
290 case 'g':
291 case 'G':
292 return V4L2_STD_PAL_BG;
293 case 'h':
294 case 'H':
295 return V4L2_STD_PAL_H;
296 case 'n':
297 case 'N':
298 if (pal[1] == 'c' || pal[1] == 'C')
299 return V4L2_STD_PAL_Nc;
300 return V4L2_STD_PAL_N;
301 case 'i':
302 case 'I':
303 return V4L2_STD_PAL_I;
304 case 'd':
305 case 'D':
306 case 'k':
307 case 'K':
308 return V4L2_STD_PAL_DK;
309 case 'M':
310 case 'm':
311 return V4L2_STD_PAL_M;
312 case '-':
313 break;
314 default:
315 CX18_WARN("pal= argument not recognised\n");
316 return 0;
317 }
318
319 switch (secam[0]) {
320 case 'b':
321 case 'B':
322 case 'g':
323 case 'G':
324 case 'h':
325 case 'H':
326 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
327 case 'd':
328 case 'D':
329 case 'k':
330 case 'K':
331 return V4L2_STD_SECAM_DK;
332 case 'l':
333 case 'L':
334 if (secam[1] == 'C' || secam[1] == 'c')
335 return V4L2_STD_SECAM_LC;
336 return V4L2_STD_SECAM_L;
337 case '-':
338 break;
339 default:
340 CX18_WARN("secam= argument not recognised\n");
341 return 0;
342 }
343
344 switch (ntsc[0]) {
345 case 'm':
346 case 'M':
347 return V4L2_STD_NTSC_M;
348 case 'j':
349 case 'J':
350 return V4L2_STD_NTSC_M_JP;
351 case 'k':
352 case 'K':
353 return V4L2_STD_NTSC_M_KR;
354 case '-':
355 break;
356 default:
357 CX18_WARN("ntsc= argument not recognised\n");
358 return 0;
359 }
360
361 /* no match found */
362 return 0;
363}
364
365static void cx18_process_options(struct cx18 *cx)
366{
367 int i, j;
368
369 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
370 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
371 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
372 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
373 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
374 cx->options.cardtype = cardtype[cx->num];
375 cx->options.tuner = tuner[cx->num];
376 cx->options.radio = radio[cx->num];
377
c641d09c
AW		 378 if (mmio_ndelay[cx->num] < 0)
379 cx->options.mmio_ndelay = CX18_DEFAULT_MMIO_NDELAY;
380 else
381 cx->options.mmio_ndelay = mmio_ndelay[cx->num];
382
1c1e45d1
HV		 383 cx->std = cx18_parse_std(cx);
384 if (cx->options.cardtype == -1) {
385 CX18_INFO("Ignore card\n");
386 return;
387 }
388 cx->card = cx18_get_card(cx->options.cardtype - 1);
389 if (cx->card)
390 CX18_INFO("User specified %s card\n", cx->card->name);
391 else if (cx->options.cardtype != 0)
392 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
393 if (cx->card == NULL) {
394 if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
395 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
396 CX18_INFO("Autodetected Hauppauge card\n");
397 }
398 }
399 if (cx->card == NULL) {
400 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
401 if (cx->card->pci_list == NULL)
402 continue;
403 for (j = 0; cx->card->pci_list[j].device; j++) {
404 if (cx->dev->device !=
405 cx->card->pci_list[j].device)
406 continue;
407 if (cx->dev->subsystem_vendor !=
408 cx->card->pci_list[j].subsystem_vendor)
409 continue;
410 if (cx->dev->subsystem_device !=
411 cx->card->pci_list[j].subsystem_device)
412 continue;
413 CX18_INFO("Autodetected %s card\n", cx->card->name);
414 goto done;
415 }
416 }
417 }
418done:
419
420 if (cx->card == NULL) {
421 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
29e66a6c 422 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
1c1e45d1 423 cx->dev->vendor, cx->dev->device);
29e66a6c 424 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
1c1e45d1
HV		 425 cx->dev->subsystem_vendor, cx->dev->subsystem_device);
426 CX18_ERR("Defaulting to %s card\n", cx->card->name);
427 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
428 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
429 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
430 }
431 cx->v4l2_cap = cx->card->v4l2_capabilities;
432 cx->card_name = cx->card->name;
433 cx->card_i2c = cx->card->i2c;
434}
435
436/* Precondition: the cx18 structure has been memset to 0. Only
437 the dev and num fields have been filled in.
438 No assumptions on the card type may be made here (see cx18_init_struct2
439 for that).
440 */
441static int __devinit cx18_init_struct1(struct cx18 *cx)
442{
443 cx->base_addr = pci_resource_start(cx->dev, 0);
444
445 mutex_init(&cx->serialize_lock);
446 mutex_init(&cx->i2c_bus_lock[0]);
447 mutex_init(&cx->i2c_bus_lock[1]);
8abdd00d 448 mutex_init(&cx->gpio_lock);
1c1e45d1
HV		 449
450 spin_lock_init(&cx->lock);
451 spin_lock_init(&cx->dma_reg_lock);
452
453 /* start counting open_id at 1 */
454 cx->open_id = 1;
455
456 /* Initial settings */
457 cx2341x_fill_defaults(&cx->params);
458 cx->temporal_strength = cx->params.video_temporal_filter;
459 cx->spatial_strength = cx->params.video_spatial_filter;
460 cx->filter_mode = cx->params.video_spatial_filter_mode |
461 (cx->params.video_temporal_filter_mode << 1) |
462 (cx->params.video_median_filter_type << 2);
463 cx->params.port = CX2341X_PORT_MEMORY;
e8b934de 464 cx->params.capabilities = CX2341X_CAP_HAS_TS;
1c1e45d1
HV		 465 init_waitqueue_head(&cx->cap_w);
466 init_waitqueue_head(&cx->mb_apu_waitq);
467 init_waitqueue_head(&cx->mb_cpu_waitq);
468 init_waitqueue_head(&cx->mb_epu_waitq);
469 init_waitqueue_head(&cx->mb_hpu_waitq);
470 init_waitqueue_head(&cx->dma_waitq);
471
472 /* VBI */
473 cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
474 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
475 cx->vbi.raw_size = 1456;
476 cx->vbi.raw_decoder_line_size = 1456;
477 cx->vbi.raw_decoder_sav_odd_field = 0x20;
478 cx->vbi.raw_decoder_sav_even_field = 0x60;
479 cx->vbi.sliced_decoder_line_size = 272;
480 cx->vbi.sliced_decoder_sav_odd_field = 0xB0;
481 cx->vbi.sliced_decoder_sav_even_field = 0xF0;
482 return 0;
483}
484
485/* Second initialization part. Here the card type has been
486 autodetected. */
487static void __devinit cx18_init_struct2(struct cx18 *cx)
488{
489 int i;
490
491 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
492 if (cx->card->video_inputs[i].video_type == 0)
493 break;
494 cx->nof_inputs = i;
495 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
496 if (cx->card->audio_inputs[i].audio_type == 0)
497 break;
498 cx->nof_audio_inputs = i;
499
500 /* Find tuner input */
501 for (i = 0; i < cx->nof_inputs; i++) {
502 if (cx->card->video_inputs[i].video_type ==
503 CX18_CARD_INPUT_VID_TUNER)
504 break;
505 }
506 if (i == cx->nof_inputs)
507 i = 0;
508 cx->active_input = i;
509 cx->audio_input = cx->card->video_inputs[i].audio_index;
510 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
511 cx->av_state.aud_input = CX18_AV_AUDIO8;
512 cx->av_state.audclk_freq = 48000;
513 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
514 cx->av_state.vbi_line_offset = 8;
515}
516
517static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
518 const struct pci_device_id *pci_id)
519{
520 u16 cmd;
521 unsigned char pci_latency;
522
523 CX18_DEBUG_INFO("Enabling pci device\n");
524
525 if (pci_enable_device(dev)) {
526 CX18_ERR("Can't enable device %d!\n", cx->num);
527 return -EIO;
528 }
529 if (pci_set_dma_mask(dev, 0xffffffff)) {
530 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
531 return -EIO;
532 }
533 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
534 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
535 return -EIO;
536 }
537
4519064c 538 /* Enable bus mastering and memory mapped IO for the CX23418 */
1c1e45d1 539 pci_read_config_word(dev, PCI_COMMAND, &cmd);
4519064c 540 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
1c1e45d1
HV		 541 pci_write_config_word(dev, PCI_COMMAND, cmd);
542
543 pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
544 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
545
546 if (pci_latency < 64 && cx18_pci_latency) {
547 CX18_INFO("Unreasonably low latency timer, "
548 "setting to 64 (was %d)\n", pci_latency);
549 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
550 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
551 }
1c1e45d1
HV		 552
553 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
554 "irq: %d, latency: %d, memory: 0x%lx\n",
555 cx->dev->device, cx->card_rev, dev->bus->number,
556 PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
557 cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
558
559 return 0;
560}
561
6a4a7935 562#ifdef MODULE
1c1e45d1
HV		 563static u32 cx18_request_module(struct cx18 *cx, u32 hw,
564 const char *name, u32 id)
565{
566 if ((hw & id) == 0)
567 return hw;
568 if (request_module(name) != 0) {
569 CX18_ERR("Failed to load module %s\n", name);
570 return hw & ~id;
571 }
572 CX18_DEBUG_INFO("Loaded module %s\n", name);
573 return hw;
574}
6a4a7935 575#endif
1c1e45d1
HV		 576
577static void cx18_load_and_init_modules(struct cx18 *cx)
578{
579 u32 hw = cx->card->hw_all;
580 int i;
581
6a4a7935 582#ifdef MODULE
1c1e45d1 583 /* load modules */
58ae1c23 584#ifdef CONFIG_MEDIA_TUNER_MODULE
1c1e45d1
HV		 585 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
586#endif
58ae1c23 587#ifdef CONFIG_VIDEO_CS5345_MODULE
1c1e45d1 588 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
6a4a7935 589#endif
1c1e45d1
HV		 590#endif
591
592 /* check which i2c devices are actually found */
593 for (i = 0; i < 32; i++) {
594 u32 device = 1 << i;
595
596 if (!(device & hw))
597 continue;
598 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
599 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
600 /* These 'devices' do not use i2c probing */
601 cx->hw_flags |= device;
602 continue;
603 }
604 cx18_i2c_register(cx, i);
605 if (cx18_i2c_hw_addr(cx, device) > 0)
606 cx->hw_flags |= device;
607 }
608
609 hw = cx->hw_flags;
610}
611
612static int __devinit cx18_probe(struct pci_dev *dev,
613 const struct pci_device_id *pci_id)
614{
615 int retval = 0;
ff086575 616 int i;
1c1e45d1
HV		 617 int vbi_buf_size;
618 u32 devtype;
619 struct cx18 *cx;
620
621 spin_lock(&cx18_cards_lock);
622
623 /* Make sure we've got a place for this card */
624 if (cx18_cards_active == CX18_MAX_CARDS) {
625 printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n",
626 cx18_cards_active);
627 spin_unlock(&cx18_cards_lock);
628 return -ENOMEM;
629 }
630
631 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
cb6969e8 632 if (!cx) {
1c1e45d1
HV		 633 spin_unlock(&cx18_cards_lock);
634 return -ENOMEM;
635 }
636 cx18_cards[cx18_cards_active] = cx;
637 cx->dev = dev;
638 cx->num = cx18_cards_active++;
b4ac3c8d 639 snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
1c1e45d1
HV		 640 CX18_INFO("Initializing card #%d\n", cx->num);
641
642 spin_unlock(&cx18_cards_lock);
643
644 cx18_process_options(cx);
645 if (cx->options.cardtype == -1) {
646 retval = -ENODEV;
647 goto err;
648 }
649 if (cx18_init_struct1(cx)) {
650 retval = -ENOMEM;
651 goto err;
652 }
653
654 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
655
656 /* PCI Device Setup */
657 retval = cx18_setup_pci(cx, dev, pci_id);
658 if (retval != 0) {
659 if (retval == -EIO)
660 goto free_workqueue;
661 else if (retval == -ENXIO)
662 goto free_mem;
663 }
664 /* save cx in the pci struct for later use */
665 pci_set_drvdata(dev, cx);
666
667 /* map io memory */
668 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
669 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
670 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
671 CX18_MEM_SIZE);
672 if (!cx->enc_mem) {
673 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
674 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
675 retval = -ENOMEM;
676 goto free_mem;
677 }
678 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
b1526421 679 devtype = cx18_read_reg(cx, 0xC72028);
1c1e45d1
HV		 680 switch (devtype & 0xff000000) {
681 case 0xff000000:
682 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
683 break;
684 case 0x01000000:
685 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
686 break;
687 default:
688 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
689 break;
690 }
691
692 cx18_init_power(cx, 1);
693 cx18_init_memory(cx);
694
990c81c8 695 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
1c1e45d1
HV		 696 cx18_init_scb(cx);
697
698 cx18_gpio_init(cx);
699
700 /* active i2c */
701 CX18_DEBUG_INFO("activating i2c...\n");
9b4a7c8a
AW		 702 retval = init_cx18_i2c(cx);
703 if (retval) {
1c1e45d1
HV		 704 CX18_ERR("Could not initialize i2c\n");
705 goto free_map;
706 }
707
708 CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
709
710 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
711 /* Based on the model number the cardtype may be changed.
712 The PCI IDs are not always reliable. */
713 cx18_process_eeprom(cx);
714 }
715 if (cx->card->comment)
716 CX18_INFO("%s", cx->card->comment);
717 if (cx->card->v4l2_capabilities == 0) {
718 retval = -ENODEV;
719 goto free_i2c;
720 }
721 cx18_init_memory(cx);
722
723 /* Register IRQ */
724 retval = request_irq(cx->dev->irq, cx18_irq_handler,
725 IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
726 if (retval) {
727 CX18_ERR("Failed to register irq %d\n", retval);
728 goto free_i2c;
729 }
730
731 if (cx->std == 0)
732 cx->std = V4L2_STD_NTSC_M;
733
734 if (cx->options.tuner == -1) {
735 int i;
736
737 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
738 if ((cx->std & cx->card->tuners[i].std) == 0)
739 continue;
740 cx->options.tuner = cx->card->tuners[i].tuner;
741 break;
742 }
743 }
744 /* if no tuner was found, then pick the first tuner in the card list */
745 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
746 cx->std = cx->card->tuners[0].std;
c3cb4d95
HV		 747 if (cx->std & V4L2_STD_PAL)
748 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
749 else if (cx->std & V4L2_STD_NTSC)
750 cx->std = V4L2_STD_NTSC_M;
751 else if (cx->std & V4L2_STD_SECAM)
752 cx->std = V4L2_STD_SECAM_L;
1c1e45d1
HV		 753 cx->options.tuner = cx->card->tuners[0].tuner;
754 }
755 if (cx->options.radio == -1)
756 cx->options.radio = (cx->card->radio_input.audio_type != 0);
757
758 /* The card is now fully identified, continue with card-specific
759 initialization. */
760 cx18_init_struct2(cx);
761
762 cx18_load_and_init_modules(cx);
763
764 if (cx->std & V4L2_STD_525_60) {
765 cx->is_60hz = 1;
766 cx->is_out_60hz = 1;
767 } else {
768 cx->is_50hz = 1;
769 cx->is_out_50hz = 1;
770 }
771 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
772
773 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
774 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
775 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
776 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
777 vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
778 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
779
780 if (cx->options.radio > 0)
781 cx->v4l2_cap |= V4L2_CAP_RADIO;
782
1c1e45d1
HV		 783 if (cx->options.tuner > -1) {
784 struct tuner_setup setup;
785
786 setup.addr = ADDR_UNSET;
787 setup.type = cx->options.tuner;
788 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
789 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
790 cx18_reset_tuner_gpio : NULL;
791 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
792 if (setup.type == TUNER_XC2028) {
793 static struct xc2028_ctrl ctrl = {
794 .fname = XC2028_DEFAULT_FIRMWARE,
795 .max_len = 64,
796 };
797 struct v4l2_priv_tun_config cfg = {
798 .tuner = cx->options.tuner,
799 .priv = &ctrl,
800 };
801 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
802 }
803 }
804
805 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
806 are not. */
807 cx->tuner_std = cx->std;
808
5e7fdc5e
HV		 809 retval = cx18_streams_setup(cx);
810 if (retval) {
811 CX18_ERR("Error %d setting up streams\n", retval);
812 goto free_irq;
813 }
814 retval = cx18_streams_register(cx);
815 if (retval) {
816 CX18_ERR("Error %d registering devices\n", retval);
817 goto free_streams;
818 }
1c1e45d1
HV		 819
820 CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
821
822 return 0;
823
824free_streams:
3f98387e 825 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 826free_irq:
827 free_irq(cx->dev->irq, (void *)cx);
828free_i2c:
829 exit_cx18_i2c(cx);
830free_map:
831 cx18_iounmap(cx);
832free_mem:
833 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
834free_workqueue:
835err:
836 if (retval == 0)
837 retval = -ENODEV;
838 CX18_ERR("Error %d on initialization\n", retval);
d267d851 839 cx18_log_statistics(cx);
1c1e45d1 840
ff086575
AW		 841 i = cx->num;
842 spin_lock(&cx18_cards_lock);
843 kfree(cx18_cards[i]);
844 cx18_cards[i] = NULL;
845 spin_unlock(&cx18_cards_lock);
1c1e45d1
HV		 846 return retval;
847}
848
849int cx18_init_on_first_open(struct cx18 *cx)
850{
851 int video_input;
852 int fw_retry_count = 3;
853 struct v4l2_frequency vf;
3b6fe58f
AW		 854 struct cx18_open_id fh;
855
856 fh.cx = cx;
1c1e45d1
HV		 857
858 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
859 return -ENXIO;
860
861 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
862 return 0;
863
864 while (--fw_retry_count > 0) {
865 /* load firmware */
866 if (cx18_firmware_init(cx) == 0)
867 break;
868 if (fw_retry_count > 1)
869 CX18_WARN("Retry loading firmware\n");
870 }
871
872 if (fw_retry_count == 0) {
873 set_bit(CX18_F_I_FAILED, &cx->i_flags);
874 return -ENXIO;
875 }
876 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
877
878 /* Init the firmware twice to work around a silicon bug
879 * transport related. */
880
881 fw_retry_count = 3;
882 while (--fw_retry_count > 0) {
883 /* load firmware */
884 if (cx18_firmware_init(cx) == 0)
885 break;
886 if (fw_retry_count > 1)
887 CX18_WARN("Retry loading firmware\n");
888 }
889
890 if (fw_retry_count == 0) {
891 set_bit(CX18_F_I_FAILED, &cx->i_flags);
892 return -ENXIO;
893 }
894
895 vf.tuner = 0;
896 vf.type = V4L2_TUNER_ANALOG_TV;
897 vf.frequency = 6400; /* the tuner 'baseline' frequency */
898
899 /* Set initial frequency. For PAL/SECAM broadcasts no
900 'default' channel exists AFAIK. */
901 if (cx->std == V4L2_STD_NTSC_M_JP)
902 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
903 else if (cx->std & V4L2_STD_NTSC_M)
904 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
905
906 video_input = cx->active_input;
907 cx->active_input++; /* Force update of input */
3b6fe58f 908 cx18_s_input(NULL, &fh, video_input);
1c1e45d1
HV		 909
910 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
911 in one place. */
912 cx->std++; /* Force full standard initialization */
3b6fe58f
AW		 913 cx18_s_std(NULL, &fh, &cx->tuner_std);
914 cx18_s_frequency(NULL, &fh, &vf);
1c1e45d1
HV		 915 return 0;
916}
917
918static void cx18_remove(struct pci_dev *pci_dev)
919{
920 struct cx18 *cx = pci_get_drvdata(pci_dev);
921
922 CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
923
924 /* Stop all captures */
925 CX18_DEBUG_INFO("Stopping all streams\n");
31554ae5 926 if (atomic_read(&cx->tot_capturing) > 0)
1c1e45d1
HV		 927 cx18_stop_all_captures(cx);
928
929 /* Interrupts */
b1526421
AW		 930 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
931 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1c1e45d1
HV		 932
933 cx18_halt_firmware(cx);
934
3f98387e 935 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 936
937 exit_cx18_i2c(cx);
938
939 free_irq(cx->dev->irq, (void *)cx);
940
cba627a5 941 cx18_iounmap(cx);
1c1e45d1
HV		 942
943 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
944
945 pci_disable_device(cx->dev);
946
d267d851 947 cx18_log_statistics(cx);
1c1e45d1
HV		 948 CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
949}
950
951/* define a pci_driver for card detection */
952static struct pci_driver cx18_pci_driver = {
953 .name = "cx18",
954 .id_table = cx18_pci_tbl,
955 .probe = cx18_probe,
956 .remove = cx18_remove,
957};
958
959static int module_start(void)
960{
961 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
962
963 memset(cx18_cards, 0, sizeof(cx18_cards));
964
965 /* Validate parameters */
966 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
dd89601d 967 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1c1e45d1
HV		 968 CX18_MAX_CARDS - 1);
969 return -1;
970 }
971
972 if (cx18_debug < 0 || cx18_debug > 511) {
973 cx18_debug = 0;
974 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
975 }
976
977 if (pci_register_driver(&cx18_pci_driver)) {
978 printk(KERN_ERR "cx18: Error detecting PCI card\n");
979 return -ENODEV;
980 }
981 printk(KERN_INFO "cx18: End initialization\n");
982 return 0;
983}
984
985static void module_cleanup(void)
986{
987 int i;
988
989 pci_unregister_driver(&cx18_pci_driver);
990
991 for (i = 0; i < cx18_cards_active; i++) {
992 if (cx18_cards[i] == NULL)
993 continue;
994 kfree(cx18_cards[i]);
995 }
996}
997
998module_init(module_start);
999module_exit(module_cleanup);
Ubuntu Focal Linux kernel mirror