?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / media / dvb-frontends / dib9000.c
blob04d92d6142797e658ca0747f330f5c935af2a2c3
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Linux-DVB Driver for DiBcom's DiB9000 and demodulator-family.
4 *
5 * Copyright (C) 2005-10 DiBcom (http://www.dibcom.fr/)
6 */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/kernel.h>
11 #include <linux/i2c.h>
12 #include <linux/mutex.h>
13
14 #include <media/dvb_math.h>
15 #include <media/dvb_frontend.h>
16
17 #include "dib9000.h"
18 #include "dibx000_common.h"
19
20 static int debug;
21 module_param(debug, int, 0644);
22 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
23
24 #define dprintk(fmt, arg...) do { \
25 if (debug) \
26 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
27 __func__, ##arg); \
28 } while (0)
29
30 #define MAX_NUMBER_OF_FRONTENDS 6
31
32 struct i2c_device {
33 struct i2c_adapter *i2c_adap;
34 u8 i2c_addr;
35 u8 *i2c_read_buffer;
36 u8 *i2c_write_buffer;
37 };
38
39 struct dib9000_pid_ctrl {
40 #define DIB9000_PID_FILTER_CTRL 0
41 #define DIB9000_PID_FILTER 1
42 u8 cmd;
43 u8 id;
44 u16 pid;
45 u8 onoff;
46 };
47
48 struct dib9000_state {
49 struct i2c_device i2c;
50
51 struct dibx000_i2c_master i2c_master;
52 struct i2c_adapter tuner_adap;
53 struct i2c_adapter component_bus;
54
55 u16 revision;
56 u8 reg_offs;
57
58 enum frontend_tune_state tune_state;
59 u32 status;
60 struct dvb_frontend_parametersContext channel_status;
61
62 u8 fe_id;
63
64 #define DIB9000_GPIO_DEFAULT_DIRECTIONS 0xffff
65 u16 gpio_dir;
66 #define DIB9000_GPIO_DEFAULT_VALUES 0x0000
67 u16 gpio_val;
68 #define DIB9000_GPIO_DEFAULT_PWM_POS 0xffff
69 u16 gpio_pwm_pos;
70
71 union { /* common for all chips */
72 struct {
73 u8 mobile_mode:1;
74 } host;
75
76 struct {
77 struct dib9000_fe_memory_map {
78 u16 addr;
79 u16 size;
80 } fe_mm[18];
81 u8 memcmd;
82
83 struct mutex mbx_if_lock; /* to protect read/write operations */
84 struct mutex mbx_lock; /* to protect the whole mailbox handling */
85
86 struct mutex mem_lock; /* to protect the memory accesses */
87 struct mutex mem_mbx_lock; /* to protect the memory-based mailbox */
88
89 #define MBX_MAX_WORDS (256 - 200 - 2)
90 #define DIB9000_MSG_CACHE_SIZE 2
91 u16 message_cache[DIB9000_MSG_CACHE_SIZE][MBX_MAX_WORDS];
92 u8 fw_is_running;
93 } risc;
94 } platform;
95
96 union { /* common for all platforms */
97 struct {
98 struct dib9000_config cfg;
99 } d9;
100 } chip;
101
102 struct dvb_frontend *fe[MAX_NUMBER_OF_FRONTENDS];
103 u16 component_bus_speed;
104
105 /* for the I2C transfer */
106 struct i2c_msg msg[2];
107 u8 i2c_write_buffer[255];
108 u8 i2c_read_buffer[255];
109 struct mutex demod_lock;
110 u8 get_frontend_internal;
111 struct dib9000_pid_ctrl pid_ctrl[10];
112 s8 pid_ctrl_index; /* -1: empty list; -2: do not use the list */
113 };
114
115 static const u32 fe_info[44] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
117 0, 0, 0, 0, 0, 0, 0, 0
118 };
119
120 enum dib9000_power_mode {
121 DIB9000_POWER_ALL = 0,
122
123 DIB9000_POWER_NO,
124 DIB9000_POWER_INTERF_ANALOG_AGC,
125 DIB9000_POWER_COR4_DINTLV_ICIRM_EQUAL_CFROD,
126 DIB9000_POWER_COR4_CRY_ESRAM_MOUT_NUD,
127 DIB9000_POWER_INTERFACE_ONLY,
128 };
129
130 enum dib9000_out_messages {
131 OUT_MSG_HBM_ACK,
132 OUT_MSG_HOST_BUF_FAIL,
133 OUT_MSG_REQ_VERSION,
134 OUT_MSG_BRIDGE_I2C_W,
135 OUT_MSG_BRIDGE_I2C_R,
136 OUT_MSG_BRIDGE_APB_W,
137 OUT_MSG_BRIDGE_APB_R,
138 OUT_MSG_SCAN_CHANNEL,
139 OUT_MSG_MONIT_DEMOD,
140 OUT_MSG_CONF_GPIO,
141 OUT_MSG_DEBUG_HELP,
142 OUT_MSG_SUBBAND_SEL,
143 OUT_MSG_ENABLE_TIME_SLICE,
144 OUT_MSG_FE_FW_DL,
145 OUT_MSG_FE_CHANNEL_SEARCH,
146 OUT_MSG_FE_CHANNEL_TUNE,
147 OUT_MSG_FE_SLEEP,
148 OUT_MSG_FE_SYNC,
149 OUT_MSG_CTL_MONIT,
150
151 OUT_MSG_CONF_SVC,
152 OUT_MSG_SET_HBM,
153 OUT_MSG_INIT_DEMOD,
154 OUT_MSG_ENABLE_DIVERSITY,
155 OUT_MSG_SET_OUTPUT_MODE,
156 OUT_MSG_SET_PRIORITARY_CHANNEL,
157 OUT_MSG_ACK_FRG,
158 OUT_MSG_INIT_PMU,
159 };
160
161 enum dib9000_in_messages {
162 IN_MSG_DATA,
163 IN_MSG_FRAME_INFO,
164 IN_MSG_CTL_MONIT,
165 IN_MSG_ACK_FREE_ITEM,
166 IN_MSG_DEBUG_BUF,
167 IN_MSG_MPE_MONITOR,
168 IN_MSG_RAWTS_MONITOR,
169 IN_MSG_END_BRIDGE_I2C_RW,
170 IN_MSG_END_BRIDGE_APB_RW,
171 IN_MSG_VERSION,
172 IN_MSG_END_OF_SCAN,
173 IN_MSG_MONIT_DEMOD,
174 IN_MSG_ERROR,
175 IN_MSG_FE_FW_DL_DONE,
176 IN_MSG_EVENT,
177 IN_MSG_ACK_CHANGE_SVC,
178 IN_MSG_HBM_PROF,
179 };
180
181 /* memory_access requests */
182 #define FE_MM_W_CHANNEL 0
183 #define FE_MM_W_FE_INFO 1
184 #define FE_MM_RW_SYNC 2
185
186 #define FE_SYNC_CHANNEL 1
187 #define FE_SYNC_W_GENERIC_MONIT 2
188 #define FE_SYNC_COMPONENT_ACCESS 3
189
190 #define FE_MM_R_CHANNEL_SEARCH_STATE 3
191 #define FE_MM_R_CHANNEL_UNION_CONTEXT 4
192 #define FE_MM_R_FE_INFO 5
193 #define FE_MM_R_FE_MONITOR 6
194
195 #define FE_MM_W_CHANNEL_HEAD 7
196 #define FE_MM_W_CHANNEL_UNION 8
197 #define FE_MM_W_CHANNEL_CONTEXT 9
198 #define FE_MM_R_CHANNEL_UNION 10
199 #define FE_MM_R_CHANNEL_CONTEXT 11
200 #define FE_MM_R_CHANNEL_TUNE_STATE 12
201
202 #define FE_MM_R_GENERIC_MONITORING_SIZE 13
203 #define FE_MM_W_GENERIC_MONITORING 14
204 #define FE_MM_R_GENERIC_MONITORING 15
205
206 #define FE_MM_W_COMPONENT_ACCESS 16
207 #define FE_MM_RW_COMPONENT_ACCESS_BUFFER 17
208 static int dib9000_risc_apb_access_read(struct dib9000_state *state, u32 address, u16 attribute, const u8 * tx, u32 txlen, u8 * b, u32 len);
209 static int dib9000_risc_apb_access_write(struct dib9000_state *state, u32 address, u16 attribute, const u8 * b, u32 len);
210
211 static u16 to_fw_output_mode(u16 mode)
212 {
213 switch (mode) {
214 case OUTMODE_HIGH_Z:
215 return 0;
216 case OUTMODE_MPEG2_PAR_GATED_CLK:
217 return 4;
218 case OUTMODE_MPEG2_PAR_CONT_CLK:
219 return 8;
220 case OUTMODE_MPEG2_SERIAL:
221 return 16;
222 case OUTMODE_DIVERSITY:
223 return 128;
224 case OUTMODE_MPEG2_FIFO:
225 return 2;
226 case OUTMODE_ANALOG_ADC:
227 return 1;
228 default:
229 return 0;
230 }
231 }
232
233 static int dib9000_read16_attr(struct dib9000_state *state, u16 reg, u8 *b, u32 len, u16 attribute)
234 {
235 u32 chunk_size = 126;
236 u32 l;
237 int ret;
238
239 if (state->platform.risc.fw_is_running && (reg < 1024))
240 return dib9000_risc_apb_access_read(state, reg, attribute, NULL, 0, b, len);
241
242 memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
243 state->msg[0].addr = state->i2c.i2c_addr >> 1;
244 state->msg[0].flags = 0;
245 state->msg[0].buf = state->i2c_write_buffer;
246 state->msg[0].len = 2;
247 state->msg[1].addr = state->i2c.i2c_addr >> 1;
248 state->msg[1].flags = I2C_M_RD;
249 state->msg[1].buf = b;
250 state->msg[1].len = len;
251
252 state->i2c_write_buffer[0] = reg >> 8;
253 state->i2c_write_buffer[1] = reg & 0xff;
254
255 if (attribute & DATA_BUS_ACCESS_MODE_8BIT)
256 state->i2c_write_buffer[0] |= (1 << 5);
257 if (attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
258 state->i2c_write_buffer[0] |= (1 << 4);
259
260 do {
261 l = len < chunk_size ? len : chunk_size;
262 state->msg[1].len = l;
263 state->msg[1].buf = b;
264 ret = i2c_transfer(state->i2c.i2c_adap, state->msg, 2) != 2 ? -EREMOTEIO : 0;
265 if (ret != 0) {
266 dprintk("i2c read error on %d\n", reg);
267 return -EREMOTEIO;
268 }
269
270 b += l;
271 len -= l;
272
273 if (!(attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT))
274 reg += l / 2;
275 } while ((ret == 0) && len);
276
277 return 0;
278 }
279
280 static u16 dib9000_i2c_read16(struct i2c_device *i2c, u16 reg)
281 {
282 struct i2c_msg msg[2] = {
283 {.addr = i2c->i2c_addr >> 1, .flags = 0,
284 .buf = i2c->i2c_write_buffer, .len = 2},
285 {.addr = i2c->i2c_addr >> 1, .flags = I2C_M_RD,
286 .buf = i2c->i2c_read_buffer, .len = 2},
287 };
288
289 i2c->i2c_write_buffer[0] = reg >> 8;
290 i2c->i2c_write_buffer[1] = reg & 0xff;
291
292 if (i2c_transfer(i2c->i2c_adap, msg, 2) != 2) {
293 dprintk("read register %x error\n", reg);
294 return 0;
295 }
296
297 return (i2c->i2c_read_buffer[0] << 8) | i2c->i2c_read_buffer[1];
298 }
299
300 static inline u16 dib9000_read_word(struct dib9000_state *state, u16 reg)
301 {
302 if (dib9000_read16_attr(state, reg, state->i2c_read_buffer, 2, 0) != 0)
303 return 0;
304 return (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
305 }
306
307 static inline u16 dib9000_read_word_attr(struct dib9000_state *state, u16 reg, u16 attribute)
308 {
309 if (dib9000_read16_attr(state, reg, state->i2c_read_buffer, 2,
310 attribute) != 0)
311 return 0;
312 return (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
313 }
314
315 #define dib9000_read16_noinc_attr(state, reg, b, len, attribute) dib9000_read16_attr(state, reg, b, len, (attribute) | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
316
317 static int dib9000_write16_attr(struct dib9000_state *state, u16 reg, const u8 *buf, u32 len, u16 attribute)
318 {
319 u32 chunk_size = 126;
320 u32 l;
321 int ret;
322
323 if (state->platform.risc.fw_is_running && (reg < 1024)) {
324 if (dib9000_risc_apb_access_write
325 (state, reg, DATA_BUS_ACCESS_MODE_16BIT | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT | attribute, buf, len) != 0)
326 return -EINVAL;
327 return 0;
328 }
329
330 memset(&state->msg[0], 0, sizeof(struct i2c_msg));
331 state->msg[0].addr = state->i2c.i2c_addr >> 1;
332 state->msg[0].flags = 0;
333 state->msg[0].buf = state->i2c_write_buffer;
334 state->msg[0].len = len + 2;
335
336 state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
337 state->i2c_write_buffer[1] = (reg) & 0xff;
338
339 if (attribute & DATA_BUS_ACCESS_MODE_8BIT)
340 state->i2c_write_buffer[0] |= (1 << 5);
341 if (attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
342 state->i2c_write_buffer[0] |= (1 << 4);
343
344 do {
345 l = len < chunk_size ? len : chunk_size;
346 state->msg[0].len = l + 2;
347 memcpy(&state->i2c_write_buffer[2], buf, l);
348
349 ret = i2c_transfer(state->i2c.i2c_adap, state->msg, 1) != 1 ? -EREMOTEIO : 0;
350
351 buf += l;
352 len -= l;
353
354 if (!(attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT))
355 reg += l / 2;
356 } while ((ret == 0) && len);
357
358 return ret;
359 }
360
361 static int dib9000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
362 {
363 struct i2c_msg msg = {
364 .addr = i2c->i2c_addr >> 1, .flags = 0,
365 .buf = i2c->i2c_write_buffer, .len = 4
366 };
367
368 i2c->i2c_write_buffer[0] = (reg >> 8) & 0xff;
369 i2c->i2c_write_buffer[1] = reg & 0xff;
370 i2c->i2c_write_buffer[2] = (val >> 8) & 0xff;
371 i2c->i2c_write_buffer[3] = val & 0xff;
372
373 return i2c_transfer(i2c->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
374 }
375
376 static inline int dib9000_write_word(struct dib9000_state *state, u16 reg, u16 val)
377 {
378 u8 b[2] = { val >> 8, val & 0xff };
379 return dib9000_write16_attr(state, reg, b, 2, 0);
380 }
381
382 static inline int dib9000_write_word_attr(struct dib9000_state *state, u16 reg, u16 val, u16 attribute)
383 {
384 u8 b[2] = { val >> 8, val & 0xff };
385 return dib9000_write16_attr(state, reg, b, 2, attribute);
386 }
387
388 #define dib9000_write(state, reg, buf, len) dib9000_write16_attr(state, reg, buf, len, 0)
389 #define dib9000_write16_noinc(state, reg, buf, len) dib9000_write16_attr(state, reg, buf, len, DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
390 #define dib9000_write16_noinc_attr(state, reg, buf, len, attribute) dib9000_write16_attr(state, reg, buf, len, DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT | (attribute))
391
392 #define dib9000_mbx_send(state, id, data, len) dib9000_mbx_send_attr(state, id, data, len, 0)
393 #define dib9000_mbx_get_message(state, id, msg, len) dib9000_mbx_get_message_attr(state, id, msg, len, 0)
394
395 #define MAC_IRQ (1 << 1)
396 #define IRQ_POL_MSK (1 << 4)
397
398 #define dib9000_risc_mem_read_chunks(state, b, len) dib9000_read16_attr(state, 1063, b, len, DATA_BUS_ACCESS_MODE_8BIT | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
399 #define dib9000_risc_mem_write_chunks(state, buf, len) dib9000_write16_attr(state, 1063, buf, len, DATA_BUS_ACCESS_MODE_8BIT | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
400
401 static void dib9000_risc_mem_setup_cmd(struct dib9000_state *state, u32 addr, u32 len, u8 reading)
402 {
403 u8 b[14] = { 0 };
404
405 /* dprintk("%d memcmd: %d %d %d\n", state->fe_id, addr, addr+len, len); */
406 /* b[0] = 0 << 7; */
407 b[1] = 1;
408
409 /* b[2] = 0; */
410 /* b[3] = 0; */
411 b[4] = (u8) (addr >> 8);
412 b[5] = (u8) (addr & 0xff);
413
414 /* b[10] = 0; */
415 /* b[11] = 0; */
416 b[12] = (u8) (addr >> 8);
417 b[13] = (u8) (addr & 0xff);
418
419 addr += len;
420 /* b[6] = 0; */
421 /* b[7] = 0; */
422 b[8] = (u8) (addr >> 8);
423 b[9] = (u8) (addr & 0xff);
424
425 dib9000_write(state, 1056, b, 14);
426 if (reading)
427 dib9000_write_word(state, 1056, (1 << 15) | 1);
428 state->platform.risc.memcmd = -1; /* if it was called directly reset it - to force a future setup-call to set it */
429 }
430
431 static void dib9000_risc_mem_setup(struct dib9000_state *state, u8 cmd)
432 {
433 struct dib9000_fe_memory_map *m = &state->platform.risc.fe_mm[cmd & 0x7f];
434 /* decide whether we need to "refresh" the memory controller */
435 if (state->platform.risc.memcmd == cmd && /* same command */
436 !(cmd & 0x80 && m->size < 67)) /* and we do not want to read something with less than 67 bytes looping - working around a bug in the memory controller */
437 return;
438 dib9000_risc_mem_setup_cmd(state, m->addr, m->size, cmd & 0x80);
439 state->platform.risc.memcmd = cmd;
440 }
441
442 static int dib9000_risc_mem_read(struct dib9000_state *state, u8 cmd, u8 * b, u16 len)
443 {
444 if (!state->platform.risc.fw_is_running)
445 return -EIO;
446
447 if (mutex_lock_interruptible(&state->platform.risc.mem_lock) < 0) {
448 dprintk("could not get the lock\n");
449 return -EINTR;
450 }
451 dib9000_risc_mem_setup(state, cmd | 0x80);
452 dib9000_risc_mem_read_chunks(state, b, len);
453 mutex_unlock(&state->platform.risc.mem_lock);
454 return 0;
455 }
456
457 static int dib9000_risc_mem_write(struct dib9000_state *state, u8 cmd, const u8 * b)
458 {
459 struct dib9000_fe_memory_map *m = &state->platform.risc.fe_mm[cmd];
460 if (!state->platform.risc.fw_is_running)
461 return -EIO;
462
463 if (mutex_lock_interruptible(&state->platform.risc.mem_lock) < 0) {
464 dprintk("could not get the lock\n");
465 return -EINTR;
466 }
467 dib9000_risc_mem_setup(state, cmd);
468 dib9000_risc_mem_write_chunks(state, b, m->size);
469 mutex_unlock(&state->platform.risc.mem_lock);
470 return 0;
471 }
472
473 static int dib9000_firmware_download(struct dib9000_state *state, u8 risc_id, u16 key, const u8 * code, u32 len)
474 {
475 u16 offs;
476
477 if (risc_id == 1)
478 offs = 16;
479 else
480 offs = 0;
481
482 /* config crtl reg */
483 dib9000_write_word(state, 1024 + offs, 0x000f);
484 dib9000_write_word(state, 1025 + offs, 0);
485 dib9000_write_word(state, 1031 + offs, key);
486
487 dprintk("going to download %dB of microcode\n", len);
488 if (dib9000_write16_noinc(state, 1026 + offs, (u8 *) code, (u16) len) != 0) {
489 dprintk("error while downloading microcode for RISC %c\n", 'A' + risc_id);
490 return -EIO;
491 }
492
493 dprintk("Microcode for RISC %c loaded\n", 'A' + risc_id);
494
495 return 0;
496 }
497
498 static int dib9000_mbx_host_init(struct dib9000_state *state, u8 risc_id)
499 {
500 u16 mbox_offs;
501 u16 reset_reg;
502 u16 tries = 1000;
503
504 if (risc_id == 1)
505 mbox_offs = 16;
506 else
507 mbox_offs = 0;
508
509 /* Reset mailbox */
510 dib9000_write_word(state, 1027 + mbox_offs, 0x8000);
511
512 /* Read reset status */
513 do {
514 reset_reg = dib9000_read_word(state, 1027 + mbox_offs);
515 msleep(100);
516 } while ((reset_reg & 0x8000) && --tries);
517
518 if (reset_reg & 0x8000) {
519 dprintk("MBX: init ERROR, no response from RISC %c\n", 'A' + risc_id);
520 return -EIO;
521 }
522 dprintk("MBX: initialized\n");
523 return 0;
524 }
525
526 #define MAX_MAILBOX_TRY 100
527 static int dib9000_mbx_send_attr(struct dib9000_state *state, u8 id, u16 * data, u8 len, u16 attr)
528 {
529 u8 *d, b[2];
530 u16 tmp;
531 u16 size;
532 u32 i;
533 int ret = 0;
534
535 if (!state->platform.risc.fw_is_running)
536 return -EINVAL;
537
538 if (mutex_lock_interruptible(&state->platform.risc.mbx_if_lock) < 0) {
539 dprintk("could not get the lock\n");
540 return -EINTR;
541 }
542 tmp = MAX_MAILBOX_TRY;
543 do {
544 size = dib9000_read_word_attr(state, 1043, attr) & 0xff;
545 if ((size + len + 1) > MBX_MAX_WORDS && --tmp) {
546 dprintk("MBX: RISC mbx full, retrying\n");
547 msleep(100);
548 } else
549 break;
550 } while (1);
551
552 /*dprintk( "MBX: size: %d\n", size); */
553
554 if (tmp == 0) {
555 ret = -EINVAL;
556 goto out;
557 }
558 #ifdef DUMP_MSG
559 dprintk("--> %02x %d %*ph\n", id, len + 1, len, data);
560 #endif
561
562 /* byte-order conversion - works on big (where it is not necessary) or little endian */
563 d = (u8 *) data;
564 for (i = 0; i < len; i++) {
565 tmp = data[i];
566 *d++ = tmp >> 8;
567 *d++ = tmp & 0xff;
568 }
569
570 /* write msg */
571 b[0] = id;
572 b[1] = len + 1;
573 if (dib9000_write16_noinc_attr(state, 1045, b, 2, attr) != 0 || dib9000_write16_noinc_attr(state, 1045, (u8 *) data, len * 2, attr) != 0) {
574 ret = -EIO;
575 goto out;
576 }
577
578 /* update register nb_mes_in_RX */
579 ret = (u8) dib9000_write_word_attr(state, 1043, 1 << 14, attr);
580
581 out:
582 mutex_unlock(&state->platform.risc.mbx_if_lock);
583
584 return ret;
585 }
586
587 static u8 dib9000_mbx_read(struct dib9000_state *state, u16 * data, u8 risc_id, u16 attr)
588 {
589 #ifdef DUMP_MSG
590 u16 *d = data;
591 #endif
592
593 u16 tmp, i;
594 u8 size;
595 u8 mc_base;
596
597 if (!state->platform.risc.fw_is_running)
598 return 0;
599
600 if (mutex_lock_interruptible(&state->platform.risc.mbx_if_lock) < 0) {
601 dprintk("could not get the lock\n");
602 return 0;
603 }
604 if (risc_id == 1)
605 mc_base = 16;
606 else
607 mc_base = 0;
608
609 /* Length and type in the first word */
610 *data = dib9000_read_word_attr(state, 1029 + mc_base, attr);
611
612 size = *data & 0xff;
613 if (size <= MBX_MAX_WORDS) {
614 data++;
615 size--; /* Initial word already read */
616
617 dib9000_read16_noinc_attr(state, 1029 + mc_base, (u8 *) data, size * 2, attr);
618
619 /* to word conversion */
620 for (i = 0; i < size; i++) {
621 tmp = *data;
622 *data = (tmp >> 8) | (tmp << 8);
623 data++;
624 }
625
626 #ifdef DUMP_MSG
627 dprintk("<--\n");
628 for (i = 0; i < size + 1; i++)
629 dprintk("%04x\n", d[i]);
630 dprintk("\n");
631 #endif
632 } else {
633 dprintk("MBX: message is too big for message cache (%d), flushing message\n", size);
634 size--; /* Initial word already read */
635 while (size--)
636 dib9000_read16_noinc_attr(state, 1029 + mc_base, (u8 *) data, 2, attr);
637 }
638 /* Update register nb_mes_in_TX */
639 dib9000_write_word_attr(state, 1028 + mc_base, 1 << 14, attr);
640
641 mutex_unlock(&state->platform.risc.mbx_if_lock);
642
643 return size + 1;
644 }
645
646 static int dib9000_risc_debug_buf(struct dib9000_state *state, u16 * data, u8 size)
647 {
648 u32 ts = data[1] << 16 | data[0];
649 char *b = (char *)&data[2];
650
651 b[2 * (size - 2) - 1] = '\0'; /* Bullet proof the buffer */
652 if (*b == '~') {
653 b++;
654 dprintk("%s\n", b);
655 } else
656 dprintk("RISC%d: %d.%04d %s\n",
657 state->fe_id,
658 ts / 10000, ts % 10000, *b ? b : "<empty>");
659 return 1;
660 }
661
662 static int dib9000_mbx_fetch_to_cache(struct dib9000_state *state, u16 attr)
663 {
664 int i;
665 u8 size;
666 u16 *block;
667 /* find a free slot */
668 for (i = 0; i < DIB9000_MSG_CACHE_SIZE; i++) {
669 block = state->platform.risc.message_cache[i];
670 if (*block == 0) {
671 size = dib9000_mbx_read(state, block, 1, attr);
672
673 /* dprintk( "MBX: fetched %04x message to cache\n", *block); */
674
675 switch (*block >> 8) {
676 case IN_MSG_DEBUG_BUF:
677 dib9000_risc_debug_buf(state, block + 1, size); /* debug-messages are going to be printed right away */
678 *block = 0; /* free the block */
679 break;
680 #if 0
681 case IN_MSG_DATA: /* FE-TRACE */
682 dib9000_risc_data_process(state, block + 1, size);
683 *block = 0;
684 break;
685 #endif
686 default:
687 break;
688 }
689
690 return 1;
691 }
692 }
693 dprintk("MBX: no free cache-slot found for new message...\n");
694 return -1;
695 }
696
697 static u8 dib9000_mbx_count(struct dib9000_state *state, u8 risc_id, u16 attr)
698 {
699 if (risc_id == 0)
700 return (u8) (dib9000_read_word_attr(state, 1028, attr) >> 10) & 0x1f; /* 5 bit field */
701 else
702 return (u8) (dib9000_read_word_attr(state, 1044, attr) >> 8) & 0x7f; /* 7 bit field */
703 }
704
705 static int dib9000_mbx_process(struct dib9000_state *state, u16 attr)
706 {
707 int ret = 0;
708
709 if (!state->platform.risc.fw_is_running)
710 return -1;
711
712 if (mutex_lock_interruptible(&state->platform.risc.mbx_lock) < 0) {
713 dprintk("could not get the lock\n");
714 return -1;
715 }
716
717 if (dib9000_mbx_count(state, 1, attr)) /* 1=RiscB */
718 ret = dib9000_mbx_fetch_to_cache(state, attr);
719
720 dib9000_read_word_attr(state, 1229, attr); /* Clear the IRQ */
721 /* if (tmp) */
722 /* dprintk( "cleared IRQ: %x\n", tmp); */
723 mutex_unlock(&state->platform.risc.mbx_lock);
724
725 return ret;
726 }
727
728 static int dib9000_mbx_get_message_attr(struct dib9000_state *state, u16 id, u16 * msg, u8 * size, u16 attr)
729 {
730 u8 i;
731 u16 *block;
732 u16 timeout = 30;
733
734 *msg = 0;
735 do {
736 /* dib9000_mbx_get_from_cache(); */
737 for (i = 0; i < DIB9000_MSG_CACHE_SIZE; i++) {
738 block = state->platform.risc.message_cache[i];
739 if ((*block >> 8) == id) {
740 *size = (*block & 0xff) - 1;
741 memcpy(msg, block + 1, (*size) * 2);
742 *block = 0; /* free the block */
743 i = 0; /* signal that we found a message */
744 break;
745 }
746 }
747
748 if (i == 0)
749 break;
750
751 if (dib9000_mbx_process(state, attr) == -1) /* try to fetch one message - if any */
752 return -1;
753
754 } while (--timeout);
755
756 if (timeout == 0) {
757 dprintk("waiting for message %d timed out\n", id);
758 return -1;
759 }
760
761 return i == 0;
762 }
763
764 static int dib9000_risc_check_version(struct dib9000_state *state)
765 {
766 u8 r[4];
767 u8 size;
768 u16 fw_version = 0;
769
770 if (dib9000_mbx_send(state, OUT_MSG_REQ_VERSION, &fw_version, 1) != 0)
771 return -EIO;
772
773 if (dib9000_mbx_get_message(state, IN_MSG_VERSION, (u16 *) r, &size) < 0)
774 return -EIO;
775
776 fw_version = (r[0] << 8) | r[1];
777 dprintk("RISC: ver: %d.%02d (IC: %d)\n", fw_version >> 10, fw_version & 0x3ff, (r[2] << 8) | r[3]);
778
779 if ((fw_version >> 10) != 7)
780 return -EINVAL;
781
782 switch (fw_version & 0x3ff) {
783 case 11:
784 case 12:
785 case 14:
786 case 15:
787 case 16:
788 case 17:
789 break;
790 default:
791 dprintk("RISC: invalid firmware version");
792 return -EINVAL;
793 }
794
795 dprintk("RISC: valid firmware version");
796 return 0;
797 }
798
799 static int dib9000_fw_boot(struct dib9000_state *state, const u8 * codeA, u32 lenA, const u8 * codeB, u32 lenB)
800 {
801 /* Reconfig pool mac ram */
802 dib9000_write_word(state, 1225, 0x02); /* A: 8k C, 4 k D - B: 32k C 6 k D - IRAM 96k */
803 dib9000_write_word(state, 1226, 0x05);
804
805 /* Toggles IP crypto to Host APB interface. */
806 dib9000_write_word(state, 1542, 1);
807
808 /* Set jump and no jump in the dma box */
809 dib9000_write_word(state, 1074, 0);
810 dib9000_write_word(state, 1075, 0);
811
812 /* Set MAC as APB Master. */
813 dib9000_write_word(state, 1237, 0);
814
815 /* Reset the RISCs */
816 if (codeA != NULL)
817 dib9000_write_word(state, 1024, 2);
818 else
819 dib9000_write_word(state, 1024, 15);
820 if (codeB != NULL)
821 dib9000_write_word(state, 1040, 2);
822
823 if (codeA != NULL)
824 dib9000_firmware_download(state, 0, 0x1234, codeA, lenA);
825 if (codeB != NULL)
826 dib9000_firmware_download(state, 1, 0x1234, codeB, lenB);
827
828 /* Run the RISCs */
829 if (codeA != NULL)
830 dib9000_write_word(state, 1024, 0);
831 if (codeB != NULL)
832 dib9000_write_word(state, 1040, 0);
833
834 if (codeA != NULL)
835 if (dib9000_mbx_host_init(state, 0) != 0)
836 return -EIO;
837 if (codeB != NULL)
838 if (dib9000_mbx_host_init(state, 1) != 0)
839 return -EIO;
840
841 msleep(100);
842 state->platform.risc.fw_is_running = 1;
843
844 if (dib9000_risc_check_version(state) != 0)
845 return -EINVAL;
846
847 state->platform.risc.memcmd = 0xff;
848 return 0;
849 }
850
851 static u16 dib9000_identify(struct i2c_device *client)
852 {
853 u16 value;
854
855 value = dib9000_i2c_read16(client, 896);
856 if (value != 0x01b3) {
857 dprintk("wrong Vendor ID (0x%x)\n", value);
858 return 0;
859 }
860
861 value = dib9000_i2c_read16(client, 897);
862 if (value != 0x4000 && value != 0x4001 && value != 0x4002 && value != 0x4003 && value != 0x4004 && value != 0x4005) {
863 dprintk("wrong Device ID (0x%x)\n", value);
864 return 0;
865 }
866
867 /* protect this driver to be used with 7000PC */
868 if (value == 0x4000 && dib9000_i2c_read16(client, 769) == 0x4000) {
869 dprintk("this driver does not work with DiB7000PC\n");
870 return 0;
871 }
872
873 switch (value) {
874 case 0x4000:
875 dprintk("found DiB7000MA/PA/MB/PB\n");
876 break;
877 case 0x4001:
878 dprintk("found DiB7000HC\n");
879 break;
880 case 0x4002:
881 dprintk("found DiB7000MC\n");
882 break;
883 case 0x4003:
884 dprintk("found DiB9000A\n");
885 break;
886 case 0x4004:
887 dprintk("found DiB9000H\n");
888 break;
889 case 0x4005:
890 dprintk("found DiB9000M\n");
891 break;
892 }
893
894 return value;
895 }
896
897 static void dib9000_set_power_mode(struct dib9000_state *state, enum dib9000_power_mode mode)
898 {
899 /* by default everything is going to be powered off */
900 u16 reg_903 = 0x3fff, reg_904 = 0xffff, reg_905 = 0xffff, reg_906;
901 u8 offset;
902
903 if (state->revision == 0x4003 || state->revision == 0x4004 || state->revision == 0x4005)
904 offset = 1;
905 else
906 offset = 0;
907
908 reg_906 = dib9000_read_word(state, 906 + offset) | 0x3; /* keep settings for RISC */
909
910 /* now, depending on the requested mode, we power on */
911 switch (mode) {
912 /* power up everything in the demod */
913 case DIB9000_POWER_ALL:
914 reg_903 = 0x0000;
915 reg_904 = 0x0000;
916 reg_905 = 0x0000;
917 reg_906 = 0x0000;
918 break;
919
920 /* just leave power on the control-interfaces: GPIO and (I2C or SDIO or SRAM) */
921 case DIB9000_POWER_INTERFACE_ONLY: /* TODO power up either SDIO or I2C or SRAM */
922 reg_905 &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 2));
923 break;
924
925 case DIB9000_POWER_INTERF_ANALOG_AGC:
926 reg_903 &= ~((1 << 15) | (1 << 14) | (1 << 11) | (1 << 10));
927 reg_905 &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 4) | (1 << 2));
928 reg_906 &= ~((1 << 0));
929 break;
930
931 case DIB9000_POWER_COR4_DINTLV_ICIRM_EQUAL_CFROD:
932 reg_903 = 0x0000;
933 reg_904 = 0x801f;
934 reg_905 = 0x0000;
935 reg_906 &= ~((1 << 0));
936 break;
937
938 case DIB9000_POWER_COR4_CRY_ESRAM_MOUT_NUD:
939 reg_903 = 0x0000;
940 reg_904 = 0x8000;
941 reg_905 = 0x010b;
942 reg_906 &= ~((1 << 0));
943 break;
944 default:
945 case DIB9000_POWER_NO:
946 break;
947 }
948
949 /* always power down unused parts */
950 if (!state->platform.host.mobile_mode)
951 reg_904 |= (1 << 7) | (1 << 6) | (1 << 4) | (1 << 2) | (1 << 1);
952
953 /* P_sdio_select_clk = 0 on MC and after */
954 if (state->revision != 0x4000)
955 reg_906 <<= 1;
956
957 dib9000_write_word(state, 903 + offset, reg_903);
958 dib9000_write_word(state, 904 + offset, reg_904);
959 dib9000_write_word(state, 905 + offset, reg_905);
960 dib9000_write_word(state, 906 + offset, reg_906);
961 }
962
963 static int dib9000_fw_reset(struct dvb_frontend *fe)
964 {
965 struct dib9000_state *state = fe->demodulator_priv;
966
967 dib9000_write_word(state, 1817, 0x0003);
968
969 dib9000_write_word(state, 1227, 1);
970 dib9000_write_word(state, 1227, 0);
971
972 switch ((state->revision = dib9000_identify(&state->i2c))) {
973 case 0x4003:
974 case 0x4004:
975 case 0x4005:
976 state->reg_offs = 1;
977 break;
978 default:
979 return -EINVAL;
980 }
981
982 /* reset the i2c-master to use the host interface */
983 dibx000_reset_i2c_master(&state->i2c_master);
984
985 dib9000_set_power_mode(state, DIB9000_POWER_ALL);
986
987 /* unforce divstr regardless whether i2c enumeration was done or not */
988 dib9000_write_word(state, 1794, dib9000_read_word(state, 1794) & ~(1 << 1));
989 dib9000_write_word(state, 1796, 0);
990 dib9000_write_word(state, 1805, 0x805);
991
992 /* restart all parts */
993 dib9000_write_word(state, 898, 0xffff);
994 dib9000_write_word(state, 899, 0xffff);
995 dib9000_write_word(state, 900, 0x0001);
996 dib9000_write_word(state, 901, 0xff19);
997 dib9000_write_word(state, 902, 0x003c);
998
999 dib9000_write_word(state, 898, 0);
1000 dib9000_write_word(state, 899, 0);
1001 dib9000_write_word(state, 900, 0);
1002 dib9000_write_word(state, 901, 0);
1003 dib9000_write_word(state, 902, 0);
1004
1005 dib9000_write_word(state, 911, state->chip.d9.cfg.if_drives);
1006
1007 dib9000_set_power_mode(state, DIB9000_POWER_INTERFACE_ONLY);
1008
1009 return 0;
1010 }
1011
1012 static int dib9000_risc_apb_access_read(struct dib9000_state *state, u32 address, u16 attribute, const u8 * tx, u32 txlen, u8 * b, u32 len)
1013 {
1014 u16 mb[10];
1015 u8 i, s;
1016
1017 if (address >= 1024 || !state->platform.risc.fw_is_running)
1018 return -EINVAL;
1019
1020 /* dprintk( "APB access through rd fw %d %x\n", address, attribute); */
1021
1022 mb[0] = (u16) address;
1023 mb[1] = len / 2;
1024 dib9000_mbx_send_attr(state, OUT_MSG_BRIDGE_APB_R, mb, 2, attribute);
1025 switch (dib9000_mbx_get_message_attr(state, IN_MSG_END_BRIDGE_APB_RW, mb, &s, attribute)) {
1026 case 1:
1027 s--;
1028 for (i = 0; i < s; i++) {
1029 b[i * 2] = (mb[i + 1] >> 8) & 0xff;
1030 b[i * 2 + 1] = (mb[i + 1]) & 0xff;
1031 }
1032 return 0;
1033 default:
1034 return -EIO;
1035 }
1036 return -EIO;
1037 }
1038
1039 static int dib9000_risc_apb_access_write(struct dib9000_state *state, u32 address, u16 attribute, const u8 * b, u32 len)
1040 {
1041 u16 mb[10];
1042 u8 s, i;
1043
1044 if (address >= 1024 || !state->platform.risc.fw_is_running)
1045 return -EINVAL;
1046
1047 if (len > 18)
1048 return -EINVAL;
1049
1050 /* dprintk( "APB access through wr fw %d %x\n", address, attribute); */
1051
1052 mb[0] = (u16)address;
1053 for (i = 0; i + 1 < len; i += 2)
1054 mb[1 + i / 2] = b[i] << 8 | b[i + 1];
1055 if (len & 1)
1056 mb[1 + len / 2] = b[len - 1] << 8;
1057
1058 dib9000_mbx_send_attr(state, OUT_MSG_BRIDGE_APB_W, mb, (3 + len) / 2, attribute);
1059 return dib9000_mbx_get_message_attr(state, IN_MSG_END_BRIDGE_APB_RW, mb, &s, attribute) == 1 ? 0 : -EINVAL;
1060 }
1061
1062 static int dib9000_fw_memmbx_sync(struct dib9000_state *state, u8 i)
1063 {
1064 u8 index_loop = 10;
1065
1066 if (!state->platform.risc.fw_is_running)
1067 return 0;
1068 dib9000_risc_mem_write(state, FE_MM_RW_SYNC, &i);
1069 do {
1070 dib9000_risc_mem_read(state, FE_MM_RW_SYNC, state->i2c_read_buffer, 1);
1071 } while (state->i2c_read_buffer[0] && index_loop--);
1072
1073 if (index_loop > 0)
1074 return 0;
1075 return -EIO;
1076 }
1077
1078 static int dib9000_fw_init(struct dib9000_state *state)
1079 {
1080 struct dibGPIOFunction *f;
1081 u16 b[40] = { 0 };
1082 u8 i;
1083 u8 size;
1084
1085 if (dib9000_fw_boot(state, NULL, 0, state->chip.d9.cfg.microcode_B_fe_buffer, state->chip.d9.cfg.microcode_B_fe_size) != 0)
1086 return -EIO;
1087
1088 /* initialize the firmware */
1089 for (i = 0; i < ARRAY_SIZE(state->chip.d9.cfg.gpio_function); i++) {
1090 f = &state->chip.d9.cfg.gpio_function[i];
1091 if (f->mask) {
1092 switch (f->function) {
1093 case BOARD_GPIO_FUNCTION_COMPONENT_ON:
1094 b[0] = (u16) f->mask;
1095 b[1] = (u16) f->direction;
1096 b[2] = (u16) f->value;
1097 break;
1098 case BOARD_GPIO_FUNCTION_COMPONENT_OFF:
1099 b[3] = (u16) f->mask;
1100 b[4] = (u16) f->direction;
1101 b[5] = (u16) f->value;
1102 break;
1103 }
1104 }
1105 }
1106 if (dib9000_mbx_send(state, OUT_MSG_CONF_GPIO, b, 15) != 0)
1107 return -EIO;
1108
1109 /* subband */
1110 b[0] = state->chip.d9.cfg.subband.size; /* type == 0 -> GPIO - PWM not yet supported */
1111 for (i = 0; i < state->chip.d9.cfg.subband.size; i++) {
1112 b[1 + i * 4] = state->chip.d9.cfg.subband.subband[i].f_mhz;
1113 b[2 + i * 4] = (u16) state->chip.d9.cfg.subband.subband[i].gpio.mask;
1114 b[3 + i * 4] = (u16) state->chip.d9.cfg.subband.subband[i].gpio.direction;
1115 b[4 + i * 4] = (u16) state->chip.d9.cfg.subband.subband[i].gpio.value;
1116 }
1117 b[1 + i * 4] = 0; /* fe_id */
1118 if (dib9000_mbx_send(state, OUT_MSG_SUBBAND_SEL, b, 2 + 4 * i) != 0)
1119 return -EIO;
1120
1121 /* 0 - id, 1 - no_of_frontends */
1122 b[0] = (0 << 8) | 1;
1123 /* 0 = i2c-address demod, 0 = tuner */
1124 b[1] = (0 << 8) | (0);
1125 b[2] = (u16) (((state->chip.d9.cfg.xtal_clock_khz * 1000) >> 16) & 0xffff);
1126 b[3] = (u16) (((state->chip.d9.cfg.xtal_clock_khz * 1000)) & 0xffff);
1127 b[4] = (u16) ((state->chip.d9.cfg.vcxo_timer >> 16) & 0xffff);
1128 b[5] = (u16) ((state->chip.d9.cfg.vcxo_timer) & 0xffff);
1129 b[6] = (u16) ((state->chip.d9.cfg.timing_frequency >> 16) & 0xffff);
1130 b[7] = (u16) ((state->chip.d9.cfg.timing_frequency) & 0xffff);
1131 b[29] = state->chip.d9.cfg.if_drives;
1132 if (dib9000_mbx_send(state, OUT_MSG_INIT_DEMOD, b, ARRAY_SIZE(b)) != 0)
1133 return -EIO;
1134
1135 if (dib9000_mbx_send(state, OUT_MSG_FE_FW_DL, NULL, 0) != 0)
1136 return -EIO;
1137
1138 if (dib9000_mbx_get_message(state, IN_MSG_FE_FW_DL_DONE, b, &size) < 0)
1139 return -EIO;
1140
1141 if (size > ARRAY_SIZE(b)) {
1142 dprintk("error : firmware returned %dbytes needed but the used buffer has only %dbytes\n Firmware init ABORTED", size,
1143 (int)ARRAY_SIZE(b));
1144 return -EINVAL;
1145 }
1146
1147 for (i = 0; i < size; i += 2) {
1148 state->platform.risc.fe_mm[i / 2].addr = b[i + 0];
1149 state->platform.risc.fe_mm[i / 2].size = b[i + 1];
1150 }
1151
1152 return 0;
1153 }
1154
1155 static void dib9000_fw_set_channel_head(struct dib9000_state *state)
1156 {
1157 u8 b[9];
1158 u32 freq = state->fe[0]->dtv_property_cache.frequency / 1000;
1159 if (state->fe_id % 2)
1160 freq += 101;
1161
1162 b[0] = (u8) ((freq >> 0) & 0xff);
1163 b[1] = (u8) ((freq >> 8) & 0xff);
1164 b[2] = (u8) ((freq >> 16) & 0xff);
1165 b[3] = (u8) ((freq >> 24) & 0xff);
1166 b[4] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 0) & 0xff);
1167 b[5] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 8) & 0xff);
1168 b[6] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 16) & 0xff);
1169 b[7] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 24) & 0xff);
1170 b[8] = 0x80; /* do not wait for CELL ID when doing autosearch */
1171 if (state->fe[0]->dtv_property_cache.delivery_system == SYS_DVBT)
1172 b[8] |= 1;
1173 dib9000_risc_mem_write(state, FE_MM_W_CHANNEL_HEAD, b);
1174 }
1175
1176 static int dib9000_fw_get_channel(struct dvb_frontend *fe)
1177 {
1178 struct dib9000_state *state = fe->demodulator_priv;
1179 struct dibDVBTChannel {
1180 s8 spectrum_inversion;
1181
1182 s8 nfft;
1183 s8 guard;
1184 s8 constellation;
1185
1186 s8 hrch;
1187 s8 alpha;
1188 s8 code_rate_hp;
1189 s8 code_rate_lp;
1190 s8 select_hp;
1191
1192 s8 intlv_native;
1193 };
1194 struct dibDVBTChannel *ch;
1195 int ret = 0;
1196
1197 if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
1198 dprintk("could not get the lock\n");
1199 return -EINTR;
1200 }
1201 if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
1202 ret = -EIO;
1203 goto error;
1204 }
1205
1206 dib9000_risc_mem_read(state, FE_MM_R_CHANNEL_UNION,
1207 state->i2c_read_buffer, sizeof(struct dibDVBTChannel));
1208 ch = (struct dibDVBTChannel *)state->i2c_read_buffer;
1209
1210
1211 switch (ch->spectrum_inversion & 0x7) {
1212 case 1:
1213 state->fe[0]->dtv_property_cache.inversion = INVERSION_ON;
1214 break;
1215 case 0:
1216 state->fe[0]->dtv_property_cache.inversion = INVERSION_OFF;
1217 break;
1218 default:
1219 case -1:
1220 state->fe[0]->dtv_property_cache.inversion = INVERSION_AUTO;
1221 break;
1222 }
1223 switch (ch->nfft) {
1224 case 0:
1225 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_2K;
1226 break;
1227 case 2:
1228 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_4K;
1229 break;
1230 case 1:
1231 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K;
1232 break;
1233 default:
1234 case -1:
1235 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_AUTO;
1236 break;
1237 }
1238 switch (ch->guard) {
1239 case 0:
1240 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_32;
1241 break;
1242 case 1:
1243 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_16;
1244 break;
1245 case 2:
1246 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8;
1247 break;
1248 case 3:
1249 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_4;
1250 break;
1251 default:
1252 case -1:
1253 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_AUTO;
1254 break;
1255 }
1256 switch (ch->constellation) {
1257 case 2:
1258 state->fe[0]->dtv_property_cache.modulation = QAM_64;
1259 break;
1260 case 1:
1261 state->fe[0]->dtv_property_cache.modulation = QAM_16;
1262 break;
1263 case 0:
1264 state->fe[0]->dtv_property_cache.modulation = QPSK;
1265 break;
1266 default:
1267 case -1:
1268 state->fe[0]->dtv_property_cache.modulation = QAM_AUTO;
1269 break;
1270 }
1271 switch (ch->hrch) {
1272 case 0:
1273 state->fe[0]->dtv_property_cache.hierarchy = HIERARCHY_NONE;
1274 break;
1275 case 1:
1276 state->fe[0]->dtv_property_cache.hierarchy = HIERARCHY_1;
1277 break;
1278 default:
1279 case -1:
1280 state->fe[0]->dtv_property_cache.hierarchy = HIERARCHY_AUTO;
1281 break;
1282 }
1283 switch (ch->code_rate_hp) {
1284 case 1:
1285 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_1_2;
1286 break;
1287 case 2:
1288 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_2_3;
1289 break;
1290 case 3:
1291 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_3_4;
1292 break;
1293 case 5:
1294 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_5_6;
1295 break;
1296 case 7:
1297 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_7_8;
1298 break;
1299 default:
1300 case -1:
1301 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_AUTO;
1302 break;
1303 }
1304 switch (ch->code_rate_lp) {
1305 case 1:
1306 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_1_2;
1307 break;
1308 case 2:
1309 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_2_3;
1310 break;
1311 case 3:
1312 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_3_4;
1313 break;
1314 case 5:
1315 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_5_6;
1316 break;
1317 case 7:
1318 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_7_8;
1319 break;
1320 default:
1321 case -1:
1322 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_AUTO;
1323 break;
1324 }
1325
1326 error:
1327 mutex_unlock(&state->platform.risc.mem_mbx_lock);
1328 return ret;
1329 }
1330
1331 static int dib9000_fw_set_channel_union(struct dvb_frontend *fe)
1332 {
1333 struct dib9000_state *state = fe->demodulator_priv;
1334 struct dibDVBTChannel {
1335 s8 spectrum_inversion;
1336
1337 s8 nfft;
1338 s8 guard;
1339 s8 constellation;
1340
1341 s8 hrch;
1342 s8 alpha;
1343 s8 code_rate_hp;
1344 s8 code_rate_lp;
1345 s8 select_hp;
1346
1347 s8 intlv_native;
1348 };
1349 struct dibDVBTChannel ch;
1350
1351 switch (state->fe[0]->dtv_property_cache.inversion) {
1352 case INVERSION_ON:
1353 ch.spectrum_inversion = 1;
1354 break;
1355 case INVERSION_OFF:
1356 ch.spectrum_inversion = 0;
1357 break;
1358 default:
1359 case INVERSION_AUTO:
1360 ch.spectrum_inversion = -1;
1361 break;
1362 }
1363 switch (state->fe[0]->dtv_property_cache.transmission_mode) {
1364 case TRANSMISSION_MODE_2K:
1365 ch.nfft = 0;
1366 break;
1367 case TRANSMISSION_MODE_4K:
1368 ch.nfft = 2;
1369 break;
1370 case TRANSMISSION_MODE_8K:
1371 ch.nfft = 1;
1372 break;
1373 default:
1374 case TRANSMISSION_MODE_AUTO:
1375 ch.nfft = 1;
1376 break;
1377 }
1378 switch (state->fe[0]->dtv_property_cache.guard_interval) {
1379 case GUARD_INTERVAL_1_32:
1380 ch.guard = 0;
1381 break;
1382 case GUARD_INTERVAL_1_16:
1383 ch.guard = 1;
1384 break;
1385 case GUARD_INTERVAL_1_8:
1386 ch.guard = 2;
1387 break;
1388 case GUARD_INTERVAL_1_4:
1389 ch.guard = 3;
1390 break;
1391 default:
1392 case GUARD_INTERVAL_AUTO:
1393 ch.guard = -1;
1394 break;
1395 }
1396 switch (state->fe[0]->dtv_property_cache.modulation) {
1397 case QAM_64:
1398 ch.constellation = 2;
1399 break;
1400 case QAM_16:
1401 ch.constellation = 1;
1402 break;
1403 case QPSK:
1404 ch.constellation = 0;
1405 break;
1406 default:
1407 case QAM_AUTO:
1408 ch.constellation = -1;
1409 break;
1410 }
1411 switch (state->fe[0]->dtv_property_cache.hierarchy) {
1412 case HIERARCHY_NONE:
1413 ch.hrch = 0;
1414 break;
1415 case HIERARCHY_1:
1416 case HIERARCHY_2:
1417 case HIERARCHY_4:
1418 ch.hrch = 1;
1419 break;
1420 default:
1421 case HIERARCHY_AUTO:
1422 ch.hrch = -1;
1423 break;
1424 }
1425 ch.alpha = 1;
1426 switch (state->fe[0]->dtv_property_cache.code_rate_HP) {
1427 case FEC_1_2:
1428 ch.code_rate_hp = 1;
1429 break;
1430 case FEC_2_3:
1431 ch.code_rate_hp = 2;
1432 break;
1433 case FEC_3_4:
1434 ch.code_rate_hp = 3;
1435 break;
1436 case FEC_5_6:
1437 ch.code_rate_hp = 5;
1438 break;
1439 case FEC_7_8:
1440 ch.code_rate_hp = 7;
1441 break;
1442 default:
1443 case FEC_AUTO:
1444 ch.code_rate_hp = -1;
1445 break;
1446 }
1447 switch (state->fe[0]->dtv_property_cache.code_rate_LP) {
1448 case FEC_1_2:
1449 ch.code_rate_lp = 1;
1450 break;
1451 case FEC_2_3:
1452 ch.code_rate_lp = 2;
1453 break;
1454 case FEC_3_4:
1455 ch.code_rate_lp = 3;
1456 break;
1457 case FEC_5_6:
1458 ch.code_rate_lp = 5;
1459 break;
1460 case FEC_7_8:
1461 ch.code_rate_lp = 7;
1462 break;
1463 default:
1464 case FEC_AUTO:
1465 ch.code_rate_lp = -1;
1466 break;
1467 }
1468 ch.select_hp = 1;
1469 ch.intlv_native = 1;
1470
1471 dib9000_risc_mem_write(state, FE_MM_W_CHANNEL_UNION, (u8 *) &ch);
1472
1473 return 0;
1474 }
1475
1476 static int dib9000_fw_tune(struct dvb_frontend *fe)
1477 {
1478 struct dib9000_state *state = fe->demodulator_priv;
1479 int ret = 10, search = state->channel_status.status == CHANNEL_STATUS_PARAMETERS_UNKNOWN;
1480 s8 i;
1481
1482 switch (state->tune_state) {
1483 case CT_DEMOD_START:
1484 dib9000_fw_set_channel_head(state);
1485
1486 /* write the channel context - a channel is initialized to 0, so it is OK */
1487 dib9000_risc_mem_write(state, FE_MM_W_CHANNEL_CONTEXT, (u8 *) fe_info);
1488 dib9000_risc_mem_write(state, FE_MM_W_FE_INFO, (u8 *) fe_info);
1489
1490 if (search)
1491 dib9000_mbx_send(state, OUT_MSG_FE_CHANNEL_SEARCH, NULL, 0);
1492 else {
1493 dib9000_fw_set_channel_union(fe);
1494 dib9000_mbx_send(state, OUT_MSG_FE_CHANNEL_TUNE, NULL, 0);
1495 }
1496 state->tune_state = CT_DEMOD_STEP_1;
1497 break;
1498 case CT_DEMOD_STEP_1:
1499 if (search)
1500 dib9000_risc_mem_read(state, FE_MM_R_CHANNEL_SEARCH_STATE, state->i2c_read_buffer, 1);
1501 else
1502 dib9000_risc_mem_read(state, FE_MM_R_CHANNEL_TUNE_STATE, state->i2c_read_buffer, 1);
1503 i = (s8)state->i2c_read_buffer[0];
1504 switch (i) { /* something happened */
1505 case 0:
1506 break;
1507 case -2: /* tps locks are "slower" than MPEG locks -> even in autosearch data is OK here */
1508 if (search)
1509 state->status = FE_STATUS_DEMOD_SUCCESS;
1510 else {
1511 state->tune_state = CT_DEMOD_STOP;
1512 state->status = FE_STATUS_LOCKED;
1513 }
1514 break;
1515 default:
1516 state->status = FE_STATUS_TUNE_FAILED;
1517 state->tune_state = CT_DEMOD_STOP;
1518 break;
1519 }
1520 break;
1521 default:
1522 ret = FE_CALLBACK_TIME_NEVER;
1523 break;
1524 }
1525
1526 return ret;
1527 }
1528
1529 static int dib9000_fw_set_diversity_in(struct dvb_frontend *fe, int onoff)
1530 {
1531 struct dib9000_state *state = fe->demodulator_priv;
1532 u16 mode = (u16) onoff;
1533 return dib9000_mbx_send(state, OUT_MSG_ENABLE_DIVERSITY, &mode, 1);
1534 }
1535
1536 static int dib9000_fw_set_output_mode(struct dvb_frontend *fe, int mode)
1537 {
1538 struct dib9000_state *state = fe->demodulator_priv;
1539 u16 outreg, smo_mode;
1540
1541 dprintk("setting output mode for demod %p to %d\n", fe, mode);
1542
1543 switch (mode) {
1544 case OUTMODE_MPEG2_PAR_GATED_CLK:
1545 outreg = (1 << 10); /* 0x0400 */
1546 break;
1547 case OUTMODE_MPEG2_PAR_CONT_CLK:
1548 outreg = (1 << 10) | (1 << 6); /* 0x0440 */
1549 break;
1550 case OUTMODE_MPEG2_SERIAL:
1551 outreg = (1 << 10) | (2 << 6) | (0 << 1); /* 0x0482 */
1552 break;
1553 case OUTMODE_DIVERSITY:
1554 outreg = (1 << 10) | (4 << 6); /* 0x0500 */
1555 break;
1556 case OUTMODE_MPEG2_FIFO:
1557 outreg = (1 << 10) | (5 << 6);
1558 break;
1559 case OUTMODE_HIGH_Z:
1560 outreg = 0;
1561 break;
1562 default:
1563 dprintk("Unhandled output_mode passed to be set for demod %p\n", &state->fe[0]);
1564 return -EINVAL;
1565 }
1566
1567 dib9000_write_word(state, 1795, outreg);
1568
1569 switch (mode) {
1570 case OUTMODE_MPEG2_PAR_GATED_CLK:
1571 case OUTMODE_MPEG2_PAR_CONT_CLK:
1572 case OUTMODE_MPEG2_SERIAL:
1573 case OUTMODE_MPEG2_FIFO:
1574 smo_mode = (dib9000_read_word(state, 295) & 0x0010) | (1 << 1);
1575 if (state->chip.d9.cfg.output_mpeg2_in_188_bytes)
1576 smo_mode |= (1 << 5);
1577 dib9000_write_word(state, 295, smo_mode);
1578 break;
1579 }
1580
1581 outreg = to_fw_output_mode(mode);
1582 return dib9000_mbx_send(state, OUT_MSG_SET_OUTPUT_MODE, &outreg, 1);
1583 }
1584
1585 static int dib9000_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
1586 {
1587 struct dib9000_state *state = i2c_get_adapdata(i2c_adap);
1588 u16 i, len, t, index_msg;
1589
1590 for (index_msg = 0; index_msg < num; index_msg++) {
1591 if (msg[index_msg].flags & I2C_M_RD) { /* read */
1592 len = msg[index_msg].len;
1593 if (len > 16)
1594 len = 16;
1595
1596 if (dib9000_read_word(state, 790) != 0)
1597 dprintk("TunerITF: read busy\n");
1598
1599 dib9000_write_word(state, 784, (u16) (msg[index_msg].addr));
1600 dib9000_write_word(state, 787, (len / 2) - 1);
1601 dib9000_write_word(state, 786, 1); /* start read */
1602
1603 i = 1000;
1604 while (dib9000_read_word(state, 790) != (len / 2) && i)
1605 i--;
1606
1607 if (i == 0)
1608 dprintk("TunerITF: read failed\n");
1609
1610 for (i = 0; i < len; i += 2) {
1611 t = dib9000_read_word(state, 785);
1612 msg[index_msg].buf[i] = (t >> 8) & 0xff;
1613 msg[index_msg].buf[i + 1] = (t) & 0xff;
1614 }
1615 if (dib9000_read_word(state, 790) != 0)
1616 dprintk("TunerITF: read more data than expected\n");
1617 } else {
1618 i = 1000;
1619 while (dib9000_read_word(state, 789) && i)
1620 i--;
1621 if (i == 0)
1622 dprintk("TunerITF: write busy\n");
1623
1624 len = msg[index_msg].len;
1625 if (len > 16)
1626 len = 16;
1627
1628 for (i = 0; i < len; i += 2)
1629 dib9000_write_word(state, 785, (msg[index_msg].buf[i] << 8) | msg[index_msg].buf[i + 1]);
1630 dib9000_write_word(state, 784, (u16) msg[index_msg].addr);
1631 dib9000_write_word(state, 787, (len / 2) - 1);
1632 dib9000_write_word(state, 786, 0); /* start write */
1633
1634 i = 1000;
1635 while (dib9000_read_word(state, 791) > 0 && i)
1636 i--;
1637 if (i == 0)
1638 dprintk("TunerITF: write failed\n");
1639 }
1640 }
1641 return num;
1642 }
1643
1644 int dib9000_fw_set_component_bus_speed(struct dvb_frontend *fe, u16 speed)
1645 {
1646 struct dib9000_state *state = fe->demodulator_priv;
1647
1648 state->component_bus_speed = speed;
1649 return 0;
1650 }
1651 EXPORT_SYMBOL(dib9000_fw_set_component_bus_speed);
1652
1653 static int dib9000_fw_component_bus_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
1654 {
1655 struct dib9000_state *state = i2c_get_adapdata(i2c_adap);
1656 u8 type = 0; /* I2C */
1657 u8 port = DIBX000_I2C_INTERFACE_GPIO_3_4;
1658 u16 scl = state->component_bus_speed; /* SCL frequency */
1659 struct dib9000_fe_memory_map *m = &state->platform.risc.fe_mm[FE_MM_RW_COMPONENT_ACCESS_BUFFER];
1660 u8 p[13] = { 0 };
1661
1662 p[0] = type;
1663 p[1] = port;
1664 p[2] = msg[0].addr << 1;
1665
1666 p[3] = (u8) scl & 0xff; /* scl */
1667 p[4] = (u8) (scl >> 8);
1668
1669 p[7] = 0;
1670 p[8] = 0;
1671
1672 p[9] = (u8) (msg[0].len);
1673 p[10] = (u8) (msg[0].len >> 8);
1674 if ((num > 1) && (msg[1].flags & I2C_M_RD)) {
1675 p[11] = (u8) (msg[1].len);
1676 p[12] = (u8) (msg[1].len >> 8);
1677 } else {
1678 p[11] = 0;
1679 p[12] = 0;
1680 }
1681
1682 if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
1683 dprintk("could not get the lock\n");
1684 return 0;
1685 }
1686
1687 dib9000_risc_mem_write(state, FE_MM_W_COMPONENT_ACCESS, p);
1688
1689 { /* write-part */
1690 dib9000_risc_mem_setup_cmd(state, m->addr, msg[0].len, 0);
1691 dib9000_risc_mem_write_chunks(state, msg[0].buf, msg[0].len);
1692 }
1693
1694 /* do the transaction */
1695 if (dib9000_fw_memmbx_sync(state, FE_SYNC_COMPONENT_ACCESS) < 0) {
1696 mutex_unlock(&state->platform.risc.mem_mbx_lock);
1697 return 0;
1698 }
1699
1700 /* read back any possible result */
1701 if ((num > 1) && (msg[1].flags & I2C_M_RD))
1702 dib9000_risc_mem_read(state, FE_MM_RW_COMPONENT_ACCESS_BUFFER, msg[1].buf, msg[1].len);
1703
1704 mutex_unlock(&state->platform.risc.mem_mbx_lock);
1705
1706 return num;
1707 }
1708
1709 static u32 dib9000_i2c_func(struct i2c_adapter *adapter)
1710 {
1711 return I2C_FUNC_I2C;
1712 }
1713
1714 static const struct i2c_algorithm dib9000_tuner_algo = {
1715 .master_xfer = dib9000_tuner_xfer,
1716 .functionality = dib9000_i2c_func,
1717 };
1718
1719 static const struct i2c_algorithm dib9000_component_bus_algo = {
1720 .master_xfer = dib9000_fw_component_bus_xfer,
1721 .functionality = dib9000_i2c_func,
1722 };
1723
1724 struct i2c_adapter *dib9000_get_tuner_interface(struct dvb_frontend *fe)
1725 {
1726 struct dib9000_state *st = fe->demodulator_priv;
1727 return &st->tuner_adap;
1728 }
1729 EXPORT_SYMBOL(dib9000_get_tuner_interface);
1730
1731 struct i2c_adapter *dib9000_get_component_bus_interface(struct dvb_frontend *fe)
1732 {
1733 struct dib9000_state *st = fe->demodulator_priv;
1734 return &st->component_bus;
1735 }
1736 EXPORT_SYMBOL(dib9000_get_component_bus_interface);
1737
1738 struct i2c_adapter *dib9000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating)
1739 {
1740 struct dib9000_state *st = fe->demodulator_priv;
1741 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
1742 }
1743 EXPORT_SYMBOL(dib9000_get_i2c_master);
1744
1745 int dib9000_set_i2c_adapter(struct dvb_frontend *fe, struct i2c_adapter *i2c)
1746 {
1747 struct dib9000_state *st = fe->demodulator_priv;
1748
1749 st->i2c.i2c_adap = i2c;
1750 return 0;
1751 }
1752 EXPORT_SYMBOL(dib9000_set_i2c_adapter);
1753
1754 static int dib9000_cfg_gpio(struct dib9000_state *st, u8 num, u8 dir, u8 val)
1755 {
1756 st->gpio_dir = dib9000_read_word(st, 773);
1757 st->gpio_dir &= ~(1 << num); /* reset the direction bit */
1758 st->gpio_dir |= (dir & 0x1) << num; /* set the new direction */
1759 dib9000_write_word(st, 773, st->gpio_dir);
1760
1761 st->gpio_val = dib9000_read_word(st, 774);
1762 st->gpio_val &= ~(1 << num); /* reset the direction bit */
1763 st->gpio_val |= (val & 0x01) << num; /* set the new value */
1764 dib9000_write_word(st, 774, st->gpio_val);
1765
1766 dprintk("gpio dir: %04x: gpio val: %04x\n", st->gpio_dir, st->gpio_val);
1767
1768 return 0;
1769 }
1770
1771 int dib9000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
1772 {
1773 struct dib9000_state *state = fe->demodulator_priv;
1774 return dib9000_cfg_gpio(state, num, dir, val);
1775 }
1776 EXPORT_SYMBOL(dib9000_set_gpio);
1777
1778 int dib9000_fw_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
1779 {
1780 struct dib9000_state *state = fe->demodulator_priv;
1781 u16 val;
1782 int ret;
1783
1784 if ((state->pid_ctrl_index != -2) && (state->pid_ctrl_index < 9)) {
1785 /* postpone the pid filtering cmd */
1786 dprintk("pid filter cmd postpone\n");
1787 state->pid_ctrl_index++;
1788 state->pid_ctrl[state->pid_ctrl_index].cmd = DIB9000_PID_FILTER_CTRL;
1789 state->pid_ctrl[state->pid_ctrl_index].onoff = onoff;
1790 return 0;
1791 }
1792
1793 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1794 dprintk("could not get the lock\n");
1795 return -EINTR;
1796 }
1797
1798 val = dib9000_read_word(state, 294 + 1) & 0xffef;
1799 val |= (onoff & 0x1) << 4;
1800
1801 dprintk("PID filter enabled %d\n", onoff);
1802 ret = dib9000_write_word(state, 294 + 1, val);
1803 mutex_unlock(&state->demod_lock);
1804 return ret;
1805
1806 }
1807 EXPORT_SYMBOL(dib9000_fw_pid_filter_ctrl);
1808
1809 int dib9000_fw_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
1810 {
1811 struct dib9000_state *state = fe->demodulator_priv;
1812 int ret;
1813
1814 if (state->pid_ctrl_index != -2) {
1815 /* postpone the pid filtering cmd */
1816 dprintk("pid filter postpone\n");
1817 if (state->pid_ctrl_index < 9) {
1818 state->pid_ctrl_index++;
1819 state->pid_ctrl[state->pid_ctrl_index].cmd = DIB9000_PID_FILTER;
1820 state->pid_ctrl[state->pid_ctrl_index].id = id;
1821 state->pid_ctrl[state->pid_ctrl_index].pid = pid;
1822 state->pid_ctrl[state->pid_ctrl_index].onoff = onoff;
1823 } else
1824 dprintk("can not add any more pid ctrl cmd\n");
1825 return 0;
1826 }
1827
1828 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1829 dprintk("could not get the lock\n");
1830 return -EINTR;
1831 }
1832 dprintk("Index %x, PID %d, OnOff %d\n", id, pid, onoff);
1833 ret = dib9000_write_word(state, 300 + 1 + id,
1834 onoff ? (1 << 13) | pid : 0);
1835 mutex_unlock(&state->demod_lock);
1836 return ret;
1837 }
1838 EXPORT_SYMBOL(dib9000_fw_pid_filter);
1839
1840 int dib9000_firmware_post_pll_init(struct dvb_frontend *fe)
1841 {
1842 struct dib9000_state *state = fe->demodulator_priv;
1843 return dib9000_fw_init(state);
1844 }
1845 EXPORT_SYMBOL(dib9000_firmware_post_pll_init);
1846
1847 static void dib9000_release(struct dvb_frontend *demod)
1848 {
1849 struct dib9000_state *st = demod->demodulator_priv;
1850 u8 index_frontend;
1851
1852 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (st->fe[index_frontend] != NULL); index_frontend++)
1853 dvb_frontend_detach(st->fe[index_frontend]);
1854
1855 dibx000_exit_i2c_master(&st->i2c_master);
1856
1857 i2c_del_adapter(&st->tuner_adap);
1858 i2c_del_adapter(&st->component_bus);
1859 kfree(st->fe[0]);
1860 kfree(st);
1861 }
1862
1863 static int dib9000_wakeup(struct dvb_frontend *fe)
1864 {
1865 return 0;
1866 }
1867
1868 static int dib9000_sleep(struct dvb_frontend *fe)
1869 {
1870 struct dib9000_state *state = fe->demodulator_priv;
1871 u8 index_frontend;
1872 int ret = 0;
1873
1874 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1875 dprintk("could not get the lock\n");
1876 return -EINTR;
1877 }
1878 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
1879 ret = state->fe[index_frontend]->ops.sleep(state->fe[index_frontend]);
1880 if (ret < 0)
1881 goto error;
1882 }
1883 ret = dib9000_mbx_send(state, OUT_MSG_FE_SLEEP, NULL, 0);
1884
1885 error:
1886 mutex_unlock(&state->demod_lock);
1887 return ret;
1888 }
1889
1890 static int dib9000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
1891 {
1892 tune->min_delay_ms = 1000;
1893 return 0;
1894 }
1895
1896 static int dib9000_get_frontend(struct dvb_frontend *fe,
1897 struct dtv_frontend_properties *c)
1898 {
1899 struct dib9000_state *state = fe->demodulator_priv;
1900 u8 index_frontend, sub_index_frontend;
1901 enum fe_status stat;
1902 int ret = 0;
1903
1904 if (state->get_frontend_internal == 0) {
1905 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1906 dprintk("could not get the lock\n");
1907 return -EINTR;
1908 }
1909 }
1910
1911 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
1912 state->fe[index_frontend]->ops.read_status(state->fe[index_frontend], &stat);
1913 if (stat & FE_HAS_SYNC) {
1914 dprintk("TPS lock on the slave%i\n", index_frontend);
1915
1916 /* synchronize the cache with the other frontends */
1917 state->fe[index_frontend]->ops.get_frontend(state->fe[index_frontend], c);
1918 for (sub_index_frontend = 0; (sub_index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[sub_index_frontend] != NULL);
1919 sub_index_frontend++) {
1920 if (sub_index_frontend != index_frontend) {
1921 state->fe[sub_index_frontend]->dtv_property_cache.modulation =
1922 state->fe[index_frontend]->dtv_property_cache.modulation;
1923 state->fe[sub_index_frontend]->dtv_property_cache.inversion =
1924 state->fe[index_frontend]->dtv_property_cache.inversion;
1925 state->fe[sub_index_frontend]->dtv_property_cache.transmission_mode =
1926 state->fe[index_frontend]->dtv_property_cache.transmission_mode;
1927 state->fe[sub_index_frontend]->dtv_property_cache.guard_interval =
1928 state->fe[index_frontend]->dtv_property_cache.guard_interval;
1929 state->fe[sub_index_frontend]->dtv_property_cache.hierarchy =
1930 state->fe[index_frontend]->dtv_property_cache.hierarchy;
1931 state->fe[sub_index_frontend]->dtv_property_cache.code_rate_HP =
1932 state->fe[index_frontend]->dtv_property_cache.code_rate_HP;
1933 state->fe[sub_index_frontend]->dtv_property_cache.code_rate_LP =
1934 state->fe[index_frontend]->dtv_property_cache.code_rate_LP;
1935 state->fe[sub_index_frontend]->dtv_property_cache.rolloff =
1936 state->fe[index_frontend]->dtv_property_cache.rolloff;
1937 }
1938 }
1939 ret = 0;
1940 goto return_value;
1941 }
1942 }
1943
1944 /* get the channel from master chip */
1945 ret = dib9000_fw_get_channel(fe);
1946 if (ret != 0)
1947 goto return_value;
1948
1949 /* synchronize the cache with the other frontends */
1950 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
1951 state->fe[index_frontend]->dtv_property_cache.inversion = c->inversion;
1952 state->fe[index_frontend]->dtv_property_cache.transmission_mode = c->transmission_mode;
1953 state->fe[index_frontend]->dtv_property_cache.guard_interval = c->guard_interval;
1954 state->fe[index_frontend]->dtv_property_cache.modulation = c->modulation;
1955 state->fe[index_frontend]->dtv_property_cache.hierarchy = c->hierarchy;
1956 state->fe[index_frontend]->dtv_property_cache.code_rate_HP = c->code_rate_HP;
1957 state->fe[index_frontend]->dtv_property_cache.code_rate_LP = c->code_rate_LP;
1958 state->fe[index_frontend]->dtv_property_cache.rolloff = c->rolloff;
1959 }
1960 ret = 0;
1961
1962 return_value:
1963 if (state->get_frontend_internal == 0)
1964 mutex_unlock(&state->demod_lock);
1965 return ret;
1966 }
1967
1968 static int dib9000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
1969 {
1970 struct dib9000_state *state = fe->demodulator_priv;
1971 state->tune_state = tune_state;
1972 if (tune_state == CT_DEMOD_START)
1973 state->status = FE_STATUS_TUNE_PENDING;
1974
1975 return 0;
1976 }
1977
1978 static u32 dib9000_get_status(struct dvb_frontend *fe)
1979 {
1980 struct dib9000_state *state = fe->demodulator_priv;
1981 return state->status;
1982 }
1983
1984 static int dib9000_set_channel_status(struct dvb_frontend *fe, struct dvb_frontend_parametersContext *channel_status)
1985 {
1986 struct dib9000_state *state = fe->demodulator_priv;
1987
1988 memcpy(&state->channel_status, channel_status, sizeof(struct dvb_frontend_parametersContext));
1989 return 0;
1990 }
1991
1992 static int dib9000_set_frontend(struct dvb_frontend *fe)
1993 {
1994 struct dib9000_state *state = fe->demodulator_priv;
1995 int sleep_time, sleep_time_slave;
1996 u32 frontend_status;
1997 u8 nbr_pending, exit_condition, index_frontend, index_frontend_success;
1998 struct dvb_frontend_parametersContext channel_status;
1999
2000 /* check that the correct parameters are set */
2001 if (state->fe[0]->dtv_property_cache.frequency == 0) {
2002 dprintk("dib9000: must specify frequency\n");
2003 return 0;
2004 }
2005
2006 if (state->fe[0]->dtv_property_cache.bandwidth_hz == 0) {
2007 dprintk("dib9000: must specify bandwidth\n");
2008 return 0;
2009 }
2010
2011 state->pid_ctrl_index = -1; /* postpone the pid filtering cmd */
2012 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2013 dprintk("could not get the lock\n");
2014 return 0;
2015 }
2016
2017 fe->dtv_property_cache.delivery_system = SYS_DVBT;
2018
2019 /* set the master status */
2020 if (state->fe[0]->dtv_property_cache.transmission_mode == TRANSMISSION_MODE_AUTO ||
2021 state->fe[0]->dtv_property_cache.guard_interval == GUARD_INTERVAL_AUTO ||
2022 state->fe[0]->dtv_property_cache.modulation == QAM_AUTO ||
2023 state->fe[0]->dtv_property_cache.code_rate_HP == FEC_AUTO) {
2024 /* no channel specified, autosearch the channel */
2025 state->channel_status.status = CHANNEL_STATUS_PARAMETERS_UNKNOWN;
2026 } else
2027 state->channel_status.status = CHANNEL_STATUS_PARAMETERS_SET;
2028
2029 /* set mode and status for the different frontends */
2030 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2031 dib9000_fw_set_diversity_in(state->fe[index_frontend], 1);
2032
2033 /* synchronization of the cache */
2034 memcpy(&state->fe[index_frontend]->dtv_property_cache, &fe->dtv_property_cache, sizeof(struct dtv_frontend_properties));
2035
2036 state->fe[index_frontend]->dtv_property_cache.delivery_system = SYS_DVBT;
2037 dib9000_fw_set_output_mode(state->fe[index_frontend], OUTMODE_HIGH_Z);
2038
2039 dib9000_set_channel_status(state->fe[index_frontend], &state->channel_status);
2040 dib9000_set_tune_state(state->fe[index_frontend], CT_DEMOD_START);
2041 }
2042
2043 /* actual tune */
2044 exit_condition = 0; /* 0: tune pending; 1: tune failed; 2:tune success */
2045 index_frontend_success = 0;
2046 do {
2047 sleep_time = dib9000_fw_tune(state->fe[0]);
2048 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2049 sleep_time_slave = dib9000_fw_tune(state->fe[index_frontend]);
2050 if (sleep_time == FE_CALLBACK_TIME_NEVER)
2051 sleep_time = sleep_time_slave;
2052 else if ((sleep_time_slave != FE_CALLBACK_TIME_NEVER) && (sleep_time_slave > sleep_time))
2053 sleep_time = sleep_time_slave;
2054 }
2055 if (sleep_time != FE_CALLBACK_TIME_NEVER)
2056 msleep(sleep_time / 10);
2057 else
2058 break;
2059
2060 nbr_pending = 0;
2061 exit_condition = 0;
2062 index_frontend_success = 0;
2063 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2064 frontend_status = -dib9000_get_status(state->fe[index_frontend]);
2065 if (frontend_status > -FE_STATUS_TUNE_PENDING) {
2066 exit_condition = 2; /* tune success */
2067 index_frontend_success = index_frontend;
2068 break;
2069 }
2070 if (frontend_status == -FE_STATUS_TUNE_PENDING)
2071 nbr_pending++; /* some frontends are still tuning */
2072 }
2073 if ((exit_condition != 2) && (nbr_pending == 0))
2074 exit_condition = 1; /* if all tune are done and no success, exit: tune failed */
2075
2076 } while (exit_condition == 0);
2077
2078 /* check the tune result */
2079 if (exit_condition == 1) { /* tune failed */
2080 dprintk("tune failed\n");
2081 mutex_unlock(&state->demod_lock);
2082 /* tune failed; put all the pid filtering cmd to junk */
2083 state->pid_ctrl_index = -1;
2084 return 0;
2085 }
2086
2087 dprintk("tune success on frontend%i\n", index_frontend_success);
2088
2089 /* synchronize all the channel cache */
2090 state->get_frontend_internal = 1;
2091 dib9000_get_frontend(state->fe[0], &state->fe[0]->dtv_property_cache);
2092 state->get_frontend_internal = 0;
2093
2094 /* retune the other frontends with the found channel */
2095 channel_status.status = CHANNEL_STATUS_PARAMETERS_SET;
2096 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2097 /* only retune the frontends which was not tuned success */
2098 if (index_frontend != index_frontend_success) {
2099 dib9000_set_channel_status(state->fe[index_frontend], &channel_status);
2100 dib9000_set_tune_state(state->fe[index_frontend], CT_DEMOD_START);
2101 }
2102 }
2103 do {
2104 sleep_time = FE_CALLBACK_TIME_NEVER;
2105 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2106 if (index_frontend != index_frontend_success) {
2107 sleep_time_slave = dib9000_fw_tune(state->fe[index_frontend]);
2108 if (sleep_time == FE_CALLBACK_TIME_NEVER)
2109 sleep_time = sleep_time_slave;
2110 else if ((sleep_time_slave != FE_CALLBACK_TIME_NEVER) && (sleep_time_slave > sleep_time))
2111 sleep_time = sleep_time_slave;
2112 }
2113 }
2114 if (sleep_time != FE_CALLBACK_TIME_NEVER)
2115 msleep(sleep_time / 10);
2116 else
2117 break;
2118
2119 nbr_pending = 0;
2120 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2121 if (index_frontend != index_frontend_success) {
2122 frontend_status = -dib9000_get_status(state->fe[index_frontend]);
2123 if ((index_frontend != index_frontend_success) && (frontend_status == -FE_STATUS_TUNE_PENDING))
2124 nbr_pending++; /* some frontends are still tuning */
2125 }
2126 }
2127 } while (nbr_pending != 0);
2128
2129 /* set the output mode */
2130 dib9000_fw_set_output_mode(state->fe[0], state->chip.d9.cfg.output_mode);
2131 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
2132 dib9000_fw_set_output_mode(state->fe[index_frontend], OUTMODE_DIVERSITY);
2133
2134 /* turn off the diversity for the last frontend */
2135 dib9000_fw_set_diversity_in(state->fe[index_frontend - 1], 0);
2136
2137 mutex_unlock(&state->demod_lock);
2138 if (state->pid_ctrl_index >= 0) {
2139 u8 index_pid_filter_cmd;
2140 u8 pid_ctrl_index = state->pid_ctrl_index;
2141
2142 state->pid_ctrl_index = -2;
2143 for (index_pid_filter_cmd = 0;
2144 index_pid_filter_cmd <= pid_ctrl_index;
2145 index_pid_filter_cmd++) {
2146 if (state->pid_ctrl[index_pid_filter_cmd].cmd == DIB9000_PID_FILTER_CTRL)
2147 dib9000_fw_pid_filter_ctrl(state->fe[0],
2148 state->pid_ctrl[index_pid_filter_cmd].onoff);
2149 else if (state->pid_ctrl[index_pid_filter_cmd].cmd == DIB9000_PID_FILTER)
2150 dib9000_fw_pid_filter(state->fe[0],
2151 state->pid_ctrl[index_pid_filter_cmd].id,
2152 state->pid_ctrl[index_pid_filter_cmd].pid,
2153 state->pid_ctrl[index_pid_filter_cmd].onoff);
2154 }
2155 }
2156 /* do not postpone any more the pid filtering */
2157 state->pid_ctrl_index = -2;
2158
2159 return 0;
2160 }
2161
2162 static u16 dib9000_read_lock(struct dvb_frontend *fe)
2163 {
2164 struct dib9000_state *state = fe->demodulator_priv;
2165
2166 return dib9000_read_word(state, 535);
2167 }
2168
2169 static int dib9000_read_status(struct dvb_frontend *fe, enum fe_status *stat)
2170 {
2171 struct dib9000_state *state = fe->demodulator_priv;
2172 u8 index_frontend;
2173 u16 lock = 0, lock_slave = 0;
2174
2175 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2176 dprintk("could not get the lock\n");
2177 return -EINTR;
2178 }
2179 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
2180 lock_slave |= dib9000_read_lock(state->fe[index_frontend]);
2181
2182 lock = dib9000_read_word(state, 535);
2183
2184 *stat = 0;
2185
2186 if ((lock & 0x8000) || (lock_slave & 0x8000))
2187 *stat |= FE_HAS_SIGNAL;
2188 if ((lock & 0x3000) || (lock_slave & 0x3000))
2189 *stat |= FE_HAS_CARRIER;
2190 if ((lock & 0x0100) || (lock_slave & 0x0100))
2191 *stat |= FE_HAS_VITERBI;
2192 if (((lock & 0x0038) == 0x38) || ((lock_slave & 0x0038) == 0x38))
2193 *stat |= FE_HAS_SYNC;
2194 if ((lock & 0x0008) || (lock_slave & 0x0008))
2195 *stat |= FE_HAS_LOCK;
2196
2197 mutex_unlock(&state->demod_lock);
2198
2199 return 0;
2200 }
2201
2202 static int dib9000_read_ber(struct dvb_frontend *fe, u32 * ber)
2203 {
2204 struct dib9000_state *state = fe->demodulator_priv;
2205 u16 *c;
2206 int ret = 0;
2207
2208 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2209 dprintk("could not get the lock\n");
2210 return -EINTR;
2211 }
2212 if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2213 dprintk("could not get the lock\n");
2214 ret = -EINTR;
2215 goto error;
2216 }
2217 if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2218 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2219 ret = -EIO;
2220 goto error;
2221 }
2222 dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR,
2223 state->i2c_read_buffer, 16 * 2);
2224 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2225
2226 c = (u16 *)state->i2c_read_buffer;
2227
2228 *ber = c[10] << 16 | c[11];
2229
2230 error:
2231 mutex_unlock(&state->demod_lock);
2232 return ret;
2233 }
2234
2235 static int dib9000_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
2236 {
2237 struct dib9000_state *state = fe->demodulator_priv;
2238 u8 index_frontend;
2239 u16 *c = (u16 *)state->i2c_read_buffer;
2240 u16 val;
2241 int ret = 0;
2242
2243 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2244 dprintk("could not get the lock\n");
2245 return -EINTR;
2246 }
2247 *strength = 0;
2248 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2249 state->fe[index_frontend]->ops.read_signal_strength(state->fe[index_frontend], &val);
2250 if (val > 65535 - *strength)
2251 *strength = 65535;
2252 else
2253 *strength += val;
2254 }
2255
2256 if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2257 dprintk("could not get the lock\n");
2258 ret = -EINTR;
2259 goto error;
2260 }
2261 if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2262 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2263 ret = -EIO;
2264 goto error;
2265 }
2266 dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR, (u8 *) c, 16 * 2);
2267 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2268
2269 val = 65535 - c[4];
2270 if (val > 65535 - *strength)
2271 *strength = 65535;
2272 else
2273 *strength += val;
2274
2275 error:
2276 mutex_unlock(&state->demod_lock);
2277 return ret;
2278 }
2279
2280 static u32 dib9000_get_snr(struct dvb_frontend *fe)
2281 {
2282 struct dib9000_state *state = fe->demodulator_priv;
2283 u16 *c = (u16 *)state->i2c_read_buffer;
2284 u32 n, s, exp;
2285 u16 val;
2286
2287 if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2288 dprintk("could not get the lock\n");
2289 return 0;
2290 }
2291 if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2292 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2293 return 0;
2294 }
2295 dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR, (u8 *) c, 16 * 2);
2296 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2297
2298 val = c[7];
2299 n = (val >> 4) & 0xff;
2300 exp = ((val & 0xf) << 2);
2301 val = c[8];
2302 exp += ((val >> 14) & 0x3);
2303 if ((exp & 0x20) != 0)
2304 exp -= 0x40;
2305 n <<= exp + 16;
2306
2307 s = (val >> 6) & 0xFF;
2308 exp = (val & 0x3F);
2309 if ((exp & 0x20) != 0)
2310 exp -= 0x40;
2311 s <<= exp + 16;
2312
2313 if (n > 0) {
2314 u32 t = (s / n) << 16;
2315 return t + ((s << 16) - n * t) / n;
2316 }
2317 return 0xffffffff;
2318 }
2319
2320 static int dib9000_read_snr(struct dvb_frontend *fe, u16 * snr)
2321 {
2322 struct dib9000_state *state = fe->demodulator_priv;
2323 u8 index_frontend;
2324 u32 snr_master;
2325
2326 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2327 dprintk("could not get the lock\n");
2328 return -EINTR;
2329 }
2330 snr_master = dib9000_get_snr(fe);
2331 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
2332 snr_master += dib9000_get_snr(state->fe[index_frontend]);
2333
2334 if ((snr_master >> 16) != 0) {
2335 snr_master = 10 * intlog10(snr_master >> 16);
2336 *snr = snr_master / ((1 << 24) / 10);
2337 } else
2338 *snr = 0;
2339
2340 mutex_unlock(&state->demod_lock);
2341
2342 return 0;
2343 }
2344
2345 static int dib9000_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
2346 {
2347 struct dib9000_state *state = fe->demodulator_priv;
2348 u16 *c = (u16 *)state->i2c_read_buffer;
2349 int ret = 0;
2350
2351 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2352 dprintk("could not get the lock\n");
2353 return -EINTR;
2354 }
2355 if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2356 dprintk("could not get the lock\n");
2357 ret = -EINTR;
2358 goto error;
2359 }
2360 if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2361 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2362 ret = -EIO;
2363 goto error;
2364 }
2365 dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR, (u8 *) c, 16 * 2);
2366 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2367
2368 *unc = c[12];
2369
2370 error:
2371 mutex_unlock(&state->demod_lock);
2372 return ret;
2373 }
2374
2375 int dib9000_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, u8 first_addr)
2376 {
2377 int k = 0, ret = 0;
2378 u8 new_addr = 0;
2379 struct i2c_device client = {.i2c_adap = i2c };
2380
2381 client.i2c_write_buffer = kzalloc(4, GFP_KERNEL);
2382 if (!client.i2c_write_buffer) {
2383 dprintk("%s: not enough memory\n", __func__);
2384 return -ENOMEM;
2385 }
2386 client.i2c_read_buffer = kzalloc(4, GFP_KERNEL);
2387 if (!client.i2c_read_buffer) {
2388 dprintk("%s: not enough memory\n", __func__);
2389 ret = -ENOMEM;
2390 goto error_memory;
2391 }
2392
2393 client.i2c_addr = default_addr + 16;
2394 dib9000_i2c_write16(&client, 1796, 0x0);
2395
2396 for (k = no_of_demods - 1; k >= 0; k--) {
2397 /* designated i2c address */
2398 new_addr = first_addr + (k << 1);
2399 client.i2c_addr = default_addr;
2400
2401 dib9000_i2c_write16(&client, 1817, 3);
2402 dib9000_i2c_write16(&client, 1796, 0);
2403 dib9000_i2c_write16(&client, 1227, 1);
2404 dib9000_i2c_write16(&client, 1227, 0);
2405
2406 client.i2c_addr = new_addr;
2407 dib9000_i2c_write16(&client, 1817, 3);
2408 dib9000_i2c_write16(&client, 1796, 0);
2409 dib9000_i2c_write16(&client, 1227, 1);
2410 dib9000_i2c_write16(&client, 1227, 0);
2411
2412 if (dib9000_identify(&client) == 0) {
2413 client.i2c_addr = default_addr;
2414 if (dib9000_identify(&client) == 0) {
2415 dprintk("DiB9000 #%d: not identified\n", k);
2416 ret = -EIO;
2417 goto error;
2418 }
2419 }
2420
2421 dib9000_i2c_write16(&client, 1795, (1 << 10) | (4 << 6));
2422 dib9000_i2c_write16(&client, 1794, (new_addr << 2) | 2);
2423
2424 dprintk("IC %d initialized (to i2c_address 0x%x)\n", k, new_addr);
2425 }
2426
2427 for (k = 0; k < no_of_demods; k++) {
2428 new_addr = first_addr | (k << 1);
2429 client.i2c_addr = new_addr;
2430
2431 dib9000_i2c_write16(&client, 1794, (new_addr << 2));
2432 dib9000_i2c_write16(&client, 1795, 0);
2433 }
2434
2435 error:
2436 kfree(client.i2c_read_buffer);
2437 error_memory:
2438 kfree(client.i2c_write_buffer);
2439
2440 return ret;
2441 }
2442 EXPORT_SYMBOL(dib9000_i2c_enumeration);
2443
2444 int dib9000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave)
2445 {
2446 struct dib9000_state *state = fe->demodulator_priv;
2447 u8 index_frontend = 1;
2448
2449 while ((index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL))
2450 index_frontend++;
2451 if (index_frontend < MAX_NUMBER_OF_FRONTENDS) {
2452 dprintk("set slave fe %p to index %i\n", fe_slave, index_frontend);
2453 state->fe[index_frontend] = fe_slave;
2454 return 0;
2455 }
2456
2457 dprintk("too many slave frontend\n");
2458 return -ENOMEM;
2459 }
2460 EXPORT_SYMBOL(dib9000_set_slave_frontend);
2461
2462 struct dvb_frontend *dib9000_get_slave_frontend(struct dvb_frontend *fe, int slave_index)
2463 {
2464 struct dib9000_state *state = fe->demodulator_priv;
2465
2466 if (slave_index >= MAX_NUMBER_OF_FRONTENDS)
2467 return NULL;
2468 return state->fe[slave_index];
2469 }
2470 EXPORT_SYMBOL(dib9000_get_slave_frontend);
2471
2472 static const struct dvb_frontend_ops dib9000_ops;
2473 struct dvb_frontend *dib9000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, const struct dib9000_config *cfg)
2474 {
2475 struct dvb_frontend *fe;
2476 struct dib9000_state *st;
2477 st = kzalloc(sizeof(struct dib9000_state), GFP_KERNEL);
2478 if (st == NULL)
2479 return NULL;
2480 fe = kzalloc(sizeof(struct dvb_frontend), GFP_KERNEL);
2481 if (fe == NULL) {
2482 kfree(st);
2483 return NULL;
2484 }
2485
2486 memcpy(&st->chip.d9.cfg, cfg, sizeof(struct dib9000_config));
2487 st->i2c.i2c_adap = i2c_adap;
2488 st->i2c.i2c_addr = i2c_addr;
2489 st->i2c.i2c_write_buffer = st->i2c_write_buffer;
2490 st->i2c.i2c_read_buffer = st->i2c_read_buffer;
2491
2492 st->gpio_dir = DIB9000_GPIO_DEFAULT_DIRECTIONS;
2493 st->gpio_val = DIB9000_GPIO_DEFAULT_VALUES;
2494 st->gpio_pwm_pos = DIB9000_GPIO_DEFAULT_PWM_POS;
2495
2496 mutex_init(&st->platform.risc.mbx_if_lock);
2497 mutex_init(&st->platform.risc.mbx_lock);
2498 mutex_init(&st->platform.risc.mem_lock);
2499 mutex_init(&st->platform.risc.mem_mbx_lock);
2500 mutex_init(&st->demod_lock);
2501 st->get_frontend_internal = 0;
2502
2503 st->pid_ctrl_index = -2;
2504
2505 st->fe[0] = fe;
2506 fe->demodulator_priv = st;
2507 memcpy(&st->fe[0]->ops, &dib9000_ops, sizeof(struct dvb_frontend_ops));
2508
2509 /* Ensure the output mode remains at the previous default if it's
2510 * not specifically set by the caller.
2511 */
2512 if ((st->chip.d9.cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (st->chip.d9.cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
2513 st->chip.d9.cfg.output_mode = OUTMODE_MPEG2_FIFO;
2514
2515 if (dib9000_identify(&st->i2c) == 0)
2516 goto error;
2517
2518 dibx000_init_i2c_master(&st->i2c_master, DIB7000MC, st->i2c.i2c_adap, st->i2c.i2c_addr);
2519
2520 st->tuner_adap.dev.parent = i2c_adap->dev.parent;
2521 strscpy(st->tuner_adap.name, "DIB9000_FW TUNER ACCESS",
2522 sizeof(st->tuner_adap.name));
2523 st->tuner_adap.algo = &dib9000_tuner_algo;
2524 st->tuner_adap.algo_data = NULL;
2525 i2c_set_adapdata(&st->tuner_adap, st);
2526 if (i2c_add_adapter(&st->tuner_adap) < 0)
2527 goto error;
2528
2529 st->component_bus.dev.parent = i2c_adap->dev.parent;
2530 strscpy(st->component_bus.name, "DIB9000_FW COMPONENT BUS ACCESS",
2531 sizeof(st->component_bus.name));
2532 st->component_bus.algo = &dib9000_component_bus_algo;
2533 st->component_bus.algo_data = NULL;
2534 st->component_bus_speed = 340;
2535 i2c_set_adapdata(&st->component_bus, st);
2536 if (i2c_add_adapter(&st->component_bus) < 0)
2537 goto component_bus_add_error;
2538
2539 dib9000_fw_reset(fe);
2540
2541 return fe;
2542
2543 component_bus_add_error:
2544 i2c_del_adapter(&st->tuner_adap);
2545 error:
2546 kfree(st);
2547 return NULL;
2548 }
2549 EXPORT_SYMBOL(dib9000_attach);
2550
2551 static const struct dvb_frontend_ops dib9000_ops = {
2552 .delsys = { SYS_DVBT },
2553 .info = {
2554 .name = "DiBcom 9000",
2555 .frequency_min_hz = 44250 * kHz,
2556 .frequency_max_hz = 867250 * kHz,
2557 .frequency_stepsize_hz = 62500,
2558 .caps = FE_CAN_INVERSION_AUTO |
2559 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
2560 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
2561 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
2562 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
2563 },
2564
2565 .release = dib9000_release,
2566
2567 .init = dib9000_wakeup,
2568 .sleep = dib9000_sleep,
2569
2570 .set_frontend = dib9000_set_frontend,
2571 .get_tune_settings = dib9000_fe_get_tune_settings,
2572 .get_frontend = dib9000_get_frontend,
2573
2574 .read_status = dib9000_read_status,
2575 .read_ber = dib9000_read_ber,
2576 .read_signal_strength = dib9000_read_signal_strength,
2577 .read_snr = dib9000_read_snr,
2578 .read_ucblocks = dib9000_read_unc_blocks,
2579 };
2580
2581 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2582 MODULE_AUTHOR("Olivier Grenie <olivier.grenie@parrot.com>");
2583 MODULE_DESCRIPTION("Driver for the DiBcom 9000 COFDM demodulator");
2584 MODULE_LICENSE("GPL");
Linux with added FPC-III support