drivers/media/pci/cobalt/cobalt-i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  cobalt I2C functions
   4  *
   5  *  Derived from cx18-i2c.c
   6  *
   7  *  Copyright 2012-2015 Cisco Systems, Inc. and/or its affiliates.
   8  *  All rights reserved.
   9  */
  10
  11 #include "cobalt-driver.h"
  12 #include "cobalt-i2c.h"
  13
  14 struct cobalt_i2c_regs {
  15         /* Clock prescaler register lo-byte */
  16         u8 prerlo;
  17         u8 dummy0[3];
  18         /* Clock prescaler register high-byte */
  19         u8 prerhi;
  20         u8 dummy1[3];
  21         /* Control register */
  22         u8 ctr;
  23         u8 dummy2[3];
  24         /* Transmit/Receive register */
  25         u8 txr_rxr;
  26         u8 dummy3[3];
  27         /* Command and Status register */
  28         u8 cr_sr;
  29         u8 dummy4[3];
  30 };
  31
  32 /* CTR[7:0] - Control register */
  33
  34 /* I2C Core enable bit */
  35 #define M00018_CTR_BITMAP_EN_MSK        (1 << 7)
  36
  37 /* I2C Core interrupt enable bit */
  38 #define M00018_CTR_BITMAP_IEN_MSK       (1 << 6)
  39
  40 /* CR[7:0] - Command register */
  41
  42 /* I2C start condition */
  43 #define M00018_CR_BITMAP_STA_MSK        (1 << 7)
  44
  45 /* I2C stop condition */
  46 #define M00018_CR_BITMAP_STO_MSK        (1 << 6)
  47
  48 /* I2C read from slave */
  49 #define M00018_CR_BITMAP_RD_MSK         (1 << 5)
  50
  51 /* I2C write to slave */
  52 #define M00018_CR_BITMAP_WR_MSK         (1 << 4)
  53
  54 /* I2C ack */
  55 #define M00018_CR_BITMAP_ACK_MSK        (1 << 3)
  56
  57 /* I2C Interrupt ack */
  58 #define M00018_CR_BITMAP_IACK_MSK       (1 << 0)
  59
  60 /* SR[7:0] - Status register */
  61
  62 /* Receive acknowledge from slave */
  63 #define M00018_SR_BITMAP_RXACK_MSK      (1 << 7)
  64
  65 /* Busy, I2C bus busy (as defined by start / stop bits) */
  66 #define M00018_SR_BITMAP_BUSY_MSK       (1 << 6)
  67
  68 /* Arbitration lost - core lost arbitration */
  69 #define M00018_SR_BITMAP_AL_MSK         (1 << 5)
  70
  71 /* Transfer in progress */
  72 #define M00018_SR_BITMAP_TIP_MSK        (1 << 1)
  73
  74 /* Interrupt flag */
  75 #define M00018_SR_BITMAP_IF_MSK         (1 << 0)
  76
  77 /* Frequency, in Hz */
  78 #define I2C_FREQUENCY                   400000
  79 #define ALT_CPU_FREQ                    83333333
  80
  81 static struct cobalt_i2c_regs __iomem *
  82 cobalt_i2c_regs(struct cobalt *cobalt, unsigned idx)
  83 {
  84         switch (idx) {
  85         case 0:
  86         default:
  87                 return (struct cobalt_i2c_regs __iomem *)
  88                         (cobalt->bar1 + COBALT_I2C_0_BASE);
  89         case 1:
  90                 return (struct cobalt_i2c_regs __iomem *)
  91                         (cobalt->bar1 + COBALT_I2C_1_BASE);
  92         case 2:
  93                 return (struct cobalt_i2c_regs __iomem *)
  94                         (cobalt->bar1 + COBALT_I2C_2_BASE);
  95         case 3:
  96                 return (struct cobalt_i2c_regs __iomem *)
  97                         (cobalt->bar1 + COBALT_I2C_3_BASE);
  98         case 4:
  99                 return (struct cobalt_i2c_regs __iomem *)
 100                         (cobalt->bar1 + COBALT_I2C_HSMA_BASE);
 101         }
 102 }
 103
 104 /* Do low-level i2c byte transfer.
 105  * Returns -1 in case of an error or 0 otherwise.
 106  */
 107 static int cobalt_tx_bytes(struct cobalt_i2c_regs __iomem *regs,
 108                 struct i2c_adapter *adap, bool start, bool stop,
 109                 u8 *data, u16 len)
 110 {
 111         unsigned long start_time;
 112         int status;
 113         int cmd;
 114         int i;
 115
 116         for (i = 0; i < len; i++) {
 117                 /* Setup data */
 118                 iowrite8(data[i], &regs->txr_rxr);
 119
 120                 /* Setup command */
 121                 if (i == 0 && start) {
 122                         /* Write + Start */
 123                         cmd = M00018_CR_BITMAP_WR_MSK |
 124                               M00018_CR_BITMAP_STA_MSK;
 125                 } else if (i == len - 1 && stop) {
 126                         /* Write + Stop */
 127                         cmd = M00018_CR_BITMAP_WR_MSK |
 128                               M00018_CR_BITMAP_STO_MSK;
 129                 } else {
 130                         /* Write only */
 131                         cmd = M00018_CR_BITMAP_WR_MSK;
 132                 }
 133
 134                 /* Execute command */
 135                 iowrite8(cmd, &regs->cr_sr);
 136
 137                 /* Wait for transfer to complete (TIP = 0) */
 138                 start_time = jiffies;
 139                 status = ioread8(&regs->cr_sr);
 140                 while (status & M00018_SR_BITMAP_TIP_MSK) {
 141                         if (time_after(jiffies, start_time + adap->timeout))
 142                                 return -ETIMEDOUT;
 143                         cond_resched();
 144                         status = ioread8(&regs->cr_sr);
 145                 }
 146
 147                 /* Verify ACK */
 148                 if (status & M00018_SR_BITMAP_RXACK_MSK) {
 149                         /* NO ACK! */
 150                         return -EIO;
 151                 }
 152
 153                 /* Verify arbitration */
 154                 if (status & M00018_SR_BITMAP_AL_MSK) {
 155                         /* Arbitration lost! */
 156                         return -EIO;
 157                 }
 158         }
 159         return 0;
 160 }
 161
 162 /* Do low-level i2c byte read.
 163  * Returns -1 in case of an error or 0 otherwise.
 164  */
 165 static int cobalt_rx_bytes(struct cobalt_i2c_regs __iomem *regs,
 166                 struct i2c_adapter *adap, bool start, bool stop,
 167                 u8 *data, u16 len)
 168 {
 169         unsigned long start_time;
 170         int status;
 171         int cmd;
 172         int i;
 173
 174         for (i = 0; i < len; i++) {
 175                 /* Setup command */
 176                 if (i == 0 && start) {
 177                         /* Read + Start */
 178                         cmd = M00018_CR_BITMAP_RD_MSK |
 179                               M00018_CR_BITMAP_STA_MSK;
 180                 } else if (i == len - 1 && stop) {
 181                         /* Read + Stop */
 182                         cmd = M00018_CR_BITMAP_RD_MSK |
 183                               M00018_CR_BITMAP_STO_MSK;
 184                 } else {
 185                         /* Read only */
 186                         cmd = M00018_CR_BITMAP_RD_MSK;
 187                 }
 188
 189                 /* Last byte to read, no ACK */
 190                 if (i == len - 1)
 191                         cmd |= M00018_CR_BITMAP_ACK_MSK;
 192
 193                 /* Execute command */
 194                 iowrite8(cmd, &regs->cr_sr);
 195
 196                 /* Wait for transfer to complete (TIP = 0) */
 197                 start_time = jiffies;
 198                 status = ioread8(&regs->cr_sr);
 199                 while (status & M00018_SR_BITMAP_TIP_MSK) {
 200                         if (time_after(jiffies, start_time + adap->timeout))
 201                                 return -ETIMEDOUT;
 202                         cond_resched();
 203                         status = ioread8(&regs->cr_sr);
 204                 }
 205
 206                 /* Verify arbitration */
 207                 if (status & M00018_SR_BITMAP_AL_MSK) {
 208                         /* Arbitration lost! */
 209                         return -EIO;
 210                 }
 211
 212                 /* Store data */
 213                 data[i] = ioread8(&regs->txr_rxr);
 214         }
 215         return 0;
 216 }
 217
 218 /* Generate stop condition on i2c bus.
 219  * The m00018 stop isn't doing the right thing (wrong timing).
 220  * So instead send a start condition, 8 zeroes and a stop condition.
 221  */
 222 static int cobalt_stop(struct cobalt_i2c_regs __iomem *regs,
 223                 struct i2c_adapter *adap)
 224 {
 225         u8 data = 0;
 226
 227         return cobalt_tx_bytes(regs, adap, true, true, &data, 1);
 228 }
 229
 230 static int cobalt_xfer(struct i2c_adapter *adap,
 231                         struct i2c_msg msgs[], int num)
 232 {
 233         struct cobalt_i2c_data *data = adap->algo_data;
 234         struct cobalt_i2c_regs __iomem *regs = data->regs;
 235         struct i2c_msg *pmsg;
 236         unsigned short flags;
 237         int ret = 0;
 238         int i, j;
 239
 240         for (i = 0; i < num; i++) {
 241                 int stop = (i == num - 1);
 242
 243                 pmsg = &msgs[i];
 244                 flags = pmsg->flags;
 245
 246                 if (!(pmsg->flags & I2C_M_NOSTART)) {
 247                         u8 addr = pmsg->addr << 1;
 248
 249                         if (flags & I2C_M_RD)
 250                                 addr |= 1;
 251                         if (flags & I2C_M_REV_DIR_ADDR)
 252                                 addr ^= 1;
 253                         for (j = 0; j < adap->retries; j++) {
 254                                 ret = cobalt_tx_bytes(regs, adap, true, false,
 255                                                       &addr, 1);
 256                                 if (!ret)
 257                                         break;
 258                                 cobalt_stop(regs, adap);
 259                         }
 260                         if (ret < 0)
 261                                 return ret;
 262                         ret = 0;
 263                 }
 264                 if (pmsg->flags & I2C_M_RD) {
 265                         /* read bytes into buffer */
 266                         ret = cobalt_rx_bytes(regs, adap, false, stop,
 267                                         pmsg->buf, pmsg->len);
 268                         if (ret < 0)
 269                                 goto bailout;
 270                 } else {
 271                         /* write bytes from buffer */
 272                         ret = cobalt_tx_bytes(regs, adap, false, stop,
 273                                         pmsg->buf, pmsg->len);
 274                         if (ret < 0)
 275                                 goto bailout;
 276                 }
 277         }
 278         ret = i;
 279
 280 bailout:
 281         if (ret < 0)
 282                 cobalt_stop(regs, adap);
 283         return ret;
 284 }
 285
 286 static u32 cobalt_func(struct i2c_adapter *adap)
 287 {
 288         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 289 }
 290
 291 /* template for i2c-bit-algo */
 292 static const struct i2c_adapter cobalt_i2c_adap_template = {
 293         .name = "cobalt i2c driver",
 294         .algo = NULL,                   /* set by i2c-algo-bit */
 295         .algo_data = NULL,              /* filled from template */
 296         .owner = THIS_MODULE,
 297 };
 298
 299 static const struct i2c_algorithm cobalt_algo = {
 300         .master_xfer    = cobalt_xfer,
 301         .functionality  = cobalt_func,
 302 };
 303
 304 /* init + register i2c algo-bit adapter */
 305 int cobalt_i2c_init(struct cobalt *cobalt)
 306 {
 307         int i, err;
 308         int status;
 309         int prescale;
 310         unsigned long start_time;
 311
 312         cobalt_dbg(1, "i2c init\n");
 313
 314         /* Define I2C clock prescaler */
 315         prescale = ((ALT_CPU_FREQ) / (5 * I2C_FREQUENCY)) - 1;
 316
 317         for (i = 0; i < COBALT_NUM_ADAPTERS; i++) {
 318                 struct cobalt_i2c_regs __iomem *regs =
 319                         cobalt_i2c_regs(cobalt, i);
 320                 struct i2c_adapter *adap = &cobalt->i2c_adap[i];
 321
 322                 /* Disable I2C */
 323                 iowrite8(M00018_CTR_BITMAP_EN_MSK, &regs->cr_sr);
 324                 iowrite8(0, &regs->ctr);
 325                 iowrite8(0, &regs->cr_sr);
 326
 327                 start_time = jiffies;
 328                 do {
 329                         if (time_after(jiffies, start_time + HZ)) {
 330                                 if (cobalt_ignore_err) {
 331                                         adap->dev.parent = NULL;
 332                                         return 0;
 333                                 }
 334                                 return -ETIMEDOUT;
 335                         }
 336                         status = ioread8(&regs->cr_sr);
 337                 } while (status & M00018_SR_BITMAP_TIP_MSK);
 338
 339                 /* Disable I2C */
 340                 iowrite8(0, &regs->ctr);
 341                 iowrite8(0, &regs->cr_sr);
 342
 343                 /* Calculate i2c prescaler */
 344                 iowrite8(prescale & 0xff, &regs->prerlo);
 345                 iowrite8((prescale >> 8) & 0xff, &regs->prerhi);
 346                 /* Enable I2C, interrupts disabled */
 347                 iowrite8(M00018_CTR_BITMAP_EN_MSK, &regs->ctr);
 348                 /* Setup algorithm for adapter */
 349                 cobalt->i2c_data[i].cobalt = cobalt;
 350                 cobalt->i2c_data[i].regs = regs;
 351                 *adap = cobalt_i2c_adap_template;
 352                 adap->algo = &cobalt_algo;
 353                 adap->algo_data = &cobalt->i2c_data[i];
 354                 adap->retries = 3;
 355                 sprintf(adap->name + strlen(adap->name),
 356                                 " #%d-%d", cobalt->instance, i);
 357                 i2c_set_adapdata(adap, &cobalt->v4l2_dev);
 358                 adap->dev.parent = &cobalt->pci_dev->dev;
 359                 err = i2c_add_adapter(adap);
 360                 if (err) {
 361                         if (cobalt_ignore_err) {
 362                                 adap->dev.parent = NULL;
 363                                 return 0;
 364                         }
 365                         while (i--)
 366                                 i2c_del_adapter(&cobalt->i2c_adap[i]);
 367                         return err;
 368                 }
 369                 cobalt_info("registered bus %s\n", adap->name);
 370         }
 371         return 0;
 372 }
 373
 374 void cobalt_i2c_exit(struct cobalt *cobalt)
 375 {
 376         int i;
 377
 378         cobalt_dbg(1, "i2c exit\n");
 379
 380         for (i = 0; i < COBALT_NUM_ADAPTERS; i++) {
 381                 cobalt_err("unregistered bus %s\n", cobalt->i2c_adap[i].name);
 382                 i2c_del_adapter(&cobalt->i2c_adap[i]);
 383         }
 384 }