1/*
2 * Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner 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 "si2157_priv.h"
18
19static const struct dvb_tuner_ops si2157_ops;
20
21/* execute firmware command */
22static int si2157_cmd_execute(struct i2c_client *client, struct si2157_cmd *cmd)
23{
24	struct si2157_dev *dev = i2c_get_clientdata(client);
25	int ret;
26	unsigned long timeout;
27
28	mutex_lock(&dev->i2c_mutex);
29
30	if (cmd->wlen) {
31		/* write cmd and args for firmware */
32		ret = i2c_master_send(client, cmd->args, cmd->wlen);
33		if (ret < 0) {
34			goto err_mutex_unlock;
35		} else if (ret != cmd->wlen) {
36			ret = -EREMOTEIO;
37			goto err_mutex_unlock;
38		}
39	}
40
41	if (cmd->rlen) {
42		/* wait cmd execution terminate */
43		#define TIMEOUT 80
44		timeout = jiffies + msecs_to_jiffies(TIMEOUT);
45		while (!time_after(jiffies, timeout)) {
46			ret = i2c_master_recv(client, cmd->args, cmd->rlen);
47			if (ret < 0) {
48				goto err_mutex_unlock;
49			} else if (ret != cmd->rlen) {
50				ret = -EREMOTEIO;
51				goto err_mutex_unlock;
52			}
53
54			/* firmware ready? */
55			if ((cmd->args[0] >> 7) & 0x01)
56				break;
57		}
58
59		dev_dbg(&client->dev, "cmd execution took %d ms\n",
60				jiffies_to_msecs(jiffies) -
61				(jiffies_to_msecs(timeout) - TIMEOUT));
62
63		if (!((cmd->args[0] >> 7) & 0x01)) {
64			ret = -ETIMEDOUT;
65			goto err_mutex_unlock;
66		}
67	}
68
69	mutex_unlock(&dev->i2c_mutex);
70	return 0;
71
72err_mutex_unlock:
73	mutex_unlock(&dev->i2c_mutex);
74	dev_dbg(&client->dev, "failed=%d\n", ret);
75	return ret;
76}
77
78static int si2157_init(struct dvb_frontend *fe)
79{
80	struct i2c_client *client = fe->tuner_priv;
81	struct si2157_dev *dev = i2c_get_clientdata(client);
82	int ret, len, remaining;
83	struct si2157_cmd cmd;
84	const struct firmware *fw;
85	const char *fw_name;
86	unsigned int chip_id;
87
88	dev_dbg(&client->dev, "\n");
89
90	if (dev->fw_loaded)
91		goto warm;
92
93	/* power up */
94	if (dev->chiptype == SI2157_CHIPTYPE_SI2146) {
95		memcpy(cmd.args, "\xc0\x05\x01\x00\x00\x0b\x00\x00\x01", 9);
96		cmd.wlen = 9;
97	} else {
98		memcpy(cmd.args, "\xc0\x00\x0c\x00\x00\x01\x01\x01\x01\x01\x01\x02\x00\x00\x01", 15);
99		cmd.wlen = 15;
100	}
101	cmd.rlen = 1;
102	ret = si2157_cmd_execute(client, &cmd);
103	if (ret)
104		goto err;
105
106	/* query chip revision */
107	memcpy(cmd.args, "\x02", 1);
108	cmd.wlen = 1;
109	cmd.rlen = 13;
110	ret = si2157_cmd_execute(client, &cmd);
111	if (ret)
112		goto err;
113
114	chip_id = cmd.args[1] << 24 | cmd.args[2] << 16 | cmd.args[3] << 8 |
115			cmd.args[4] << 0;
116
117	#define SI2158_A20 ('A' << 24 | 58 << 16 | '2' << 8 | '0' << 0)
118	#define SI2148_A20 ('A' << 24 | 48 << 16 | '2' << 8 | '0' << 0)
119	#define SI2157_A30 ('A' << 24 | 57 << 16 | '3' << 8 | '0' << 0)
120	#define SI2147_A30 ('A' << 24 | 47 << 16 | '3' << 8 | '0' << 0)
121	#define SI2146_A10 ('A' << 24 | 46 << 16 | '1' << 8 | '0' << 0)
122
123	switch (chip_id) {
124	case SI2158_A20:
125	case SI2148_A20:
126		fw_name = SI2158_A20_FIRMWARE;
127		break;
128	case SI2157_A30:
129	case SI2147_A30:
130	case SI2146_A10:
131		fw_name = NULL;
132		break;
133	default:
134		dev_err(&client->dev, "unknown chip version Si21%d-%c%c%c\n",
135				cmd.args[2], cmd.args[1],
136				cmd.args[3], cmd.args[4]);
137		ret = -EINVAL;
138		goto err;
139	}
140
141	dev_info(&client->dev, "found a 'Silicon Labs Si21%d-%c%c%c'\n",
142			cmd.args[2], cmd.args[1], cmd.args[3], cmd.args[4]);
143
144	if (fw_name == NULL)
145		goto skip_fw_download;
146
147	/* request the firmware, this will block and timeout */
148	ret = request_firmware(&fw, fw_name, &client->dev);
149	if (ret) {
150		dev_err(&client->dev, "firmware file '%s' not found\n",
151				fw_name);
152		goto err;
153	}
154
155	/* firmware should be n chunks of 17 bytes */
156	if (fw->size % 17 != 0) {
157		dev_err(&client->dev, "firmware file '%s' is invalid\n",
158				fw_name);
159		ret = -EINVAL;
160		goto err_release_firmware;
161	}
162
163	dev_info(&client->dev, "downloading firmware from file '%s'\n",
164			fw_name);
165
166	for (remaining = fw->size; remaining > 0; remaining -= 17) {
167		len = fw->data[fw->size - remaining];
168		if (len > SI2157_ARGLEN) {
169			dev_err(&client->dev, "Bad firmware length\n");
170			ret = -EINVAL;
171			goto err_release_firmware;
172		}
173		memcpy(cmd.args, &fw->data[(fw->size - remaining) + 1], len);
174		cmd.wlen = len;
175		cmd.rlen = 1;
176		ret = si2157_cmd_execute(client, &cmd);
177		if (ret) {
178			dev_err(&client->dev, "firmware download failed %d\n",
179					ret);
180			goto err_release_firmware;
181		}
182	}
183
184	release_firmware(fw);
185
186skip_fw_download:
187	/* reboot the tuner with new firmware? */
188	memcpy(cmd.args, "\x01\x01", 2);
189	cmd.wlen = 2;
190	cmd.rlen = 1;
191	ret = si2157_cmd_execute(client, &cmd);
192	if (ret)
193		goto err;
194
195	/* query firmware version */
196	memcpy(cmd.args, "\x11", 1);
197	cmd.wlen = 1;
198	cmd.rlen = 10;
199	ret = si2157_cmd_execute(client, &cmd);
200	if (ret)
201		goto err;
202
203	dev_info(&client->dev, "firmware version: %c.%c.%d\n",
204			cmd.args[6], cmd.args[7], cmd.args[8]);
205
206	dev->fw_loaded = true;
207
208warm:
209	dev->active = true;
210	return 0;
211
212err_release_firmware:
213	release_firmware(fw);
214err:
215	dev_dbg(&client->dev, "failed=%d\n", ret);
216	return ret;
217}
218
219static int si2157_sleep(struct dvb_frontend *fe)
220{
221	struct i2c_client *client = fe->tuner_priv;
222	struct si2157_dev *dev = i2c_get_clientdata(client);
223	int ret;
224	struct si2157_cmd cmd;
225
226	dev_dbg(&client->dev, "\n");
227
228	dev->active = false;
229
230	/* standby */
231	memcpy(cmd.args, "\x16\x00", 2);
232	cmd.wlen = 2;
233	cmd.rlen = 1;
234	ret = si2157_cmd_execute(client, &cmd);
235	if (ret)
236		goto err;
237
238	return 0;
239err:
240	dev_dbg(&client->dev, "failed=%d\n", ret);
241	return ret;
242}
243
244static int si2157_set_params(struct dvb_frontend *fe)
245{
246	struct i2c_client *client = fe->tuner_priv;
247	struct si2157_dev *dev = i2c_get_clientdata(client);
248	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
249	int ret;
250	struct si2157_cmd cmd;
251	u8 bandwidth, delivery_system;
252	u32 if_frequency = 5000000;
253
254	dev_dbg(&client->dev,
255			"delivery_system=%d frequency=%u bandwidth_hz=%u\n",
256			c->delivery_system, c->frequency, c->bandwidth_hz);
257
258	if (!dev->active) {
259		ret = -EAGAIN;
260		goto err;
261	}
262
263	if (c->bandwidth_hz <= 6000000)
264		bandwidth = 0x06;
265	else if (c->bandwidth_hz <= 7000000)
266		bandwidth = 0x07;
267	else if (c->bandwidth_hz <= 8000000)
268		bandwidth = 0x08;
269	else
270		bandwidth = 0x0f;
271
272	switch (c->delivery_system) {
273	case SYS_ATSC:
274			delivery_system = 0x00;
275			if_frequency = 3250000;
276			break;
277	case SYS_DVBC_ANNEX_B:
278			delivery_system = 0x10;
279			if_frequency = 4000000;
280			break;
281	case SYS_DVBT:
282	case SYS_DVBT2: /* it seems DVB-T and DVB-T2 both are 0x20 here */
283			delivery_system = 0x20;
284			break;
285	case SYS_DVBC_ANNEX_A:
286			delivery_system = 0x30;
287			break;
288	default:
289			ret = -EINVAL;
290			goto err;
291	}
292
293	memcpy(cmd.args, "\x14\x00\x03\x07\x00\x00", 6);
294	cmd.args[4] = delivery_system | bandwidth;
295	if (dev->inversion)
296		cmd.args[5] = 0x01;
297	cmd.wlen = 6;
298	cmd.rlen = 4;
299	ret = si2157_cmd_execute(client, &cmd);
300	if (ret)
301		goto err;
302
303	if (dev->chiptype == SI2157_CHIPTYPE_SI2146)
304		memcpy(cmd.args, "\x14\x00\x02\x07\x00\x01", 6);
305	else
306		memcpy(cmd.args, "\x14\x00\x02\x07\x01\x00", 6);
307	cmd.wlen = 6;
308	cmd.rlen = 4;
309	ret = si2157_cmd_execute(client, &cmd);
310	if (ret)
311		goto err;
312
313	/* set if frequency if needed */
314	if (if_frequency != dev->if_frequency) {
315		memcpy(cmd.args, "\x14\x00\x06\x07", 4);
316		cmd.args[4] = (if_frequency / 1000) & 0xff;
317		cmd.args[5] = ((if_frequency / 1000) >> 8) & 0xff;
318		cmd.wlen = 6;
319		cmd.rlen = 4;
320		ret = si2157_cmd_execute(client, &cmd);
321		if (ret)
322			goto err;
323
324		dev->if_frequency = if_frequency;
325	}
326
327	/* set frequency */
328	memcpy(cmd.args, "\x41\x00\x00\x00\x00\x00\x00\x00", 8);
329	cmd.args[4] = (c->frequency >>  0) & 0xff;
330	cmd.args[5] = (c->frequency >>  8) & 0xff;
331	cmd.args[6] = (c->frequency >> 16) & 0xff;
332	cmd.args[7] = (c->frequency >> 24) & 0xff;
333	cmd.wlen = 8;
334	cmd.rlen = 1;
335	ret = si2157_cmd_execute(client, &cmd);
336	if (ret)
337		goto err;
338
339	return 0;
340err:
341	dev_dbg(&client->dev, "failed=%d\n", ret);
342	return ret;
343}
344
345static int si2157_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
346{
347	struct i2c_client *client = fe->tuner_priv;
348	struct si2157_dev *dev = i2c_get_clientdata(client);
349
350	*frequency = dev->if_frequency;
351	return 0;
352}
353
354static const struct dvb_tuner_ops si2157_ops = {
355	.info = {
356		.name           = "Silicon Labs Si2146/2147/2148/2157/2158",
357		.frequency_min  = 55000000,
358		.frequency_max  = 862000000,
359	},
360
361	.init = si2157_init,
362	.sleep = si2157_sleep,
363	.set_params = si2157_set_params,
364	.get_if_frequency = si2157_get_if_frequency,
365};
366
367static int si2157_probe(struct i2c_client *client,
368		const struct i2c_device_id *id)
369{
370	struct si2157_config *cfg = client->dev.platform_data;
371	struct dvb_frontend *fe = cfg->fe;
372	struct si2157_dev *dev;
373	struct si2157_cmd cmd;
374	int ret;
375
376	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
377	if (!dev) {
378		ret = -ENOMEM;
379		dev_err(&client->dev, "kzalloc() failed\n");
380		goto err;
381	}
382
383	i2c_set_clientdata(client, dev);
384	dev->fe = cfg->fe;
385	dev->inversion = cfg->inversion;
386	dev->fw_loaded = false;
387	dev->chiptype = (u8)id->driver_data;
388	dev->if_frequency = 5000000; /* default value of property 0x0706 */
389	mutex_init(&dev->i2c_mutex);
390
391	/* check if the tuner is there */
392	cmd.wlen = 0;
393	cmd.rlen = 1;
394	ret = si2157_cmd_execute(client, &cmd);
395	if (ret)
396		goto err_kfree;
397
398	memcpy(&fe->ops.tuner_ops, &si2157_ops, sizeof(struct dvb_tuner_ops));
399	fe->tuner_priv = client;
400
401	dev_info(&client->dev, "Silicon Labs %s successfully attached\n",
402			dev->chiptype == SI2157_CHIPTYPE_SI2146 ?
403			"Si2146" : "Si2147/2148/2157/2158");
404
405	return 0;
406
407err_kfree:
408	kfree(dev);
409err:
410	dev_dbg(&client->dev, "failed=%d\n", ret);
411	return ret;
412}
413
414static int si2157_remove(struct i2c_client *client)
415{
416	struct si2157_dev *dev = i2c_get_clientdata(client);
417	struct dvb_frontend *fe = dev->fe;
418
419	dev_dbg(&client->dev, "\n");
420
421	memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
422	fe->tuner_priv = NULL;
423	kfree(dev);
424
425	return 0;
426}
427
428static const struct i2c_device_id si2157_id_table[] = {
429	{"si2157", SI2157_CHIPTYPE_SI2157},
430	{"si2146", SI2157_CHIPTYPE_SI2146},
431	{}
432};
433MODULE_DEVICE_TABLE(i2c, si2157_id_table);
434
435static struct i2c_driver si2157_driver = {
436	.driver = {
437		.owner	= THIS_MODULE,
438		.name	= "si2157",
439	},
440	.probe		= si2157_probe,
441	.remove		= si2157_remove,
442	.id_table	= si2157_id_table,
443};
444
445module_i2c_driver(si2157_driver);
446
447MODULE_DESCRIPTION("Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner driver");
448MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
449MODULE_LICENSE("GPL");
450MODULE_FIRMWARE(SI2158_A20_FIRMWARE);
451