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