]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/media/video/tuner-xc2028.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
V4L/DVB (6561): Fix xc2028 get register functions and calls
[mirror_ubuntu-hirsute-kernel.git] / drivers / media / video / tuner-xc2028.c
1 /* tuner-xc2028
2 *
3 * Copyright (c) 2007 Mauro Carvalho Chehab (mchehab@infradead.org)
4 *
5 * Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com)
6 * - frontend interface
7 *
8 * This code is placed under the terms of the GNU General Public License v2
9 */
10
11 #include <linux/i2c.h>
12 #include <asm/div64.h>
13 #include <linux/firmware.h>
14 #include <linux/videodev2.h>
15 #include <linux/delay.h>
16 #include <media/tuner.h>
17 #include <linux/mutex.h>
18 #include "tuner-i2c.h"
19 #include "tuner-xc2028.h"
20 #include "tuner-xc2028-types.h"
21
22 #include <linux/dvb/frontend.h>
23 #include "dvb_frontend.h"
24
25 #define PREFIX "xc2028"
26
27 static LIST_HEAD(xc2028_list);
28 /* struct for storing firmware table */
29 struct firmware_description {
30 unsigned int type;
31 v4l2_std_id id;
32 unsigned char *ptr;
33 unsigned int size;
34 };
35
36 struct xc2028_data {
37 struct list_head xc2028_list;
38 struct tuner_i2c_props i2c_props;
39 int (*tuner_callback) (void *dev,
40 int command, int arg);
41 struct device *dev;
42 void *video_dev;
43 int count;
44 __u32 frequency;
45
46 struct firmware_description *firm;
47 int firm_size;
48
49 __u16 version;
50
51 struct xc2028_ctrl ctrl;
52
53 v4l2_std_id firm_type; /* video stds supported
54 by current firmware */
55 fe_bandwidth_t bandwidth; /* Firmware bandwidth:
56 6M, 7M or 8M */
57 int need_load_generic; /* The generic firmware
58 were loaded? */
59
60 int max_len; /* Max firmware chunk */
61
62 enum tuner_mode mode;
63 struct i2c_client *i2c_client;
64
65 struct mutex lock;
66 };
67
68 #define i2c_send(rc, priv, buf, size) do { \
69 rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size); \
70 if (size != rc) \
71 tuner_info("i2c output error: rc = %d (should be %d)\n",\
72 rc, (int)size); \
73 } while (0)
74
75 #define i2c_rcv(rc, priv, buf, size) do { \
76 rc = tuner_i2c_xfer_recv(&priv->i2c_props, buf, size); \
77 if (size != rc) \
78 tuner_info("i2c input error: rc = %d (should be %d)\n", \
79 rc, (int)size); \
80 } while (0)
81
82 #define send_seq(priv, data...) do { \
83 int rc; \
84 static u8 _val[] = data; \
85 if (sizeof(_val) != \
86 (rc = tuner_i2c_xfer_send(&priv->i2c_props, \
87 _val, sizeof(_val)))) { \
88 tuner_info("Error on line %d: %d\n", __LINE__, rc); \
89 return -EINVAL; \
90 } \
91 msleep(10); \
92 } while (0)
93
94 static unsigned int xc2028_get_reg(struct xc2028_data *priv, u16 reg)
95 {
96 int rc;
97 unsigned char buf[2];
98
99 tuner_info("%s called\n", __FUNCTION__);
100
101 buf[0] = reg>>8;
102 buf[1] = (unsigned char) reg;
103
104 i2c_send(rc, priv, buf, 2);
105 if (rc < 0)
106 return rc;
107
108 i2c_rcv(rc, priv, buf, 2);
109 if (rc < 0)
110 return rc;
111
112 return (buf[1]) | (buf[0] << 8);
113 }
114
115 static void free_firmware(struct xc2028_data *priv)
116 {
117 int i;
118
119 if (!priv->firm)
120 return;
121
122 for (i = 0; i < priv->firm_size; i++)
123 kfree(priv->firm[i].ptr);
124
125 kfree(priv->firm);
126
127 priv->firm = NULL;
128 priv->need_load_generic = 1;
129 }
130
131 static int load_all_firmwares(struct dvb_frontend *fe)
132 {
133 struct xc2028_data *priv = fe->tuner_priv;
134 const struct firmware *fw = NULL;
135 unsigned char *p, *endp;
136 int rc = 0;
137 int n, n_array;
138 char name[33];
139
140 tuner_info("%s called\n", __FUNCTION__);
141
142 tuner_info("Loading firmware %s\n", priv->ctrl.fname);
143 rc = request_firmware(&fw, priv->ctrl.fname, priv->dev);
144 if (rc < 0) {
145 if (rc == -ENOENT)
146 tuner_info("Error: firmware %s not found.\n",
147 priv->ctrl.fname);
148 else
149 tuner_info("Error %d while requesting firmware %s \n",
150 rc, priv->ctrl.fname);
151
152 return rc;
153 }
154 p = fw->data;
155 endp = p + fw->size;
156
157 if (fw->size < sizeof(name) - 1 + 2) {
158 tuner_info("Error: firmware size is zero!\n");
159 rc = -EINVAL;
160 goto done;
161 }
162
163 memcpy(name, p, sizeof(name) - 1);
164 name[sizeof(name) - 1] = 0;
165 p += sizeof(name) - 1;
166
167 priv->version = le16_to_cpu(*(__u16 *) p);
168 p += 2;
169
170 tuner_info("firmware: %s, ver %d.%d\n", name,
171 priv->version >> 8, priv->version & 0xff);
172
173 if (p + 2 > endp)
174 goto corrupt;
175
176 n_array = le16_to_cpu(*(__u16 *) p);
177 p += 2;
178
179 tuner_info("there are %d firmwares at %s\n", n_array, priv->ctrl.fname);
180
181 priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
182
183 if (!fw) {
184 tuner_info("Not enough memory for loading firmware.\n");
185 rc = -ENOMEM;
186 goto done;
187 }
188
189 priv->firm_size = n_array;
190 n = -1;
191 while (p < endp) {
192 __u32 type, size;
193 v4l2_std_id id;
194
195 n++;
196 if (n >= n_array) {
197 tuner_info("Too much firmwares at the file\n");
198 goto corrupt;
199 }
200
201 /* Checks if there's enough bytes to read */
202 if (p + sizeof(type) + sizeof(id) + sizeof(size) > endp) {
203 tuner_info("Lost firmware!\n");
204 goto corrupt;
205 }
206
207 type = le32_to_cpu(*(__u32 *) p);
208 p += sizeof(type);
209
210 id = le64_to_cpu(*(v4l2_std_id *) p);
211 p += sizeof(id);
212
213 size = le32_to_cpu(*(v4l2_std_id *) p);
214 p += sizeof(size);
215
216 if ((!size) || (size + p > endp)) {
217 tuner_info("Firmware type %x, id %lx corrupt\n",
218 type, (unsigned long)id);
219 goto corrupt;
220 }
221
222 priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
223 if (!priv->firm[n].ptr) {
224 tuner_info("Not enough memory.\n");
225 rc = -ENOMEM;
226 goto err;
227 }
228 tuner_info("Loading firmware type %x, id %lx, size=%d.\n",
229 type, (unsigned long)id, size);
230
231 memcpy(priv->firm[n].ptr, p, size);
232 priv->firm[n].type = type;
233 priv->firm[n].id = id;
234 priv->firm[n].size = size;
235
236 p += size;
237 }
238
239 if (n + 1 != priv->firm_size) {
240 tuner_info("Firmware file is incomplete!\n");
241 goto corrupt;
242 }
243
244 goto done;
245
246 corrupt:
247 rc = -EINVAL;
248 tuner_info("Error: firmware file is corrupted!\n");
249
250 err:
251 tuner_info("Releasing loaded firmware file.\n");
252
253 free_firmware(priv);
254
255 done:
256 release_firmware(fw);
257 tuner_info("Firmware files loaded.\n");
258
259 return rc;
260 }
261
262 static int load_firmware(struct dvb_frontend *fe, unsigned int type,
263 v4l2_std_id * id)
264 {
265 struct xc2028_data *priv = fe->tuner_priv;
266 int i, rc;
267 unsigned char *p, *endp, buf[priv->max_len];
268
269 tuner_info("%s called\n", __FUNCTION__);
270
271 if (!priv->firm) {
272 printk(KERN_ERR PREFIX "Error! firmware not loaded\n");
273 return -EINVAL;
274 }
275
276 if ((type == 0) && (*id == 0))
277 *id = V4L2_STD_PAL;
278
279 /* Seek for exact match */
280 for (i = 0; i < priv->firm_size; i++) {
281 if ((type == priv->firm[i].type) && (*id == priv->firm[i].id))
282 goto found;
283 }
284
285 /* Seek for generic video standard match */
286 for (i = 0; i < priv->firm_size; i++) {
287 if ((type == priv->firm[i].type) && (*id & priv->firm[i].id))
288 goto found;
289 }
290
291 /*FIXME: Would make sense to seek for type "hint" match ? */
292
293 tuner_info("Can't find firmware for type=%x, id=%lx\n", type,
294 (long int)*id);
295 return -EINVAL;
296
297 found:
298 *id = priv->firm[i].id;
299 tuner_info("Found firmware for type=%x, id=%lx\n", type, (long int)*id);
300
301 p = priv->firm[i].ptr;
302
303 if (!p) {
304 printk(KERN_ERR PREFIX "Firmware pointer were freed!");
305 return -EINVAL;
306 }
307 endp = p + priv->firm[i].size;
308
309 while (p < endp) {
310 __u16 size;
311
312 /* Checks if there's enough bytes to read */
313 if (p + sizeof(size) > endp) {
314 tuner_info("missing bytes\n");
315 return -EINVAL;
316 }
317
318 size = le16_to_cpu(*(__u16 *) p);
319 p += sizeof(size);
320
321 if (size == 0xffff)
322 return 0;
323
324 if (!size) {
325 /* Special callback command received */
326 rc = priv->tuner_callback(priv->video_dev,
327 XC2028_TUNER_RESET, 0);
328 if (rc < 0) {
329 tuner_info("Error at RESET code %d\n",
330 (*p) & 0x7f);
331 return -EINVAL;
332 }
333 continue;
334 }
335
336 /* Checks for a sleep command */
337 if (size & 0x8000) {
338 msleep(size & 0x7fff);
339 continue;
340 }
341
342 if ((size + p > endp)) {
343 tuner_info("missing bytes: need %d, have %d\n",
344 size, (int)(endp - p));
345 return -EINVAL;
346 }
347
348 buf[0] = *p;
349 p++;
350 size--;
351
352 /* Sends message chunks */
353 while (size > 0) {
354 int len = (size < priv->max_len - 1) ?
355 size : priv->max_len - 1;
356
357 memcpy(buf + 1, p, len);
358
359 i2c_send(rc, priv, buf, len + 1);
360 if (rc < 0) {
361 tuner_info("%d returned from send\n", rc);
362 return -EINVAL;
363 }
364
365 p += len;
366 size -= len;
367 }
368 }
369 return -EINVAL;
370 }
371
372 static int check_firmware(struct dvb_frontend *fe, enum tuner_mode new_mode,
373 v4l2_std_id std, fe_bandwidth_t bandwidth)
374 {
375 struct xc2028_data *priv = fe->tuner_priv;
376 int rc, version, hwmodel;
377 v4l2_std_id std0 = 0;
378 unsigned int type0 = 0, type = 0;
379 int change_digital_bandwidth;
380
381 tuner_info("%s called\n", __FUNCTION__);
382
383 if (!priv->firm) {
384 if (!priv->ctrl.fname)
385 return -EINVAL;
386
387 rc = load_all_firmwares(fe);
388 if (rc < 0)
389 return rc;
390 }
391
392 tuner_info("I am in mode %u and I should switch to mode %i\n",
393 priv->mode, new_mode);
394
395 /* first of all, determine whether we have switched the mode */
396 if (new_mode != priv->mode) {
397 priv->mode = new_mode;
398 priv->need_load_generic = 1;
399 }
400
401 change_digital_bandwidth = (priv->mode == T_DIGITAL_TV
402 && bandwidth != priv->bandwidth) ? 1 : 0;
403 tuner_info("old bandwidth %u, new bandwidth %u\n", priv->bandwidth,
404 bandwidth);
405
406 if (priv->need_load_generic) {
407 /* Reset is needed before loading firmware */
408 rc = priv->tuner_callback(priv->video_dev,
409 XC2028_TUNER_RESET, 0);
410 if (rc < 0)
411 return rc;
412
413 type0 = BASE;
414
415 if (priv->ctrl.type == XC2028_FIRM_MTS)
416 type0 |= MTS;
417
418 if (priv->bandwidth == 8)
419 type0 |= F8MHZ;
420
421 /* FIXME: How to load FM and FM|INPUT1 firmwares? */
422
423 rc = load_firmware(fe, type0, &std0);
424 if (rc < 0) {
425 tuner_info("Error %d while loading generic firmware\n",
426 rc);
427 return rc;
428 }
429
430 priv->need_load_generic = 0;
431 priv->firm_type = 0;
432 if (priv->mode == T_DIGITAL_TV)
433 change_digital_bandwidth = 1;
434 }
435
436 tuner_info("I should change bandwidth %u\n", change_digital_bandwidth);
437
438 if (change_digital_bandwidth) {
439
440 /*FIXME: Should allow selecting between D2620 and D2633 */
441 type |= D2620;
442
443 /* FIXME: When should select a DTV78 firmware?
444 */
445 switch (bandwidth) {
446 case BANDWIDTH_8_MHZ:
447 type |= DTV8;
448 break;
449 case BANDWIDTH_7_MHZ:
450 type |= DTV7;
451 break;
452 case BANDWIDTH_6_MHZ:
453 /* FIXME: Should allow select also ATSC */
454 type |= DTV6_QAM;
455 break;
456
457 default:
458 tuner_info("error: bandwidth not supported.\n");
459 };
460 priv->bandwidth = bandwidth;
461 }
462
463 /* Load INIT1, if needed */
464 tuner_info("Trying to load init1 firmware\n");
465 type0 = BASE | INIT1 | priv->ctrl.type;
466 if (priv->ctrl.type == XC2028_FIRM_MTS)
467 type0 |= MTS;
468
469 /* FIXME: Should handle errors - if INIT1 found */
470 rc = load_firmware(fe, type0, &std0);
471
472 /* FIXME: Should add support for FM radio
473 */
474
475 if (priv->ctrl.type == XC2028_FIRM_MTS)
476 type |= MTS;
477
478 tuner_info("firmware standard to load: %08lx\n", (unsigned long)std);
479 if (priv->firm_type & std) {
480 tuner_info("no need to load a std-specific firmware.\n");
481 return 0;
482 }
483
484 rc = load_firmware(fe, type, &std);
485 if (rc < 0)
486 return rc;
487
488 version = xc2028_get_reg(priv, 0x0004);
489 hwmodel = xc2028_get_reg(priv, 0x0008);
490
491 tuner_info("Device is Xceive %d version %d.%d, "
492 "firmware version %d.%d\n",
493 hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8,
494 (version & 0xf0) >> 4, version & 0xf);
495
496 priv->firm_type = std;
497
498 return 0;
499 }
500
501 static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
502 {
503 struct xc2028_data *priv = fe->tuner_priv;
504 int frq_lock, signal = 0;
505
506 tuner_info("%s called\n", __FUNCTION__);
507
508 mutex_lock(&priv->lock);
509
510 *strength = 0;
511
512 /* Sync Lock Indicator */
513 frq_lock = xc2028_get_reg(priv, 0x0002);
514 if (frq_lock <= 0)
515 goto ret;
516
517 /* Frequency is locked. Return signal quality */
518
519 /* Get SNR of the video signal */
520 signal = xc2028_get_reg(priv, 0x0040);
521
522 if (signal <= 0)
523 signal = frq_lock;
524
525 ret:
526 mutex_unlock(&priv->lock);
527
528 *strength = signal;
529
530 return 0;
531 }
532
533 #define DIV 15625
534
535 static int generic_set_tv_freq(struct dvb_frontend *fe, u32 freq /* in Hz */ ,
536 enum tuner_mode new_mode,
537 v4l2_std_id std, fe_bandwidth_t bandwidth)
538 {
539 struct xc2028_data *priv = fe->tuner_priv;
540 int rc = -EINVAL;
541 unsigned char buf[5];
542 u32 div, offset = 0;
543
544 tuner_info("%s called\n", __FUNCTION__);
545
546 mutex_lock(&priv->lock);
547
548 /* HACK: It seems that specific firmware need to be reloaded
549 when freq is changed */
550
551 priv->firm_type = 0;
552
553 /* Reset GPIO 1 */
554 rc = priv->tuner_callback(priv->video_dev, XC2028_TUNER_RESET, 0);
555 if (rc < 0)
556 goto ret;
557
558 msleep(10);
559 tuner_info("should set frequency %d kHz)\n", freq / 1000);
560
561 if (check_firmware(fe, new_mode, std, bandwidth) < 0)
562 goto ret;
563
564 if (new_mode == T_DIGITAL_TV)
565 offset = 2750000;
566
567 div = (freq - offset + DIV / 2) / DIV;
568
569 /* CMD= Set frequency */
570
571 if (priv->version < 0x0202) {
572 send_seq(priv, {0x00, 0x02, 0x00, 0x00});
573 } else {
574 send_seq(priv, {0x80, 0x02, 0x00, 0x00});
575 }
576
577 rc = priv->tuner_callback(priv->video_dev, XC2028_RESET_CLK, 1);
578 if (rc < 0)
579 goto ret;
580
581 msleep(10);
582
583 buf[0] = 0xff & (div >> 24);
584 buf[1] = 0xff & (div >> 16);
585 buf[2] = 0xff & (div >> 8);
586 buf[3] = 0xff & (div);
587 buf[4] = 0;
588
589 i2c_send(rc, priv, buf, sizeof(buf));
590 if (rc < 0)
591 goto ret;
592 msleep(100);
593
594 priv->frequency = freq;
595
596 printk("divider= %02x %02x %02x %02x (freq=%d.%02d)\n",
597 buf[1], buf[2], buf[3], buf[4],
598 freq / 1000000, (freq % 1000000) / 10000);
599
600 rc = 0;
601
602 ret:
603 mutex_unlock(&priv->lock);
604
605 return rc;
606 }
607
608 static int xc2028_set_tv_freq(struct dvb_frontend *fe,
609 struct analog_parameters *p)
610 {
611 struct xc2028_data *priv = fe->tuner_priv;
612
613 tuner_info("%s called\n", __FUNCTION__);
614
615 return generic_set_tv_freq(fe, 62500l * p->frequency, T_ANALOG_TV,
616 p->std, BANDWIDTH_8_MHZ /* NOT USED */);
617 }
618
619 static int xc2028_set_params(struct dvb_frontend *fe,
620 struct dvb_frontend_parameters *p)
621 {
622 struct xc2028_data *priv = fe->tuner_priv;
623
624 tuner_info("%s called\n", __FUNCTION__);
625
626 /* FIXME: Only OFDM implemented */
627 if (fe->ops.info.type != FE_OFDM) {
628 tuner_info("DTV type not implemented.\n");
629 return -EINVAL;
630 }
631
632 return generic_set_tv_freq(fe, p->frequency, T_DIGITAL_TV,
633 0 /* NOT USED */,
634 p->u.ofdm.bandwidth);
635
636 }
637
638 static int xc2028_dvb_release(struct dvb_frontend *fe)
639 {
640 struct xc2028_data *priv = fe->tuner_priv;
641
642 tuner_info("%s called\n", __FUNCTION__);
643
644 priv->count--;
645
646 if (!priv->count) {
647 list_del(&priv->xc2028_list);
648
649 kfree(priv->ctrl.fname);
650
651 free_firmware(priv);
652 kfree(priv);
653 }
654
655 return 0;
656 }
657
658 static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency)
659 {
660 struct xc2028_data *priv = fe->tuner_priv;
661
662 tuner_info("%s called\n", __FUNCTION__);
663
664 *frequency = priv->frequency;
665
666 return 0;
667 }
668
669 static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
670 {
671 struct xc2028_data *priv = fe->tuner_priv;
672 struct xc2028_ctrl *p = priv_cfg;
673
674 tuner_info("%s called\n", __FUNCTION__);
675
676 priv->ctrl.type = p->type;
677
678 if (p->fname) {
679 kfree(priv->ctrl.fname);
680
681 priv->ctrl.fname = kmalloc(strlen(p->fname) + 1, GFP_KERNEL);
682 if (!priv->ctrl.fname)
683 return -ENOMEM;
684
685 free_firmware(priv);
686 strcpy(priv->ctrl.fname, p->fname);
687 }
688
689 if (p->max_len > 0)
690 priv->max_len = p->max_len;
691
692 tuner_info("%s OK\n", __FUNCTION__);
693
694 return 0;
695 }
696
697 static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
698 .info = {
699 .name = "Xceive XC3028",
700 .frequency_min = 42000000,
701 .frequency_max = 864000000,
702 .frequency_step = 50000,
703 },
704
705 .set_config = xc2028_set_config,
706 .set_analog_params = xc2028_set_tv_freq,
707 .release = xc2028_dvb_release,
708 .get_frequency = xc2028_get_frequency,
709 .get_rf_strength = xc2028_signal,
710 .set_params = xc2028_set_params,
711
712 };
713
714 int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c_adap,
715 u8 i2c_addr, struct device *dev, void *video_dev,
716 int (*tuner_callback) (void *dev, int command, int arg))
717 {
718 struct xc2028_data *priv;
719
720 printk(KERN_INFO PREFIX "Xcv2028/3028 init called!\n");
721
722 if (NULL == dev)
723 return -ENODEV;
724
725 if (NULL == video_dev)
726 return -ENODEV;
727
728 if (!tuner_callback) {
729 printk(KERN_ERR PREFIX "No tuner callback!\n");
730 return -EINVAL;
731 }
732
733 list_for_each_entry(priv, &xc2028_list, xc2028_list) {
734 if (priv->dev == dev)
735 dev = NULL;
736 }
737
738 if (dev) {
739 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
740 if (priv == NULL)
741 return -ENOMEM;
742
743 fe->tuner_priv = priv;
744
745 priv->bandwidth = BANDWIDTH_6_MHZ;
746 priv->need_load_generic = 1;
747 priv->mode = T_UNINITIALIZED;
748 priv->i2c_props.addr = i2c_addr;
749 priv->i2c_props.adap = i2c_adap;
750 priv->dev = dev;
751 priv->video_dev = video_dev;
752 priv->tuner_callback = tuner_callback;
753 priv->max_len = 13;
754
755
756 mutex_init(&priv->lock);
757
758 list_add_tail(&priv->xc2028_list, &xc2028_list);
759 }
760 priv->count++;
761
762 memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
763 sizeof(xc2028_dvb_tuner_ops));
764
765 tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");
766
767 return 0;
768 }
769 EXPORT_SYMBOL(xc2028_attach);
770
771 MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
772 MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
773 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
774 MODULE_LICENSE("GPL");
Ubuntu Hirsute Linux kernel mirror