drivers/media/dvb/frontends/dibx000_common.c

   1 #include <linux/i2c.h>
   2 #include <linux/mutex.h>
   3 #include <linux/module.h>
   4
   5 #include "dibx000_common.h"
   6
   7 static int debug;
   8 module_param(debug, int, 0644);
   9 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
  10
  11 #define dprintk(args...) do { if (debug) { printk(KERN_DEBUG "DiBX000: "); printk(args); printk("\n"); } } while (0)
  12
  13 static int dibx000_write_word(struct dibx000_i2c_master *mst, u16 reg, u16 val)
  14 {
  15         int ret;
  16
  17         if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
  18                 dprintk("could not acquire lock");
  19                 return -EINVAL;
  20         }
  21
  22         mst->i2c_write_buffer[0] = (reg >> 8) & 0xff;
  23         mst->i2c_write_buffer[1] = reg & 0xff;
  24         mst->i2c_write_buffer[2] = (val >> 8) & 0xff;
  25         mst->i2c_write_buffer[3] = val & 0xff;
  26
  27         memset(mst->msg, 0, sizeof(struct i2c_msg));
  28         mst->msg[0].addr = mst->i2c_addr;
  29         mst->msg[0].flags = 0;
  30         mst->msg[0].buf = mst->i2c_write_buffer;
  31         mst->msg[0].len = 4;
  32
  33         ret = i2c_transfer(mst->i2c_adap, mst->msg, 1) != 1 ? -EREMOTEIO : 0;
  34         mutex_unlock(&mst->i2c_buffer_lock);
  35
  36         return ret;
  37 }
  38
  39 static u16 dibx000_read_word(struct dibx000_i2c_master *mst, u16 reg)
  40 {
  41         u16 ret;
  42
  43         if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
  44                 dprintk("could not acquire lock");
  45                 return 0;
  46         }
  47
  48         mst->i2c_write_buffer[0] = reg >> 8;
  49         mst->i2c_write_buffer[1] = reg & 0xff;
  50
  51         memset(mst->msg, 0, 2 * sizeof(struct i2c_msg));
  52         mst->msg[0].addr = mst->i2c_addr;
  53         mst->msg[0].flags = 0;
  54         mst->msg[0].buf = mst->i2c_write_buffer;
  55         mst->msg[0].len = 2;
  56         mst->msg[1].addr = mst->i2c_addr;
  57         mst->msg[1].flags = I2C_M_RD;
  58         mst->msg[1].buf = mst->i2c_read_buffer;
  59         mst->msg[1].len = 2;
  60
  61         if (i2c_transfer(mst->i2c_adap, mst->msg, 2) != 2)
  62                 dprintk("i2c read error on %d", reg);
  63
  64         ret = (mst->i2c_read_buffer[0] << 8) | mst->i2c_read_buffer[1];
  65         mutex_unlock(&mst->i2c_buffer_lock);
  66
  67         return ret;
  68 }
  69
  70 static int dibx000_is_i2c_done(struct dibx000_i2c_master *mst)
  71 {
  72         int i = 100;
  73         u16 status;
  74
  75         while (((status = dibx000_read_word(mst, mst->base_reg + 2)) & 0x0100) == 0 && --i > 0)
  76                 ;
  77
  78         /* i2c timed out */
  79         if (i == 0)
  80                 return -EREMOTEIO;
  81
  82         /* no acknowledge */
  83         if ((status & 0x0080) == 0)
  84                 return -EREMOTEIO;
  85
  86         return 0;
  87 }
  88
  89 static int dibx000_master_i2c_write(struct dibx000_i2c_master *mst, struct i2c_msg *msg, u8 stop)
  90 {
  91         u16 data;
  92         u16 da;
  93         u16 i;
  94         u16 txlen = msg->len, len;
  95         const u8 *b = msg->buf;
  96
  97         while (txlen) {
  98                 dibx000_read_word(mst, mst->base_reg + 2);
  99
 100                 len = txlen > 8 ? 8 : txlen;
 101                 for (i = 0; i < len; i += 2) {
 102                         data = *b++ << 8;
 103                         if (i+1 < len)
 104                                 data |= *b++;
 105                         dibx000_write_word(mst, mst->base_reg, data);
 106                 }
 107                 da = (((u8) (msg->addr))  << 9) |
 108                         (1           << 8) |
 109                         (1           << 7) |
 110                         (0           << 6) |
 111                         (0           << 5) |
 112                         ((len & 0x7) << 2) |
 113                         (0           << 1) |
 114                         (0           << 0);
 115
 116                 if (txlen == msg->len)
 117                         da |= 1 << 5; /* start */
 118
 119                 if (txlen-len == 0 && stop)
 120                         da |= 1 << 6; /* stop */
 121
 122                 dibx000_write_word(mst, mst->base_reg+1, da);
 123
 124                 if (dibx000_is_i2c_done(mst) != 0)
 125                         return -EREMOTEIO;
 126                 txlen -= len;
 127         }
 128
 129         return 0;
 130 }
 131
 132 static int dibx000_master_i2c_read(struct dibx000_i2c_master *mst, struct i2c_msg *msg)
 133 {
 134         u16 da;
 135         u8 *b = msg->buf;
 136         u16 rxlen = msg->len, len;
 137
 138         while (rxlen) {
 139                 len = rxlen > 8 ? 8 : rxlen;
 140                 da = (((u8) (msg->addr)) << 9) |
 141                         (1           << 8) |
 142                         (1           << 7) |
 143                         (0           << 6) |
 144                         (0           << 5) |
 145                         ((len & 0x7) << 2) |
 146                         (1           << 1) |
 147                         (0           << 0);
 148
 149                 if (rxlen == msg->len)
 150                         da |= 1 << 5; /* start */
 151
 152                 if (rxlen-len == 0)
 153                         da |= 1 << 6; /* stop */
 154                 dibx000_write_word(mst, mst->base_reg+1, da);
 155
 156                 if (dibx000_is_i2c_done(mst) != 0)
 157                         return -EREMOTEIO;
 158
 159                 rxlen -= len;
 160
 161                 while (len) {
 162                         da = dibx000_read_word(mst, mst->base_reg);
 163                         *b++ = (da >> 8) & 0xff;
 164                         len--;
 165                         if (len >= 1) {
 166                                 *b++ =  da   & 0xff;
 167                                 len--;
 168                         }
 169                 }
 170         }
 171
 172         return 0;
 173 }
 174
 175 int dibx000_i2c_set_speed(struct i2c_adapter *i2c_adap, u16 speed)
 176 {
 177         struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);
 178
 179         if (mst->device_rev < DIB7000MC && speed < 235)
 180                 speed = 235;
 181         return dibx000_write_word(mst, mst->base_reg + 3, (u16)(60000 / speed));
 182
 183 }
 184 EXPORT_SYMBOL(dibx000_i2c_set_speed);
 185
 186 static u32 dibx000_i2c_func(struct i2c_adapter *adapter)
 187 {
 188         return I2C_FUNC_I2C;
 189 }
 190
 191 static int dibx000_i2c_select_interface(struct dibx000_i2c_master *mst,
 192                                         enum dibx000_i2c_interface intf)
 193 {
 194         if (mst->device_rev > DIB3000MC && mst->selected_interface != intf) {
 195                 dprintk("selecting interface: %d", intf);
 196                 mst->selected_interface = intf;
 197                 return dibx000_write_word(mst, mst->base_reg + 4, intf);
 198         }
 199         return 0;
 200 }
 201
 202 static int dibx000_i2c_master_xfer_gpio12(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
 203 {
 204         struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);
 205         int msg_index;
 206         int ret = 0;
 207
 208         dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_GPIO_1_2);
 209         for (msg_index = 0; msg_index < num; msg_index++) {
 210                 if (msg[msg_index].flags & I2C_M_RD) {
 211                         ret = dibx000_master_i2c_read(mst, &msg[msg_index]);
 212                         if (ret != 0)
 213                                 return 0;
 214                 } else {
 215                         ret = dibx000_master_i2c_write(mst, &msg[msg_index], 1);
 216                         if (ret != 0)
 217                                 return 0;
 218                 }
 219         }
 220
 221         return num;
 222 }
 223
 224 static int dibx000_i2c_master_xfer_gpio34(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
 225 {
 226         struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);
 227         int msg_index;
 228         int ret = 0;
 229
 230         dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_GPIO_3_4);
 231         for (msg_index = 0; msg_index < num; msg_index++) {
 232                 if (msg[msg_index].flags & I2C_M_RD) {
 233                         ret = dibx000_master_i2c_read(mst, &msg[msg_index]);
 234                         if (ret != 0)
 235                                 return 0;
 236                 } else {
 237                         ret = dibx000_master_i2c_write(mst, &msg[msg_index], 1);
 238                         if (ret != 0)
 239                                 return 0;
 240                 }
 241         }
 242
 243         return num;
 244 }
 245
 246 static struct i2c_algorithm dibx000_i2c_master_gpio12_xfer_algo = {
 247         .master_xfer = dibx000_i2c_master_xfer_gpio12,
 248         .functionality = dibx000_i2c_func,
 249 };
 250
 251 static struct i2c_algorithm dibx000_i2c_master_gpio34_xfer_algo = {
 252         .master_xfer = dibx000_i2c_master_xfer_gpio34,
 253         .functionality = dibx000_i2c_func,
 254 };
 255
 256 static int dibx000_i2c_gate_ctrl(struct dibx000_i2c_master *mst, u8 tx[4],
 257                                  u8 addr, int onoff)
 258 {
 259         u16 val;
 260
 261
 262         if (onoff)
 263                 val = addr << 8;        // bit 7 = use master or not, if 0, the gate is open
 264         else
 265                 val = 1 << 7;
 266
 267         if (mst->device_rev > DIB7000)
 268                 val <<= 1;
 269
 270         tx[0] = (((mst->base_reg + 1) >> 8) & 0xff);
 271         tx[1] = ((mst->base_reg + 1) & 0xff);
 272         tx[2] = val >> 8;
 273         tx[3] = val & 0xff;
 274
 275         return 0;
 276 }
 277
 278 static int dibx000_i2c_gated_gpio67_xfer(struct i2c_adapter *i2c_adap,
 279                                         struct i2c_msg msg[], int num)
 280 {
 281         struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);
 282         int ret;
 283
 284         if (num > 32) {
 285                 dprintk("%s: too much I2C message to be transmitted (%i).\
 286                                 Maximum is 32", __func__, num);
 287                 return -ENOMEM;
 288         }
 289
 290         dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_GPIO_6_7);
 291
 292         if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
 293                 dprintk("could not acquire lock");
 294                 return -EINVAL;
 295         }
 296
 297         memset(mst->msg, 0, sizeof(struct i2c_msg) * (2 + num));
 298
 299         /* open the gate */
 300         dibx000_i2c_gate_ctrl(mst, &mst->i2c_write_buffer[0], msg[0].addr, 1);
 301         mst->msg[0].addr = mst->i2c_addr;
 302         mst->msg[0].buf = &mst->i2c_write_buffer[0];
 303         mst->msg[0].len = 4;
 304
 305         memcpy(&mst->msg[1], msg, sizeof(struct i2c_msg) * num);
 306
 307         /* close the gate */
 308         dibx000_i2c_gate_ctrl(mst, &mst->i2c_write_buffer[4], 0, 0);
 309         mst->msg[num + 1].addr = mst->i2c_addr;
 310         mst->msg[num + 1].buf = &mst->i2c_write_buffer[4];
 311         mst->msg[num + 1].len = 4;
 312
 313         ret = (i2c_transfer(mst->i2c_adap, mst->msg, 2 + num) == 2 + num ?
 314                         num : -EIO);
 315
 316         mutex_unlock(&mst->i2c_buffer_lock);
 317         return ret;
 318 }
 319
 320 static struct i2c_algorithm dibx000_i2c_gated_gpio67_algo = {
 321         .master_xfer = dibx000_i2c_gated_gpio67_xfer,
 322         .functionality = dibx000_i2c_func,
 323 };
 324
 325 static int dibx000_i2c_gated_tuner_xfer(struct i2c_adapter *i2c_adap,
 326                                         struct i2c_msg msg[], int num)
 327 {
 328         struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);
 329         int ret;
 330
 331         if (num > 32) {
 332                 dprintk("%s: too much I2C message to be transmitted (%i).\
 333                                 Maximum is 32", __func__, num);
 334                 return -ENOMEM;
 335         }
 336
 337         dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_TUNER);
 338
 339         if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
 340                 dprintk("could not acquire lock");
 341                 return -EINVAL;
 342         }
 343         memset(mst->msg, 0, sizeof(struct i2c_msg) * (2 + num));
 344
 345         /* open the gate */
 346         dibx000_i2c_gate_ctrl(mst, &mst->i2c_write_buffer[0], msg[0].addr, 1);
 347         mst->msg[0].addr = mst->i2c_addr;
 348         mst->msg[0].buf = &mst->i2c_write_buffer[0];
 349         mst->msg[0].len = 4;
 350
 351         memcpy(&mst->msg[1], msg, sizeof(struct i2c_msg) * num);
 352
 353         /* close the gate */
 354         dibx000_i2c_gate_ctrl(mst, &mst->i2c_write_buffer[4], 0, 0);
 355         mst->msg[num + 1].addr = mst->i2c_addr;
 356         mst->msg[num + 1].buf = &mst->i2c_write_buffer[4];
 357         mst->msg[num + 1].len = 4;
 358
 359         ret = (i2c_transfer(mst->i2c_adap, mst->msg, 2 + num) == 2 + num ?
 360                         num : -EIO);
 361         mutex_unlock(&mst->i2c_buffer_lock);
 362         return ret;
 363 }
 364
 365 static struct i2c_algorithm dibx000_i2c_gated_tuner_algo = {
 366         .master_xfer = dibx000_i2c_gated_tuner_xfer,
 367         .functionality = dibx000_i2c_func,
 368 };
 369
 370 struct i2c_adapter *dibx000_get_i2c_adapter(struct dibx000_i2c_master *mst,
 371                                                 enum dibx000_i2c_interface intf,
 372                                                 int gating)
 373 {
 374         struct i2c_adapter *i2c = NULL;
 375
 376         switch (intf) {
 377         case DIBX000_I2C_INTERFACE_TUNER:
 378                 if (gating)
 379                         i2c = &mst->gated_tuner_i2c_adap;
 380                 break;
 381         case DIBX000_I2C_INTERFACE_GPIO_1_2:
 382                 if (!gating)
 383                         i2c = &mst->master_i2c_adap_gpio12;
 384                 break;
 385         case DIBX000_I2C_INTERFACE_GPIO_3_4:
 386                 if (!gating)
 387                         i2c = &mst->master_i2c_adap_gpio34;
 388                 break;
 389         case DIBX000_I2C_INTERFACE_GPIO_6_7:
 390                 if (gating)
 391                         i2c = &mst->master_i2c_adap_gpio67;
 392                 break;
 393         default:
 394                 printk(KERN_ERR "DiBX000: incorrect I2C interface selected\n");
 395                 break;
 396         }
 397
 398         return i2c;
 399 }
 400
 401 EXPORT_SYMBOL(dibx000_get_i2c_adapter);
 402
 403 void dibx000_reset_i2c_master(struct dibx000_i2c_master *mst)
 404 {
 405         /* initialize the i2c-master by closing the gate */
 406         u8 tx[4];
 407         struct i2c_msg m = {.addr = mst->i2c_addr,.buf = tx,.len = 4 };
 408
 409         dibx000_i2c_gate_ctrl(mst, tx, 0, 0);
 410         i2c_transfer(mst->i2c_adap, &m, 1);
 411         mst->selected_interface = 0xff; // the first time force a select of the I2C
 412         dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_TUNER);
 413 }
 414
 415 EXPORT_SYMBOL(dibx000_reset_i2c_master);
 416
 417 static int i2c_adapter_init(struct i2c_adapter *i2c_adap,
 418                                 struct i2c_algorithm *algo, const char *name,
 419                                 struct dibx000_i2c_master *mst)
 420 {
 421         strncpy(i2c_adap->name, name, sizeof(i2c_adap->name));
 422         i2c_adap->algo = algo;
 423         i2c_adap->algo_data = NULL;
 424         i2c_set_adapdata(i2c_adap, mst);
 425         if (i2c_add_adapter(i2c_adap) < 0)
 426                 return -ENODEV;
 427         return 0;
 428 }
 429
 430 int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev,
 431                                 struct i2c_adapter *i2c_adap, u8 i2c_addr)
 432 {
 433         int ret;
 434
 435         mutex_init(&mst->i2c_buffer_lock);
 436         if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
 437                 dprintk("could not acquire lock");
 438                 return -EINVAL;
 439         }
 440         memset(mst->msg, 0, sizeof(struct i2c_msg));
 441         mst->msg[0].addr = i2c_addr >> 1;
 442         mst->msg[0].flags = 0;
 443         mst->msg[0].buf = mst->i2c_write_buffer;
 444         mst->msg[0].len = 4;
 445
 446         mst->device_rev = device_rev;
 447         mst->i2c_adap = i2c_adap;
 448         mst->i2c_addr = i2c_addr >> 1;
 449
 450         if (device_rev == DIB7000P || device_rev == DIB8000)
 451                 mst->base_reg = 1024;
 452         else
 453                 mst->base_reg = 768;
 454
 455         mst->gated_tuner_i2c_adap.dev.parent = mst->i2c_adap->dev.parent;
 456         if (i2c_adapter_init
 457                         (&mst->gated_tuner_i2c_adap, &dibx000_i2c_gated_tuner_algo,
 458                          "DiBX000 tuner I2C bus", mst) != 0)
 459                 printk(KERN_ERR
 460                                 "DiBX000: could not initialize the tuner i2c_adapter\n");
 461
 462         mst->master_i2c_adap_gpio12.dev.parent = mst->i2c_adap->dev.parent;
 463         if (i2c_adapter_init
 464                         (&mst->master_i2c_adap_gpio12, &dibx000_i2c_master_gpio12_xfer_algo,
 465                          "DiBX000 master GPIO12 I2C bus", mst) != 0)
 466                 printk(KERN_ERR
 467                                 "DiBX000: could not initialize the master i2c_adapter\n");
 468
 469         mst->master_i2c_adap_gpio34.dev.parent = mst->i2c_adap->dev.parent;
 470         if (i2c_adapter_init
 471                         (&mst->master_i2c_adap_gpio34, &dibx000_i2c_master_gpio34_xfer_algo,
 472                          "DiBX000 master GPIO34 I2C bus", mst) != 0)
 473                 printk(KERN_ERR
 474                                 "DiBX000: could not initialize the master i2c_adapter\n");
 475
 476         mst->master_i2c_adap_gpio67.dev.parent = mst->i2c_adap->dev.parent;
 477         if (i2c_adapter_init
 478                         (&mst->master_i2c_adap_gpio67, &dibx000_i2c_gated_gpio67_algo,
 479                          "DiBX000 master GPIO67 I2C bus", mst) != 0)
 480                 printk(KERN_ERR
 481                                 "DiBX000: could not initialize the master i2c_adapter\n");
 482
 483         /* initialize the i2c-master by closing the gate */
 484         dibx000_i2c_gate_ctrl(mst, mst->i2c_write_buffer, 0, 0);
 485
 486         ret = (i2c_transfer(i2c_adap, mst->msg, 1) == 1);
 487         mutex_unlock(&mst->i2c_buffer_lock);
 488
 489         return ret;
 490 }
 491
 492 EXPORT_SYMBOL(dibx000_init_i2c_master);
 493
 494 void dibx000_exit_i2c_master(struct dibx000_i2c_master *mst)
 495 {
 496         i2c_del_adapter(&mst->gated_tuner_i2c_adap);
 497         i2c_del_adapter(&mst->master_i2c_adap_gpio12);
 498         i2c_del_adapter(&mst->master_i2c_adap_gpio34);
 499         i2c_del_adapter(&mst->master_i2c_adap_gpio67);
 500 }
 501 EXPORT_SYMBOL(dibx000_exit_i2c_master);
 502
 503
 504 u32 systime(void)
 505 {
 506         struct timespec t;
 507
 508         t = current_kernel_time();
 509         return (t.tv_sec * 10000) + (t.tv_nsec / 100000);
 510 }
 511 EXPORT_SYMBOL(systime);
 512
 513 MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>");
 514 MODULE_DESCRIPTION("Common function the DiBcom demodulator family");
 515 MODULE_LICENSE("GPL");