1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include "cxd2820r_priv.h"
23
24
25int cxd2820r_wr_reg_val_mask_tab(struct cxd2820r_priv *priv,
26 const struct reg_val_mask *tab, int tab_len)
27{
28 struct i2c_client *client = priv->client[0];
29 int ret;
30 unsigned int i, reg, mask, val;
31 struct regmap *regmap;
32
33 dev_dbg(&client->dev, "tab_len=%d\n", tab_len);
34
35 for (i = 0; i < tab_len; i++) {
36 if ((tab[i].reg >> 16) & 0x1)
37 regmap = priv->regmap[1];
38 else
39 regmap = priv->regmap[0];
40
41 reg = (tab[i].reg >> 0) & 0xffff;
42 val = tab[i].val;
43 mask = tab[i].mask;
44
45 if (mask == 0xff)
46 ret = regmap_write(regmap, reg, val);
47 else
48 ret = regmap_write_bits(regmap, reg, mask, val);
49 if (ret)
50 goto error;
51 }
52
53 return 0;
54error:
55 dev_dbg(&client->dev, "failed=%d\n", ret);
56 return ret;
57}
58
59int cxd2820r_gpio(struct dvb_frontend *fe, u8 *gpio)
60{
61 struct cxd2820r_priv *priv = fe->demodulator_priv;
62 struct i2c_client *client = priv->client[0];
63 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
64 int ret, i;
65 u8 tmp0, tmp1;
66
67 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
68
69
70 if (!memcmp(gpio, priv->gpio, sizeof(priv->gpio)))
71 return 0;
72
73 tmp0 = 0x00;
74 tmp1 = 0x00;
75 for (i = 0; i < sizeof(priv->gpio); i++) {
76
77 if (gpio[i] & CXD2820R_GPIO_E)
78 tmp0 |= (2 << 6) >> (2 * i);
79 else
80 tmp0 |= (1 << 6) >> (2 * i);
81
82
83 if (gpio[i] & CXD2820R_GPIO_I)
84 tmp1 |= (1 << (3 + i));
85 else
86 tmp1 |= (0 << (3 + i));
87
88
89 if (gpio[i] & CXD2820R_GPIO_H)
90 tmp1 |= (1 << (0 + i));
91 else
92 tmp1 |= (0 << (0 + i));
93
94 dev_dbg(&client->dev, "gpio i=%d %02x %02x\n", i, tmp0, tmp1);
95 }
96
97 dev_dbg(&client->dev, "wr gpio=%02x %02x\n", tmp0, tmp1);
98
99
100 ret = regmap_update_bits(priv->regmap[0], 0x0089, 0xfc, tmp0);
101 if (ret)
102 goto error;
103
104
105 ret = regmap_update_bits(priv->regmap[0], 0x008e, 0x3f, tmp1);
106 if (ret)
107 goto error;
108
109 memcpy(priv->gpio, gpio, sizeof(priv->gpio));
110
111 return ret;
112error:
113 dev_dbg(&client->dev, "failed=%d\n", ret);
114 return ret;
115}
116
117static int cxd2820r_set_frontend(struct dvb_frontend *fe)
118{
119 struct cxd2820r_priv *priv = fe->demodulator_priv;
120 struct i2c_client *client = priv->client[0];
121 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
122 int ret;
123
124 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
125
126 switch (c->delivery_system) {
127 case SYS_DVBT:
128 ret = cxd2820r_init_t(fe);
129 if (ret < 0)
130 goto err;
131 ret = cxd2820r_set_frontend_t(fe);
132 if (ret < 0)
133 goto err;
134 break;
135 case SYS_DVBT2:
136 ret = cxd2820r_init_t(fe);
137 if (ret < 0)
138 goto err;
139 ret = cxd2820r_set_frontend_t2(fe);
140 if (ret < 0)
141 goto err;
142 break;
143 case SYS_DVBC_ANNEX_A:
144 ret = cxd2820r_init_c(fe);
145 if (ret < 0)
146 goto err;
147 ret = cxd2820r_set_frontend_c(fe);
148 if (ret < 0)
149 goto err;
150 break;
151 default:
152 dev_dbg(&client->dev, "invalid delivery_system\n");
153 ret = -EINVAL;
154 break;
155 }
156err:
157 return ret;
158}
159
160static int cxd2820r_read_status(struct dvb_frontend *fe, enum fe_status *status)
161{
162 struct cxd2820r_priv *priv = fe->demodulator_priv;
163 struct i2c_client *client = priv->client[0];
164 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
165 int ret;
166
167 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
168
169 switch (c->delivery_system) {
170 case SYS_DVBT:
171 ret = cxd2820r_read_status_t(fe, status);
172 break;
173 case SYS_DVBT2:
174 ret = cxd2820r_read_status_t2(fe, status);
175 break;
176 case SYS_DVBC_ANNEX_A:
177 ret = cxd2820r_read_status_c(fe, status);
178 break;
179 default:
180 ret = -EINVAL;
181 break;
182 }
183 return ret;
184}
185
186static int cxd2820r_get_frontend(struct dvb_frontend *fe,
187 struct dtv_frontend_properties *p)
188{
189 struct cxd2820r_priv *priv = fe->demodulator_priv;
190 struct i2c_client *client = priv->client[0];
191 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
192 int ret;
193
194 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
195
196 if (priv->delivery_system == SYS_UNDEFINED)
197 return 0;
198
199 switch (c->delivery_system) {
200 case SYS_DVBT:
201 ret = cxd2820r_get_frontend_t(fe, p);
202 break;
203 case SYS_DVBT2:
204 ret = cxd2820r_get_frontend_t2(fe, p);
205 break;
206 case SYS_DVBC_ANNEX_A:
207 ret = cxd2820r_get_frontend_c(fe, p);
208 break;
209 default:
210 ret = -EINVAL;
211 break;
212 }
213 return ret;
214}
215
216static int cxd2820r_read_ber(struct dvb_frontend *fe, u32 *ber)
217{
218 struct cxd2820r_priv *priv = fe->demodulator_priv;
219 struct i2c_client *client = priv->client[0];
220 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
221
222 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
223
224 *ber = (priv->post_bit_error - priv->post_bit_error_prev_dvbv3);
225 priv->post_bit_error_prev_dvbv3 = priv->post_bit_error;
226
227 return 0;
228}
229
230static int cxd2820r_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
231{
232 struct cxd2820r_priv *priv = fe->demodulator_priv;
233 struct i2c_client *client = priv->client[0];
234 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
235
236 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
237
238 if (c->strength.stat[0].scale == FE_SCALE_RELATIVE)
239 *strength = c->strength.stat[0].uvalue;
240 else
241 *strength = 0;
242
243 return 0;
244}
245
246static int cxd2820r_read_snr(struct dvb_frontend *fe, u16 *snr)
247{
248 struct cxd2820r_priv *priv = fe->demodulator_priv;
249 struct i2c_client *client = priv->client[0];
250 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
251
252 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
253
254 if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
255 *snr = div_s64(c->cnr.stat[0].svalue, 100);
256 else
257 *snr = 0;
258
259 return 0;
260}
261
262static int cxd2820r_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
263{
264 struct cxd2820r_priv *priv = fe->demodulator_priv;
265 struct i2c_client *client = priv->client[0];
266 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
267
268 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
269
270 *ucblocks = 0;
271
272 return 0;
273}
274
275static int cxd2820r_init(struct dvb_frontend *fe)
276{
277 return 0;
278}
279
280static int cxd2820r_sleep(struct dvb_frontend *fe)
281{
282 struct cxd2820r_priv *priv = fe->demodulator_priv;
283 struct i2c_client *client = priv->client[0];
284 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
285 int ret;
286
287 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
288
289 switch (c->delivery_system) {
290 case SYS_DVBT:
291 ret = cxd2820r_sleep_t(fe);
292 break;
293 case SYS_DVBT2:
294 ret = cxd2820r_sleep_t2(fe);
295 break;
296 case SYS_DVBC_ANNEX_A:
297 ret = cxd2820r_sleep_c(fe);
298 break;
299 default:
300 ret = -EINVAL;
301 break;
302 }
303 return ret;
304}
305
306static int cxd2820r_get_tune_settings(struct dvb_frontend *fe,
307 struct dvb_frontend_tune_settings *s)
308{
309 struct cxd2820r_priv *priv = fe->demodulator_priv;
310 struct i2c_client *client = priv->client[0];
311 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
312 int ret;
313
314 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
315
316 switch (c->delivery_system) {
317 case SYS_DVBT:
318 ret = cxd2820r_get_tune_settings_t(fe, s);
319 break;
320 case SYS_DVBT2:
321 ret = cxd2820r_get_tune_settings_t2(fe, s);
322 break;
323 case SYS_DVBC_ANNEX_A:
324 ret = cxd2820r_get_tune_settings_c(fe, s);
325 break;
326 default:
327 ret = -EINVAL;
328 break;
329 }
330 return ret;
331}
332
333static enum dvbfe_search cxd2820r_search(struct dvb_frontend *fe)
334{
335 struct cxd2820r_priv *priv = fe->demodulator_priv;
336 struct i2c_client *client = priv->client[0];
337 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
338 int ret, i;
339 enum fe_status status = 0;
340
341 dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
342
343
344 if (priv->last_tune_failed) {
345 if (priv->delivery_system == SYS_DVBT) {
346 ret = cxd2820r_sleep_t(fe);
347 if (ret)
348 goto error;
349
350 c->delivery_system = SYS_DVBT2;
351 } else if (priv->delivery_system == SYS_DVBT2) {
352 ret = cxd2820r_sleep_t2(fe);
353 if (ret)
354 goto error;
355
356 c->delivery_system = SYS_DVBT;
357 }
358 }
359
360
361 ret = cxd2820r_set_frontend(fe);
362 if (ret)
363 goto error;
364
365
366 switch (priv->delivery_system) {
367 case SYS_DVBT:
368 case SYS_DVBC_ANNEX_A:
369 i = 20;
370 break;
371 case SYS_DVBT2:
372 i = 40;
373 break;
374 case SYS_UNDEFINED:
375 default:
376 i = 0;
377 break;
378 }
379
380
381 for (; i > 0; i--) {
382 dev_dbg(&client->dev, "loop=%d\n", i);
383 msleep(50);
384 ret = cxd2820r_read_status(fe, &status);
385 if (ret)
386 goto error;
387
388 if (status & FE_HAS_LOCK)
389 break;
390 }
391
392
393 if (status & FE_HAS_LOCK) {
394 priv->last_tune_failed = false;
395 return DVBFE_ALGO_SEARCH_SUCCESS;
396 } else {
397 priv->last_tune_failed = true;
398 return DVBFE_ALGO_SEARCH_AGAIN;
399 }
400
401error:
402 dev_dbg(&client->dev, "failed=%d\n", ret);
403 return DVBFE_ALGO_SEARCH_ERROR;
404}
405
406static int cxd2820r_get_frontend_algo(struct dvb_frontend *fe)
407{
408 return DVBFE_ALGO_CUSTOM;
409}
410
411static void cxd2820r_release(struct dvb_frontend *fe)
412{
413 struct cxd2820r_priv *priv = fe->demodulator_priv;
414 struct i2c_client *client = priv->client[0];
415
416 dev_dbg(&client->dev, "\n");
417
418 i2c_unregister_device(client);
419
420 return;
421}
422
423static int cxd2820r_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
424{
425 struct cxd2820r_priv *priv = fe->demodulator_priv;
426 struct i2c_client *client = priv->client[0];
427
428 dev_dbg_ratelimited(&client->dev, "enable=%d\n", enable);
429
430 return regmap_update_bits(priv->regmap[0], 0x00db, 0x01, enable ? 1 : 0);
431}
432
433#ifdef CONFIG_GPIOLIB
434static int cxd2820r_gpio_direction_output(struct gpio_chip *chip, unsigned nr,
435 int val)
436{
437 struct cxd2820r_priv *priv = gpiochip_get_data(chip);
438 struct i2c_client *client = priv->client[0];
439 u8 gpio[GPIO_COUNT];
440
441 dev_dbg(&client->dev, "nr=%u val=%d\n", nr, val);
442
443 memcpy(gpio, priv->gpio, sizeof(gpio));
444 gpio[nr] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | (val << 2);
445
446 return cxd2820r_gpio(&priv->fe, gpio);
447}
448
449static void cxd2820r_gpio_set(struct gpio_chip *chip, unsigned nr, int val)
450{
451 struct cxd2820r_priv *priv = gpiochip_get_data(chip);
452 struct i2c_client *client = priv->client[0];
453 u8 gpio[GPIO_COUNT];
454
455 dev_dbg(&client->dev, "nr=%u val=%d\n", nr, val);
456
457 memcpy(gpio, priv->gpio, sizeof(gpio));
458 gpio[nr] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | (val << 2);
459
460 (void) cxd2820r_gpio(&priv->fe, gpio);
461
462 return;
463}
464
465static int cxd2820r_gpio_get(struct gpio_chip *chip, unsigned nr)
466{
467 struct cxd2820r_priv *priv = gpiochip_get_data(chip);
468 struct i2c_client *client = priv->client[0];
469
470 dev_dbg(&client->dev, "nr=%u\n", nr);
471
472 return (priv->gpio[nr] >> 2) & 0x01;
473}
474#endif
475
476static const struct dvb_frontend_ops cxd2820r_ops = {
477 .delsys = { SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A },
478
479 .info = {
480 .name = "Sony CXD2820R",
481
482 .caps = FE_CAN_FEC_1_2 |
483 FE_CAN_FEC_2_3 |
484 FE_CAN_FEC_3_4 |
485 FE_CAN_FEC_5_6 |
486 FE_CAN_FEC_7_8 |
487 FE_CAN_FEC_AUTO |
488 FE_CAN_QPSK |
489 FE_CAN_QAM_16 |
490 FE_CAN_QAM_32 |
491 FE_CAN_QAM_64 |
492 FE_CAN_QAM_128 |
493 FE_CAN_QAM_256 |
494 FE_CAN_QAM_AUTO |
495 FE_CAN_TRANSMISSION_MODE_AUTO |
496 FE_CAN_GUARD_INTERVAL_AUTO |
497 FE_CAN_HIERARCHY_AUTO |
498 FE_CAN_MUTE_TS |
499 FE_CAN_2G_MODULATION |
500 FE_CAN_MULTISTREAM
501 },
502
503 .release = cxd2820r_release,
504 .init = cxd2820r_init,
505 .sleep = cxd2820r_sleep,
506
507 .get_tune_settings = cxd2820r_get_tune_settings,
508 .i2c_gate_ctrl = cxd2820r_i2c_gate_ctrl,
509
510 .get_frontend = cxd2820r_get_frontend,
511
512 .get_frontend_algo = cxd2820r_get_frontend_algo,
513 .search = cxd2820r_search,
514
515 .read_status = cxd2820r_read_status,
516 .read_snr = cxd2820r_read_snr,
517 .read_ber = cxd2820r_read_ber,
518 .read_ucblocks = cxd2820r_read_ucblocks,
519 .read_signal_strength = cxd2820r_read_signal_strength,
520};
521
522
523
524
525
526
527struct dvb_frontend *cxd2820r_attach(const struct cxd2820r_config *config,
528 struct i2c_adapter *adapter,
529 int *gpio_chip_base)
530{
531 struct i2c_client *client;
532 struct i2c_board_info board_info;
533 struct cxd2820r_platform_data pdata;
534
535 pdata.ts_mode = config->ts_mode;
536 pdata.ts_clk_inv = config->ts_clock_inv;
537 pdata.if_agc_polarity = config->if_agc_polarity;
538 pdata.spec_inv = config->spec_inv;
539 pdata.gpio_chip_base = &gpio_chip_base;
540 pdata.attach_in_use = true;
541
542 memset(&board_info, 0, sizeof(board_info));
543 strlcpy(board_info.type, "cxd2820r", I2C_NAME_SIZE);
544 board_info.addr = config->i2c_address;
545 board_info.platform_data = &pdata;
546 client = i2c_new_device(adapter, &board_info);
547 if (!client || !client->dev.driver)
548 return NULL;
549
550 return pdata.get_dvb_frontend(client);
551}
552EXPORT_SYMBOL(cxd2820r_attach);
553
554static struct dvb_frontend *cxd2820r_get_dvb_frontend(struct i2c_client *client)
555{
556 struct cxd2820r_priv *priv = i2c_get_clientdata(client);
557
558 dev_dbg(&client->dev, "\n");
559
560 return &priv->fe;
561}
562
563static int cxd2820r_probe(struct i2c_client *client,
564 const struct i2c_device_id *id)
565{
566 struct cxd2820r_platform_data *pdata = client->dev.platform_data;
567 struct cxd2820r_priv *priv;
568 int ret, *gpio_chip_base;
569 unsigned int utmp;
570 static const struct regmap_range_cfg regmap_range_cfg0[] = {
571 {
572 .range_min = 0x0000,
573 .range_max = 0x3fff,
574 .selector_reg = 0x00,
575 .selector_mask = 0xff,
576 .selector_shift = 0,
577 .window_start = 0x00,
578 .window_len = 0x100,
579 },
580 };
581 static const struct regmap_range_cfg regmap_range_cfg1[] = {
582 {
583 .range_min = 0x0000,
584 .range_max = 0x01ff,
585 .selector_reg = 0x00,
586 .selector_mask = 0xff,
587 .selector_shift = 0,
588 .window_start = 0x00,
589 .window_len = 0x100,
590 },
591 };
592 static const struct regmap_config regmap_config0 = {
593 .reg_bits = 8,
594 .val_bits = 8,
595 .max_register = 0x3fff,
596 .ranges = regmap_range_cfg0,
597 .num_ranges = ARRAY_SIZE(regmap_range_cfg0),
598 .cache_type = REGCACHE_NONE,
599 };
600 static const struct regmap_config regmap_config1 = {
601 .reg_bits = 8,
602 .val_bits = 8,
603 .max_register = 0x01ff,
604 .ranges = regmap_range_cfg1,
605 .num_ranges = ARRAY_SIZE(regmap_range_cfg1),
606 .cache_type = REGCACHE_NONE,
607 };
608
609 dev_dbg(&client->dev, "\n");
610
611 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
612 if (!priv) {
613 ret = -ENOMEM;
614 goto err;
615 }
616
617 priv->client[0] = client;
618 priv->fe.demodulator_priv = priv;
619 priv->i2c = client->adapter;
620 priv->ts_mode = pdata->ts_mode;
621 priv->ts_clk_inv = pdata->ts_clk_inv;
622 priv->if_agc_polarity = pdata->if_agc_polarity;
623 priv->spec_inv = pdata->spec_inv;
624 gpio_chip_base = *pdata->gpio_chip_base;
625 priv->regmap[0] = regmap_init_i2c(priv->client[0], ®map_config0);
626 if (IS_ERR(priv->regmap[0])) {
627 ret = PTR_ERR(priv->regmap[0]);
628 goto err_kfree;
629 }
630
631
632 ret = regmap_read(priv->regmap[0], 0x00fd, &utmp);
633 if (ret)
634 goto err_regmap_0_regmap_exit;
635
636 dev_dbg(&client->dev, "chip_id=%02x\n", utmp);
637
638 if (utmp != 0xe1) {
639 ret = -ENODEV;
640 goto err_regmap_0_regmap_exit;
641 }
642
643
644
645
646
647
648 priv->client[1] = i2c_new_dummy(client->adapter, client->addr | (1 << 1));
649 if (!priv->client[1]) {
650 ret = -ENODEV;
651 dev_err(&client->dev, "I2C registration failed\n");
652 if (ret)
653 goto err_regmap_0_regmap_exit;
654 }
655
656 priv->regmap[1] = regmap_init_i2c(priv->client[1], ®map_config1);
657 if (IS_ERR(priv->regmap[1])) {
658 ret = PTR_ERR(priv->regmap[1]);
659 goto err_client_1_i2c_unregister_device;
660 }
661
662 if (gpio_chip_base) {
663#ifdef CONFIG_GPIOLIB
664
665 priv->gpio_chip.label = KBUILD_MODNAME;
666 priv->gpio_chip.parent = &client->dev;
667 priv->gpio_chip.owner = THIS_MODULE;
668 priv->gpio_chip.direction_output = cxd2820r_gpio_direction_output;
669 priv->gpio_chip.set = cxd2820r_gpio_set;
670 priv->gpio_chip.get = cxd2820r_gpio_get;
671 priv->gpio_chip.base = -1;
672 priv->gpio_chip.ngpio = GPIO_COUNT;
673 priv->gpio_chip.can_sleep = 1;
674 ret = gpiochip_add_data(&priv->gpio_chip, priv);
675 if (ret)
676 goto err_regmap_1_regmap_exit;
677
678 dev_dbg(&client->dev, "gpio_chip.base=%d\n",
679 priv->gpio_chip.base);
680
681 *gpio_chip_base = priv->gpio_chip.base;
682#else
683
684
685
686
687 u8 gpio[GPIO_COUNT];
688 gpio[0] = (*gpio_chip_base >> 0) & 0x07;
689 gpio[1] = (*gpio_chip_base >> 3) & 0x07;
690 gpio[2] = 0;
691 ret = cxd2820r_gpio(&priv->fe, gpio);
692 if (ret)
693 goto err_regmap_1_regmap_exit;
694#endif
695 }
696
697
698 memcpy(&priv->fe.ops, &cxd2820r_ops, sizeof(priv->fe.ops));
699 if (!pdata->attach_in_use)
700 priv->fe.ops.release = NULL;
701 i2c_set_clientdata(client, priv);
702
703
704 pdata->get_dvb_frontend = cxd2820r_get_dvb_frontend;
705
706 dev_info(&client->dev, "Sony CXD2820R successfully identified\n");
707
708 return 0;
709err_regmap_1_regmap_exit:
710 regmap_exit(priv->regmap[1]);
711err_client_1_i2c_unregister_device:
712 i2c_unregister_device(priv->client[1]);
713err_regmap_0_regmap_exit:
714 regmap_exit(priv->regmap[0]);
715err_kfree:
716 kfree(priv);
717err:
718 dev_dbg(&client->dev, "failed=%d\n", ret);
719 return ret;
720}
721
722static int cxd2820r_remove(struct i2c_client *client)
723{
724 struct cxd2820r_priv *priv = i2c_get_clientdata(client);
725
726 dev_dbg(&client->dev, "\n");
727
728#ifdef CONFIG_GPIOLIB
729 if (priv->gpio_chip.label)
730 gpiochip_remove(&priv->gpio_chip);
731#endif
732 regmap_exit(priv->regmap[1]);
733 i2c_unregister_device(priv->client[1]);
734
735 regmap_exit(priv->regmap[0]);
736
737 kfree(priv);
738
739 return 0;
740}
741
742static const struct i2c_device_id cxd2820r_id_table[] = {
743 {"cxd2820r", 0},
744 {}
745};
746MODULE_DEVICE_TABLE(i2c, cxd2820r_id_table);
747
748static struct i2c_driver cxd2820r_driver = {
749 .driver = {
750 .name = "cxd2820r",
751 .suppress_bind_attrs = true,
752 },
753 .probe = cxd2820r_probe,
754 .remove = cxd2820r_remove,
755 .id_table = cxd2820r_id_table,
756};
757
758module_i2c_driver(cxd2820r_driver);
759
760MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
761MODULE_DESCRIPTION("Sony CXD2820R demodulator driver");
762MODULE_LICENSE("GPL");
763
