drivers/net/sfc/i2c-direct.c

   1 /****************************************************************************
   2  * Driver for Solarflare Solarstorm network controllers and boards
   3  * Copyright 2005 Fen Systems Ltd.
   4  * Copyright 2006-2008 Solarflare Communications Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation, incorporated herein by reference.
   9  */
  10
  11 #include <linux/delay.h>
  12 #include "net_driver.h"
  13 #include "i2c-direct.h"
  14
  15 /*
  16  * I2C data (SDA) and clock (SCL) line read/writes with appropriate
  17  * delays.
  18  */
  19
  20 static inline void setsda(struct efx_i2c_interface *i2c, int state)
  21 {
  22         udelay(i2c->op->udelay);
  23         i2c->sda = state;
  24         i2c->op->setsda(i2c);
  25         udelay(i2c->op->udelay);
  26 }
  27
  28 static inline void setscl(struct efx_i2c_interface *i2c, int state)
  29 {
  30         udelay(i2c->op->udelay);
  31         i2c->scl = state;
  32         i2c->op->setscl(i2c);
  33         udelay(i2c->op->udelay);
  34 }
  35
  36 static inline int getsda(struct efx_i2c_interface *i2c)
  37 {
  38         int sda;
  39
  40         udelay(i2c->op->udelay);
  41         sda = i2c->op->getsda(i2c);
  42         udelay(i2c->op->udelay);
  43         return sda;
  44 }
  45
  46 static inline int getscl(struct efx_i2c_interface *i2c)
  47 {
  48         int scl;
  49
  50         udelay(i2c->op->udelay);
  51         scl = i2c->op->getscl(i2c);
  52         udelay(i2c->op->udelay);
  53         return scl;
  54 }
  55
  56 /*
  57  * I2C low-level protocol operations
  58  *
  59  */
  60
  61 static inline void i2c_release(struct efx_i2c_interface *i2c)
  62 {
  63         EFX_WARN_ON_PARANOID(!i2c->scl);
  64         EFX_WARN_ON_PARANOID(!i2c->sda);
  65         /* Devices may time out if operations do not end */
  66         setscl(i2c, 1);
  67         setsda(i2c, 1);
  68         EFX_BUG_ON_PARANOID(getsda(i2c) != 1);
  69         EFX_BUG_ON_PARANOID(getscl(i2c) != 1);
  70 }
  71
  72 static inline void i2c_start(struct efx_i2c_interface *i2c)
  73 {
  74         /* We may be restarting immediately after a {send,recv}_bit,
  75          * so SCL will not necessarily already be high.
  76          */
  77         EFX_WARN_ON_PARANOID(!i2c->sda);
  78         setscl(i2c, 1);
  79         setsda(i2c, 0);
  80         setscl(i2c, 0);
  81         setsda(i2c, 1);
  82 }
  83
  84 static inline void i2c_send_bit(struct efx_i2c_interface *i2c, int bit)
  85 {
  86         EFX_WARN_ON_PARANOID(i2c->scl != 0);
  87         setsda(i2c, bit);
  88         setscl(i2c, 1);
  89         setscl(i2c, 0);
  90         setsda(i2c, 1);
  91 }
  92
  93 static inline int i2c_recv_bit(struct efx_i2c_interface *i2c)
  94 {
  95         int bit;
  96
  97         EFX_WARN_ON_PARANOID(i2c->scl != 0);
  98         EFX_WARN_ON_PARANOID(!i2c->sda);
  99         setscl(i2c, 1);
 100         bit = getsda(i2c);
 101         setscl(i2c, 0);
 102         return bit;
 103 }
 104
 105 static inline void i2c_stop(struct efx_i2c_interface *i2c)
 106 {
 107         EFX_WARN_ON_PARANOID(i2c->scl != 0);
 108         setsda(i2c, 0);
 109         setscl(i2c, 1);
 110         setsda(i2c, 1);
 111 }
 112
 113 /*
 114  * I2C mid-level protocol operations
 115  *
 116  */
 117
 118 /* Sends a byte via the I2C bus and checks for an acknowledgement from
 119  * the slave device.
 120  */
 121 static int i2c_send_byte(struct efx_i2c_interface *i2c, u8 byte)
 122 {
 123         int i;
 124
 125         /* Send byte */
 126         for (i = 0; i < 8; i++) {
 127                 i2c_send_bit(i2c, !!(byte & 0x80));
 128                 byte <<= 1;
 129         }
 130
 131         /* Check for acknowledgement from slave */
 132         return (i2c_recv_bit(i2c) == 0 ? 0 : -EIO);
 133 }
 134
 135 /* Receives a byte via the I2C bus and sends ACK/NACK to the slave device. */
 136 static u8 i2c_recv_byte(struct efx_i2c_interface *i2c, int ack)
 137 {
 138         u8 value = 0;
 139         int i;
 140
 141         /* Receive byte */
 142         for (i = 0; i < 8; i++)
 143                 value = (value << 1) | i2c_recv_bit(i2c);
 144
 145         /* Send ACK/NACK */
 146         i2c_send_bit(i2c, (ack ? 0 : 1));
 147
 148         return value;
 149 }
 150
 151 /* Calculate command byte for a read operation */
 152 static inline u8 i2c_read_cmd(u8 device_id)
 153 {
 154         return ((device_id << 1) | 1);
 155 }
 156
 157 /* Calculate command byte for a write operation */
 158 static inline u8 i2c_write_cmd(u8 device_id)
 159 {
 160         return ((device_id << 1) | 0);
 161 }
 162
 163 int efx_i2c_check_presence(struct efx_i2c_interface *i2c, u8 device_id)
 164 {
 165         int rc;
 166
 167         /* If someone is driving the bus low we just give up. */
 168         if (getsda(i2c) == 0 || getscl(i2c) == 0) {
 169                 EFX_ERR(i2c->efx, "%s someone is holding the I2C bus low."
 170                         " Giving up.\n", __func__);
 171                 return -EFAULT;
 172         }
 173
 174         /* Pretend to initiate a device write */
 175         i2c_start(i2c);
 176         rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
 177         if (rc)
 178                 goto out;
 179
 180  out:
 181         i2c_stop(i2c);
 182         i2c_release(i2c);
 183
 184         return rc;
 185 }
 186
 187 /* This performs a fast read of one or more consecutive bytes from an
 188  * I2C device.  Not all devices support consecutive reads of more than
 189  * one byte; for these devices use efx_i2c_read() instead.
 190  */
 191 int efx_i2c_fast_read(struct efx_i2c_interface *i2c,
 192                       u8 device_id, u8 offset, u8 *data, unsigned int len)
 193 {
 194         int i;
 195         int rc;
 196
 197         EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
 198         EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
 199         EFX_WARN_ON_PARANOID(data == NULL);
 200         EFX_WARN_ON_PARANOID(len < 1);
 201
 202         /* Select device and starting offset */
 203         i2c_start(i2c);
 204         rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
 205         if (rc)
 206                 goto out;
 207         rc = i2c_send_byte(i2c, offset);
 208         if (rc)
 209                 goto out;
 210
 211         /* Read data from device */
 212         i2c_start(i2c);
 213         rc = i2c_send_byte(i2c, i2c_read_cmd(device_id));
 214         if (rc)
 215                 goto out;
 216         for (i = 0; i < (len - 1); i++)
 217                 /* Read and acknowledge all but the last byte */
 218                 data[i] = i2c_recv_byte(i2c, 1);
 219         /* Read last byte with no acknowledgement */
 220         data[i] = i2c_recv_byte(i2c, 0);
 221
 222  out:
 223         i2c_stop(i2c);
 224         i2c_release(i2c);
 225
 226         return rc;
 227 }
 228
 229 /* This performs a fast write of one or more consecutive bytes to an
 230  * I2C device.  Not all devices support consecutive writes of more
 231  * than one byte; for these devices use efx_i2c_write() instead.
 232  */
 233 int efx_i2c_fast_write(struct efx_i2c_interface *i2c,
 234                        u8 device_id, u8 offset,
 235                        const u8 *data, unsigned int len)
 236 {
 237         int i;
 238         int rc;
 239
 240         EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
 241         EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
 242         EFX_WARN_ON_PARANOID(len < 1);
 243
 244         /* Select device and starting offset */
 245         i2c_start(i2c);
 246         rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
 247         if (rc)
 248                 goto out;
 249         rc = i2c_send_byte(i2c, offset);
 250         if (rc)
 251                 goto out;
 252
 253         /* Write data to device */
 254         for (i = 0; i < len; i++) {
 255                 rc = i2c_send_byte(i2c, data[i]);
 256                 if (rc)
 257                         goto out;
 258         }
 259
 260  out:
 261         i2c_stop(i2c);
 262         i2c_release(i2c);
 263
 264         return rc;
 265 }
 266
 267 /* I2C byte-by-byte read */
 268 int efx_i2c_read(struct efx_i2c_interface *i2c,
 269                  u8 device_id, u8 offset, u8 *data, unsigned int len)
 270 {
 271         int rc;
 272
 273         /* i2c_fast_read with length 1 is a single byte read */
 274         for (; len > 0; offset++, data++, len--) {
 275                 rc = efx_i2c_fast_read(i2c, device_id, offset, data, 1);
 276                 if (rc)
 277                         return rc;
 278         }
 279
 280         return 0;
 281 }
 282
 283 /* I2C byte-by-byte write */
 284 int efx_i2c_write(struct efx_i2c_interface *i2c,
 285                   u8 device_id, u8 offset, const u8 *data, unsigned int len)
 286 {
 287         int rc;
 288
 289         /* i2c_fast_write with length 1 is a single byte write */
 290         for (; len > 0; offset++, data++, len--) {
 291                 rc = efx_i2c_fast_write(i2c, device_id, offset, data, 1);
 292                 if (rc)
 293                         return rc;
 294                 mdelay(i2c->op->mdelay);
 295         }
 296
 297         return 0;
 298 }
 299
 300
 301 /* This is just a slightly neater wrapper round efx_i2c_fast_write
 302  * in the case where the target doesn't take an offset
 303  */
 304 int efx_i2c_send_bytes(struct efx_i2c_interface *i2c,
 305                        u8 device_id, const u8 *data, unsigned int len)
 306 {
 307         return efx_i2c_fast_write(i2c, device_id, data[0], data + 1, len - 1);
 308 }
 309
 310 /* I2C receiving of bytes - does not send an offset byte */
 311 int efx_i2c_recv_bytes(struct efx_i2c_interface *i2c, u8 device_id,
 312                        u8 *bytes, unsigned int len)
 313 {
 314         int i;
 315         int rc;
 316
 317         EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
 318         EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
 319         EFX_WARN_ON_PARANOID(len < 1);
 320
 321         /* Select device */
 322         i2c_start(i2c);
 323
 324         /* Read data from device */
 325         rc = i2c_send_byte(i2c, i2c_read_cmd(device_id));
 326         if (rc)
 327                 goto out;
 328
 329         for (i = 0; i < (len - 1); i++)
 330                 /* Read and acknowledge all but the last byte */
 331                 bytes[i] = i2c_recv_byte(i2c, 1);
 332         /* Read last byte with no acknowledgement */
 333         bytes[i] = i2c_recv_byte(i2c, 0);
 334
 335  out:
 336         i2c_stop(i2c);
 337         i2c_release(i2c);
 338
 339         return rc;
 340 }
 341
 342 /* SMBus and some I2C devices will time out if the I2C clock is
 343  * held low for too long. This is most likely to happen in virtualised
 344  * systems (when the entire domain is descheduled) but could in
 345  * principle happen due to preemption on any busy system (and given the
 346  * potential length of an I2C operation turning preemption off is not
 347  * a sensible option). The following functions deal with the failure by
 348  * retrying up to a fixed number of times.
 349   */
 350
 351 #define I2C_MAX_RETRIES (10)
 352
 353 /* The timeout problem will result in -EIO. If the wrapped function
 354  * returns any other error, pass this up and do not retry. */
 355 #define RETRY_WRAPPER(_f) \
 356         int retries = I2C_MAX_RETRIES; \
 357         int rc; \
 358         while (retries) { \
 359                 rc = _f; \
 360                 if (rc != -EIO) \
 361                         return rc; \
 362                 retries--; \
 363         } \
 364         return rc; \
 365
 366 int efx_i2c_check_presence_retry(struct efx_i2c_interface *i2c, u8 device_id)
 367 {
 368         RETRY_WRAPPER(efx_i2c_check_presence(i2c, device_id))
 369 }
 370
 371 int efx_i2c_read_retry(struct efx_i2c_interface *i2c,
 372                  u8 device_id, u8 offset, u8 *data, unsigned int len)
 373 {
 374         RETRY_WRAPPER(efx_i2c_read(i2c, device_id, offset, data, len))
 375 }
 376
 377 int efx_i2c_write_retry(struct efx_i2c_interface *i2c,
 378                   u8 device_id, u8 offset, const u8 *data, unsigned int len)
 379 {
 380         RETRY_WRAPPER(efx_i2c_write(i2c, device_id, offset, data, len))
 381 }