drivers/staging/media/mn88472/mn88472.c

   1 /*
   2  * Panasonic MN88472 DVB-T/T2/C demodulator driver
   3  *
   4  * Copyright (C) 2013 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 "mn88472_priv.h"
  18
  19 static int mn88472_get_tune_settings(struct dvb_frontend *fe,
  20         struct dvb_frontend_tune_settings *s)
  21 {
  22         s->min_delay_ms = 400;
  23         return 0;
  24 }
  25
  26 static int mn88472_set_frontend(struct dvb_frontend *fe)
  27 {
  28         struct i2c_client *client = fe->demodulator_priv;
  29         struct mn88472_dev *dev = i2c_get_clientdata(client);
  30         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
  31         int ret, i;
  32         u32 if_frequency = 0;
  33         u64 tmp;
  34         u8 delivery_system_val, if_val[3], bw_val[7], bw_val2;
  35
  36         dev_dbg(&client->dev,
  37                         "delivery_system=%d modulation=%d frequency=%d symbol_rate=%d inversion=%d\n",
  38                         c->delivery_system, c->modulation,
  39                         c->frequency, c->symbol_rate, c->inversion);
  40
  41         if (!dev->warm) {
  42                 ret = -EAGAIN;
  43                 goto err;
  44         }
  45
  46         switch (c->delivery_system) {
  47         case SYS_DVBT:
  48                 delivery_system_val = 0x02;
  49                 break;
  50         case SYS_DVBT2:
  51                 delivery_system_val = 0x03;
  52                 break;
  53         case SYS_DVBC_ANNEX_A:
  54                 delivery_system_val = 0x04;
  55                 break;
  56         default:
  57                 ret = -EINVAL;
  58                 goto err;
  59         }
  60
  61         if (c->bandwidth_hz <= 5000000) {
  62                 memcpy(bw_val, "\xe5\x99\x9a\x1b\xa9\x1b\xa9", 7);
  63                 bw_val2 = 0x03;
  64         } else if (c->bandwidth_hz <= 6000000) {
  65                 /* IF 3570000 Hz, BW 6000000 Hz */
  66                 memcpy(bw_val, "\xbf\x55\x55\x15\x6b\x15\x6b", 7);
  67                 bw_val2 = 0x02;
  68         } else if (c->bandwidth_hz <= 7000000) {
  69                 /* IF 4570000 Hz, BW 7000000 Hz */
  70                 memcpy(bw_val, "\xa4\x00\x00\x0f\x2c\x0f\x2c", 7);
  71                 bw_val2 = 0x01;
  72         } else if (c->bandwidth_hz <= 8000000) {
  73                 /* IF 4570000 Hz, BW 8000000 Hz */
  74                 memcpy(bw_val, "\x8f\x80\x00\x08\xee\x08\xee", 7);
  75                 bw_val2 = 0x00;
  76         } else {
  77                 ret = -EINVAL;
  78                 goto err;
  79         }
  80
  81         /* program tuner */
  82         if (fe->ops.tuner_ops.set_params) {
  83                 ret = fe->ops.tuner_ops.set_params(fe);
  84                 if (ret)
  85                         goto err;
  86         }
  87
  88         if (fe->ops.tuner_ops.get_if_frequency) {
  89                 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
  90                 if (ret)
  91                         goto err;
  92
  93                 dev_dbg(&client->dev, "get_if_frequency=%d\n", if_frequency);
  94         }
  95
  96         /* Calculate IF registers ( (1<<24)*IF / Xtal ) */
  97         tmp =  div_u64(if_frequency * (u64)(1<<24) + (dev->xtal / 2),
  98                                    dev->xtal);
  99         if_val[0] = ((tmp >> 16) & 0xff);
 100         if_val[1] = ((tmp >>  8) & 0xff);
 101         if_val[2] = ((tmp >>  0) & 0xff);
 102
 103         ret = regmap_write(dev->regmap[2], 0xfb, 0x13);
 104         ret = regmap_write(dev->regmap[2], 0xef, 0x13);
 105         ret = regmap_write(dev->regmap[2], 0xf9, 0x13);
 106         if (ret)
 107                 goto err;
 108
 109         ret = regmap_write(dev->regmap[2], 0x00, 0x66);
 110         if (ret)
 111                 goto err;
 112         ret = regmap_write(dev->regmap[2], 0x01, 0x00);
 113         if (ret)
 114                 goto err;
 115         ret = regmap_write(dev->regmap[2], 0x02, 0x01);
 116         if (ret)
 117                 goto err;
 118         ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val);
 119         if (ret)
 120                 goto err;
 121         ret = regmap_write(dev->regmap[2], 0x04, bw_val2);
 122         if (ret)
 123                 goto err;
 124
 125         for (i = 0; i < sizeof(if_val); i++) {
 126                 ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]);
 127                 if (ret)
 128                         goto err;
 129         }
 130
 131         for (i = 0; i < sizeof(bw_val); i++) {
 132                 ret = regmap_write(dev->regmap[2], 0x13 + i, bw_val[i]);
 133                 if (ret)
 134                         goto err;
 135         }
 136
 137         switch (c->delivery_system) {
 138         case SYS_DVBT:
 139                 ret = regmap_write(dev->regmap[0], 0x07, 0x26);
 140                 ret = regmap_write(dev->regmap[0], 0xb0, 0x0a);
 141                 ret = regmap_write(dev->regmap[0], 0xb4, 0x00);
 142                 ret = regmap_write(dev->regmap[0], 0xcd, 0x1f);
 143                 ret = regmap_write(dev->regmap[0], 0xd4, 0x0a);
 144                 ret = regmap_write(dev->regmap[0], 0xd6, 0x48);
 145                 ret = regmap_write(dev->regmap[0], 0x00, 0xba);
 146                 ret = regmap_write(dev->regmap[0], 0x01, 0x13);
 147                 if (ret)
 148                         goto err;
 149                 break;
 150         case SYS_DVBT2:
 151                 ret = regmap_write(dev->regmap[2], 0x2b, 0x13);
 152                 ret = regmap_write(dev->regmap[2], 0x4f, 0x05);
 153                 ret = regmap_write(dev->regmap[1], 0xf6, 0x05);
 154                 ret = regmap_write(dev->regmap[0], 0xb0, 0x0a);
 155                 ret = regmap_write(dev->regmap[0], 0xb4, 0xf6);
 156                 ret = regmap_write(dev->regmap[0], 0xcd, 0x01);
 157                 ret = regmap_write(dev->regmap[0], 0xd4, 0x09);
 158                 ret = regmap_write(dev->regmap[0], 0xd6, 0x46);
 159                 ret = regmap_write(dev->regmap[2], 0x30, 0x80);
 160                 ret = regmap_write(dev->regmap[2], 0x32, 0x00);
 161                 if (ret)
 162                         goto err;
 163                 break;
 164         case SYS_DVBC_ANNEX_A:
 165                 ret = regmap_write(dev->regmap[0], 0xb0, 0x0b);
 166                 ret = regmap_write(dev->regmap[0], 0xb4, 0x00);
 167                 ret = regmap_write(dev->regmap[0], 0xcd, 0x17);
 168                 ret = regmap_write(dev->regmap[0], 0xd4, 0x09);
 169                 ret = regmap_write(dev->regmap[0], 0xd6, 0x48);
 170                 ret = regmap_write(dev->regmap[1], 0x00, 0xb0);
 171                 if (ret)
 172                         goto err;
 173                 break;
 174         default:
 175                 ret = -EINVAL;
 176                 goto err;
 177         }
 178
 179         ret = regmap_write(dev->regmap[0], 0x46, 0x00);
 180         ret = regmap_write(dev->regmap[0], 0xae, 0x00);
 181         ret = regmap_write(dev->regmap[2], 0x08, 0x1d);
 182         ret = regmap_write(dev->regmap[0], 0xd9, 0xe3);
 183
 184         /* Reset demod */
 185         ret = regmap_write(dev->regmap[2], 0xf8, 0x9f);
 186         if (ret)
 187                 goto err;
 188
 189         dev->delivery_system = c->delivery_system;
 190
 191         return 0;
 192 err:
 193         dev_dbg(&client->dev, "failed=%d\n", ret);
 194         return ret;
 195 }
 196
 197 static int mn88472_read_status(struct dvb_frontend *fe, fe_status_t *status)
 198 {
 199         struct i2c_client *client = fe->demodulator_priv;
 200         struct mn88472_dev *dev = i2c_get_clientdata(client);
 201         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 202         int ret;
 203         unsigned int utmp;
 204
 205         *status = 0;
 206
 207         if (!dev->warm) {
 208                 ret = -EAGAIN;
 209                 goto err;
 210         }
 211
 212         switch (c->delivery_system) {
 213         case SYS_DVBT:
 214         case SYS_DVBT2:
 215                 /* FIXME: implement me */
 216                 utmp = 0x08; /* DVB-C lock value */
 217                 break;
 218         case SYS_DVBC_ANNEX_A:
 219                 ret = regmap_read(dev->regmap[1], 0x84, &utmp);
 220                 if (ret)
 221                         goto err;
 222                 break;
 223         default:
 224                 ret = -EINVAL;
 225                 goto err;
 226         }
 227
 228         if (utmp == 0x08)
 229                 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
 230                                 FE_HAS_SYNC | FE_HAS_LOCK;
 231
 232         return 0;
 233 err:
 234         dev_dbg(&client->dev, "failed=%d\n", ret);
 235         return ret;
 236 }
 237
 238 static int mn88472_init(struct dvb_frontend *fe)
 239 {
 240         struct i2c_client *client = fe->demodulator_priv;
 241         struct mn88472_dev *dev = i2c_get_clientdata(client);
 242         int ret, len, remaining;
 243         const struct firmware *fw = NULL;
 244         u8 *fw_file = MN88472_FIRMWARE;
 245
 246         dev_dbg(&client->dev, "\n");
 247
 248         /* set cold state by default */
 249         dev->warm = false;
 250
 251         /* power on */
 252         ret = regmap_write(dev->regmap[2], 0x05, 0x00);
 253         if (ret)
 254                 goto err;
 255
 256         ret = regmap_bulk_write(dev->regmap[2], 0x0b, "\x00\x00", 2);
 257         if (ret)
 258                 goto err;
 259
 260         /* request the firmware, this will block and timeout */
 261         ret = request_firmware(&fw, fw_file, &client->dev);
 262         if (ret) {
 263                 dev_err(&client->dev, "firmare file '%s' not found\n",
 264                                 fw_file);
 265                 goto err;
 266         }
 267
 268         dev_info(&client->dev, "downloading firmware from file '%s'\n",
 269                         fw_file);
 270
 271         ret = regmap_write(dev->regmap[0], 0xf5, 0x03);
 272         if (ret)
 273                 goto err;
 274
 275         for (remaining = fw->size; remaining > 0;
 276                         remaining -= (dev->i2c_wr_max - 1)) {
 277                 len = remaining;
 278                 if (len > (dev->i2c_wr_max - 1))
 279                         len = (dev->i2c_wr_max - 1);
 280
 281                 ret = regmap_bulk_write(dev->regmap[0], 0xf6,
 282                                 &fw->data[fw->size - remaining], len);
 283                 if (ret) {
 284                         dev_err(&client->dev,
 285                                         "firmware download failed=%d\n", ret);
 286                         goto err;
 287                 }
 288         }
 289
 290         ret = regmap_write(dev->regmap[0], 0xf5, 0x00);
 291         if (ret)
 292                 goto err;
 293
 294         release_firmware(fw);
 295         fw = NULL;
 296
 297         /* warm state */
 298         dev->warm = true;
 299
 300         return 0;
 301 err:
 302         if (fw)
 303                 release_firmware(fw);
 304
 305         dev_dbg(&client->dev, "failed=%d\n", ret);
 306         return ret;
 307 }
 308
 309 static int mn88472_sleep(struct dvb_frontend *fe)
 310 {
 311         struct i2c_client *client = fe->demodulator_priv;
 312         struct mn88472_dev *dev = i2c_get_clientdata(client);
 313         int ret;
 314
 315         dev_dbg(&client->dev, "\n");
 316
 317         /* power off */
 318         ret = regmap_write(dev->regmap[2], 0x0b, 0x30);
 319
 320         if (ret)
 321                 goto err;
 322
 323         ret = regmap_write(dev->regmap[2], 0x05, 0x3e);
 324         if (ret)
 325                 goto err;
 326
 327         dev->delivery_system = SYS_UNDEFINED;
 328
 329         return 0;
 330 err:
 331         dev_dbg(&client->dev, "failed=%d\n", ret);
 332         return ret;
 333 }
 334
 335 static struct dvb_frontend_ops mn88472_ops = {
 336         .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A},
 337         .info = {
 338                 .name = "Panasonic MN88472",
 339                 .caps = FE_CAN_FEC_1_2                 |
 340                         FE_CAN_FEC_2_3                 |
 341                         FE_CAN_FEC_3_4                 |
 342                         FE_CAN_FEC_5_6                 |
 343                         FE_CAN_FEC_7_8                 |
 344                         FE_CAN_FEC_AUTO                |
 345                         FE_CAN_QPSK                    |
 346                         FE_CAN_QAM_16                  |
 347                         FE_CAN_QAM_32                  |
 348                         FE_CAN_QAM_64                  |
 349                         FE_CAN_QAM_128                 |
 350                         FE_CAN_QAM_256                 |
 351                         FE_CAN_QAM_AUTO                |
 352                         FE_CAN_TRANSMISSION_MODE_AUTO  |
 353                         FE_CAN_GUARD_INTERVAL_AUTO     |
 354                         FE_CAN_HIERARCHY_AUTO          |
 355                         FE_CAN_MUTE_TS                 |
 356                         FE_CAN_2G_MODULATION           |
 357                         FE_CAN_MULTISTREAM
 358         },
 359
 360         .get_tune_settings = mn88472_get_tune_settings,
 361
 362         .init = mn88472_init,
 363         .sleep = mn88472_sleep,
 364
 365         .set_frontend = mn88472_set_frontend,
 366
 367         .read_status = mn88472_read_status,
 368 };
 369
 370 static int mn88472_probe(struct i2c_client *client,
 371                 const struct i2c_device_id *id)
 372 {
 373         struct mn88472_config *config = client->dev.platform_data;
 374         struct mn88472_dev *dev;
 375         int ret;
 376         unsigned int utmp;
 377         static const struct regmap_config regmap_config = {
 378                 .reg_bits = 8,
 379                 .val_bits = 8,
 380         };
 381
 382         dev_dbg(&client->dev, "\n");
 383
 384         /* Caller really need to provide pointer for frontend we create. */
 385         if (config->fe == NULL) {
 386                 dev_err(&client->dev, "frontend pointer not defined\n");
 387                 ret = -EINVAL;
 388                 goto err;
 389         }
 390
 391         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 392         if (dev == NULL) {
 393                 ret = -ENOMEM;
 394                 goto err;
 395         }
 396
 397         dev->i2c_wr_max = config->i2c_wr_max;
 398         dev->xtal = config->xtal;
 399         dev->client[0] = client;
 400         dev->regmap[0] = regmap_init_i2c(dev->client[0], &regmap_config);
 401         if (IS_ERR(dev->regmap[0])) {
 402                 ret = PTR_ERR(dev->regmap[0]);
 403                 goto err_kfree;
 404         }
 405
 406         /* check demod answers to I2C */
 407         ret = regmap_read(dev->regmap[0], 0x00, &utmp);
 408         if (ret)
 409                 goto err_regmap_0_regmap_exit;
 410
 411         /*
 412          * Chip has three I2C addresses for different register pages. Used
 413          * addresses are 0x18, 0x1a and 0x1c. We register two dummy clients,
 414          * 0x1a and 0x1c, in order to get own I2C client for each register page.
 415          */
 416         dev->client[1] = i2c_new_dummy(client->adapter, 0x1a);
 417         if (dev->client[1] == NULL) {
 418                 ret = -ENODEV;
 419                 dev_err(&client->dev, "I2C registration failed\n");
 420                 if (ret)
 421                         goto err_regmap_0_regmap_exit;
 422         }
 423         dev->regmap[1] = regmap_init_i2c(dev->client[1], &regmap_config);
 424         if (IS_ERR(dev->regmap[1])) {
 425                 ret = PTR_ERR(dev->regmap[1]);
 426                 goto err_client_1_i2c_unregister_device;
 427         }
 428         i2c_set_clientdata(dev->client[1], dev);
 429
 430         dev->client[2] = i2c_new_dummy(client->adapter, 0x1c);
 431         if (dev->client[2] == NULL) {
 432                 ret = -ENODEV;
 433                 dev_err(&client->dev, "2nd I2C registration failed\n");
 434                 if (ret)
 435                         goto err_regmap_1_regmap_exit;
 436         }
 437         dev->regmap[2] = regmap_init_i2c(dev->client[2], &regmap_config);
 438         if (IS_ERR(dev->regmap[2])) {
 439                 ret = PTR_ERR(dev->regmap[2]);
 440                 goto err_client_2_i2c_unregister_device;
 441         }
 442         i2c_set_clientdata(dev->client[2], dev);
 443
 444         /* create dvb_frontend */
 445         memcpy(&dev->fe.ops, &mn88472_ops, sizeof(struct dvb_frontend_ops));
 446         dev->fe.demodulator_priv = client;
 447         *config->fe = &dev->fe;
 448         i2c_set_clientdata(client, dev);
 449
 450         dev_info(&client->dev, "Panasonic MN88472 successfully attached\n");
 451         return 0;
 452
 453 err_client_2_i2c_unregister_device:
 454         i2c_unregister_device(dev->client[2]);
 455 err_regmap_1_regmap_exit:
 456         regmap_exit(dev->regmap[1]);
 457 err_client_1_i2c_unregister_device:
 458         i2c_unregister_device(dev->client[1]);
 459 err_regmap_0_regmap_exit:
 460         regmap_exit(dev->regmap[0]);
 461 err_kfree:
 462         kfree(dev);
 463 err:
 464         dev_dbg(&client->dev, "failed=%d\n", ret);
 465         return ret;
 466 }
 467
 468 static int mn88472_remove(struct i2c_client *client)
 469 {
 470         struct mn88472_dev *dev = i2c_get_clientdata(client);
 471
 472         dev_dbg(&client->dev, "\n");
 473
 474         regmap_exit(dev->regmap[2]);
 475         i2c_unregister_device(dev->client[2]);
 476
 477         regmap_exit(dev->regmap[1]);
 478         i2c_unregister_device(dev->client[1]);
 479
 480         regmap_exit(dev->regmap[0]);
 481
 482         kfree(dev);
 483
 484         return 0;
 485 }
 486
 487 static const struct i2c_device_id mn88472_id_table[] = {
 488         {"mn88472", 0},
 489         {}
 490 };
 491 MODULE_DEVICE_TABLE(i2c, mn88472_id_table);
 492
 493 static struct i2c_driver mn88472_driver = {
 494         .driver = {
 495                 .owner  = THIS_MODULE,
 496                 .name   = "mn88472",
 497         },
 498         .probe          = mn88472_probe,
 499         .remove         = mn88472_remove,
 500         .id_table       = mn88472_id_table,
 501 };
 502
 503 module_i2c_driver(mn88472_driver);
 504
 505 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 506 MODULE_DESCRIPTION("Panasonic MN88472 DVB-T/T2/C demodulator driver");
 507 MODULE_LICENSE("GPL");
 508 MODULE_FIRMWARE(MN88472_FIRMWARE);