Lines Matching refs:dev
10 static int e4000_init(struct e4000_dev *dev)
12 struct i2c_client *client = dev->client;
15 dev_dbg(&client->dev, "\n");
18 ret = regmap_write(dev->regmap, 0x00, 0x01);
23 ret = regmap_write(dev->regmap, 0x06, 0x00);
27 ret = regmap_write(dev->regmap, 0x7a, 0x96);
32 ret = regmap_bulk_write(dev->regmap, 0x7e, "\x01\xfe", 2);
36 ret = regmap_write(dev->regmap, 0x82, 0x00);
40 ret = regmap_write(dev->regmap, 0x24, 0x05);
44 ret = regmap_bulk_write(dev->regmap, 0x87, "\x20\x01", 2);
48 ret = regmap_bulk_write(dev->regmap, 0x9f, "\x7f\x07", 2);
53 ret = regmap_write(dev->regmap, 0x2d, 0x1f);
57 ret = regmap_bulk_write(dev->regmap, 0x70, "\x01\x01", 2);
62 ret = regmap_write(dev->regmap, 0x1a, 0x17);
66 ret = regmap_write(dev->regmap, 0x1f, 0x1a);
70 dev->active = true;
74 dev_dbg(&client->dev, "failed=%d\n", ret);
78 static int e4000_sleep(struct e4000_dev *dev)
80 struct i2c_client *client = dev->client;
83 dev_dbg(&client->dev, "\n");
85 dev->active = false;
87 ret = regmap_write(dev->regmap, 0x00, 0x00);
93 dev_dbg(&client->dev, "failed=%d\n", ret);
97 static int e4000_set_params(struct e4000_dev *dev)
99 struct i2c_client *client = dev->client;
105 if (!dev->active) {
106 dev_dbg(&client->dev, "tuner is sleeping\n");
111 ret = regmap_write(dev->regmap, 0x1a, 0x00);
131 if (dev->f_frequency <= e4000_pll_lut[i].freq)
139 #define F_REF dev->clk
141 f_vco = (u64) dev->f_frequency * div_out;
146 dev_dbg(&client->dev,
148 dev->f_frequency, dev->f_bandwidth, f_vco, F_REF, div_n, k,
156 ret = regmap_bulk_write(dev->regmap, 0x09, buf, 5);
162 if (dev->f_frequency <= e400_lna_filter_lut[i].freq)
170 ret = regmap_write(dev->regmap, 0x10, e400_lna_filter_lut[i].val);
176 if (dev->f_bandwidth <= e4000_if_filter_lut[i].freq)
187 ret = regmap_bulk_write(dev->regmap, 0x11, buf, 2);
193 if (dev->f_frequency <= e4000_band_lut[i].freq)
201 ret = regmap_write(dev->regmap, 0x07, e4000_band_lut[i].reg07_val);
205 ret = regmap_write(dev->regmap, 0x78, e4000_band_lut[i].reg78_val);
212 ret = regmap_bulk_write(dev->regmap, 0x15, "\x00\x7e\x24", 3);
214 ret = regmap_bulk_write(dev->regmap, 0x15, "\x00\x7f", 2);
216 ret = regmap_bulk_write(dev->regmap, 0x15, "\x01", 1);
218 ret = regmap_bulk_write(dev->regmap, 0x16, "\x7e", 1);
223 ret = regmap_write(dev->regmap, 0x29, 0x01);
227 ret = regmap_bulk_read(dev->regmap, 0x2a, buf, 3);
238 ret = regmap_bulk_write(dev->regmap, 0x50, q_data, 4);
242 ret = regmap_bulk_write(dev->regmap, 0x60, i_data, 4);
247 ret = regmap_write(dev->regmap, 0x1a, 0x17);
253 dev_dbg(&client->dev, "failed=%d\n", ret);
285 struct e4000_dev *dev = e4000_subdev_to_dev(sd);
288 ret = e4000_sleep(dev);
292 return e4000_set_params(dev);
297 struct e4000_dev *dev = e4000_subdev_to_dev(sd);
298 struct i2c_client *client = dev->client;
300 dev_dbg(&client->dev, "index=%d\n", v->index);
312 struct e4000_dev *dev = e4000_subdev_to_dev(sd);
313 struct i2c_client *client = dev->client;
315 dev_dbg(&client->dev, "index=%d\n", v->index);
321 struct e4000_dev *dev = e4000_subdev_to_dev(sd);
322 struct i2c_client *client = dev->client;
324 dev_dbg(&client->dev, "tuner=%d\n", f->tuner);
325 f->frequency = dev->f_frequency;
332 struct e4000_dev *dev = e4000_subdev_to_dev(sd);
333 struct i2c_client *client = dev->client;
335 dev_dbg(&client->dev, "tuner=%d type=%d frequency=%u\n",
338 dev->f_frequency = clamp_t(unsigned int, f->frequency,
340 return e4000_set_params(dev);
346 struct e4000_dev *dev = e4000_subdev_to_dev(sd);
347 struct i2c_client *client = dev->client;
349 dev_dbg(&client->dev, "tuner=%d type=%d index=%d\n",
376 struct e4000_dev *dev = fe->tuner_priv;
377 struct i2c_client *client = dev->client;
381 dev_dbg(&client->dev, "lna auto=%d->%d val=%d->%d\n",
382 dev->lna_gain_auto->cur.val, dev->lna_gain_auto->val,
383 dev->lna_gain->cur.val, dev->lna_gain->val);
385 if (dev->lna_gain_auto->val && dev->if_gain_auto->cur.val)
387 else if (dev->lna_gain_auto->val)
389 else if (dev->if_gain_auto->cur.val)
394 ret = regmap_write(dev->regmap, 0x1a, u8tmp);
398 if (dev->lna_gain_auto->val == false) {
399 ret = regmap_write(dev->regmap, 0x14, dev->lna_gain->val);
406 dev_dbg(&client->dev, "failed=%d\n", ret);
412 struct e4000_dev *dev = fe->tuner_priv;
413 struct i2c_client *client = dev->client;
417 dev_dbg(&client->dev, "mixer auto=%d->%d val=%d->%d\n",
418 dev->mixer_gain_auto->cur.val, dev->mixer_gain_auto->val,
419 dev->mixer_gain->cur.val, dev->mixer_gain->val);
421 if (dev->mixer_gain_auto->val)
426 ret = regmap_write(dev->regmap, 0x20, u8tmp);
430 if (dev->mixer_gain_auto->val == false) {
431 ret = regmap_write(dev->regmap, 0x15, dev->mixer_gain->val);
438 dev_dbg(&client->dev, "failed=%d\n", ret);
444 struct e4000_dev *dev = fe->tuner_priv;
445 struct i2c_client *client = dev->client;
450 dev_dbg(&client->dev, "if auto=%d->%d val=%d->%d\n",
451 dev->if_gain_auto->cur.val, dev->if_gain_auto->val,
452 dev->if_gain->cur.val, dev->if_gain->val);
454 if (dev->if_gain_auto->val && dev->lna_gain_auto->cur.val)
456 else if (dev->lna_gain_auto->cur.val)
458 else if (dev->if_gain_auto->val)
463 ret = regmap_write(dev->regmap, 0x1a, u8tmp);
467 if (dev->if_gain_auto->val == false) {
468 buf[0] = e4000_if_gain_lut[dev->if_gain->val].reg16_val;
469 buf[1] = e4000_if_gain_lut[dev->if_gain->val].reg17_val;
470 ret = regmap_bulk_write(dev->regmap, 0x16, buf, 2);
477 dev_dbg(&client->dev, "failed=%d\n", ret);
483 struct e4000_dev *dev = fe->tuner_priv;
484 struct i2c_client *client = dev->client;
488 ret = regmap_read(dev->regmap, 0x07, &uitmp);
492 dev->pll_lock->val = (uitmp & 0x01);
496 dev_dbg(&client->dev, "failed=%d\n", ret);
502 struct e4000_dev *dev = container_of(ctrl->handler, struct e4000_dev, hdl);
503 struct i2c_client *client = dev->client;
506 if (!dev->active)
511 ret = e4000_pll_lock(dev->fe);
514 dev_dbg(&client->dev, "unknown ctrl: id=%d name=%s\n",
524 struct e4000_dev *dev = container_of(ctrl->handler, struct e4000_dev, hdl);
525 struct i2c_client *client = dev->client;
528 if (!dev->active)
539 dev->f_bandwidth = dev->bandwidth->val;
540 ret = e4000_set_params(dev);
544 ret = e4000_set_lna_gain(dev->fe);
548 ret = e4000_set_mixer_gain(dev->fe);
552 ret = e4000_set_if_gain(dev->fe);
555 dev_dbg(&client->dev, "unknown ctrl: id=%d name=%s\n",
574 struct e4000_dev *dev = fe->tuner_priv;
577 dev->f_frequency = c->frequency;
578 dev->f_bandwidth = c->bandwidth_hz;
579 return e4000_set_params(dev);
615 struct e4000_dev *dev;
616 struct e4000_config *cfg = client->dev.platform_data;
625 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
626 if (!dev) {
631 dev->clk = cfg->clock;
632 dev->client = client;
633 dev->fe = cfg->fe;
634 dev->regmap = devm_regmap_init_i2c(client, ®map_config);
635 if (IS_ERR(dev->regmap)) {
636 ret = PTR_ERR(dev->regmap);
641 ret = regmap_read(dev->regmap, 0x02, &uitmp);
645 dev_dbg(&client->dev, "chip id=%02x\n", uitmp);
653 ret = regmap_write(dev->regmap, 0x00, 0x00);
659 v4l2_ctrl_handler_init(&dev->hdl, 9);
660 dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
662 dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
664 v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
665 dev->lna_gain_auto = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
667 dev->lna_gain = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
669 v4l2_ctrl_auto_cluster(2, &dev->lna_gain_auto, 0, false);
670 dev->mixer_gain_auto = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
672 dev->mixer_gain = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
674 v4l2_ctrl_auto_cluster(2, &dev->mixer_gain_auto, 0, false);
675 dev->if_gain_auto = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
677 dev->if_gain = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
679 v4l2_ctrl_auto_cluster(2, &dev->if_gain_auto, 0, false);
680 dev->pll_lock = v4l2_ctrl_new_std(&dev->hdl, &e4000_ctrl_ops,
682 if (dev->hdl.error) {
683 ret = dev->hdl.error;
684 dev_err(&client->dev, "Could not initialize controls\n");
685 v4l2_ctrl_handler_free(&dev->hdl);
689 dev->sd.ctrl_handler = &dev->hdl;
690 dev->f_frequency = bands[0].rangelow;
691 dev->f_bandwidth = dev->bandwidth->val;
692 v4l2_i2c_subdev_init(&dev->sd, client, &e4000_subdev_ops);
694 fe->tuner_priv = dev;
697 v4l2_set_subdevdata(&dev->sd, client);
698 i2c_set_clientdata(client, &dev->sd);
700 dev_info(&client->dev, "Elonics E4000 successfully identified\n");
703 kfree(dev);
705 dev_dbg(&client->dev, "failed=%d\n", ret);
712 struct e4000_dev *dev = container_of(sd, struct e4000_dev, sd);
714 dev_dbg(&client->dev, "\n");
717 v4l2_ctrl_handler_free(&dev->hdl);
719 kfree(dev);