• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Silicon Labs Si2168 DVB-T/T2/C demodulator driver
3  *
4  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
5  *
6  *    This program is free software; you can redistribute it and/or modify
7  *    it under the terms of the GNU General Public License as published by
8  *    the Free Software Foundation; either version 2 of the License, or
9  *    (at your option) any later version.
10  *
11  *    This program is distributed in the hope that it will be useful,
12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *    GNU General Public License for more details.
15  */
16 
17 #include "si2168_priv.h"
18 
19 static const struct dvb_frontend_ops si2168_ops;
20 
21 /* execute firmware command */
si2168_cmd_execute(struct si2168 * s,struct si2168_cmd * cmd)22 static int si2168_cmd_execute(struct si2168 *s, struct si2168_cmd *cmd)
23 {
24 	int ret;
25 	unsigned long timeout;
26 
27 	mutex_lock(&s->i2c_mutex);
28 
29 	if (cmd->wlen) {
30 		/* write cmd and args for firmware */
31 		ret = i2c_master_send(s->client, cmd->args, cmd->wlen);
32 		if (ret < 0) {
33 			goto err_mutex_unlock;
34 		} else if (ret != cmd->wlen) {
35 			ret = -EREMOTEIO;
36 			goto err_mutex_unlock;
37 		}
38 	}
39 
40 	if (cmd->rlen) {
41 		/* wait cmd execution terminate */
42 		#define TIMEOUT 50
43 		timeout = jiffies + msecs_to_jiffies(TIMEOUT);
44 		while (!time_after(jiffies, timeout)) {
45 			ret = i2c_master_recv(s->client, cmd->args, cmd->rlen);
46 			if (ret < 0) {
47 				goto err_mutex_unlock;
48 			} else if (ret != cmd->rlen) {
49 				ret = -EREMOTEIO;
50 				goto err_mutex_unlock;
51 			}
52 
53 			/* firmware ready? */
54 			if ((cmd->args[0] >> 7) & 0x01)
55 				break;
56 		}
57 
58 		dev_dbg(&s->client->dev, "cmd execution took %d ms\n",
59 				jiffies_to_msecs(jiffies) -
60 				(jiffies_to_msecs(timeout) - TIMEOUT));
61 
62 		if (!((cmd->args[0] >> 7) & 0x01)) {
63 			ret = -ETIMEDOUT;
64 			goto err_mutex_unlock;
65 		}
66 	}
67 
68 	ret = 0;
69 
70 err_mutex_unlock:
71 	mutex_unlock(&s->i2c_mutex);
72 	if (ret)
73 		goto err;
74 
75 	return 0;
76 err:
77 	dev_dbg(&s->client->dev, "failed=%d\n", ret);
78 	return ret;
79 }
80 
si2168_read_status(struct dvb_frontend * fe,fe_status_t * status)81 static int si2168_read_status(struct dvb_frontend *fe, fe_status_t *status)
82 {
83 	struct si2168 *s = fe->demodulator_priv;
84 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
85 	int ret;
86 	struct si2168_cmd cmd;
87 
88 	*status = 0;
89 
90 	if (!s->active) {
91 		ret = -EAGAIN;
92 		goto err;
93 	}
94 
95 	switch (c->delivery_system) {
96 	case SYS_DVBT:
97 		memcpy(cmd.args, "\xa0\x01", 2);
98 		cmd.wlen = 2;
99 		cmd.rlen = 13;
100 		break;
101 	case SYS_DVBC_ANNEX_A:
102 		memcpy(cmd.args, "\x90\x01", 2);
103 		cmd.wlen = 2;
104 		cmd.rlen = 9;
105 		break;
106 	case SYS_DVBT2:
107 		memcpy(cmd.args, "\x50\x01", 2);
108 		cmd.wlen = 2;
109 		cmd.rlen = 14;
110 		break;
111 	default:
112 		ret = -EINVAL;
113 		goto err;
114 	}
115 
116 	ret = si2168_cmd_execute(s, &cmd);
117 	if (ret)
118 		goto err;
119 
120 	/*
121 	 * Possible values seen, in order from strong signal to weak:
122 	 * 16 0001 0110 full lock
123 	 * 1e 0001 1110 partial lock
124 	 * 1a 0001 1010 partial lock
125 	 * 18 0001 1000 no lock
126 	 *
127 	 * [b3:b1] lock bits
128 	 * [b4] statistics ready? Set in a few secs after lock is gained.
129 	 */
130 
131 	switch ((cmd.args[2] >> 1) & 0x03) {
132 	case 0x01:
133 		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
134 		break;
135 	case 0x03:
136 		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
137 				FE_HAS_SYNC | FE_HAS_LOCK;
138 		break;
139 	}
140 
141 	s->fe_status = *status;
142 
143 	if (*status & FE_HAS_LOCK) {
144 		c->cnr.len = 1;
145 		c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
146 		c->cnr.stat[0].svalue = cmd.args[3] * 1000 / 4;
147 	} else {
148 		c->cnr.len = 1;
149 		c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
150 	}
151 
152 	dev_dbg(&s->client->dev, "status=%02x args=%*ph\n",
153 			*status, cmd.rlen, cmd.args);
154 
155 	return 0;
156 err:
157 	dev_dbg(&s->client->dev, "failed=%d\n", ret);
158 	return ret;
159 }
160 
si2168_set_frontend(struct dvb_frontend * fe)161 static int si2168_set_frontend(struct dvb_frontend *fe)
162 {
163 	struct si2168 *s = fe->demodulator_priv;
164 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
165 	int ret;
166 	struct si2168_cmd cmd;
167 	u8 bandwidth, delivery_system;
168 
169 	dev_dbg(&s->client->dev,
170 			"delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%u, stream_id=%d\n",
171 			c->delivery_system, c->modulation,
172 			c->frequency, c->bandwidth_hz, c->symbol_rate,
173 			c->inversion, c->stream_id);
174 
175 	if (!s->active) {
176 		ret = -EAGAIN;
177 		goto err;
178 	}
179 
180 	switch (c->delivery_system) {
181 	case SYS_DVBT:
182 		delivery_system = 0x20;
183 		break;
184 	case SYS_DVBC_ANNEX_A:
185 		delivery_system = 0x30;
186 		break;
187 	case SYS_DVBT2:
188 		delivery_system = 0x70;
189 		break;
190 	default:
191 		ret = -EINVAL;
192 		goto err;
193 	}
194 
195 	if (c->bandwidth_hz <= 5000000)
196 		bandwidth = 0x05;
197 	else if (c->bandwidth_hz <= 6000000)
198 		bandwidth = 0x06;
199 	else if (c->bandwidth_hz <= 7000000)
200 		bandwidth = 0x07;
201 	else if (c->bandwidth_hz <= 8000000)
202 		bandwidth = 0x08;
203 	else if (c->bandwidth_hz <= 9000000)
204 		bandwidth = 0x09;
205 	else if (c->bandwidth_hz <= 10000000)
206 		bandwidth = 0x0a;
207 	else
208 		bandwidth = 0x0f;
209 
210 	/* program tuner */
211 	if (fe->ops.tuner_ops.set_params) {
212 		ret = fe->ops.tuner_ops.set_params(fe);
213 		if (ret)
214 			goto err;
215 	}
216 
217 	memcpy(cmd.args, "\x88\x02\x02\x02\x02", 5);
218 	cmd.wlen = 5;
219 	cmd.rlen = 5;
220 	ret = si2168_cmd_execute(s, &cmd);
221 	if (ret)
222 		goto err;
223 
224 	/* that has no big effect */
225 	if (c->delivery_system == SYS_DVBT)
226 		memcpy(cmd.args, "\x89\x21\x06\x11\xff\x98", 6);
227 	else if (c->delivery_system == SYS_DVBC_ANNEX_A)
228 		memcpy(cmd.args, "\x89\x21\x06\x11\x89\xf0", 6);
229 	else if (c->delivery_system == SYS_DVBT2)
230 		memcpy(cmd.args, "\x89\x21\x06\x11\x89\x20", 6);
231 	cmd.wlen = 6;
232 	cmd.rlen = 3;
233 	ret = si2168_cmd_execute(s, &cmd);
234 	if (ret)
235 		goto err;
236 
237 	if (c->delivery_system == SYS_DVBT2) {
238 		/* select PLP */
239 		cmd.args[0] = 0x52;
240 		cmd.args[1] = c->stream_id & 0xff;
241 		cmd.args[2] = c->stream_id == NO_STREAM_ID_FILTER ? 0 : 1;
242 		cmd.wlen = 3;
243 		cmd.rlen = 1;
244 		ret = si2168_cmd_execute(s, &cmd);
245 		if (ret)
246 			goto err;
247 	}
248 
249 	memcpy(cmd.args, "\x51\x03", 2);
250 	cmd.wlen = 2;
251 	cmd.rlen = 12;
252 	ret = si2168_cmd_execute(s, &cmd);
253 	if (ret)
254 		goto err;
255 
256 	memcpy(cmd.args, "\x12\x08\x04", 3);
257 	cmd.wlen = 3;
258 	cmd.rlen = 3;
259 	ret = si2168_cmd_execute(s, &cmd);
260 	if (ret)
261 		goto err;
262 
263 	memcpy(cmd.args, "\x14\x00\x0c\x10\x12\x00", 6);
264 	cmd.wlen = 6;
265 	cmd.rlen = 4;
266 	ret = si2168_cmd_execute(s, &cmd);
267 	if (ret)
268 		goto err;
269 
270 	memcpy(cmd.args, "\x14\x00\x06\x10\x24\x00", 6);
271 	cmd.wlen = 6;
272 	cmd.rlen = 4;
273 	ret = si2168_cmd_execute(s, &cmd);
274 	if (ret)
275 		goto err;
276 
277 	memcpy(cmd.args, "\x14\x00\x07\x10\x00\x24", 6);
278 	cmd.wlen = 6;
279 	cmd.rlen = 4;
280 	ret = si2168_cmd_execute(s, &cmd);
281 	if (ret)
282 		goto err;
283 
284 	memcpy(cmd.args, "\x14\x00\x0a\x10\x00\x00", 6);
285 	cmd.args[4] = delivery_system | bandwidth;
286 	cmd.wlen = 6;
287 	cmd.rlen = 4;
288 	ret = si2168_cmd_execute(s, &cmd);
289 	if (ret)
290 		goto err;
291 
292 	/* set DVB-C symbol rate */
293 	if (c->delivery_system == SYS_DVBC_ANNEX_A) {
294 		memcpy(cmd.args, "\x14\x00\x02\x11", 4);
295 		cmd.args[4] = (c->symbol_rate / 1000) & 0xff;
296 		cmd.args[5] = ((c->symbol_rate / 1000) >> 8) & 0xff;
297 		cmd.wlen = 6;
298 		cmd.rlen = 4;
299 		ret = si2168_cmd_execute(s, &cmd);
300 		if (ret)
301 			goto err;
302 	}
303 
304 	memcpy(cmd.args, "\x14\x00\x0f\x10\x10\x00", 6);
305 	cmd.wlen = 6;
306 	cmd.rlen = 4;
307 	ret = si2168_cmd_execute(s, &cmd);
308 	if (ret)
309 		goto err;
310 
311 	memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x18", 6);
312 	cmd.wlen = 6;
313 	cmd.rlen = 4;
314 	ret = si2168_cmd_execute(s, &cmd);
315 	if (ret)
316 		goto err;
317 
318 	memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x15", 6);
319 	cmd.wlen = 6;
320 	cmd.rlen = 4;
321 	ret = si2168_cmd_execute(s, &cmd);
322 	if (ret)
323 		goto err;
324 
325 	memcpy(cmd.args, "\x14\x00\x01\x12\x00\x00", 6);
326 	cmd.wlen = 6;
327 	cmd.rlen = 4;
328 	ret = si2168_cmd_execute(s, &cmd);
329 	if (ret)
330 		goto err;
331 
332 	memcpy(cmd.args, "\x14\x00\x01\x03\x0c\x00", 6);
333 	cmd.wlen = 6;
334 	cmd.rlen = 4;
335 	ret = si2168_cmd_execute(s, &cmd);
336 	if (ret)
337 		goto err;
338 
339 	memcpy(cmd.args, "\x85", 1);
340 	cmd.wlen = 1;
341 	cmd.rlen = 1;
342 	ret = si2168_cmd_execute(s, &cmd);
343 	if (ret)
344 		goto err;
345 
346 	s->delivery_system = c->delivery_system;
347 
348 	return 0;
349 err:
350 	dev_dbg(&s->client->dev, "failed=%d\n", ret);
351 	return ret;
352 }
353 
si2168_init(struct dvb_frontend * fe)354 static int si2168_init(struct dvb_frontend *fe)
355 {
356 	struct si2168 *s = fe->demodulator_priv;
357 	int ret, len, remaining;
358 	const struct firmware *fw = NULL;
359 	u8 *fw_file;
360 	const unsigned int i2c_wr_max = 8;
361 	struct si2168_cmd cmd;
362 	unsigned int chip_id;
363 
364 	dev_dbg(&s->client->dev, "\n");
365 
366 	/* initialize */
367 	memcpy(cmd.args, "\xc0\x12\x00\x0c\x00\x0d\x16\x00\x00\x00\x00\x00\x00", 13);
368 	cmd.wlen = 13;
369 	cmd.rlen = 0;
370 	ret = si2168_cmd_execute(s, &cmd);
371 	if (ret)
372 		goto err;
373 
374 	if (s->fw_loaded) {
375 		/* resume */
376 		memcpy(cmd.args, "\xc0\x06\x08\x0f\x00\x20\x21\x01", 8);
377 		cmd.wlen = 8;
378 		cmd.rlen = 1;
379 		ret = si2168_cmd_execute(s, &cmd);
380 		if (ret)
381 			goto err;
382 
383 		memcpy(cmd.args, "\x85", 1);
384 		cmd.wlen = 1;
385 		cmd.rlen = 1;
386 		ret = si2168_cmd_execute(s, &cmd);
387 		if (ret)
388 			goto err;
389 
390 		goto warm;
391 	}
392 
393 	/* power up */
394 	memcpy(cmd.args, "\xc0\x06\x01\x0f\x00\x20\x20\x01", 8);
395 	cmd.wlen = 8;
396 	cmd.rlen = 1;
397 	ret = si2168_cmd_execute(s, &cmd);
398 	if (ret)
399 		goto err;
400 
401 	/* query chip revision */
402 	memcpy(cmd.args, "\x02", 1);
403 	cmd.wlen = 1;
404 	cmd.rlen = 13;
405 	ret = si2168_cmd_execute(s, &cmd);
406 	if (ret)
407 		goto err;
408 
409 	chip_id = cmd.args[1] << 24 | cmd.args[2] << 16 | cmd.args[3] << 8 |
410 			cmd.args[4] << 0;
411 
412 	#define SI2168_A20 ('A' << 24 | 68 << 16 | '2' << 8 | '0' << 0)
413 	#define SI2168_A30 ('A' << 24 | 68 << 16 | '3' << 8 | '0' << 0)
414 	#define SI2168_B40 ('B' << 24 | 68 << 16 | '4' << 8 | '0' << 0)
415 
416 	switch (chip_id) {
417 	case SI2168_A20:
418 		fw_file = SI2168_A20_FIRMWARE;
419 		break;
420 	case SI2168_A30:
421 		fw_file = SI2168_A30_FIRMWARE;
422 		break;
423 	case SI2168_B40:
424 		fw_file = SI2168_B40_FIRMWARE;
425 		break;
426 	default:
427 		dev_err(&s->client->dev,
428 				"unknown chip version Si21%d-%c%c%c\n",
429 				cmd.args[2], cmd.args[1],
430 				cmd.args[3], cmd.args[4]);
431 		ret = -EINVAL;
432 		goto err;
433 	}
434 
435 	/* cold state - try to download firmware */
436 	dev_info(&s->client->dev, "found a '%s' in cold state\n",
437 			si2168_ops.info.name);
438 
439 	/* request the firmware, this will block and timeout */
440 	ret = request_firmware(&fw, fw_file, &s->client->dev);
441 	if (ret) {
442 		/* fallback mechanism to handle old name for Si2168 B40 fw */
443 		if (chip_id == SI2168_B40) {
444 			fw_file = SI2168_B40_FIRMWARE_FALLBACK;
445 			ret = request_firmware(&fw, fw_file, &s->client->dev);
446 		}
447 
448 		if (ret == 0) {
449 			dev_notice(&s->client->dev,
450 					"please install firmware file '%s'\n",
451 					SI2168_B40_FIRMWARE);
452 		} else {
453 			dev_err(&s->client->dev,
454 					"firmware file '%s' not found\n",
455 					fw_file);
456 			goto err;
457 		}
458 	}
459 
460 	dev_info(&s->client->dev, "downloading firmware from file '%s'\n",
461 			fw_file);
462 
463 	for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) {
464 		len = remaining;
465 		if (len > i2c_wr_max)
466 			len = i2c_wr_max;
467 
468 		memcpy(cmd.args, &fw->data[fw->size - remaining], len);
469 		cmd.wlen = len;
470 		cmd.rlen = 1;
471 		ret = si2168_cmd_execute(s, &cmd);
472 		if (ret) {
473 			dev_err(&s->client->dev,
474 					"firmware download failed=%d\n",
475 					ret);
476 			goto err;
477 		}
478 	}
479 
480 	release_firmware(fw);
481 	fw = NULL;
482 
483 	memcpy(cmd.args, "\x01\x01", 2);
484 	cmd.wlen = 2;
485 	cmd.rlen = 1;
486 	ret = si2168_cmd_execute(s, &cmd);
487 	if (ret)
488 		goto err;
489 
490 	/* set ts mode */
491 	memcpy(cmd.args, "\x14\x00\x01\x10\x10\x00", 6);
492 	cmd.args[4] |= s->ts_mode;
493 	cmd.wlen = 6;
494 	cmd.rlen = 4;
495 	ret = si2168_cmd_execute(s, &cmd);
496 	if (ret)
497 		goto err;
498 
499 	s->fw_loaded = true;
500 
501 warm:
502 	dev_info(&s->client->dev, "found a '%s' in warm state\n",
503 			si2168_ops.info.name);
504 
505 	s->active = true;
506 
507 	return 0;
508 err:
509 	if (fw)
510 		release_firmware(fw);
511 
512 	dev_dbg(&s->client->dev, "failed=%d\n", ret);
513 	return ret;
514 }
515 
si2168_sleep(struct dvb_frontend * fe)516 static int si2168_sleep(struct dvb_frontend *fe)
517 {
518 	struct si2168 *s = fe->demodulator_priv;
519 	int ret;
520 	struct si2168_cmd cmd;
521 
522 	dev_dbg(&s->client->dev, "\n");
523 
524 	s->active = false;
525 
526 	memcpy(cmd.args, "\x13", 1);
527 	cmd.wlen = 1;
528 	cmd.rlen = 0;
529 	ret = si2168_cmd_execute(s, &cmd);
530 	if (ret)
531 		goto err;
532 
533 	return 0;
534 err:
535 	dev_dbg(&s->client->dev, "failed=%d\n", ret);
536 	return ret;
537 }
538 
si2168_get_tune_settings(struct dvb_frontend * fe,struct dvb_frontend_tune_settings * s)539 static int si2168_get_tune_settings(struct dvb_frontend *fe,
540 	struct dvb_frontend_tune_settings *s)
541 {
542 	s->min_delay_ms = 900;
543 
544 	return 0;
545 }
546 
547 /*
548  * I2C gate logic
549  * We must use unlocked i2c_transfer() here because I2C lock is already taken
550  * by tuner driver.
551  */
si2168_select(struct i2c_adapter * adap,void * mux_priv,u32 chan)552 static int si2168_select(struct i2c_adapter *adap, void *mux_priv, u32 chan)
553 {
554 	struct si2168 *s = mux_priv;
555 	int ret;
556 	struct i2c_msg gate_open_msg = {
557 		.addr = s->client->addr,
558 		.flags = 0,
559 		.len = 3,
560 		.buf = "\xc0\x0d\x01",
561 	};
562 
563 	mutex_lock(&s->i2c_mutex);
564 
565 	/* open tuner I2C gate */
566 	ret = __i2c_transfer(s->client->adapter, &gate_open_msg, 1);
567 	if (ret != 1) {
568 		dev_warn(&s->client->dev, "i2c write failed=%d\n", ret);
569 		if (ret >= 0)
570 			ret = -EREMOTEIO;
571 	} else {
572 		ret = 0;
573 	}
574 
575 	return ret;
576 }
577 
si2168_deselect(struct i2c_adapter * adap,void * mux_priv,u32 chan)578 static int si2168_deselect(struct i2c_adapter *adap, void *mux_priv, u32 chan)
579 {
580 	struct si2168 *s = mux_priv;
581 	int ret;
582 	struct i2c_msg gate_close_msg = {
583 		.addr = s->client->addr,
584 		.flags = 0,
585 		.len = 3,
586 		.buf = "\xc0\x0d\x00",
587 	};
588 
589 	/* close tuner I2C gate */
590 	ret = __i2c_transfer(s->client->adapter, &gate_close_msg, 1);
591 	if (ret != 1) {
592 		dev_warn(&s->client->dev, "i2c write failed=%d\n", ret);
593 		if (ret >= 0)
594 			ret = -EREMOTEIO;
595 	} else {
596 		ret = 0;
597 	}
598 
599 	mutex_unlock(&s->i2c_mutex);
600 
601 	return ret;
602 }
603 
604 static const struct dvb_frontend_ops si2168_ops = {
605 	.delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A},
606 	.info = {
607 		.name = "Silicon Labs Si2168",
608 		.symbol_rate_min = 1000000,
609 		.symbol_rate_max = 7200000,
610 		.caps =	FE_CAN_FEC_1_2 |
611 			FE_CAN_FEC_2_3 |
612 			FE_CAN_FEC_3_4 |
613 			FE_CAN_FEC_5_6 |
614 			FE_CAN_FEC_7_8 |
615 			FE_CAN_FEC_AUTO |
616 			FE_CAN_QPSK |
617 			FE_CAN_QAM_16 |
618 			FE_CAN_QAM_32 |
619 			FE_CAN_QAM_64 |
620 			FE_CAN_QAM_128 |
621 			FE_CAN_QAM_256 |
622 			FE_CAN_QAM_AUTO |
623 			FE_CAN_TRANSMISSION_MODE_AUTO |
624 			FE_CAN_GUARD_INTERVAL_AUTO |
625 			FE_CAN_HIERARCHY_AUTO |
626 			FE_CAN_MUTE_TS |
627 			FE_CAN_2G_MODULATION |
628 			FE_CAN_MULTISTREAM
629 	},
630 
631 	.get_tune_settings = si2168_get_tune_settings,
632 
633 	.init = si2168_init,
634 	.sleep = si2168_sleep,
635 
636 	.set_frontend = si2168_set_frontend,
637 
638 	.read_status = si2168_read_status,
639 };
640 
si2168_probe(struct i2c_client * client,const struct i2c_device_id * id)641 static int si2168_probe(struct i2c_client *client,
642 		const struct i2c_device_id *id)
643 {
644 	struct si2168_config *config = client->dev.platform_data;
645 	struct si2168 *s;
646 	int ret;
647 
648 	dev_dbg(&client->dev, "\n");
649 
650 	s = kzalloc(sizeof(struct si2168), GFP_KERNEL);
651 	if (!s) {
652 		ret = -ENOMEM;
653 		dev_err(&client->dev, "kzalloc() failed\n");
654 		goto err;
655 	}
656 
657 	s->client = client;
658 	mutex_init(&s->i2c_mutex);
659 
660 	/* create mux i2c adapter for tuner */
661 	s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s,
662 			0, 0, 0, si2168_select, si2168_deselect);
663 	if (s->adapter == NULL) {
664 		ret = -ENODEV;
665 		goto err;
666 	}
667 
668 	/* create dvb_frontend */
669 	memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops));
670 	s->fe.demodulator_priv = s;
671 
672 	*config->i2c_adapter = s->adapter;
673 	*config->fe = &s->fe;
674 	s->ts_mode = config->ts_mode;
675 	s->fw_loaded = false;
676 
677 	i2c_set_clientdata(client, s);
678 
679 	dev_info(&s->client->dev,
680 			"Silicon Labs Si2168 successfully attached\n");
681 	return 0;
682 err:
683 	kfree(s);
684 	dev_dbg(&client->dev, "failed=%d\n", ret);
685 	return ret;
686 }
687 
si2168_remove(struct i2c_client * client)688 static int si2168_remove(struct i2c_client *client)
689 {
690 	struct si2168 *s = i2c_get_clientdata(client);
691 
692 	dev_dbg(&client->dev, "\n");
693 
694 	i2c_del_mux_adapter(s->adapter);
695 
696 	s->fe.ops.release = NULL;
697 	s->fe.demodulator_priv = NULL;
698 
699 	kfree(s);
700 
701 	return 0;
702 }
703 
704 static const struct i2c_device_id si2168_id[] = {
705 	{"si2168", 0},
706 	{}
707 };
708 MODULE_DEVICE_TABLE(i2c, si2168_id);
709 
710 static struct i2c_driver si2168_driver = {
711 	.driver = {
712 		.owner	= THIS_MODULE,
713 		.name	= "si2168",
714 	},
715 	.probe		= si2168_probe,
716 	.remove		= si2168_remove,
717 	.id_table	= si2168_id,
718 };
719 
720 module_i2c_driver(si2168_driver);
721 
722 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
723 MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver");
724 MODULE_LICENSE("GPL");
725 MODULE_FIRMWARE(SI2168_A20_FIRMWARE);
726 MODULE_FIRMWARE(SI2168_A30_FIRMWARE);
727 MODULE_FIRMWARE(SI2168_B40_FIRMWARE);
728