Lines Matching refs:state
257 static int cx24117_writereg(struct cx24117_state *state, u8 reg, u8 data)
260 struct i2c_msg msg = { .addr = state->priv->demod_address,
264 dev_dbg(&state->priv->i2c->dev,
266 __func__, state->demod, reg, data);
268 ret = i2c_transfer(state->priv->i2c, &msg, 1);
270 dev_warn(&state->priv->i2c->dev,
272 KBUILD_MODNAME, state->demod, ret, reg, data);
278 static int cx24117_writecmd(struct cx24117_state *state,
285 dev_dbg(&state->priv->i2c->dev,
287 __func__, state->demod, cmd->len);
292 msg.addr = state->priv->demod_address;
296 ret = i2c_transfer(state->priv->i2c, &msg, 1);
298 dev_warn(&state->priv->i2c->dev,
300 KBUILD_MODNAME, state->demod, ret, cmd->len);
306 static int cx24117_readreg(struct cx24117_state *state, u8 reg)
311 { .addr = state->priv->demod_address, .flags = 0,
313 { .addr = state->priv->demod_address, .flags = I2C_M_RD,
317 ret = i2c_transfer(state->priv->i2c, msg, 2);
319 dev_warn(&state->priv->i2c->dev,
321 KBUILD_MODNAME, state->demod, ret, reg);
325 dev_dbg(&state->priv->i2c->dev, "%s() demod%d i2c rd @0x%02x=0x%02x\n",
326 __func__, state->demod, reg, recv);
331 static int cx24117_readregN(struct cx24117_state *state,
336 { .addr = state->priv->demod_address, .flags = 0,
338 { .addr = state->priv->demod_address, .flags = I2C_M_RD,
342 ret = i2c_transfer(state->priv->i2c, msg, 2);
344 dev_warn(&state->priv->i2c->dev,
346 KBUILD_MODNAME, state->demod, ret, reg);
352 static int cx24117_set_inversion(struct cx24117_state *state,
355 dev_dbg(&state->priv->i2c->dev, "%s(%d) demod%d\n",
356 __func__, inversion, state->demod);
360 state->dnxt.inversion_val = 0x00;
363 state->dnxt.inversion_val = 0x04;
366 state->dnxt.inversion_val = 0x0C;
372 state->dnxt.inversion = inversion;
377 static int cx24117_lookup_fecmod(struct cx24117_state *state,
382 dev_dbg(&state->priv->i2c->dev,
384 __func__, m, f, state->demod);
398 static int cx24117_set_fec(struct cx24117_state *state,
405 dev_dbg(&state->priv->i2c->dev,
407 __func__, mod, fec, state->demod);
409 ret = cx24117_lookup_fecmod(state, delsys, mod, fec);
413 state->dnxt.fec = fec;
414 state->dnxt.fec_val = cx24117_modfec_modes[ret].val;
415 state->dnxt.fec_mask = cx24117_modfec_modes[ret].mask;
416 dev_dbg(&state->priv->i2c->dev,
418 state->demod, state->dnxt.fec_mask, state->dnxt.fec_val);
423 static int cx24117_set_symbolrate(struct cx24117_state *state, u32 rate)
425 dev_dbg(&state->priv->i2c->dev, "%s(%d) demod%d\n",
426 __func__, rate, state->demod);
428 state->dnxt.symbol_rate = rate;
430 dev_dbg(&state->priv->i2c->dev,
432 __func__, state->demod, rate);
442 struct cx24117_state *state = fe->demodulator_priv;
446 dev_dbg(&state->priv->i2c->dev, "%s() demod%d skip_fw_load=%d\n",
447 __func__, state->demod, state->priv->skip_fw_load);
449 if (state->priv->skip_fw_load)
453 if (cx24117_readreg(state, 0xeb) != 0xa) {
456 dev_dbg(&state->priv->i2c->dev,
460 state->priv->i2c->dev.parent);
461 dev_dbg(&state->priv->i2c->dev,
464 dev_err(&state->priv->i2c->dev,
472 state->priv->skip_fw_load = 1;
476 dev_err(&state->priv->i2c->dev,
480 dev_info(&state->priv->i2c->dev,
485 state->priv->skip_fw_load = 0;
497 struct cx24117_state *state = fe->demodulator_priv;
500 dev_dbg(&state->priv->i2c->dev, "%s() demod%d\n",
501 __func__, state->demod);
509 cx24117_writecmd(state, cmd);
512 cx24117_writereg(state, CX24117_REG_EXECUTE, 0x01);
514 while (cx24117_readreg(state, CX24117_REG_EXECUTE)) {
519 dev_warn(&state->priv->i2c->dev,
529 struct cx24117_state *state = fe->demodulator_priv;
532 mutex_lock(&state->priv->fe_lock);
534 mutex_unlock(&state->priv->fe_lock);
542 struct cx24117_state *state = fe->demodulator_priv;
550 dev_dbg(&state->priv->i2c->dev,
552 __func__, state->demod, fw->size, fw->data[0], fw->data[1],
555 cx24117_writereg(state, 0xea, 0x00);
556 cx24117_writereg(state, 0xea, 0x01);
557 cx24117_writereg(state, 0xea, 0x00);
559 cx24117_writereg(state, 0xce, 0x92);
561 cx24117_writereg(state, 0xfb, 0x00);
562 cx24117_writereg(state, 0xfc, 0x00);
564 cx24117_writereg(state, 0xc3, 0x04);
565 cx24117_writereg(state, 0xc4, 0x04);
567 cx24117_writereg(state, 0xce, 0x00);
568 cx24117_writereg(state, 0xcf, 0x00);
570 cx24117_writereg(state, 0xea, 0x00);
571 cx24117_writereg(state, 0xeb, 0x0c);
572 cx24117_writereg(state, 0xec, 0x06);
573 cx24117_writereg(state, 0xed, 0x05);
574 cx24117_writereg(state, 0xee, 0x03);
575 cx24117_writereg(state, 0xef, 0x05);
577 cx24117_writereg(state, 0xf3, 0x03);
578 cx24117_writereg(state, 0xf4, 0x44);
580 cx24117_writereg(state, CX24117_REG_RATEDIV0, 0x04);
581 cx24117_writereg(state, CX24117_REG_CLKDIV0, 0x02);
583 cx24117_writereg(state, CX24117_REG_RATEDIV1, 0x04);
584 cx24117_writereg(state, CX24117_REG_CLKDIV1, 0x02);
586 cx24117_writereg(state, 0xf2, 0x04);
587 cx24117_writereg(state, 0xe8, 0x02);
588 cx24117_writereg(state, 0xea, 0x01);
589 cx24117_writereg(state, 0xc8, 0x00);
590 cx24117_writereg(state, 0xc9, 0x00);
591 cx24117_writereg(state, 0xca, 0x00);
592 cx24117_writereg(state, 0xcb, 0x00);
593 cx24117_writereg(state, 0xcc, 0x00);
594 cx24117_writereg(state, 0xcd, 0x00);
595 cx24117_writereg(state, 0xe4, 0x03);
596 cx24117_writereg(state, 0xeb, 0x0a);
598 cx24117_writereg(state, 0xfb, 0x00);
599 cx24117_writereg(state, 0xe0, 0x76);
600 cx24117_writereg(state, 0xf7, 0x81);
601 cx24117_writereg(state, 0xf8, 0x00);
602 cx24117_writereg(state, 0xf9, 0x00);
606 state->priv->skip_fw_load = 0;
615 msg.addr = state->priv->demod_address;
621 ret = i2c_transfer(state->priv->i2c, &msg, 1);
629 cx24117_writereg(state, 0xf7, 0x0c);
630 cx24117_writereg(state, 0xe0, 0x00);
708 cx24117_writereg(state, 0xce, 0xc0);
709 cx24117_writereg(state, 0xcf, 0x00);
710 cx24117_writereg(state, 0xe5, 0x04);
720 vers[i] = cx24117_readreg(state, 0x33);
722 dev_info(&state->priv->i2c->dev,
727 state->priv->skip_fw_load = 0;
728 dev_err(&state->priv->i2c->dev, "%s() Error running FW.\n", __func__);
734 struct cx24117_state *state = fe->demodulator_priv;
737 lock = cx24117_readreg(state,
738 (state->demod == 0) ? CX24117_REG_SSTATUS0 :
742 dev_dbg(&state->priv->i2c->dev, "%s() demod%d status = 0x%02x\n",
743 __func__, state->demod, lock);
761 struct cx24117_state *state = fe->demodulator_priv;
764 u8 base_reg = (state->demod == 0) ?
768 ret = cx24117_readregN(state, base_reg, buf, 4);
775 dev_dbg(&state->priv->i2c->dev, "%s() demod%d ber=0x%04x\n",
776 __func__, state->demod, *ber);
784 struct cx24117_state *state = fe->demodulator_priv;
789 u8 reg = (state->demod == 0) ?
794 cmd.args[1] = (u8) state->demod;
800 ret = cx24117_readregN(state, reg, buf, 2);
807 dev_dbg(&state->priv->i2c->dev,
809 __func__, state->demod, sig_reading, *signal_strength);
816 struct cx24117_state *state = fe->demodulator_priv;
819 u8 reg = (state->demod == 0) ?
822 ret = cx24117_readregN(state, reg, buf, 2);
828 dev_dbg(&state->priv->i2c->dev,
830 __func__, state->demod, *snr);
837 struct cx24117_state *state = fe->demodulator_priv;
841 u8 reg = (state->demod == 0) ?
855 ret = cx24117_readregN(state, reg, buf, 2);
860 dev_dbg(&state->priv->i2c->dev, "%s() demod%d ucb=0x%04x\n",
861 __func__, state->demod, *ucblocks);
869 struct cx24117_state *state = fe->demodulator_priv;
870 state->dcur = state->dnxt;
876 struct cx24117_state *state = fe->demodulator_priv;
878 u8 val, reg = (state->demod == 0) ? CX24117_REG_QSTATUS0 :
881 dev_dbg(&state->priv->i2c->dev, "%s() demod%d qstatus = 0x%02x\n",
882 __func__, state->demod, cx24117_readreg(state, reg));
886 val = cx24117_readreg(state, reg) & 0x01;
892 dev_warn(&state->priv->i2c->dev, "%s: demod%d LNB not ready\n",
893 KBUILD_MODNAME, state->demod);
901 struct cx24117_state *state = fe->demodulator_priv;
904 u8 reg = (state->demod == 0) ? 0x10 : 0x20;
906 dev_dbg(&state->priv->i2c->dev, "%s() demod%d %s\n",
907 __func__, state->demod,
934 cmd.args[1] = state->demod ? 0 : 1;
953 struct cx24117_state *state = fe->demodulator_priv;
957 dev_dbg(&state->priv->i2c->dev, "%s(%d) demod%d\n",
958 __func__, state->demod, tone);
960 dev_warn(&state->priv->i2c->dev, "%s: demod%d invalid tone=%d\n",
961 KBUILD_MODNAME, state->demod, tone);
975 cmd.args[1] = (state->demod ? 0 : 1);
996 struct cx24117_state *state = fe->demodulator_priv;
999 state->dsec_cmd.args[0] = CMD_LNBSEND;
1002 state->dsec_cmd.args[CX24117_DISEQC_DEMOD] = state->demod ? 0 : 1;
1005 state->dsec_cmd.args[CX24117_DISEQC_BURST] = CX24117_DISEQC_MINI_A;
1008 state->dsec_cmd.args[CX24117_DISEQC_ARG3_2] = 0x02;
1009 state->dsec_cmd.args[CX24117_DISEQC_ARG4_0] = 0x00;
1012 state->dsec_cmd.args[CX24117_DISEQC_ARG5_0] = 0x00;
1015 state->dsec_cmd.args[CX24117_DISEQC_MSGLEN] = 0x00;
1018 state->dsec_cmd.len = 7;
1027 struct cx24117_state *state = fe->demodulator_priv;
1031 dev_dbg(&state->priv->i2c->dev, "%s: demod %d (",
1032 __func__, state->demod);
1034 dev_dbg(&state->priv->i2c->dev, "0x%02x ", d->msg[i]);
1035 dev_dbg(&state->priv->i2c->dev, ")\n");
1043 state->dsec_cmd.args[CX24117_DISEQC_MSGOFS + i] = d->msg[i];
1046 state->dsec_cmd.args[CX24117_DISEQC_MSGLEN] = d->msg_len;
1049 state->dsec_cmd.len = CX24117_DISEQC_MSGOFS +
1050 state->dsec_cmd.args[CX24117_DISEQC_MSGLEN];
1071 state->dsec_cmd.args[CX24117_DISEQC_BURST] =
1074 dev_dbg(&state->priv->i2c->dev, "%s() demod%d burst=%d\n",
1075 __func__, state->demod,
1076 state->dsec_cmd.args[CX24117_DISEQC_BURST]);
1087 ret = cx24117_cmd_execute(fe, &state->dsec_cmd);
1100 msleep((state->dsec_cmd.args[CX24117_DISEQC_MSGLEN] << 4) + 60);
1109 struct cx24117_state *state = fe->demodulator_priv;
1111 dev_dbg(&state->priv->i2c->dev, "%s(%d) demod=%d\n",
1112 __func__, burst, state->demod);
1116 state->dsec_cmd.args[CX24117_DISEQC_BURST] =
1119 state->dsec_cmd.args[CX24117_DISEQC_BURST] =
1150 struct cx24117_state *state = fe->demodulator_priv;
1151 dev_dbg(&state->priv->i2c->dev, "%s demod%d\n",
1152 __func__, state->demod);
1153 cx24117_release_priv(state->priv);
1154 kfree(state);
1162 struct cx24117_state *state = NULL;
1187 /* allocate memory for the internal state */
1188 state = kzalloc(sizeof(struct cx24117_state), GFP_KERNEL);
1189 if (state == NULL)
1192 state->demod = demod - 1;
1193 state->priv = priv;
1195 dev_info(&state->priv->i2c->dev,
1197 KBUILD_MODNAME, state->demod);
1200 memcpy(&state->frontend.ops, &cx24117_ops,
1202 state->frontend.demodulator_priv = state;
1203 return &state->frontend;
1219 struct cx24117_state *state = fe->demodulator_priv;
1223 dev_dbg(&state->priv->i2c->dev, "%s() demod%d\n",
1224 __func__, state->demod);
1226 mutex_lock(&state->priv->fe_lock);
1230 cmd.args[1] = (state->demod ? 1 : 0);
1243 cmd.args[1] = (state->demod ? 1 : 0);
1253 cmd.args[1] = (state->demod ? 1 : 0);
1269 mutex_unlock(&state->priv->fe_lock);
1279 struct cx24117_state *state = fe->demodulator_priv;
1282 dev_dbg(&state->priv->i2c->dev, "%s() demod%d\n",
1283 __func__, state->demod);
1287 cmd.args[1] = (state->demod ? 1 : 0);
1298 struct cx24117_state *state = fe->demodulator_priv;
1305 dev_dbg(&state->priv->i2c->dev, "%s() demod%d\n",
1306 __func__, state->demod);
1310 dev_dbg(&state->priv->i2c->dev, "%s() demod%d DVB-S\n",
1311 __func__, state->demod);
1315 dev_dbg(&state->priv->i2c->dev,
1317 __func__, state->demod, c->modulation);
1322 state->dnxt.pilot_val = CX24117_PILOT_OFF;
1325 state->dnxt.rolloff_val = CX24117_ROLLOFF_035;
1329 dev_dbg(&state->priv->i2c->dev, "%s() demod%d DVB-S2\n",
1330 __func__, state->demod);
1337 dev_dbg(&state->priv->i2c->dev,
1339 __func__, state->demod, c->modulation);
1345 state->dnxt.pilot_val = CX24117_PILOT_AUTO;
1348 state->dnxt.pilot_val = CX24117_PILOT_OFF;
1351 state->dnxt.pilot_val = CX24117_PILOT_ON;
1354 dev_dbg(&state->priv->i2c->dev,
1356 __func__, state->demod, c->pilot);
1362 state->dnxt.rolloff_val = CX24117_ROLLOFF_020;
1365 state->dnxt.rolloff_val = CX24117_ROLLOFF_025;
1368 state->dnxt.rolloff_val = CX24117_ROLLOFF_035;
1371 state->dnxt.rolloff_val = CX24117_ROLLOFF_035;
1376 dev_warn(&state->priv->i2c->dev,
1378 KBUILD_MODNAME, state->demod, c->rolloff);
1384 dev_warn(&state->priv->i2c->dev,
1386 KBUILD_MODNAME, state->demod, c->delivery_system);
1390 state->dnxt.delsys = c->delivery_system;
1391 state->dnxt.modulation = c->modulation;
1392 state->dnxt.frequency = c->frequency;
1393 state->dnxt.pilot = c->pilot;
1394 state->dnxt.rolloff = c->rolloff;
1396 ret = cx24117_set_inversion(state, c->inversion);
1400 ret = cx24117_set_fec(state,
1405 ret = cx24117_set_symbolrate(state, c->symbol_rate);
1412 dev_dbg(&state->priv->i2c->dev,
1413 "%s: delsys = %d\n", __func__, state->dcur.delsys);
1414 dev_dbg(&state->priv->i2c->dev,
1415 "%s: modulation = %d\n", __func__, state->dcur.modulation);
1416 dev_dbg(&state->priv->i2c->dev,
1417 "%s: frequency = %d\n", __func__, state->dcur.frequency);
1418 dev_dbg(&state->priv->i2c->dev,
1420 state->dcur.pilot, state->dcur.pilot_val);
1421 dev_dbg(&state->priv->i2c->dev,
1423 dev_dbg(&state->priv->i2c->dev,
1425 state->dcur.rolloff, state->dcur.rolloff_val);
1426 dev_dbg(&state->priv->i2c->dev,
1427 "%s: symbol_rate = %d\n", __func__, state->dcur.symbol_rate);
1428 dev_dbg(&state->priv->i2c->dev,
1430 state->dcur.fec, state->dcur.fec_mask, state->dcur.fec_val);
1431 dev_dbg(&state->priv->i2c->dev,
1433 state->dcur.inversion, state->dcur.inversion_val);
1439 cmd.args[1] = state->demod;
1442 cmd.args[2] = (state->dcur.frequency & 0xff0000) >> 16;
1443 cmd.args[3] = (state->dcur.frequency & 0x00ff00) >> 8;
1444 cmd.args[4] = (state->dcur.frequency & 0x0000ff);
1447 cmd.args[5] = ((state->dcur.symbol_rate / 1000) & 0xff00) >> 8;
1448 cmd.args[6] = ((state->dcur.symbol_rate / 1000) & 0x00ff);
1451 cmd.args[7] = state->dcur.inversion_val;
1454 cmd.args[8] = state->dcur.fec_val | state->dcur.pilot_val;
1459 cmd.args[11] = state->dcur.rolloff_val;
1460 cmd.args[12] = state->dcur.fec_mask;
1462 if (state->dcur.symbol_rate > 30000000) {
1465 } else if (state->dcur.symbol_rate > 10000000) {
1476 cx24117_writereg(state, (state->demod == 0) ?
1478 cx24117_writereg(state, (state->demod == 0) ?
1486 status = cx24117_readreg(state, (state->demod == 0) ?
1490 dev_dbg(&state->priv->i2c->dev,
1492 __func__, state->demod, status);
1494 cx24117_writereg(state, (state->demod == 0) ?
1512 dev_dbg(&state->priv->i2c->dev,
1514 __func__, state->demod);
1520 dev_dbg(&state->priv->i2c->dev, "%s() demod%d not tuned\n",
1521 __func__, state->demod);
1524 if (state->dcur.rolloff == 3)
1534 struct cx24117_state *state = fe->demodulator_priv;
1536 dev_dbg(&state->priv->i2c->dev, "%s() demod%d\n",
1537 __func__, state->demod);
1556 struct cx24117_state *state = fe->demodulator_priv;
1567 cmd.args[1] = (u8) state->demod;
1574 reg = (state->demod == 0) ? CX24117_REG_FREQ3_0 : CX24117_REG_FREQ3_1;
1575 ret = cx24117_readregN(state, reg, buf, 0x1f-4);
1582 inv = (((state->demod == 0) ? ~st : st) >> 6) & 1;
1607 c->symbol_rate = -1000 * srate_os + state->dcur.symbol_rate;