1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // xc2028 |
3 | // |
4 | // Copyright (c) 2007-2008 Mauro Carvalho Chehab <mchehab@kernel.org> |
5 | // |
6 | // Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com) |
7 | // - frontend interface |
8 | |
9 | #include <linux/i2c.h> |
10 | #include <asm/div64.h> |
11 | #include <linux/firmware.h> |
12 | #include <linux/videodev2.h> |
13 | #include <linux/delay.h> |
14 | #include <media/tuner.h> |
15 | #include <linux/mutex.h> |
16 | #include <linux/slab.h> |
17 | #include <asm/unaligned.h> |
18 | #include "tuner-i2c.h" |
19 | #include "xc2028.h" |
20 | #include "xc2028-types.h" |
21 | |
22 | #include <linux/dvb/frontend.h> |
23 | #include <media/dvb_frontend.h> |
24 | |
25 | /* Max transfer size done by I2C transfer functions */ |
26 | #define MAX_XFER_SIZE 80 |
27 | |
28 | /* Registers (Write-only) */ |
29 | #define XREG_INIT 0x00 |
30 | #define XREG_RF_FREQ 0x02 |
31 | #define XREG_POWER_DOWN 0x08 |
32 | |
33 | /* Registers (Read-only) */ |
34 | #define XREG_FREQ_ERROR 0x01 |
35 | #define XREG_LOCK 0x02 |
36 | #define XREG_VERSION 0x04 |
37 | #define XREG_PRODUCT_ID 0x08 |
38 | #define XREG_HSYNC_FREQ 0x10 |
39 | #define XREG_FRAME_LINES 0x20 |
40 | #define XREG_SNR 0x40 |
41 | |
42 | #define XREG_ADC_ENV 0x0100 |
43 | |
44 | static int debug; |
45 | module_param(debug, int, 0644); |
46 | MODULE_PARM_DESC(debug, "enable verbose debug messages" ); |
47 | |
48 | static int no_poweroff; |
49 | module_param(no_poweroff, int, 0644); |
50 | MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n" |
51 | "1 keep device energized and with tuner ready all the times.\n" |
52 | " Faster, but consumes more power and keeps the device hotter\n" ); |
53 | |
54 | static char audio_std[8]; |
55 | module_param_string(audio_std, audio_std, sizeof(audio_std), 0); |
56 | MODULE_PARM_DESC(audio_std, |
57 | "Audio standard. XC3028 audio decoder explicitly needs to know what audio\n" |
58 | "standard is needed for some video standards with audio A2 or NICAM.\n" |
59 | "The valid values are:\n" |
60 | "A2\n" |
61 | "A2/A\n" |
62 | "A2/B\n" |
63 | "NICAM\n" |
64 | "NICAM/A\n" |
65 | "NICAM/B\n" ); |
66 | |
67 | static char firmware_name[30]; |
68 | module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0); |
69 | MODULE_PARM_DESC(firmware_name, |
70 | "Firmware file name. Allows overriding the default firmware name\n" ); |
71 | |
72 | static LIST_HEAD(hybrid_tuner_instance_list); |
73 | static DEFINE_MUTEX(xc2028_list_mutex); |
74 | |
75 | /* struct for storing firmware table */ |
76 | struct firmware_description { |
77 | unsigned int type; |
78 | v4l2_std_id id; |
79 | __u16 int_freq; |
80 | unsigned char *ptr; |
81 | unsigned int size; |
82 | }; |
83 | |
84 | struct firmware_properties { |
85 | unsigned int type; |
86 | v4l2_std_id id; |
87 | v4l2_std_id std_req; |
88 | __u16 int_freq; |
89 | unsigned int scode_table; |
90 | int scode_nr; |
91 | }; |
92 | |
93 | enum xc2028_state { |
94 | XC2028_NO_FIRMWARE = 0, |
95 | XC2028_WAITING_FIRMWARE, |
96 | XC2028_ACTIVE, |
97 | XC2028_SLEEP, |
98 | XC2028_NODEV, |
99 | }; |
100 | |
101 | struct xc2028_data { |
102 | struct list_head hybrid_tuner_instance_list; |
103 | struct tuner_i2c_props i2c_props; |
104 | __u32 frequency; |
105 | |
106 | enum xc2028_state state; |
107 | const char *fname; |
108 | |
109 | struct firmware_description *firm; |
110 | int firm_size; |
111 | __u16 firm_version; |
112 | |
113 | __u16 hwmodel; |
114 | __u16 hwvers; |
115 | |
116 | struct xc2028_ctrl ctrl; |
117 | |
118 | struct firmware_properties cur_fw; |
119 | |
120 | struct mutex lock; |
121 | }; |
122 | |
123 | #define i2c_send(priv, buf, size) ({ \ |
124 | int _rc; \ |
125 | _rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size); \ |
126 | if (size != _rc) \ |
127 | tuner_info("i2c output error: rc = %d (should be %d)\n",\ |
128 | _rc, (int)size); \ |
129 | if (priv->ctrl.msleep) \ |
130 | msleep(priv->ctrl.msleep); \ |
131 | _rc; \ |
132 | }) |
133 | |
134 | #define i2c_send_recv(priv, obuf, osize, ibuf, isize) ({ \ |
135 | int _rc; \ |
136 | _rc = tuner_i2c_xfer_send_recv(&priv->i2c_props, obuf, osize, \ |
137 | ibuf, isize); \ |
138 | if (isize != _rc) \ |
139 | tuner_err("i2c input error: rc = %d (should be %d)\n", \ |
140 | _rc, (int)isize); \ |
141 | if (priv->ctrl.msleep) \ |
142 | msleep(priv->ctrl.msleep); \ |
143 | _rc; \ |
144 | }) |
145 | |
146 | #define send_seq(priv, data...) ({ \ |
147 | static u8 _val[] = data; \ |
148 | int _rc; \ |
149 | if (sizeof(_val) != \ |
150 | (_rc = tuner_i2c_xfer_send(&priv->i2c_props, \ |
151 | _val, sizeof(_val)))) { \ |
152 | tuner_err("Error on line %d: %d\n", __LINE__, _rc); \ |
153 | } else if (priv->ctrl.msleep) \ |
154 | msleep(priv->ctrl.msleep); \ |
155 | _rc; \ |
156 | }) |
157 | |
158 | static int xc2028_get_reg(struct xc2028_data *priv, u16 reg, u16 *val) |
159 | { |
160 | unsigned char buf[2]; |
161 | unsigned char ibuf[2]; |
162 | |
163 | tuner_dbg("%s %04x called\n" , __func__, reg); |
164 | |
165 | buf[0] = reg >> 8; |
166 | buf[1] = (unsigned char) reg; |
167 | |
168 | if (i2c_send_recv(priv, buf, 2, ibuf, 2) != 2) |
169 | return -EIO; |
170 | |
171 | *val = (ibuf[1]) | (ibuf[0] << 8); |
172 | return 0; |
173 | } |
174 | |
175 | #define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0) |
176 | static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq) |
177 | { |
178 | if (type & BASE) |
179 | printk(KERN_CONT "BASE " ); |
180 | if (type & INIT1) |
181 | printk(KERN_CONT "INIT1 " ); |
182 | if (type & F8MHZ) |
183 | printk(KERN_CONT "F8MHZ " ); |
184 | if (type & MTS) |
185 | printk(KERN_CONT "MTS " ); |
186 | if (type & D2620) |
187 | printk(KERN_CONT "D2620 " ); |
188 | if (type & D2633) |
189 | printk(KERN_CONT "D2633 " ); |
190 | if (type & DTV6) |
191 | printk(KERN_CONT "DTV6 " ); |
192 | if (type & QAM) |
193 | printk(KERN_CONT "QAM " ); |
194 | if (type & DTV7) |
195 | printk(KERN_CONT "DTV7 " ); |
196 | if (type & DTV78) |
197 | printk(KERN_CONT "DTV78 " ); |
198 | if (type & DTV8) |
199 | printk(KERN_CONT "DTV8 " ); |
200 | if (type & FM) |
201 | printk(KERN_CONT "FM " ); |
202 | if (type & INPUT1) |
203 | printk(KERN_CONT "INPUT1 " ); |
204 | if (type & LCD) |
205 | printk(KERN_CONT "LCD " ); |
206 | if (type & NOGD) |
207 | printk(KERN_CONT "NOGD " ); |
208 | if (type & MONO) |
209 | printk(KERN_CONT "MONO " ); |
210 | if (type & ATSC) |
211 | printk(KERN_CONT "ATSC " ); |
212 | if (type & IF) |
213 | printk(KERN_CONT "IF " ); |
214 | if (type & LG60) |
215 | printk(KERN_CONT "LG60 " ); |
216 | if (type & ATI638) |
217 | printk(KERN_CONT "ATI638 " ); |
218 | if (type & OREN538) |
219 | printk(KERN_CONT "OREN538 " ); |
220 | if (type & OREN36) |
221 | printk(KERN_CONT "OREN36 " ); |
222 | if (type & TOYOTA388) |
223 | printk(KERN_CONT "TOYOTA388 " ); |
224 | if (type & TOYOTA794) |
225 | printk(KERN_CONT "TOYOTA794 " ); |
226 | if (type & DIBCOM52) |
227 | printk(KERN_CONT "DIBCOM52 " ); |
228 | if (type & ZARLINK456) |
229 | printk(KERN_CONT "ZARLINK456 " ); |
230 | if (type & CHINA) |
231 | printk(KERN_CONT "CHINA " ); |
232 | if (type & F6MHZ) |
233 | printk(KERN_CONT "F6MHZ " ); |
234 | if (type & INPUT2) |
235 | printk(KERN_CONT "INPUT2 " ); |
236 | if (type & SCODE) |
237 | printk(KERN_CONT "SCODE " ); |
238 | if (type & HAS_IF) |
239 | printk(KERN_CONT "HAS_IF_%d " , int_freq); |
240 | } |
241 | |
242 | static v4l2_std_id parse_audio_std_option(void) |
243 | { |
244 | if (strcasecmp(s1: audio_std, s2: "A2" ) == 0) |
245 | return V4L2_STD_A2; |
246 | if (strcasecmp(s1: audio_std, s2: "A2/A" ) == 0) |
247 | return V4L2_STD_A2_A; |
248 | if (strcasecmp(s1: audio_std, s2: "A2/B" ) == 0) |
249 | return V4L2_STD_A2_B; |
250 | if (strcasecmp(s1: audio_std, s2: "NICAM" ) == 0) |
251 | return V4L2_STD_NICAM; |
252 | if (strcasecmp(s1: audio_std, s2: "NICAM/A" ) == 0) |
253 | return V4L2_STD_NICAM_A; |
254 | if (strcasecmp(s1: audio_std, s2: "NICAM/B" ) == 0) |
255 | return V4L2_STD_NICAM_B; |
256 | |
257 | return 0; |
258 | } |
259 | |
260 | static int check_device_status(struct xc2028_data *priv) |
261 | { |
262 | switch (priv->state) { |
263 | case XC2028_NO_FIRMWARE: |
264 | case XC2028_WAITING_FIRMWARE: |
265 | return -EAGAIN; |
266 | case XC2028_ACTIVE: |
267 | return 1; |
268 | case XC2028_SLEEP: |
269 | return 0; |
270 | case XC2028_NODEV: |
271 | return -ENODEV; |
272 | } |
273 | return 0; |
274 | } |
275 | |
276 | static void free_firmware(struct xc2028_data *priv) |
277 | { |
278 | int i; |
279 | tuner_dbg("%s called\n" , __func__); |
280 | |
281 | /* free allocated f/w string */ |
282 | if (priv->fname != firmware_name) |
283 | kfree(objp: priv->fname); |
284 | priv->fname = NULL; |
285 | |
286 | priv->state = XC2028_NO_FIRMWARE; |
287 | memset(&priv->cur_fw, 0, sizeof(priv->cur_fw)); |
288 | |
289 | if (!priv->firm) |
290 | return; |
291 | |
292 | for (i = 0; i < priv->firm_size; i++) |
293 | kfree(objp: priv->firm[i].ptr); |
294 | |
295 | kfree(objp: priv->firm); |
296 | |
297 | priv->firm = NULL; |
298 | priv->firm_size = 0; |
299 | } |
300 | |
301 | static int load_all_firmwares(struct dvb_frontend *fe, |
302 | const struct firmware *fw) |
303 | { |
304 | struct xc2028_data *priv = fe->tuner_priv; |
305 | const unsigned char *p, *endp; |
306 | int rc = 0; |
307 | int n, n_array; |
308 | char name[33]; |
309 | |
310 | tuner_dbg("%s called\n" , __func__); |
311 | |
312 | p = fw->data; |
313 | endp = p + fw->size; |
314 | |
315 | if (fw->size < sizeof(name) - 1 + 2 + 2) { |
316 | tuner_err("Error: firmware file %s has invalid size!\n" , |
317 | priv->fname); |
318 | goto corrupt; |
319 | } |
320 | |
321 | memcpy(name, p, sizeof(name) - 1); |
322 | name[sizeof(name) - 1] = 0; |
323 | p += sizeof(name) - 1; |
324 | |
325 | priv->firm_version = get_unaligned_le16(p); |
326 | p += 2; |
327 | |
328 | n_array = get_unaligned_le16(p); |
329 | p += 2; |
330 | |
331 | tuner_info("Loading %d firmware images from %s, type: %s, ver %d.%d\n" , |
332 | n_array, priv->fname, name, |
333 | priv->firm_version >> 8, priv->firm_version & 0xff); |
334 | |
335 | priv->firm = kcalloc(n: n_array, size: sizeof(*priv->firm), GFP_KERNEL); |
336 | if (priv->firm == NULL) { |
337 | tuner_err("Not enough memory to load firmware file.\n" ); |
338 | rc = -ENOMEM; |
339 | goto err; |
340 | } |
341 | priv->firm_size = n_array; |
342 | |
343 | n = -1; |
344 | while (p < endp) { |
345 | __u32 type, size; |
346 | v4l2_std_id id; |
347 | __u16 int_freq = 0; |
348 | |
349 | n++; |
350 | if (n >= n_array) { |
351 | tuner_err("More firmware images in file than were expected!\n" ); |
352 | goto corrupt; |
353 | } |
354 | |
355 | /* Checks if there's enough bytes to read */ |
356 | if (endp - p < sizeof(type) + sizeof(id) + sizeof(size)) |
357 | goto header; |
358 | |
359 | type = get_unaligned_le32(p); |
360 | p += sizeof(type); |
361 | |
362 | id = get_unaligned_le64(p); |
363 | p += sizeof(id); |
364 | |
365 | if (type & HAS_IF) { |
366 | int_freq = get_unaligned_le16(p); |
367 | p += sizeof(int_freq); |
368 | if (endp - p < sizeof(size)) |
369 | goto header; |
370 | } |
371 | |
372 | size = get_unaligned_le32(p); |
373 | p += sizeof(size); |
374 | |
375 | if (!size || size > endp - p) { |
376 | tuner_err("Firmware type " ); |
377 | dump_firm_type(type); |
378 | printk(KERN_CONT |
379 | "(%x), id %llx is corrupted (size=%zd, expected %d)\n" , |
380 | type, (unsigned long long)id, (endp - p), size); |
381 | goto corrupt; |
382 | } |
383 | |
384 | priv->firm[n].ptr = kmemdup(p, size, GFP_KERNEL); |
385 | if (priv->firm[n].ptr == NULL) { |
386 | tuner_err("Not enough memory to load firmware file.\n" ); |
387 | rc = -ENOMEM; |
388 | goto err; |
389 | } |
390 | tuner_dbg("Reading firmware type " ); |
391 | if (debug) { |
392 | dump_firm_type_and_int_freq(type, int_freq); |
393 | printk(KERN_CONT "(%x), id %llx, size=%d.\n" , |
394 | type, (unsigned long long)id, size); |
395 | } |
396 | |
397 | priv->firm[n].type = type; |
398 | priv->firm[n].id = id; |
399 | priv->firm[n].size = size; |
400 | priv->firm[n].int_freq = int_freq; |
401 | |
402 | p += size; |
403 | } |
404 | |
405 | if (n + 1 != priv->firm_size) { |
406 | tuner_err("Firmware file is incomplete!\n" ); |
407 | goto corrupt; |
408 | } |
409 | |
410 | goto done; |
411 | |
412 | : |
413 | tuner_err("Firmware header is incomplete!\n" ); |
414 | corrupt: |
415 | rc = -EINVAL; |
416 | tuner_err("Error: firmware file is corrupted!\n" ); |
417 | |
418 | err: |
419 | tuner_info("Releasing partially loaded firmware file.\n" ); |
420 | free_firmware(priv); |
421 | |
422 | done: |
423 | if (rc == 0) |
424 | tuner_dbg("Firmware files loaded.\n" ); |
425 | else |
426 | priv->state = XC2028_NODEV; |
427 | |
428 | return rc; |
429 | } |
430 | |
431 | static int seek_firmware(struct dvb_frontend *fe, unsigned int type, |
432 | v4l2_std_id *id) |
433 | { |
434 | struct xc2028_data *priv = fe->tuner_priv; |
435 | int i, best_i = -1, best_nr_matches = 0; |
436 | unsigned int type_mask = 0; |
437 | |
438 | tuner_dbg("%s called, want type=" , __func__); |
439 | if (debug) { |
440 | dump_firm_type(type); |
441 | printk(KERN_CONT "(%x), id %016llx.\n" , |
442 | type, (unsigned long long)*id); |
443 | } |
444 | |
445 | if (!priv->firm) { |
446 | tuner_err("Error! firmware not loaded\n" ); |
447 | return -EINVAL; |
448 | } |
449 | |
450 | if (((type & ~SCODE) == 0) && (*id == 0)) |
451 | *id = V4L2_STD_PAL; |
452 | |
453 | if (type & BASE) |
454 | type_mask = BASE_TYPES; |
455 | else if (type & SCODE) { |
456 | type &= SCODE_TYPES; |
457 | type_mask = SCODE_TYPES & ~HAS_IF; |
458 | } else if (type & DTV_TYPES) |
459 | type_mask = DTV_TYPES; |
460 | else if (type & STD_SPECIFIC_TYPES) |
461 | type_mask = STD_SPECIFIC_TYPES; |
462 | |
463 | type &= type_mask; |
464 | |
465 | if (!(type & SCODE)) |
466 | type_mask = ~0; |
467 | |
468 | /* Seek for exact match */ |
469 | for (i = 0; i < priv->firm_size; i++) { |
470 | if ((type == (priv->firm[i].type & type_mask)) && |
471 | (*id == priv->firm[i].id)) |
472 | goto found; |
473 | } |
474 | |
475 | /* Seek for generic video standard match */ |
476 | for (i = 0; i < priv->firm_size; i++) { |
477 | v4l2_std_id match_mask; |
478 | int nr_matches; |
479 | |
480 | if (type != (priv->firm[i].type & type_mask)) |
481 | continue; |
482 | |
483 | match_mask = *id & priv->firm[i].id; |
484 | if (!match_mask) |
485 | continue; |
486 | |
487 | if ((*id & match_mask) == *id) |
488 | goto found; /* Supports all the requested standards */ |
489 | |
490 | nr_matches = hweight64(match_mask); |
491 | if (nr_matches > best_nr_matches) { |
492 | best_nr_matches = nr_matches; |
493 | best_i = i; |
494 | } |
495 | } |
496 | |
497 | if (best_nr_matches > 0) { |
498 | tuner_dbg("Selecting best matching firmware (%d bits) for type=" , |
499 | best_nr_matches); |
500 | dump_firm_type(type); |
501 | printk(KERN_CONT |
502 | "(%x), id %016llx:\n" , type, (unsigned long long)*id); |
503 | i = best_i; |
504 | goto found; |
505 | } |
506 | |
507 | /*FIXME: Would make sense to seek for type "hint" match ? */ |
508 | |
509 | i = -ENOENT; |
510 | goto ret; |
511 | |
512 | found: |
513 | *id = priv->firm[i].id; |
514 | |
515 | ret: |
516 | tuner_dbg("%s firmware for type=" , (i < 0) ? "Can't find" : "Found" ); |
517 | if (debug) { |
518 | dump_firm_type(type); |
519 | printk(KERN_CONT "(%x), id %016llx.\n" , |
520 | type, (unsigned long long)*id); |
521 | } |
522 | return i; |
523 | } |
524 | |
525 | static inline int do_tuner_callback(struct dvb_frontend *fe, int cmd, int arg) |
526 | { |
527 | struct xc2028_data *priv = fe->tuner_priv; |
528 | |
529 | /* analog side (tuner-core) uses i2c_adap->algo_data. |
530 | * digital side is not guaranteed to have algo_data defined. |
531 | * |
532 | * digital side will always have fe->dvb defined. |
533 | * analog side (tuner-core) doesn't (yet) define fe->dvb. |
534 | */ |
535 | |
536 | return (!fe->callback) ? -EINVAL : |
537 | fe->callback(((fe->dvb) && (fe->dvb->priv)) ? |
538 | fe->dvb->priv : priv->i2c_props.adap->algo_data, |
539 | DVB_FRONTEND_COMPONENT_TUNER, cmd, arg); |
540 | } |
541 | |
542 | static int load_firmware(struct dvb_frontend *fe, unsigned int type, |
543 | v4l2_std_id *id) |
544 | { |
545 | struct xc2028_data *priv = fe->tuner_priv; |
546 | int pos, rc; |
547 | unsigned char *p, *endp, buf[MAX_XFER_SIZE]; |
548 | |
549 | if (priv->ctrl.max_len > sizeof(buf)) |
550 | priv->ctrl.max_len = sizeof(buf); |
551 | |
552 | tuner_dbg("%s called\n" , __func__); |
553 | |
554 | pos = seek_firmware(fe, type, id); |
555 | if (pos < 0) |
556 | return pos; |
557 | |
558 | tuner_info("Loading firmware for type=" ); |
559 | dump_firm_type(priv->firm[pos].type); |
560 | printk(KERN_CONT "(%x), id %016llx.\n" , |
561 | priv->firm[pos].type, (unsigned long long)*id); |
562 | |
563 | p = priv->firm[pos].ptr; |
564 | endp = p + priv->firm[pos].size; |
565 | |
566 | while (p < endp) { |
567 | __u16 size; |
568 | |
569 | /* Checks if there's enough bytes to read */ |
570 | if (p + sizeof(size) > endp) { |
571 | tuner_err("Firmware chunk size is wrong\n" ); |
572 | return -EINVAL; |
573 | } |
574 | |
575 | size = le16_to_cpu(*(__le16 *) p); |
576 | p += sizeof(size); |
577 | |
578 | if (size == 0xffff) |
579 | return 0; |
580 | |
581 | if (!size) { |
582 | /* Special callback command received */ |
583 | rc = do_tuner_callback(fe, XC2028_TUNER_RESET, arg: 0); |
584 | if (rc < 0) { |
585 | tuner_err("Error at RESET code %d\n" , |
586 | (*p) & 0x7f); |
587 | return -EINVAL; |
588 | } |
589 | continue; |
590 | } |
591 | if (size >= 0xff00) { |
592 | switch (size) { |
593 | case 0xff00: |
594 | rc = do_tuner_callback(fe, XC2028_RESET_CLK, arg: 0); |
595 | if (rc < 0) { |
596 | tuner_err("Error at RESET code %d\n" , |
597 | (*p) & 0x7f); |
598 | return -EINVAL; |
599 | } |
600 | break; |
601 | default: |
602 | tuner_info("Invalid RESET code %d\n" , |
603 | size & 0x7f); |
604 | return -EINVAL; |
605 | |
606 | } |
607 | continue; |
608 | } |
609 | |
610 | /* Checks for a sleep command */ |
611 | if (size & 0x8000) { |
612 | msleep(msecs: size & 0x7fff); |
613 | continue; |
614 | } |
615 | |
616 | if ((size + p > endp)) { |
617 | tuner_err("missing bytes: need %d, have %zd\n" , |
618 | size, (endp - p)); |
619 | return -EINVAL; |
620 | } |
621 | |
622 | buf[0] = *p; |
623 | p++; |
624 | size--; |
625 | |
626 | /* Sends message chunks */ |
627 | while (size > 0) { |
628 | int len = (size < priv->ctrl.max_len - 1) ? |
629 | size : priv->ctrl.max_len - 1; |
630 | |
631 | memcpy(buf + 1, p, len); |
632 | |
633 | rc = i2c_send(priv, buf, len + 1); |
634 | if (rc < 0) { |
635 | tuner_err("%d returned from send\n" , rc); |
636 | return -EINVAL; |
637 | } |
638 | |
639 | p += len; |
640 | size -= len; |
641 | } |
642 | |
643 | /* silently fail if the frontend doesn't support I2C flush */ |
644 | rc = do_tuner_callback(fe, XC2028_I2C_FLUSH, arg: 0); |
645 | if ((rc < 0) && (rc != -EINVAL)) { |
646 | tuner_err("error executing flush: %d\n" , rc); |
647 | return rc; |
648 | } |
649 | } |
650 | return 0; |
651 | } |
652 | |
653 | static int load_scode(struct dvb_frontend *fe, unsigned int type, |
654 | v4l2_std_id *id, __u16 int_freq, int scode) |
655 | { |
656 | struct xc2028_data *priv = fe->tuner_priv; |
657 | int pos, rc; |
658 | unsigned char *p; |
659 | |
660 | tuner_dbg("%s called\n" , __func__); |
661 | |
662 | if (!int_freq) { |
663 | pos = seek_firmware(fe, type, id); |
664 | if (pos < 0) |
665 | return pos; |
666 | } else { |
667 | for (pos = 0; pos < priv->firm_size; pos++) { |
668 | if ((priv->firm[pos].int_freq == int_freq) && |
669 | (priv->firm[pos].type & HAS_IF)) |
670 | break; |
671 | } |
672 | if (pos == priv->firm_size) |
673 | return -ENOENT; |
674 | } |
675 | |
676 | p = priv->firm[pos].ptr; |
677 | |
678 | if (priv->firm[pos].type & HAS_IF) { |
679 | if (priv->firm[pos].size != 12 * 16 || scode >= 16) |
680 | return -EINVAL; |
681 | p += 12 * scode; |
682 | } else { |
683 | /* 16 SCODE entries per file; each SCODE entry is 12 bytes and |
684 | * has a 2-byte size header in the firmware format. */ |
685 | if (priv->firm[pos].size != 14 * 16 || scode >= 16 || |
686 | le16_to_cpu(*(__le16 *)(p + 14 * scode)) != 12) |
687 | return -EINVAL; |
688 | p += 14 * scode + 2; |
689 | } |
690 | |
691 | tuner_info("Loading SCODE for type=" ); |
692 | dump_firm_type_and_int_freq(type: priv->firm[pos].type, |
693 | int_freq: priv->firm[pos].int_freq); |
694 | printk(KERN_CONT "(%x), id %016llx.\n" , priv->firm[pos].type, |
695 | (unsigned long long)*id); |
696 | |
697 | if (priv->firm_version < 0x0202) |
698 | rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00}); |
699 | else |
700 | rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00}); |
701 | if (rc < 0) |
702 | return -EIO; |
703 | |
704 | rc = i2c_send(priv, p, 12); |
705 | if (rc < 0) |
706 | return -EIO; |
707 | |
708 | rc = send_seq(priv, {0x00, 0x8c}); |
709 | if (rc < 0) |
710 | return -EIO; |
711 | |
712 | return 0; |
713 | } |
714 | |
715 | static int xc2028_sleep(struct dvb_frontend *fe); |
716 | |
717 | static int check_firmware(struct dvb_frontend *fe, unsigned int type, |
718 | v4l2_std_id std, __u16 int_freq) |
719 | { |
720 | struct xc2028_data *priv = fe->tuner_priv; |
721 | struct firmware_properties new_fw; |
722 | int rc, retry_count = 0; |
723 | u16 version, hwmodel; |
724 | v4l2_std_id std0; |
725 | |
726 | tuner_dbg("%s called\n" , __func__); |
727 | |
728 | rc = check_device_status(priv); |
729 | if (rc < 0) |
730 | return rc; |
731 | |
732 | if (priv->ctrl.mts && !(type & FM)) |
733 | type |= MTS; |
734 | |
735 | retry: |
736 | new_fw.type = type; |
737 | new_fw.id = std; |
738 | new_fw.std_req = std; |
739 | new_fw.scode_table = SCODE | priv->ctrl.scode_table; |
740 | new_fw.scode_nr = 0; |
741 | new_fw.int_freq = int_freq; |
742 | |
743 | tuner_dbg("checking firmware, user requested type=" ); |
744 | if (debug) { |
745 | dump_firm_type(new_fw.type); |
746 | printk(KERN_CONT "(%x), id %016llx, " , new_fw.type, |
747 | (unsigned long long)new_fw.std_req); |
748 | if (!int_freq) { |
749 | printk(KERN_CONT "scode_tbl " ); |
750 | dump_firm_type(priv->ctrl.scode_table); |
751 | printk(KERN_CONT "(%x), " , priv->ctrl.scode_table); |
752 | } else |
753 | printk(KERN_CONT "int_freq %d, " , new_fw.int_freq); |
754 | printk(KERN_CONT "scode_nr %d\n" , new_fw.scode_nr); |
755 | } |
756 | |
757 | /* |
758 | * No need to reload base firmware if it matches and if the tuner |
759 | * is not at sleep mode |
760 | */ |
761 | if ((priv->state == XC2028_ACTIVE) && |
762 | (((BASE | new_fw.type) & BASE_TYPES) == |
763 | (priv->cur_fw.type & BASE_TYPES))) { |
764 | tuner_dbg("BASE firmware not changed.\n" ); |
765 | goto skip_base; |
766 | } |
767 | |
768 | /* Updating BASE - forget about all currently loaded firmware */ |
769 | memset(&priv->cur_fw, 0, sizeof(priv->cur_fw)); |
770 | |
771 | /* Reset is needed before loading firmware */ |
772 | rc = do_tuner_callback(fe, XC2028_TUNER_RESET, arg: 0); |
773 | if (rc < 0) |
774 | goto fail; |
775 | |
776 | /* BASE firmwares are all std0 */ |
777 | std0 = 0; |
778 | rc = load_firmware(fe, BASE | new_fw.type, id: &std0); |
779 | if (rc < 0) { |
780 | tuner_err("Error %d while loading base firmware\n" , |
781 | rc); |
782 | goto fail; |
783 | } |
784 | |
785 | /* Load INIT1, if needed */ |
786 | tuner_dbg("Load init1 firmware, if exists\n" ); |
787 | |
788 | rc = load_firmware(fe, BASE | INIT1 | new_fw.type, id: &std0); |
789 | if (rc == -ENOENT) |
790 | rc = load_firmware(fe, type: (BASE | INIT1 | new_fw.type) & ~F8MHZ, |
791 | id: &std0); |
792 | if (rc < 0 && rc != -ENOENT) { |
793 | tuner_err("Error %d while loading init1 firmware\n" , |
794 | rc); |
795 | goto fail; |
796 | } |
797 | |
798 | skip_base: |
799 | /* |
800 | * No need to reload standard specific firmware if base firmware |
801 | * was not reloaded and requested video standards have not changed. |
802 | */ |
803 | if (priv->cur_fw.type == (BASE | new_fw.type) && |
804 | priv->cur_fw.std_req == std) { |
805 | tuner_dbg("Std-specific firmware already loaded.\n" ); |
806 | goto skip_std_specific; |
807 | } |
808 | |
809 | /* Reloading std-specific firmware forces a SCODE update */ |
810 | priv->cur_fw.scode_table = 0; |
811 | |
812 | rc = load_firmware(fe, type: new_fw.type, id: &new_fw.id); |
813 | if (rc == -ENOENT) |
814 | rc = load_firmware(fe, type: new_fw.type & ~F8MHZ, id: &new_fw.id); |
815 | |
816 | if (rc < 0) |
817 | goto fail; |
818 | |
819 | skip_std_specific: |
820 | if (priv->cur_fw.scode_table == new_fw.scode_table && |
821 | priv->cur_fw.scode_nr == new_fw.scode_nr) { |
822 | tuner_dbg("SCODE firmware already loaded.\n" ); |
823 | goto check_device; |
824 | } |
825 | |
826 | if (new_fw.type & FM) |
827 | goto check_device; |
828 | |
829 | /* Load SCODE firmware, if exists */ |
830 | tuner_dbg("Trying to load scode %d\n" , new_fw.scode_nr); |
831 | |
832 | rc = load_scode(fe, type: new_fw.type | new_fw.scode_table, id: &new_fw.id, |
833 | int_freq: new_fw.int_freq, scode: new_fw.scode_nr); |
834 | |
835 | check_device: |
836 | if (xc2028_get_reg(priv, reg: 0x0004, val: &version) < 0 || |
837 | xc2028_get_reg(priv, reg: 0x0008, val: &hwmodel) < 0) { |
838 | tuner_err("Unable to read tuner registers.\n" ); |
839 | goto fail; |
840 | } |
841 | |
842 | tuner_dbg("Device is Xceive %d version %d.%d, firmware version %d.%d\n" , |
843 | hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8, |
844 | (version & 0xf0) >> 4, version & 0xf); |
845 | |
846 | |
847 | if (priv->ctrl.read_not_reliable) |
848 | goto read_not_reliable; |
849 | |
850 | /* Check firmware version against what we downloaded. */ |
851 | if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) { |
852 | if (!priv->ctrl.read_not_reliable) { |
853 | tuner_err("Incorrect readback of firmware version.\n" ); |
854 | goto fail; |
855 | } else { |
856 | tuner_err("Returned an incorrect version. However, read is not reliable enough. Ignoring it.\n" ); |
857 | hwmodel = 3028; |
858 | } |
859 | } |
860 | |
861 | /* Check that the tuner hardware model remains consistent over time. */ |
862 | if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) { |
863 | priv->hwmodel = hwmodel; |
864 | priv->hwvers = version & 0xff00; |
865 | } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel || |
866 | priv->hwvers != (version & 0xff00)) { |
867 | tuner_err("Read invalid device hardware information - tuner hung?\n" ); |
868 | goto fail; |
869 | } |
870 | |
871 | read_not_reliable: |
872 | priv->cur_fw = new_fw; |
873 | |
874 | /* |
875 | * By setting BASE in cur_fw.type only after successfully loading all |
876 | * firmwares, we can: |
877 | * 1. Identify that BASE firmware with type=0 has been loaded; |
878 | * 2. Tell whether BASE firmware was just changed the next time through. |
879 | */ |
880 | priv->cur_fw.type |= BASE; |
881 | priv->state = XC2028_ACTIVE; |
882 | |
883 | return 0; |
884 | |
885 | fail: |
886 | free_firmware(priv); |
887 | |
888 | if (retry_count < 8) { |
889 | msleep(msecs: 50); |
890 | retry_count++; |
891 | tuner_dbg("Retrying firmware load\n" ); |
892 | goto retry; |
893 | } |
894 | |
895 | /* Firmware didn't load. Put the device to sleep */ |
896 | xc2028_sleep(fe); |
897 | |
898 | if (rc == -ENOENT) |
899 | rc = -EINVAL; |
900 | return rc; |
901 | } |
902 | |
903 | static int xc2028_signal(struct dvb_frontend *fe, u16 *strength) |
904 | { |
905 | struct xc2028_data *priv = fe->tuner_priv; |
906 | u16 frq_lock, signal = 0; |
907 | int rc, i; |
908 | |
909 | tuner_dbg("%s called\n" , __func__); |
910 | |
911 | rc = check_device_status(priv); |
912 | if (rc < 0) |
913 | return rc; |
914 | |
915 | /* If the device is sleeping, no channel is tuned */ |
916 | if (!rc) { |
917 | *strength = 0; |
918 | return 0; |
919 | } |
920 | |
921 | mutex_lock(&priv->lock); |
922 | |
923 | /* Sync Lock Indicator */ |
924 | for (i = 0; i < 3; i++) { |
925 | rc = xc2028_get_reg(priv, XREG_LOCK, val: &frq_lock); |
926 | if (rc < 0) |
927 | goto ret; |
928 | |
929 | if (frq_lock) |
930 | break; |
931 | msleep(msecs: 6); |
932 | } |
933 | |
934 | /* Frequency didn't lock */ |
935 | if (frq_lock == 2) |
936 | goto ret; |
937 | |
938 | /* Get SNR of the video signal */ |
939 | rc = xc2028_get_reg(priv, XREG_SNR, val: &signal); |
940 | if (rc < 0) |
941 | goto ret; |
942 | |
943 | /* Signal level is 3 bits only */ |
944 | |
945 | signal = ((1 << 12) - 1) | ((signal & 0x07) << 12); |
946 | |
947 | ret: |
948 | mutex_unlock(lock: &priv->lock); |
949 | |
950 | *strength = signal; |
951 | |
952 | tuner_dbg("signal strength is %d\n" , signal); |
953 | |
954 | return rc; |
955 | } |
956 | |
957 | static int xc2028_get_afc(struct dvb_frontend *fe, s32 *afc) |
958 | { |
959 | struct xc2028_data *priv = fe->tuner_priv; |
960 | int i, rc; |
961 | u16 frq_lock = 0; |
962 | s16 afc_reg = 0; |
963 | |
964 | rc = check_device_status(priv); |
965 | if (rc < 0) |
966 | return rc; |
967 | |
968 | /* If the device is sleeping, no channel is tuned */ |
969 | if (!rc) { |
970 | *afc = 0; |
971 | return 0; |
972 | } |
973 | |
974 | mutex_lock(&priv->lock); |
975 | |
976 | /* Sync Lock Indicator */ |
977 | for (i = 0; i < 3; i++) { |
978 | rc = xc2028_get_reg(priv, XREG_LOCK, val: &frq_lock); |
979 | if (rc < 0) |
980 | goto ret; |
981 | |
982 | if (frq_lock) |
983 | break; |
984 | msleep(msecs: 6); |
985 | } |
986 | |
987 | /* Frequency didn't lock */ |
988 | if (frq_lock == 2) |
989 | goto ret; |
990 | |
991 | /* Get AFC */ |
992 | rc = xc2028_get_reg(priv, XREG_FREQ_ERROR, val: &afc_reg); |
993 | if (rc < 0) |
994 | goto ret; |
995 | |
996 | *afc = afc_reg * 15625; /* Hz */ |
997 | |
998 | tuner_dbg("AFC is %d Hz\n" , *afc); |
999 | |
1000 | ret: |
1001 | mutex_unlock(lock: &priv->lock); |
1002 | |
1003 | return rc; |
1004 | } |
1005 | |
1006 | #define DIV 15625 |
1007 | |
1008 | static int generic_set_freq(struct dvb_frontend *fe, u32 freq /* in HZ */, |
1009 | enum v4l2_tuner_type new_type, |
1010 | unsigned int type, |
1011 | v4l2_std_id std, |
1012 | u16 int_freq) |
1013 | { |
1014 | struct xc2028_data *priv = fe->tuner_priv; |
1015 | int rc = -EINVAL; |
1016 | unsigned char buf[4]; |
1017 | u32 div, offset = 0; |
1018 | |
1019 | tuner_dbg("%s called\n" , __func__); |
1020 | |
1021 | mutex_lock(&priv->lock); |
1022 | |
1023 | tuner_dbg("should set frequency %d kHz\n" , freq / 1000); |
1024 | |
1025 | if (check_firmware(fe, type, std, int_freq) < 0) |
1026 | goto ret; |
1027 | |
1028 | /* On some cases xc2028 can disable video output, if |
1029 | * very weak signals are received. By sending a soft |
1030 | * reset, this is re-enabled. So, it is better to always |
1031 | * send a soft reset before changing channels, to be sure |
1032 | * that xc2028 will be in a safe state. |
1033 | * Maybe this might also be needed for DTV. |
1034 | */ |
1035 | switch (new_type) { |
1036 | case V4L2_TUNER_ANALOG_TV: |
1037 | rc = send_seq(priv, {0x00, 0x00}); |
1038 | |
1039 | /* Analog mode requires offset = 0 */ |
1040 | break; |
1041 | case V4L2_TUNER_RADIO: |
1042 | /* Radio mode requires offset = 0 */ |
1043 | break; |
1044 | case V4L2_TUNER_DIGITAL_TV: |
1045 | /* |
1046 | * Digital modes require an offset to adjust to the |
1047 | * proper frequency. The offset depends on what |
1048 | * firmware version is used. |
1049 | */ |
1050 | |
1051 | /* |
1052 | * Adjust to the center frequency. This is calculated by the |
1053 | * formula: offset = 1.25MHz - BW/2 |
1054 | * For DTV 7/8, the firmware uses BW = 8000, so it needs a |
1055 | * further adjustment to get the frequency center on VHF |
1056 | */ |
1057 | |
1058 | /* |
1059 | * The firmware DTV78 used to work fine in UHF band (8 MHz |
1060 | * bandwidth) but not at all in VHF band (7 MHz bandwidth). |
1061 | * The real problem was connected to the formula used to |
1062 | * calculate the center frequency offset in VHF band. |
1063 | * In fact, removing the 500KHz adjustment fixed the problem. |
1064 | * This is coherent to what was implemented for the DTV7 |
1065 | * firmware. |
1066 | * In the end, now the center frequency is the same for all 3 |
1067 | * firmwares (DTV7, DTV8, DTV78) and doesn't depend on channel |
1068 | * bandwidth. |
1069 | */ |
1070 | |
1071 | if (priv->cur_fw.type & DTV6) |
1072 | offset = 1750000; |
1073 | else /* DTV7 or DTV8 or DTV78 */ |
1074 | offset = 2750000; |
1075 | |
1076 | /* |
1077 | * xc3028 additional "magic" |
1078 | * Depending on the firmware version, it needs some adjustments |
1079 | * to properly centralize the frequency. This seems to be |
1080 | * needed to compensate the SCODE table adjustments made by |
1081 | * newer firmwares |
1082 | */ |
1083 | |
1084 | /* |
1085 | * The proper adjustment would be to do it at s-code table. |
1086 | * However, this didn't work, as reported by |
1087 | * Robert Lowery <rglowery@exemail.com.au> |
1088 | */ |
1089 | |
1090 | #if 0 |
1091 | /* |
1092 | * Still need tests for XC3028L (firmware 3.2 or upper) |
1093 | * So, for now, let's just comment the per-firmware |
1094 | * version of this change. Reports with xc3028l working |
1095 | * with and without the lines below are welcome |
1096 | */ |
1097 | |
1098 | if (priv->firm_version < 0x0302) { |
1099 | if (priv->cur_fw.type & DTV7) |
1100 | offset += 500000; |
1101 | } else { |
1102 | if (priv->cur_fw.type & DTV7) |
1103 | offset -= 300000; |
1104 | else if (type != ATSC) /* DVB @6MHz, DTV 8 and DTV 7/8 */ |
1105 | offset += 200000; |
1106 | } |
1107 | #endif |
1108 | break; |
1109 | default: |
1110 | tuner_err("Unsupported tuner type %d.\n" , new_type); |
1111 | break; |
1112 | } |
1113 | |
1114 | div = (freq - offset + DIV / 2) / DIV; |
1115 | |
1116 | /* CMD= Set frequency */ |
1117 | if (priv->firm_version < 0x0202) |
1118 | rc = send_seq(priv, {0x00, XREG_RF_FREQ, 0x00, 0x00}); |
1119 | else |
1120 | rc = send_seq(priv, {0x80, XREG_RF_FREQ, 0x00, 0x00}); |
1121 | if (rc < 0) |
1122 | goto ret; |
1123 | |
1124 | /* Return code shouldn't be checked. |
1125 | The reset CLK is needed only with tm6000. |
1126 | Driver should work fine even if this fails. |
1127 | */ |
1128 | if (priv->ctrl.msleep) |
1129 | msleep(msecs: priv->ctrl.msleep); |
1130 | do_tuner_callback(fe, XC2028_RESET_CLK, arg: 1); |
1131 | |
1132 | msleep(msecs: 10); |
1133 | |
1134 | buf[0] = 0xff & (div >> 24); |
1135 | buf[1] = 0xff & (div >> 16); |
1136 | buf[2] = 0xff & (div >> 8); |
1137 | buf[3] = 0xff & (div); |
1138 | |
1139 | rc = i2c_send(priv, buf, sizeof(buf)); |
1140 | if (rc < 0) |
1141 | goto ret; |
1142 | msleep(msecs: 100); |
1143 | |
1144 | priv->frequency = freq; |
1145 | |
1146 | tuner_dbg("divisor= %*ph (freq=%d.%03d)\n" , 4, buf, |
1147 | freq / 1000000, (freq % 1000000) / 1000); |
1148 | |
1149 | rc = 0; |
1150 | |
1151 | ret: |
1152 | mutex_unlock(lock: &priv->lock); |
1153 | |
1154 | return rc; |
1155 | } |
1156 | |
1157 | static int xc2028_set_analog_freq(struct dvb_frontend *fe, |
1158 | struct analog_parameters *p) |
1159 | { |
1160 | struct xc2028_data *priv = fe->tuner_priv; |
1161 | unsigned int type=0; |
1162 | |
1163 | tuner_dbg("%s called\n" , __func__); |
1164 | |
1165 | if (p->mode == V4L2_TUNER_RADIO) { |
1166 | type |= FM; |
1167 | if (priv->ctrl.input1) |
1168 | type |= INPUT1; |
1169 | return generic_set_freq(fe, freq: (625l * p->frequency) / 10, |
1170 | new_type: V4L2_TUNER_RADIO, type, std: 0, int_freq: 0); |
1171 | } |
1172 | |
1173 | /* if std is not defined, choose one */ |
1174 | if (!p->std) |
1175 | p->std = V4L2_STD_MN; |
1176 | |
1177 | /* PAL/M, PAL/N, PAL/Nc and NTSC variants should use 6MHz firmware */ |
1178 | if (!(p->std & V4L2_STD_MN)) |
1179 | type |= F8MHZ; |
1180 | |
1181 | /* Add audio hack to std mask */ |
1182 | p->std |= parse_audio_std_option(); |
1183 | |
1184 | return generic_set_freq(fe, freq: 62500l * p->frequency, |
1185 | new_type: V4L2_TUNER_ANALOG_TV, type, std: p->std, int_freq: 0); |
1186 | } |
1187 | |
1188 | static int xc2028_set_params(struct dvb_frontend *fe) |
1189 | { |
1190 | struct dtv_frontend_properties *c = &fe->dtv_property_cache; |
1191 | u32 delsys = c->delivery_system; |
1192 | u32 bw = c->bandwidth_hz; |
1193 | struct xc2028_data *priv = fe->tuner_priv; |
1194 | int rc; |
1195 | unsigned int type = 0; |
1196 | u16 demod = 0; |
1197 | |
1198 | tuner_dbg("%s called\n" , __func__); |
1199 | |
1200 | rc = check_device_status(priv); |
1201 | if (rc < 0) |
1202 | return rc; |
1203 | |
1204 | switch (delsys) { |
1205 | case SYS_DVBT: |
1206 | case SYS_DVBT2: |
1207 | /* |
1208 | * The only countries with 6MHz seem to be Taiwan/Uruguay. |
1209 | * Both seem to require QAM firmware for OFDM decoding |
1210 | * Tested in Taiwan by Terry Wu <terrywu2009@gmail.com> |
1211 | */ |
1212 | if (bw <= 6000000) |
1213 | type |= QAM; |
1214 | |
1215 | switch (priv->ctrl.type) { |
1216 | case XC2028_D2633: |
1217 | type |= D2633; |
1218 | break; |
1219 | case XC2028_D2620: |
1220 | type |= D2620; |
1221 | break; |
1222 | case XC2028_AUTO: |
1223 | default: |
1224 | /* Zarlink seems to need D2633 */ |
1225 | if (priv->ctrl.demod == XC3028_FE_ZARLINK456) |
1226 | type |= D2633; |
1227 | else |
1228 | type |= D2620; |
1229 | } |
1230 | break; |
1231 | case SYS_ATSC: |
1232 | /* The only ATSC firmware (at least on v2.7) is D2633 */ |
1233 | type |= ATSC | D2633; |
1234 | break; |
1235 | /* DVB-S and pure QAM (FE_QAM) are not supported */ |
1236 | default: |
1237 | return -EINVAL; |
1238 | } |
1239 | |
1240 | if (bw <= 6000000) { |
1241 | type |= DTV6; |
1242 | priv->ctrl.vhfbw7 = 0; |
1243 | priv->ctrl.uhfbw8 = 0; |
1244 | } else if (bw <= 7000000) { |
1245 | if (c->frequency < 470000000) |
1246 | priv->ctrl.vhfbw7 = 1; |
1247 | else |
1248 | priv->ctrl.uhfbw8 = 0; |
1249 | type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7; |
1250 | type |= F8MHZ; |
1251 | } else { |
1252 | if (c->frequency < 470000000) |
1253 | priv->ctrl.vhfbw7 = 0; |
1254 | else |
1255 | priv->ctrl.uhfbw8 = 1; |
1256 | type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8; |
1257 | type |= F8MHZ; |
1258 | } |
1259 | |
1260 | /* All S-code tables need a 200kHz shift */ |
1261 | if (priv->ctrl.demod) { |
1262 | demod = priv->ctrl.demod; |
1263 | |
1264 | /* |
1265 | * Newer firmwares require a 200 kHz offset only for ATSC |
1266 | */ |
1267 | if (type == ATSC || priv->firm_version < 0x0302) |
1268 | demod += 200; |
1269 | /* |
1270 | * The DTV7 S-code table needs a 700 kHz shift. |
1271 | * |
1272 | * DTV7 is only used in Australia. Germany or Italy may also |
1273 | * use this firmware after initialization, but a tune to a UHF |
1274 | * channel should then cause DTV78 to be used. |
1275 | * |
1276 | * Unfortunately, on real-field tests, the s-code offset |
1277 | * didn't work as expected, as reported by |
1278 | * Robert Lowery <rglowery@exemail.com.au> |
1279 | */ |
1280 | } |
1281 | |
1282 | return generic_set_freq(fe, freq: c->frequency, |
1283 | new_type: V4L2_TUNER_DIGITAL_TV, type, std: 0, int_freq: demod); |
1284 | } |
1285 | |
1286 | static int xc2028_sleep(struct dvb_frontend *fe) |
1287 | { |
1288 | struct xc2028_data *priv = fe->tuner_priv; |
1289 | int rc; |
1290 | |
1291 | rc = check_device_status(priv); |
1292 | if (rc < 0) |
1293 | return rc; |
1294 | |
1295 | /* Device is already in sleep mode */ |
1296 | if (!rc) |
1297 | return 0; |
1298 | |
1299 | /* Avoid firmware reload on slow devices or if PM disabled */ |
1300 | if (no_poweroff || priv->ctrl.disable_power_mgmt) |
1301 | return 0; |
1302 | |
1303 | tuner_dbg("Putting xc2028/3028 into poweroff mode.\n" ); |
1304 | if (debug > 1) { |
1305 | tuner_dbg("Printing sleep stack trace:\n" ); |
1306 | dump_stack(); |
1307 | } |
1308 | |
1309 | mutex_lock(&priv->lock); |
1310 | |
1311 | if (priv->firm_version < 0x0202) |
1312 | rc = send_seq(priv, {0x00, XREG_POWER_DOWN, 0x00, 0x00}); |
1313 | else |
1314 | rc = send_seq(priv, {0x80, XREG_POWER_DOWN, 0x00, 0x00}); |
1315 | |
1316 | if (rc >= 0) |
1317 | priv->state = XC2028_SLEEP; |
1318 | |
1319 | mutex_unlock(lock: &priv->lock); |
1320 | |
1321 | return rc; |
1322 | } |
1323 | |
1324 | static void xc2028_dvb_release(struct dvb_frontend *fe) |
1325 | { |
1326 | struct xc2028_data *priv = fe->tuner_priv; |
1327 | |
1328 | tuner_dbg("%s called\n" , __func__); |
1329 | |
1330 | mutex_lock(&xc2028_list_mutex); |
1331 | |
1332 | /* only perform final cleanup if this is the last instance */ |
1333 | if (hybrid_tuner_report_instance_count(priv) == 1) |
1334 | free_firmware(priv); |
1335 | |
1336 | if (priv) |
1337 | hybrid_tuner_release_state(priv); |
1338 | |
1339 | mutex_unlock(lock: &xc2028_list_mutex); |
1340 | |
1341 | fe->tuner_priv = NULL; |
1342 | } |
1343 | |
1344 | static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency) |
1345 | { |
1346 | struct xc2028_data *priv = fe->tuner_priv; |
1347 | int rc; |
1348 | |
1349 | tuner_dbg("%s called\n" , __func__); |
1350 | |
1351 | rc = check_device_status(priv); |
1352 | if (rc < 0) |
1353 | return rc; |
1354 | |
1355 | *frequency = priv->frequency; |
1356 | |
1357 | return 0; |
1358 | } |
1359 | |
1360 | static void load_firmware_cb(const struct firmware *fw, |
1361 | void *context) |
1362 | { |
1363 | struct dvb_frontend *fe = context; |
1364 | struct xc2028_data *priv = fe->tuner_priv; |
1365 | int rc; |
1366 | |
1367 | tuner_dbg("request_firmware_nowait(): %s\n" , fw ? "OK" : "error" ); |
1368 | if (!fw) { |
1369 | tuner_err("Could not load firmware %s.\n" , priv->fname); |
1370 | priv->state = XC2028_NODEV; |
1371 | return; |
1372 | } |
1373 | |
1374 | rc = load_all_firmwares(fe, fw); |
1375 | |
1376 | release_firmware(fw); |
1377 | |
1378 | if (rc < 0) |
1379 | return; |
1380 | priv->state = XC2028_ACTIVE; |
1381 | } |
1382 | |
1383 | static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg) |
1384 | { |
1385 | struct xc2028_data *priv = fe->tuner_priv; |
1386 | struct xc2028_ctrl *p = priv_cfg; |
1387 | int rc = 0; |
1388 | |
1389 | tuner_dbg("%s called\n" , __func__); |
1390 | |
1391 | mutex_lock(&priv->lock); |
1392 | |
1393 | /* |
1394 | * Copy the config data. |
1395 | */ |
1396 | memcpy(&priv->ctrl, p, sizeof(priv->ctrl)); |
1397 | |
1398 | /* |
1399 | * If firmware name changed, frees firmware. As free_firmware will |
1400 | * reset the status to NO_FIRMWARE, this forces a new request_firmware |
1401 | */ |
1402 | if (!firmware_name[0] && p->fname && |
1403 | priv->fname && strcmp(p->fname, priv->fname)) |
1404 | free_firmware(priv); |
1405 | |
1406 | if (priv->ctrl.max_len < 9) |
1407 | priv->ctrl.max_len = 13; |
1408 | |
1409 | if (priv->state == XC2028_NO_FIRMWARE) { |
1410 | if (!firmware_name[0]) |
1411 | priv->fname = kstrdup(s: p->fname, GFP_KERNEL); |
1412 | else |
1413 | priv->fname = firmware_name; |
1414 | |
1415 | if (!priv->fname) { |
1416 | rc = -ENOMEM; |
1417 | goto unlock; |
1418 | } |
1419 | |
1420 | rc = request_firmware_nowait(THIS_MODULE, uevent: 1, |
1421 | name: priv->fname, |
1422 | device: priv->i2c_props.adap->dev.parent, |
1423 | GFP_KERNEL, |
1424 | context: fe, cont: load_firmware_cb); |
1425 | if (rc < 0) { |
1426 | tuner_err("Failed to request firmware %s\n" , |
1427 | priv->fname); |
1428 | priv->state = XC2028_NODEV; |
1429 | } else |
1430 | priv->state = XC2028_WAITING_FIRMWARE; |
1431 | } |
1432 | unlock: |
1433 | mutex_unlock(lock: &priv->lock); |
1434 | |
1435 | return rc; |
1436 | } |
1437 | |
1438 | static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = { |
1439 | .info = { |
1440 | .name = "Xceive XC3028" , |
1441 | .frequency_min_hz = 42 * MHz, |
1442 | .frequency_max_hz = 864 * MHz, |
1443 | .frequency_step_hz = 50 * kHz, |
1444 | }, |
1445 | |
1446 | .set_config = xc2028_set_config, |
1447 | .set_analog_params = xc2028_set_analog_freq, |
1448 | .release = xc2028_dvb_release, |
1449 | .get_frequency = xc2028_get_frequency, |
1450 | .get_rf_strength = xc2028_signal, |
1451 | .get_afc = xc2028_get_afc, |
1452 | .set_params = xc2028_set_params, |
1453 | .sleep = xc2028_sleep, |
1454 | }; |
1455 | |
1456 | struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe, |
1457 | struct xc2028_config *cfg) |
1458 | { |
1459 | struct xc2028_data *priv; |
1460 | int instance; |
1461 | |
1462 | if (debug) |
1463 | printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n" ); |
1464 | |
1465 | if (NULL == cfg) |
1466 | return NULL; |
1467 | |
1468 | if (!fe) { |
1469 | printk(KERN_ERR "xc2028: No frontend!\n" ); |
1470 | return NULL; |
1471 | } |
1472 | |
1473 | mutex_lock(&xc2028_list_mutex); |
1474 | |
1475 | instance = hybrid_tuner_request_state(struct xc2028_data, priv, |
1476 | hybrid_tuner_instance_list, |
1477 | cfg->i2c_adap, cfg->i2c_addr, |
1478 | "xc2028" ); |
1479 | switch (instance) { |
1480 | case 0: |
1481 | /* memory allocation failure */ |
1482 | goto fail; |
1483 | case 1: |
1484 | /* new tuner instance */ |
1485 | priv->ctrl.max_len = 13; |
1486 | |
1487 | mutex_init(&priv->lock); |
1488 | |
1489 | fe->tuner_priv = priv; |
1490 | break; |
1491 | case 2: |
1492 | /* existing tuner instance */ |
1493 | fe->tuner_priv = priv; |
1494 | break; |
1495 | } |
1496 | |
1497 | memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops, |
1498 | sizeof(xc2028_dvb_tuner_ops)); |
1499 | |
1500 | tuner_info("type set to %s\n" , "XCeive xc2028/xc3028 tuner" ); |
1501 | |
1502 | if (cfg->ctrl) |
1503 | xc2028_set_config(fe, priv_cfg: cfg->ctrl); |
1504 | |
1505 | mutex_unlock(lock: &xc2028_list_mutex); |
1506 | |
1507 | return fe; |
1508 | fail: |
1509 | mutex_unlock(lock: &xc2028_list_mutex); |
1510 | |
1511 | xc2028_dvb_release(fe); |
1512 | return NULL; |
1513 | } |
1514 | |
1515 | EXPORT_SYMBOL_GPL(xc2028_attach); |
1516 | |
1517 | MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver" ); |
1518 | MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>" ); |
1519 | MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>" ); |
1520 | MODULE_LICENSE("GPL v2" ); |
1521 | MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE); |
1522 | MODULE_FIRMWARE(XC3028L_DEFAULT_FIRMWARE); |
1523 | |