?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] Support register switch in nommu mode
[linux-2.6/verdex.git] / drivers / media / dvb / frontends / or51211.c
blob7c3aed1f546be2609631206639271fbd6f9b178b
1 /*
2 * Support for OR51211 (pcHDTV HD-2000) - VSB
3 *
4 * Copyright (C) 2005 Kirk Lapray <kirk_lapray@bigfoot.com>
5 *
6 * Based on code from Jack Kelliher (kelliher@xmission.com)
7 * Copyright (C) 2002 & pcHDTV, inc.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 */
24
25 /*
26 * This driver needs external firmware. Please use the command
27 * "<kerneldir>/Documentation/dvb/get_dvb_firmware or51211" to
28 * download/extract it, and then copy it to /usr/lib/hotplug/firmware
29 * or /lib/firmware (depending on configuration of firmware hotplug).
30 */
31 #define OR51211_DEFAULT_FIRMWARE "dvb-fe-or51211.fw"
32
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/device.h>
37 #include <linux/firmware.h>
38 #include <linux/string.h>
39 #include <linux/slab.h>
40 #include <asm/byteorder.h>
41
42 #include "dvb_frontend.h"
43 #include "or51211.h"
44
45 static int debug;
46 #define dprintk(args...) \
47 do { \
48 if (debug) printk(KERN_DEBUG "or51211: " args); \
49 } while (0)
50
51 static u8 run_buf[] = {0x7f,0x01};
52 static u8 cmd_buf[] = {0x04,0x01,0x50,0x80,0x06}; // ATSC
53
54 struct or51211_state {
55
56 struct i2c_adapter* i2c;
57 struct dvb_frontend_ops ops;
58
59 /* Configuration settings */
60 const struct or51211_config* config;
61
62 struct dvb_frontend frontend;
63 struct bt878* bt;
64
65 /* Demodulator private data */
66 u8 initialized:1;
67
68 /* Tuner private data */
69 u32 current_frequency;
70 };
71
72 static int i2c_writebytes (struct or51211_state* state, u8 reg, u8 *buf,
73 int len)
74 {
75 int err;
76 struct i2c_msg msg;
77 msg.addr = reg;
78 msg.flags = 0;
79 msg.len = len;
80 msg.buf = buf;
81
82 if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
83 printk(KERN_WARNING "or51211: i2c_writebytes error "
84 "(addr %02x, err == %i)\n", reg, err);
85 return -EREMOTEIO;
86 }
87
88 return 0;
89 }
90
91 static u8 i2c_readbytes (struct or51211_state* state, u8 reg, u8* buf, int len)
92 {
93 int err;
94 struct i2c_msg msg;
95 msg.addr = reg;
96 msg.flags = I2C_M_RD;
97 msg.len = len;
98 msg.buf = buf;
99
100 if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
101 printk(KERN_WARNING "or51211: i2c_readbytes error "
102 "(addr %02x, err == %i)\n", reg, err);
103 return -EREMOTEIO;
104 }
105
106 return 0;
107 }
108
109 static int or51211_load_firmware (struct dvb_frontend* fe,
110 const struct firmware *fw)
111 {
112 struct or51211_state* state = fe->demodulator_priv;
113 u8 tudata[585];
114 int i;
115
116 dprintk("Firmware is %zd bytes\n",fw->size);
117
118 /* Get eprom data */
119 tudata[0] = 17;
120 if (i2c_writebytes(state,0x50,tudata,1)) {
121 printk(KERN_WARNING "or51211:load_firmware error eprom addr\n");
122 return -1;
123 }
124 if (i2c_readbytes(state,0x50,&tudata[145],192)) {
125 printk(KERN_WARNING "or51211: load_firmware error eprom\n");
126 return -1;
127 }
128
129 /* Create firmware buffer */
130 for (i = 0; i < 145; i++)
131 tudata[i] = fw->data[i];
132
133 for (i = 0; i < 248; i++)
134 tudata[i+337] = fw->data[145+i];
135
136 state->config->reset(fe);
137
138 if (i2c_writebytes(state,state->config->demod_address,tudata,585)) {
139 printk(KERN_WARNING "or51211: load_firmware error 1\n");
140 return -1;
141 }
142 msleep(1);
143
144 if (i2c_writebytes(state,state->config->demod_address,
145 &fw->data[393],8125)) {
146 printk(KERN_WARNING "or51211: load_firmware error 2\n");
147 return -1;
148 }
149 msleep(1);
150
151 if (i2c_writebytes(state,state->config->demod_address,run_buf,2)) {
152 printk(KERN_WARNING "or51211: load_firmware error 3\n");
153 return -1;
154 }
155
156 /* Wait at least 5 msec */
157 msleep(10);
158 if (i2c_writebytes(state,state->config->demod_address,run_buf,2)) {
159 printk(KERN_WARNING "or51211: load_firmware error 4\n");
160 return -1;
161 }
162 msleep(10);
163
164 printk("or51211: Done.\n");
165 return 0;
166 };
167
168 static int or51211_setmode(struct dvb_frontend* fe, int mode)
169 {
170 struct or51211_state* state = fe->demodulator_priv;
171 u8 rec_buf[14];
172
173 state->config->setmode(fe, mode);
174
175 if (i2c_writebytes(state,state->config->demod_address,run_buf,2)) {
176 printk(KERN_WARNING "or51211: setmode error 1\n");
177 return -1;
178 }
179
180 /* Wait at least 5 msec */
181 msleep(10);
182 if (i2c_writebytes(state,state->config->demod_address,run_buf,2)) {
183 printk(KERN_WARNING "or51211: setmode error 2\n");
184 return -1;
185 }
186
187 msleep(10);
188
189 /* Set operation mode in Receiver 1 register;
190 * type 1:
191 * data 0x50h Automatic sets receiver channel conditions
192 * Automatic NTSC rejection filter
193 * Enable MPEG serial data output
194 * MPEG2tr
195 * High tuner phase noise
196 * normal +/-150kHz Carrier acquisition range
197 */
198 if (i2c_writebytes(state,state->config->demod_address,cmd_buf,3)) {
199 printk(KERN_WARNING "or51211: setmode error 3\n");
200 return -1;
201 }
202
203 rec_buf[0] = 0x04;
204 rec_buf[1] = 0x00;
205 rec_buf[2] = 0x03;
206 rec_buf[3] = 0x00;
207 msleep(20);
208 if (i2c_writebytes(state,state->config->demod_address,rec_buf,3)) {
209 printk(KERN_WARNING "or51211: setmode error 5\n");
210 }
211 msleep(3);
212 if (i2c_readbytes(state,state->config->demod_address,&rec_buf[10],2)) {
213 printk(KERN_WARNING "or51211: setmode error 6");
214 return -1;
215 }
216 dprintk("setmode rec status %02x %02x\n",rec_buf[10],rec_buf[11]);
217
218 return 0;
219 }
220
221 static int or51211_set_parameters(struct dvb_frontend* fe,
222 struct dvb_frontend_parameters *param)
223 {
224 struct or51211_state* state = fe->demodulator_priv;
225 u32 freq = 0;
226 u16 tunerfreq = 0;
227 u8 buf[4];
228
229 /* Change only if we are actually changing the channel */
230 if (state->current_frequency != param->frequency) {
231 freq = 44000 + (param->frequency/1000);
232 tunerfreq = freq * 16/1000;
233
234 dprintk("set_parameters frequency = %d (tunerfreq = %d)\n",
235 param->frequency,tunerfreq);
236
237 buf[0] = (tunerfreq >> 8) & 0x7F;
238 buf[1] = (tunerfreq & 0xFF);
239 buf[2] = 0x8E;
240
241 if (param->frequency < 157250000) {
242 buf[3] = 0xA0;
243 dprintk("set_parameters VHF low range\n");
244 } else if (param->frequency < 454000000) {
245 buf[3] = 0x90;
246 dprintk("set_parameters VHF high range\n");
247 } else {
248 buf[3] = 0x30;
249 dprintk("set_parameters UHF range\n");
250 }
251 dprintk("set_parameters tuner bytes: 0x%02x 0x%02x "
252 "0x%02x 0x%02x\n",buf[0],buf[1],buf[2],buf[3]);
253
254 if (i2c_writebytes(state,0xC2>>1,buf,4))
255 printk(KERN_WARNING "or51211:set_parameters error "
256 "writing to tuner\n");
257
258 /* Set to ATSC mode */
259 or51211_setmode(fe,0);
260
261 /* Update current frequency */
262 state->current_frequency = param->frequency;
263 }
264 return 0;
265 }
266
267 static int or51211_read_status(struct dvb_frontend* fe, fe_status_t* status)
268 {
269 struct or51211_state* state = fe->demodulator_priv;
270 unsigned char rec_buf[2];
271 unsigned char snd_buf[] = {0x04,0x00,0x03,0x00};
272 *status = 0;
273
274 /* Receiver Status */
275 if (i2c_writebytes(state,state->config->demod_address,snd_buf,3)) {
276 printk(KERN_WARNING "or51132: read_status write error\n");
277 return -1;
278 }
279 msleep(3);
280 if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
281 printk(KERN_WARNING "or51132: read_status read error\n");
282 return -1;
283 }
284 dprintk("read_status %x %x\n",rec_buf[0],rec_buf[1]);
285
286 if (rec_buf[0] & 0x01) { /* Receiver Lock */
287 *status |= FE_HAS_SIGNAL;
288 *status |= FE_HAS_CARRIER;
289 *status |= FE_HAS_VITERBI;
290 *status |= FE_HAS_SYNC;
291 *status |= FE_HAS_LOCK;
292 }
293 return 0;
294 }
295
296 /* log10-1 table at .5 increments from 1 to 100.5 */
297 static unsigned int i100x20log10[] = {
298 0, 352, 602, 795, 954, 1088, 1204, 1306, 1397, 1480,
299 1556, 1625, 1690, 1750, 1806, 1858, 1908, 1955, 2000, 2042,
300 2082, 2121, 2158, 2193, 2227, 2260, 2292, 2322, 2352, 2380,
301 2408, 2434, 2460, 2486, 2510, 2534, 2557, 2580, 2602, 2623,
302 2644, 2664, 2684, 2704, 2723, 2742, 2760, 2778, 2795, 2813,
303 2829, 2846, 2862, 2878, 2894, 2909, 2924, 2939, 2954, 2968,
304 2982, 2996, 3010, 3023, 3037, 3050, 3062, 3075, 3088, 3100,
305 3112, 3124, 3136, 3148, 3159, 3170, 3182, 3193, 3204, 3214,
306 3225, 3236, 3246, 3256, 3266, 3276, 3286, 3296, 3306, 3316,
307 3325, 3334, 3344, 3353, 3362, 3371, 3380, 3389, 3397, 3406,
308 3415, 3423, 3432, 3440, 3448, 3456, 3464, 3472, 3480, 3488,
309 3496, 3504, 3511, 3519, 3526, 3534, 3541, 3549, 3556, 3563,
310 3570, 3577, 3584, 3591, 3598, 3605, 3612, 3619, 3625, 3632,
311 3639, 3645, 3652, 3658, 3665, 3671, 3677, 3683, 3690, 3696,
312 3702, 3708, 3714, 3720, 3726, 3732, 3738, 3744, 3750, 3755,
313 3761, 3767, 3772, 3778, 3784, 3789, 3795, 3800, 3806, 3811,
314 3816, 3822, 3827, 3832, 3838, 3843, 3848, 3853, 3858, 3863,
315 3868, 3874, 3879, 3884, 3888, 3893, 3898, 3903, 3908, 3913,
316 3918, 3922, 3927, 3932, 3936, 3941, 3946, 3950, 3955, 3960,
317 3964, 3969, 3973, 3978, 3982, 3986, 3991, 3995, 4000, 4004,
318 };
319
320 static unsigned int denom[] = {1,1,100,1000,10000,100000,1000000,10000000,100000000};
321
322 static unsigned int i20Log10(unsigned short val)
323 {
324 unsigned int rntval = 100;
325 unsigned int tmp = val;
326 unsigned int exp = 1;
327
328 while(tmp > 100) {tmp /= 100; exp++;}
329
330 val = (2 * val)/denom[exp];
331 if (exp > 1) rntval = 2000*exp;
332
333 rntval += i100x20log10[val];
334 return rntval;
335 }
336
337 static int or51211_read_signal_strength(struct dvb_frontend* fe, u16* strength)
338 {
339 struct or51211_state* state = fe->demodulator_priv;
340 u8 rec_buf[2];
341 u8 snd_buf[4];
342 u8 snr_equ;
343 u32 signal_strength;
344
345 /* SNR after Equalizer */
346 snd_buf[0] = 0x04;
347 snd_buf[1] = 0x00;
348 snd_buf[2] = 0x04;
349 snd_buf[3] = 0x00;
350
351 if (i2c_writebytes(state,state->config->demod_address,snd_buf,3)) {
352 printk(KERN_WARNING "or51211: read_status write error\n");
353 return -1;
354 }
355 msleep(3);
356 if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
357 printk(KERN_WARNING "or51211: read_status read error\n");
358 return -1;
359 }
360 snr_equ = rec_buf[0] & 0xff;
361
362 /* The value reported back from the frontend will be FFFF=100% 0000=0% */
363 signal_strength = (((5334 - i20Log10(snr_equ))/3+5)*65535)/1000;
364 if (signal_strength > 0xffff)
365 *strength = 0xffff;
366 else
367 *strength = signal_strength;
368 dprintk("read_signal_strength %i\n",*strength);
369
370 return 0;
371 }
372
373 static int or51211_read_snr(struct dvb_frontend* fe, u16* snr)
374 {
375 struct or51211_state* state = fe->demodulator_priv;
376 u8 rec_buf[2];
377 u8 snd_buf[4];
378
379 /* SNR after Equalizer */
380 snd_buf[0] = 0x04;
381 snd_buf[1] = 0x00;
382 snd_buf[2] = 0x04;
383 snd_buf[3] = 0x00;
384
385 if (i2c_writebytes(state,state->config->demod_address,snd_buf,3)) {
386 printk(KERN_WARNING "or51211: read_status write error\n");
387 return -1;
388 }
389 msleep(3);
390 if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
391 printk(KERN_WARNING "or51211: read_status read error\n");
392 return -1;
393 }
394 *snr = rec_buf[0] & 0xff;
395
396 dprintk("read_snr %i\n",*snr);
397
398 return 0;
399 }
400
401 static int or51211_read_ber(struct dvb_frontend* fe, u32* ber)
402 {
403 *ber = -ENOSYS;
404 return 0;
405 }
406
407 static int or51211_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
408 {
409 *ucblocks = -ENOSYS;
410 return 0;
411 }
412
413 static int or51211_sleep(struct dvb_frontend* fe)
414 {
415 return 0;
416 }
417
418 static int or51211_init(struct dvb_frontend* fe)
419 {
420 struct or51211_state* state = fe->demodulator_priv;
421 const struct or51211_config* config = state->config;
422 const struct firmware* fw;
423 unsigned char get_ver_buf[] = {0x04,0x00,0x30,0x00,0x00};
424 unsigned char rec_buf[14];
425 int ret,i;
426
427 if (!state->initialized) {
428 /* Request the firmware, this will block until it uploads */
429 printk(KERN_INFO "or51211: Waiting for firmware upload "
430 "(%s)...\n", OR51211_DEFAULT_FIRMWARE);
431 ret = config->request_firmware(fe, &fw,
432 OR51211_DEFAULT_FIRMWARE);
433 printk(KERN_INFO "or51211:Got Hotplug firmware\n");
434 if (ret) {
435 printk(KERN_WARNING "or51211: No firmware uploaded "
436 "(timeout or file not found?)\n");
437 return ret;
438 }
439
440 ret = or51211_load_firmware(fe, fw);
441 if (ret) {
442 printk(KERN_WARNING "or51211: Writing firmware to "
443 "device failed!\n");
444 release_firmware(fw);
445 return ret;
446 }
447 printk(KERN_INFO "or51211: Firmware upload complete.\n");
448
449 /* Set operation mode in Receiver 1 register;
450 * type 1:
451 * data 0x50h Automatic sets receiver channel conditions
452 * Automatic NTSC rejection filter
453 * Enable MPEG serial data output
454 * MPEG2tr
455 * High tuner phase noise
456 * normal +/-150kHz Carrier acquisition range
457 */
458 if (i2c_writebytes(state,state->config->demod_address,
459 cmd_buf,3)) {
460 printk(KERN_WARNING "or51211: Load DVR Error 5\n");
461 return -1;
462 }
463
464 /* Read back ucode version to besure we loaded correctly */
465 /* and are really up and running */
466 rec_buf[0] = 0x04;
467 rec_buf[1] = 0x00;
468 rec_buf[2] = 0x03;
469 rec_buf[3] = 0x00;
470 msleep(30);
471 if (i2c_writebytes(state,state->config->demod_address,
472 rec_buf,3)) {
473 printk(KERN_WARNING "or51211: Load DVR Error A\n");
474 return -1;
475 }
476 msleep(3);
477 if (i2c_readbytes(state,state->config->demod_address,
478 &rec_buf[10],2)) {
479 printk(KERN_WARNING "or51211: Load DVR Error B\n");
480 return -1;
481 }
482
483 rec_buf[0] = 0x04;
484 rec_buf[1] = 0x00;
485 rec_buf[2] = 0x01;
486 rec_buf[3] = 0x00;
487 msleep(20);
488 if (i2c_writebytes(state,state->config->demod_address,
489 rec_buf,3)) {
490 printk(KERN_WARNING "or51211: Load DVR Error C\n");
491 return -1;
492 }
493 msleep(3);
494 if (i2c_readbytes(state,state->config->demod_address,
495 &rec_buf[12],2)) {
496 printk(KERN_WARNING "or51211: Load DVR Error D\n");
497 return -1;
498 }
499
500 for (i = 0; i < 8; i++)
501 rec_buf[i]=0xed;
502
503 for (i = 0; i < 5; i++) {
504 msleep(30);
505 get_ver_buf[4] = i+1;
506 if (i2c_writebytes(state,state->config->demod_address,
507 get_ver_buf,5)) {
508 printk(KERN_WARNING "or51211:Load DVR Error 6"
509 " - %d\n",i);
510 return -1;
511 }
512 msleep(3);
513
514 if (i2c_readbytes(state,state->config->demod_address,
515 &rec_buf[i*2],2)) {
516 printk(KERN_WARNING "or51211:Load DVR Error 7"
517 " - %d\n",i);
518 return -1;
519 }
520 /* If we didn't receive the right index, try again */
521 if ((int)rec_buf[i*2+1]!=i+1){
522 i--;
523 }
524 }
525 dprintk("read_fwbits %x %x %x %x %x %x %x %x %x %x\n",
526 rec_buf[0], rec_buf[1], rec_buf[2], rec_buf[3],
527 rec_buf[4], rec_buf[5], rec_buf[6], rec_buf[7],
528 rec_buf[8], rec_buf[9]);
529
530 printk(KERN_INFO "or51211: ver TU%02x%02x%02x VSB mode %02x"
531 " Status %02x\n",
532 rec_buf[2], rec_buf[4],rec_buf[6],
533 rec_buf[12],rec_buf[10]);
534
535 rec_buf[0] = 0x04;
536 rec_buf[1] = 0x00;
537 rec_buf[2] = 0x03;
538 rec_buf[3] = 0x00;
539 msleep(20);
540 if (i2c_writebytes(state,state->config->demod_address,
541 rec_buf,3)) {
542 printk(KERN_WARNING "or51211: Load DVR Error 8\n");
543 return -1;
544 }
545 msleep(20);
546 if (i2c_readbytes(state,state->config->demod_address,
547 &rec_buf[8],2)) {
548 printk(KERN_WARNING "or51211: Load DVR Error 9\n");
549 return -1;
550 }
551 state->initialized = 1;
552 }
553
554 return 0;
555 }
556
557 static int or51211_get_tune_settings(struct dvb_frontend* fe,
558 struct dvb_frontend_tune_settings* fesettings)
559 {
560 fesettings->min_delay_ms = 500;
561 fesettings->step_size = 0;
562 fesettings->max_drift = 0;
563 return 0;
564 }
565
566 static void or51211_release(struct dvb_frontend* fe)
567 {
568 struct or51211_state* state = fe->demodulator_priv;
569 state->config->sleep(fe);
570 kfree(state);
571 }
572
573 static struct dvb_frontend_ops or51211_ops;
574
575 struct dvb_frontend* or51211_attach(const struct or51211_config* config,
576 struct i2c_adapter* i2c)
577 {
578 struct or51211_state* state = NULL;
579
580 /* Allocate memory for the internal state */
581 state = kmalloc(sizeof(struct or51211_state), GFP_KERNEL);
582 if (state == NULL)
583 goto error;
584
585 /* Setup the state */
586 state->config = config;
587 state->i2c = i2c;
588 memcpy(&state->ops, &or51211_ops, sizeof(struct dvb_frontend_ops));
589 state->initialized = 0;
590 state->current_frequency = 0;
591
592 /* Create dvb_frontend */
593 state->frontend.ops = &state->ops;
594 state->frontend.demodulator_priv = state;
595 return &state->frontend;
596
597 error:
598 kfree(state);
599 return NULL;
600 }
601
602 static struct dvb_frontend_ops or51211_ops = {
603
604 .info = {
605 .name = "Oren OR51211 VSB Frontend",
606 .type = FE_ATSC,
607 .frequency_min = 44000000,
608 .frequency_max = 958000000,
609 .frequency_stepsize = 166666,
610 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
611 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
612 FE_CAN_8VSB
613 },
614
615 .release = or51211_release,
616
617 .init = or51211_init,
618 .sleep = or51211_sleep,
619
620 .set_frontend = or51211_set_parameters,
621 .get_tune_settings = or51211_get_tune_settings,
622
623 .read_status = or51211_read_status,
624 .read_ber = or51211_read_ber,
625 .read_signal_strength = or51211_read_signal_strength,
626 .read_snr = or51211_read_snr,
627 .read_ucblocks = or51211_read_ucblocks,
628 };
629
630 module_param(debug, int, 0644);
631 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
632
633 MODULE_DESCRIPTION("Oren OR51211 VSB [pcHDTV HD-2000] Demodulator Driver");
634 MODULE_AUTHOR("Kirk Lapray");
635 MODULE_LICENSE("GPL");
636
637 EXPORT_SYMBOL(or51211_attach);
638
Verdex Pro support