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