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 19 static const struct dvb_tuner_ops si2157_ops; 20 21 /* execute firmware command */ 22 static 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 /* 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 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 /* 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 81 static 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 /* power up */ 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 /* query chip revision */ 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 /* cold state - try to download firmware */ 144 dev_info(&s->client->dev, "found a '%s' in cold state\n", 145 si2157_ops.info.name); 146 147 /* request the firmware, this will block and timeout */ 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 /* firmware should be n chunks of 17 bytes */ 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 183 skip_fw_download: 184 /* reboot the tuner with new firmware? */ 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 194 warm: 195 s->active = true; 196 return 0; 197 198 fw_release_exit: 199 release_firmware(fw); 200 err: 201 dev_dbg(&s->client->dev, "failed=%d\n", ret); 202 return ret; 203 } 204 205 static 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 /* standby */ 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; 224 err: 225 dev_dbg(&s->client->dev, "failed=%d\n", ret); 226 return ret; 227 } 228 229 static 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: /* it seems DVB-T and DVB-T2 both are 0x20 here */ 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 /* set frequency */ 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; 308 err: 309 dev_dbg(&s->client->dev, "failed=%d\n", ret); 310 return ret; 311 } 312 313 static int si2157_get_if_frequency(struct dvb_frontend *fe, u32 *frequency) 314 { 315 *frequency = 5000000; /* default value of property 0x0706 */ 316 return 0; 317 } 318 319 static 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 332 static 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 /* check if the tuner is there */ 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; 374 err: 375 dev_dbg(&client->dev, "failed=%d\n", ret); 376 kfree(s); 377 378 return ret; 379 } 380 381 static 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 395 static const struct i2c_device_id si2157_id[] = { 396 {"si2157", 0}, 397 {"si2146", 1}, 398 {} 399 }; 400 MODULE_DEVICE_TABLE(i2c, si2157_id); 401 402 static 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 412 module_i2c_driver(si2157_driver); 413 414 MODULE_DESCRIPTION("Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner driver"); 415 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 416 MODULE_LICENSE("GPL"); 417 MODULE_FIRMWARE(SI2158_A20_FIRMWARE); 418