?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / media / tuners / m88rs6000t.c
blobb3505f4024764344c8508cf9e687d825abfd7eb2
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Driver for the internal tuner of Montage M88RS6000
4 *
5 * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
6 */
7
8 #include "m88rs6000t.h"
9 #include <linux/regmap.h>
10
11 struct m88rs6000t_dev {
12 struct m88rs6000t_config cfg;
13 struct i2c_client *client;
14 struct regmap *regmap;
15 u32 frequency_khz;
16 };
17
18 struct m88rs6000t_reg_val {
19 u8 reg;
20 u8 val;
21 };
22
23 /* set demod main mclk and ts mclk */
24 static int m88rs6000t_set_demod_mclk(struct dvb_frontend *fe)
25 {
26 struct m88rs6000t_dev *dev = fe->tuner_priv;
27 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
28 u8 reg11, reg15, reg16, reg1D, reg1E, reg1F;
29 u8 N, f0 = 0, f1 = 0, f2 = 0, f3 = 0;
30 u16 pll_div_fb;
31 u32 div, ts_mclk;
32 unsigned int utmp;
33 int ret;
34
35 /* select demod main mclk */
36 ret = regmap_read(dev->regmap, 0x15, &utmp);
37 if (ret)
38 goto err;
39 reg15 = utmp;
40 if (c->symbol_rate > 45010000) {
41 reg11 = 0x0E;
42 reg15 |= 0x02;
43 reg16 = 115; /* mclk = 110.25MHz */
44 } else {
45 reg11 = 0x0A;
46 reg15 &= ~0x02;
47 reg16 = 96; /* mclk = 96MHz */
48 }
49
50 /* set ts mclk */
51 if (c->delivery_system == SYS_DVBS)
52 ts_mclk = 96000;
53 else
54 ts_mclk = 144000;
55
56 pll_div_fb = (reg15 & 0x01) << 8;
57 pll_div_fb += reg16;
58 pll_div_fb += 32;
59
60 div = 36000 * pll_div_fb;
61 div /= ts_mclk;
62
63 if (div <= 32) {
64 N = 2;
65 f0 = 0;
66 f1 = div / 2;
67 f2 = div - f1;
68 f3 = 0;
69 } else if (div <= 48) {
70 N = 3;
71 f0 = div / 3;
72 f1 = (div - f0) / 2;
73 f2 = div - f0 - f1;
74 f3 = 0;
75 } else if (div <= 64) {
76 N = 4;
77 f0 = div / 4;
78 f1 = (div - f0) / 3;
79 f2 = (div - f0 - f1) / 2;
80 f3 = div - f0 - f1 - f2;
81 } else {
82 N = 4;
83 f0 = 16;
84 f1 = 16;
85 f2 = 16;
86 f3 = 16;
87 }
88
89 if (f0 == 16)
90 f0 = 0;
91 if (f1 == 16)
92 f1 = 0;
93 if (f2 == 16)
94 f2 = 0;
95 if (f3 == 16)
96 f3 = 0;
97
98 ret = regmap_read(dev->regmap, 0x1D, &utmp);
99 if (ret)
100 goto err;
101 reg1D = utmp;
102 reg1D &= ~0x03;
103 reg1D |= N - 1;
104 reg1E = ((f3 << 4) + f2) & 0xFF;
105 reg1F = ((f1 << 4) + f0) & 0xFF;
106
107 /* program and recalibrate demod PLL */
108 ret = regmap_write(dev->regmap, 0x05, 0x40);
109 if (ret)
110 goto err;
111 ret = regmap_write(dev->regmap, 0x11, 0x08);
112 if (ret)
113 goto err;
114 ret = regmap_write(dev->regmap, 0x15, reg15);
115 if (ret)
116 goto err;
117 ret = regmap_write(dev->regmap, 0x16, reg16);
118 if (ret)
119 goto err;
120 ret = regmap_write(dev->regmap, 0x1D, reg1D);
121 if (ret)
122 goto err;
123 ret = regmap_write(dev->regmap, 0x1E, reg1E);
124 if (ret)
125 goto err;
126 ret = regmap_write(dev->regmap, 0x1F, reg1F);
127 if (ret)
128 goto err;
129 ret = regmap_write(dev->regmap, 0x17, 0xc1);
130 if (ret)
131 goto err;
132 ret = regmap_write(dev->regmap, 0x17, 0x81);
133 if (ret)
134 goto err;
135 usleep_range(5000, 50000);
136 ret = regmap_write(dev->regmap, 0x05, 0x00);
137 if (ret)
138 goto err;
139 ret = regmap_write(dev->regmap, 0x11, reg11);
140 if (ret)
141 goto err;
142 usleep_range(5000, 50000);
143 err:
144 if (ret)
145 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
146 return ret;
147 }
148
149 static int m88rs6000t_set_pll_freq(struct m88rs6000t_dev *dev,
150 u32 tuner_freq_MHz)
151 {
152 u32 fcry_KHz, ulNDiv1, ulNDiv2, ulNDiv;
153 u8 refDiv, ucLoDiv1, ucLomod1, ucLoDiv2, ucLomod2, ucLoDiv, ucLomod;
154 u8 reg27, reg29, reg42, reg42buf;
155 unsigned int utmp;
156 int ret;
157
158 fcry_KHz = 27000; /* in kHz */
159 refDiv = 27;
160
161 ret = regmap_write(dev->regmap, 0x36, (refDiv - 8));
162 if (ret)
163 goto err;
164 ret = regmap_write(dev->regmap, 0x31, 0x00);
165 if (ret)
166 goto err;
167 ret = regmap_write(dev->regmap, 0x2c, 0x02);
168 if (ret)
169 goto err;
170
171 if (tuner_freq_MHz >= 1550) {
172 ucLoDiv1 = 2;
173 ucLomod1 = 0;
174 ucLoDiv2 = 2;
175 ucLomod2 = 0;
176 } else if (tuner_freq_MHz >= 1380) {
177 ucLoDiv1 = 3;
178 ucLomod1 = 16;
179 ucLoDiv2 = 2;
180 ucLomod2 = 0;
181 } else if (tuner_freq_MHz >= 1070) {
182 ucLoDiv1 = 3;
183 ucLomod1 = 16;
184 ucLoDiv2 = 3;
185 ucLomod2 = 16;
186 } else if (tuner_freq_MHz >= 1000) {
187 ucLoDiv1 = 3;
188 ucLomod1 = 16;
189 ucLoDiv2 = 4;
190 ucLomod2 = 64;
191 } else if (tuner_freq_MHz >= 775) {
192 ucLoDiv1 = 4;
193 ucLomod1 = 64;
194 ucLoDiv2 = 4;
195 ucLomod2 = 64;
196 } else if (tuner_freq_MHz >= 700) {
197 ucLoDiv1 = 6;
198 ucLomod1 = 48;
199 ucLoDiv2 = 4;
200 ucLomod2 = 64;
201 } else if (tuner_freq_MHz >= 520) {
202 ucLoDiv1 = 6;
203 ucLomod1 = 48;
204 ucLoDiv2 = 6;
205 ucLomod2 = 48;
206 } else {
207 ucLoDiv1 = 8;
208 ucLomod1 = 96;
209 ucLoDiv2 = 8;
210 ucLomod2 = 96;
211 }
212
213 ulNDiv1 = ((tuner_freq_MHz * ucLoDiv1 * 1000) * refDiv
214 / fcry_KHz - 1024) / 2;
215 ulNDiv2 = ((tuner_freq_MHz * ucLoDiv2 * 1000) * refDiv
216 / fcry_KHz - 1024) / 2;
217
218 reg27 = (((ulNDiv1 >> 8) & 0x0F) + ucLomod1) & 0x7F;
219 ret = regmap_write(dev->regmap, 0x27, reg27);
220 if (ret)
221 goto err;
222 ret = regmap_write(dev->regmap, 0x28, (u8)(ulNDiv1 & 0xFF));
223 if (ret)
224 goto err;
225 reg29 = (((ulNDiv2 >> 8) & 0x0F) + ucLomod2) & 0x7f;
226 ret = regmap_write(dev->regmap, 0x29, reg29);
227 if (ret)
228 goto err;
229 ret = regmap_write(dev->regmap, 0x2a, (u8)(ulNDiv2 & 0xFF));
230 if (ret)
231 goto err;
232 ret = regmap_write(dev->regmap, 0x2F, 0xf5);
233 if (ret)
234 goto err;
235 ret = regmap_write(dev->regmap, 0x30, 0x05);
236 if (ret)
237 goto err;
238 ret = regmap_write(dev->regmap, 0x08, 0x1f);
239 if (ret)
240 goto err;
241 ret = regmap_write(dev->regmap, 0x08, 0x3f);
242 if (ret)
243 goto err;
244 ret = regmap_write(dev->regmap, 0x09, 0x20);
245 if (ret)
246 goto err;
247 ret = regmap_write(dev->regmap, 0x09, 0x00);
248 if (ret)
249 goto err;
250 ret = regmap_write(dev->regmap, 0x3e, 0x11);
251 if (ret)
252 goto err;
253 ret = regmap_write(dev->regmap, 0x08, 0x2f);
254 if (ret)
255 goto err;
256 ret = regmap_write(dev->regmap, 0x08, 0x3f);
257 if (ret)
258 goto err;
259 ret = regmap_write(dev->regmap, 0x09, 0x10);
260 if (ret)
261 goto err;
262 ret = regmap_write(dev->regmap, 0x09, 0x00);
263 if (ret)
264 goto err;
265 usleep_range(2000, 50000);
266
267 ret = regmap_read(dev->regmap, 0x42, &utmp);
268 if (ret)
269 goto err;
270 reg42 = utmp;
271
272 ret = regmap_write(dev->regmap, 0x3e, 0x10);
273 if (ret)
274 goto err;
275 ret = regmap_write(dev->regmap, 0x08, 0x2f);
276 if (ret)
277 goto err;
278 ret = regmap_write(dev->regmap, 0x08, 0x3f);
279 if (ret)
280 goto err;
281 ret = regmap_write(dev->regmap, 0x09, 0x10);
282 if (ret)
283 goto err;
284 ret = regmap_write(dev->regmap, 0x09, 0x00);
285 if (ret)
286 goto err;
287 usleep_range(2000, 50000);
288
289 ret = regmap_read(dev->regmap, 0x42, &utmp);
290 if (ret)
291 goto err;
292 reg42buf = utmp;
293 if (reg42buf < reg42) {
294 ret = regmap_write(dev->regmap, 0x3e, 0x11);
295 if (ret)
296 goto err;
297 }
298 usleep_range(5000, 50000);
299
300 ret = regmap_read(dev->regmap, 0x2d, &utmp);
301 if (ret)
302 goto err;
303 ret = regmap_write(dev->regmap, 0x2d, utmp);
304 if (ret)
305 goto err;
306 ret = regmap_read(dev->regmap, 0x2e, &utmp);
307 if (ret)
308 goto err;
309 ret = regmap_write(dev->regmap, 0x2e, utmp);
310 if (ret)
311 goto err;
312
313 ret = regmap_read(dev->regmap, 0x27, &utmp);
314 if (ret)
315 goto err;
316 reg27 = utmp & 0x70;
317 ret = regmap_read(dev->regmap, 0x83, &utmp);
318 if (ret)
319 goto err;
320 if (reg27 == (utmp & 0x70)) {
321 ucLoDiv = ucLoDiv1;
322 ulNDiv = ulNDiv1;
323 ucLomod = ucLomod1 / 16;
324 } else {
325 ucLoDiv = ucLoDiv2;
326 ulNDiv = ulNDiv2;
327 ucLomod = ucLomod2 / 16;
328 }
329
330 if ((ucLoDiv == 3) || (ucLoDiv == 6)) {
331 refDiv = 18;
332 ret = regmap_write(dev->regmap, 0x36, (refDiv - 8));
333 if (ret)
334 goto err;
335 ulNDiv = ((tuner_freq_MHz * ucLoDiv * 1000) * refDiv
336 / fcry_KHz - 1024) / 2;
337 }
338
339 reg27 = (0x80 + ((ucLomod << 4) & 0x70)
340 + ((ulNDiv >> 8) & 0x0F)) & 0xFF;
341 ret = regmap_write(dev->regmap, 0x27, reg27);
342 if (ret)
343 goto err;
344 ret = regmap_write(dev->regmap, 0x28, (u8)(ulNDiv & 0xFF));
345 if (ret)
346 goto err;
347 ret = regmap_write(dev->regmap, 0x29, 0x80);
348 if (ret)
349 goto err;
350 ret = regmap_write(dev->regmap, 0x31, 0x03);
351 if (ret)
352 goto err;
353
354 if (ucLoDiv == 3)
355 utmp = 0xCE;
356 else
357 utmp = 0x8A;
358 ret = regmap_write(dev->regmap, 0x3b, utmp);
359 if (ret)
360 goto err;
361
362 dev->frequency_khz = fcry_KHz * (ulNDiv * 2 + 1024) / refDiv / ucLoDiv;
363
364 dev_dbg(&dev->client->dev,
365 "actual tune frequency=%d\n", dev->frequency_khz);
366 err:
367 if (ret)
368 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
369 return ret;
370 }
371
372 static int m88rs6000t_set_bb(struct m88rs6000t_dev *dev,
373 u32 symbol_rate_KSs, s32 lpf_offset_KHz)
374 {
375 u32 f3dB;
376 u8 reg40;
377
378 f3dB = symbol_rate_KSs * 9 / 14 + 2000;
379 f3dB += lpf_offset_KHz;
380 f3dB = clamp_val(f3dB, 6000U, 43000U);
381 reg40 = f3dB / 1000;
382 return regmap_write(dev->regmap, 0x40, reg40);
383 }
384
385 static int m88rs6000t_set_params(struct dvb_frontend *fe)
386 {
387 struct m88rs6000t_dev *dev = fe->tuner_priv;
388 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
389 int ret;
390 s32 lpf_offset_KHz;
391 u32 realFreq, freq_MHz;
392
393 dev_dbg(&dev->client->dev,
394 "frequency=%d symbol_rate=%d\n",
395 c->frequency, c->symbol_rate);
396
397 if (c->symbol_rate < 5000000)
398 lpf_offset_KHz = 3000;
399 else
400 lpf_offset_KHz = 0;
401
402 realFreq = c->frequency + lpf_offset_KHz;
403 /* set tuner pll.*/
404 freq_MHz = (realFreq + 500) / 1000;
405 ret = m88rs6000t_set_pll_freq(dev, freq_MHz);
406 if (ret)
407 goto err;
408 ret = m88rs6000t_set_bb(dev, c->symbol_rate / 1000, lpf_offset_KHz);
409 if (ret)
410 goto err;
411 ret = regmap_write(dev->regmap, 0x00, 0x01);
412 if (ret)
413 goto err;
414 ret = regmap_write(dev->regmap, 0x00, 0x00);
415 if (ret)
416 goto err;
417 /* set demod mlck */
418 ret = m88rs6000t_set_demod_mclk(fe);
419 err:
420 if (ret)
421 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
422 return ret;
423 }
424
425 static int m88rs6000t_init(struct dvb_frontend *fe)
426 {
427 struct m88rs6000t_dev *dev = fe->tuner_priv;
428 int ret;
429
430 dev_dbg(&dev->client->dev, "%s:\n", __func__);
431
432 ret = regmap_update_bits(dev->regmap, 0x11, 0x08, 0x08);
433 if (ret)
434 goto err;
435 usleep_range(5000, 50000);
436 ret = regmap_update_bits(dev->regmap, 0x10, 0x01, 0x01);
437 if (ret)
438 goto err;
439 usleep_range(10000, 50000);
440 ret = regmap_write(dev->regmap, 0x07, 0x7d);
441 err:
442 if (ret)
443 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
444 return ret;
445 }
446
447 static int m88rs6000t_sleep(struct dvb_frontend *fe)
448 {
449 struct m88rs6000t_dev *dev = fe->tuner_priv;
450 int ret;
451
452 dev_dbg(&dev->client->dev, "%s:\n", __func__);
453
454 ret = regmap_write(dev->regmap, 0x07, 0x6d);
455 if (ret) {
456 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
457 return ret;
458 }
459 usleep_range(5000, 10000);
460 return 0;
461 }
462
463 static int m88rs6000t_get_frequency(struct dvb_frontend *fe, u32 *frequency)
464 {
465 struct m88rs6000t_dev *dev = fe->tuner_priv;
466
467 dev_dbg(&dev->client->dev, "\n");
468
469 *frequency = dev->frequency_khz;
470 return 0;
471 }
472
473 static int m88rs6000t_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
474 {
475 struct m88rs6000t_dev *dev = fe->tuner_priv;
476
477 dev_dbg(&dev->client->dev, "\n");
478
479 *frequency = 0; /* Zero-IF */
480 return 0;
481 }
482
483
484 static int m88rs6000t_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
485 {
486 struct m88rs6000t_dev *dev = fe->tuner_priv;
487 unsigned int val, i;
488 int ret;
489 u16 gain;
490 u32 PGA2_cri_GS = 46, PGA2_crf_GS = 290, TIA_GS = 290;
491 u32 RF_GC = 1200, IF_GC = 1100, BB_GC = 300;
492 u32 PGA2_GC = 300, TIA_GC = 300, PGA2_cri = 0, PGA2_crf = 0;
493 u32 RFG = 0, IFG = 0, BBG = 0, PGA2G = 0, TIAG = 0;
494 u32 RFGS[13] = {0, 245, 266, 268, 270, 285,
495 298, 295, 283, 285, 285, 300, 300};
496 u32 IFGS[12] = {0, 300, 230, 270, 270, 285,
497 295, 285, 290, 295, 295, 310};
498 u32 BBGS[14] = {0, 286, 275, 290, 294, 300, 290,
499 290, 285, 283, 260, 295, 290, 260};
500
501 ret = regmap_read(dev->regmap, 0x5A, &val);
502 if (ret)
503 goto err;
504 RF_GC = val & 0x0f;
505
506 ret = regmap_read(dev->regmap, 0x5F, &val);
507 if (ret)
508 goto err;
509 IF_GC = val & 0x0f;
510
511 ret = regmap_read(dev->regmap, 0x3F, &val);
512 if (ret)
513 goto err;
514 TIA_GC = (val >> 4) & 0x07;
515
516 ret = regmap_read(dev->regmap, 0x77, &val);
517 if (ret)
518 goto err;
519 BB_GC = (val >> 4) & 0x0f;
520
521 ret = regmap_read(dev->regmap, 0x76, &val);
522 if (ret)
523 goto err;
524 PGA2_GC = val & 0x3f;
525 PGA2_cri = PGA2_GC >> 2;
526 PGA2_crf = PGA2_GC & 0x03;
527
528 for (i = 0; i <= RF_GC; i++)
529 RFG += RFGS[i];
530
531 if (RF_GC == 0)
532 RFG += 400;
533 if (RF_GC == 1)
534 RFG += 300;
535 if (RF_GC == 2)
536 RFG += 200;
537 if (RF_GC == 3)
538 RFG += 100;
539
540 for (i = 0; i <= IF_GC; i++)
541 IFG += IFGS[i];
542
543 TIAG = TIA_GC * TIA_GS;
544
545 for (i = 0; i <= BB_GC; i++)
546 BBG += BBGS[i];
547
548 PGA2G = PGA2_cri * PGA2_cri_GS + PGA2_crf * PGA2_crf_GS;
549
550 gain = RFG + IFG - TIAG + BBG + PGA2G;
551
552 /* scale value to 0x0000-0xffff */
553 gain = clamp_val(gain, 1000U, 10500U);
554 *strength = (10500 - gain) * 0xffff / (10500 - 1000);
555 err:
556 if (ret)
557 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
558 return ret;
559 }
560
561 static const struct dvb_tuner_ops m88rs6000t_tuner_ops = {
562 .info = {
563 .name = "Montage M88RS6000 Internal Tuner",
564 .frequency_min_hz = 950 * MHz,
565 .frequency_max_hz = 2150 * MHz,
566 },
567
568 .init = m88rs6000t_init,
569 .sleep = m88rs6000t_sleep,
570 .set_params = m88rs6000t_set_params,
571 .get_frequency = m88rs6000t_get_frequency,
572 .get_if_frequency = m88rs6000t_get_if_frequency,
573 .get_rf_strength = m88rs6000t_get_rf_strength,
574 };
575
576 static int m88rs6000t_probe(struct i2c_client *client,
577 const struct i2c_device_id *id)
578 {
579 struct m88rs6000t_config *cfg = client->dev.platform_data;
580 struct dvb_frontend *fe = cfg->fe;
581 struct m88rs6000t_dev *dev;
582 int ret, i;
583 unsigned int utmp;
584 static const struct regmap_config regmap_config = {
585 .reg_bits = 8,
586 .val_bits = 8,
587 };
588 static const struct m88rs6000t_reg_val reg_vals[] = {
589 {0x10, 0xfb},
590 {0x24, 0x38},
591 {0x11, 0x0a},
592 {0x12, 0x00},
593 {0x2b, 0x1c},
594 {0x44, 0x48},
595 {0x54, 0x24},
596 {0x55, 0x06},
597 {0x59, 0x00},
598 {0x5b, 0x4c},
599 {0x60, 0x8b},
600 {0x61, 0xf4},
601 {0x65, 0x07},
602 {0x6d, 0x6f},
603 {0x6e, 0x31},
604 {0x3c, 0xf3},
605 {0x37, 0x0f},
606 {0x48, 0x28},
607 {0x49, 0xd8},
608 {0x70, 0x66},
609 {0x71, 0xCF},
610 {0x72, 0x81},
611 {0x73, 0xA7},
612 {0x74, 0x4F},
613 {0x75, 0xFC},
614 };
615
616 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
617 if (!dev) {
618 ret = -ENOMEM;
619 dev_err(&client->dev, "kzalloc() failed\n");
620 goto err;
621 }
622
623 memcpy(&dev->cfg, cfg, sizeof(struct m88rs6000t_config));
624 dev->client = client;
625 dev->regmap = devm_regmap_init_i2c(client, &regmap_config);
626 if (IS_ERR(dev->regmap)) {
627 ret = PTR_ERR(dev->regmap);
628 goto err;
629 }
630
631 ret = regmap_update_bits(dev->regmap, 0x11, 0x08, 0x08);
632 if (ret)
633 goto err;
634 usleep_range(5000, 50000);
635 ret = regmap_update_bits(dev->regmap, 0x10, 0x01, 0x01);
636 if (ret)
637 goto err;
638 usleep_range(10000, 50000);
639 ret = regmap_write(dev->regmap, 0x07, 0x7d);
640 if (ret)
641 goto err;
642 ret = regmap_write(dev->regmap, 0x04, 0x01);
643 if (ret)
644 goto err;
645
646 /* check tuner chip id */
647 ret = regmap_read(dev->regmap, 0x01, &utmp);
648 if (ret)
649 goto err;
650 dev_info(&dev->client->dev, "chip_id=%02x\n", utmp);
651 if (utmp != 0x64) {
652 ret = -ENODEV;
653 goto err;
654 }
655
656 /* tuner init. */
657 ret = regmap_write(dev->regmap, 0x05, 0x40);
658 if (ret)
659 goto err;
660 ret = regmap_write(dev->regmap, 0x11, 0x08);
661 if (ret)
662 goto err;
663 ret = regmap_write(dev->regmap, 0x15, 0x6c);
664 if (ret)
665 goto err;
666 ret = regmap_write(dev->regmap, 0x17, 0xc1);
667 if (ret)
668 goto err;
669 ret = regmap_write(dev->regmap, 0x17, 0x81);
670 if (ret)
671 goto err;
672 usleep_range(10000, 50000);
673 ret = regmap_write(dev->regmap, 0x05, 0x00);
674 if (ret)
675 goto err;
676 ret = regmap_write(dev->regmap, 0x11, 0x0a);
677 if (ret)
678 goto err;
679
680 for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
681 ret = regmap_write(dev->regmap,
682 reg_vals[i].reg, reg_vals[i].val);
683 if (ret)
684 goto err;
685 }
686
687 dev_info(&dev->client->dev, "Montage M88RS6000 internal tuner successfully identified\n");
688
689 fe->tuner_priv = dev;
690 memcpy(&fe->ops.tuner_ops, &m88rs6000t_tuner_ops,
691 sizeof(struct dvb_tuner_ops));
692 i2c_set_clientdata(client, dev);
693 return 0;
694 err:
695 dev_dbg(&client->dev, "failed=%d\n", ret);
696 kfree(dev);
697 return ret;
698 }
699
700 static int m88rs6000t_remove(struct i2c_client *client)
701 {
702 struct m88rs6000t_dev *dev = i2c_get_clientdata(client);
703 struct dvb_frontend *fe = dev->cfg.fe;
704
705 dev_dbg(&client->dev, "\n");
706
707 memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
708 fe->tuner_priv = NULL;
709 kfree(dev);
710
711 return 0;
712 }
713
714 static const struct i2c_device_id m88rs6000t_id[] = {
715 {"m88rs6000t", 0},
716 {}
717 };
718 MODULE_DEVICE_TABLE(i2c, m88rs6000t_id);
719
720 static struct i2c_driver m88rs6000t_driver = {
721 .driver = {
722 .name = "m88rs6000t",
723 },
724 .probe = m88rs6000t_probe,
725 .remove = m88rs6000t_remove,
726 .id_table = m88rs6000t_id,
727 };
728
729 module_i2c_driver(m88rs6000t_driver);
730
731 MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
732 MODULE_DESCRIPTION("Montage M88RS6000 internal tuner driver");
733 MODULE_LICENSE("GPL");
Linux with added FPC-III support