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 = min(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 = min(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"); 2585