drivers/i2c/busses/i2c-pasemi.c

   1 /*
   2  * Copyright (C) 2006-2007 PA Semi, Inc
   3  *
   4  * SMBus host driver for PA Semi PWRficient
   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 version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/pci.h>
  22 #include <linux/kernel.h>
  23 #include <linux/stddef.h>
  24 #include <linux/sched.h>
  25 #include <linux/i2c.h>
  26 #include <linux/delay.h>
  27 #include <asm/io.h>
  28
  29 static struct pci_driver pasemi_smb_driver;
  30
  31 struct pasemi_smbus {
  32         struct pci_dev          *dev;
  33         struct i2c_adapter       adapter;
  34         unsigned long            base;
  35         int                      size;
  36 };
  37
  38 /* Register offsets */
  39 #define REG_MTXFIFO     0x00
  40 #define REG_MRXFIFO     0x04
  41 #define REG_SMSTA       0x14
  42 #define REG_CTL         0x1c
  43
  44 /* Register defs */
  45 #define MTXFIFO_READ    0x00000400
  46 #define MTXFIFO_STOP    0x00000200
  47 #define MTXFIFO_START   0x00000100
  48 #define MTXFIFO_DATA_M  0x000000ff
  49
  50 #define MRXFIFO_EMPTY   0x00000100
  51 #define MRXFIFO_DATA_M  0x000000ff
  52
  53 #define SMSTA_XEN       0x08000000
  54 #define SMSTA_MTN       0x00200000
  55
  56 #define CTL_MRR         0x00000400
  57 #define CTL_MTR         0x00000200
  58 #define CTL_CLK_M       0x000000ff
  59
  60 #define CLK_100K_DIV    84
  61 #define CLK_400K_DIV    21
  62
  63 static inline void reg_write(struct pasemi_smbus *smbus, int reg, int val)
  64 {
  65         dev_dbg(&smbus->dev->dev, "smbus write reg %lx val %08x\n",
  66                 smbus->base + reg, val);
  67         outl(val, smbus->base + reg);
  68 }
  69
  70 static inline int reg_read(struct pasemi_smbus *smbus, int reg)
  71 {
  72         int ret;
  73         ret = inl(smbus->base + reg);
  74         dev_dbg(&smbus->dev->dev, "smbus read reg %lx val %08x\n",
  75                 smbus->base + reg, ret);
  76         return ret;
  77 }
  78
  79 #define TXFIFO_WR(smbus, reg)   reg_write((smbus), REG_MTXFIFO, (reg))
  80 #define RXFIFO_RD(smbus)        reg_read((smbus), REG_MRXFIFO)
  81
  82 static void pasemi_smb_clear(struct pasemi_smbus *smbus)
  83 {
  84         unsigned int status;
  85
  86         status = reg_read(smbus, REG_SMSTA);
  87         reg_write(smbus, REG_SMSTA, status);
  88 }
  89
  90 static unsigned int pasemi_smb_waitready(struct pasemi_smbus *smbus)
  91 {
  92         int timeout = 10;
  93         unsigned int status;
  94
  95         status = reg_read(smbus, REG_SMSTA);
  96
  97         while (!(status & SMSTA_XEN) && timeout--) {
  98                 msleep(1);
  99                 status = reg_read(smbus, REG_SMSTA);
 100         }
 101
 102         /* Got NACK? */
 103         if (status & SMSTA_MTN)
 104                 return -ENXIO;
 105
 106         if (timeout < 0) {
 107                 dev_warn(&smbus->dev->dev, "Timeout, status 0x%08x\n", status);
 108                 reg_write(smbus, REG_SMSTA, status);
 109                 return -ETIME;
 110         }
 111
 112         /* Clear XEN */
 113         reg_write(smbus, REG_SMSTA, SMSTA_XEN);
 114
 115         return 0;
 116 }
 117
 118 static int pasemi_i2c_xfer_msg(struct i2c_adapter *adapter,
 119                                struct i2c_msg *msg, int stop)
 120 {
 121         struct pasemi_smbus *smbus = adapter->algo_data;
 122         int read, i, err;
 123         u32 rd;
 124
 125         read = msg->flags & I2C_M_RD ? 1 : 0;
 126
 127         TXFIFO_WR(smbus, MTXFIFO_START | (msg->addr << 1) | read);
 128
 129         if (read) {
 130                 TXFIFO_WR(smbus, msg->len | MTXFIFO_READ |
 131                                  (stop ? MTXFIFO_STOP : 0));
 132
 133                 err = pasemi_smb_waitready(smbus);
 134                 if (err)
 135                         goto reset_out;
 136
 137                 for (i = 0; i < msg->len; i++) {
 138                         rd = RXFIFO_RD(smbus);
 139                         if (rd & MRXFIFO_EMPTY) {
 140                                 err = -ENODATA;
 141                                 goto reset_out;
 142                         }
 143                         msg->buf[i] = rd & MRXFIFO_DATA_M;
 144                 }
 145         } else {
 146                 for (i = 0; i < msg->len - 1; i++)
 147                         TXFIFO_WR(smbus, msg->buf[i]);
 148
 149                 TXFIFO_WR(smbus, msg->buf[msg->len-1] |
 150                           (stop ? MTXFIFO_STOP : 0));
 151         }
 152
 153         return 0;
 154
 155  reset_out:
 156         reg_write(smbus, REG_CTL, (CTL_MTR | CTL_MRR |
 157                   (CLK_100K_DIV & CTL_CLK_M)));
 158         return err;
 159 }
 160
 161 static int pasemi_i2c_xfer(struct i2c_adapter *adapter,
 162                            struct i2c_msg *msgs, int num)
 163 {
 164         struct pasemi_smbus *smbus = adapter->algo_data;
 165         int ret, i;
 166
 167         pasemi_smb_clear(smbus);
 168
 169         ret = 0;
 170
 171         for (i = 0; i < num && !ret; i++)
 172                 ret = pasemi_i2c_xfer_msg(adapter, &msgs[i], (i == (num - 1)));
 173
 174         return ret ? ret : num;
 175 }
 176
 177 static int pasemi_smb_xfer(struct i2c_adapter *adapter,
 178                 u16 addr, unsigned short flags, char read_write, u8 command,
 179                 int size, union i2c_smbus_data *data)
 180 {
 181         struct pasemi_smbus *smbus = adapter->algo_data;
 182         unsigned int rd;
 183         int read_flag, err;
 184         int len = 0, i;
 185
 186         /* All our ops take 8-bit shifted addresses */
 187         addr <<= 1;
 188         read_flag = read_write == I2C_SMBUS_READ;
 189
 190         pasemi_smb_clear(smbus);
 191
 192         switch (size) {
 193         case I2C_SMBUS_QUICK:
 194                 TXFIFO_WR(smbus, addr | read_flag | MTXFIFO_START |
 195                           MTXFIFO_STOP);
 196                 break;
 197         case I2C_SMBUS_BYTE:
 198                 TXFIFO_WR(smbus, addr | read_flag | MTXFIFO_START);
 199                 if (read_write)
 200                         TXFIFO_WR(smbus, 1 | MTXFIFO_STOP | MTXFIFO_READ);
 201                 else
 202                         TXFIFO_WR(smbus, MTXFIFO_STOP | command);
 203                 break;
 204         case I2C_SMBUS_BYTE_DATA:
 205                 TXFIFO_WR(smbus, addr | MTXFIFO_START);
 206                 TXFIFO_WR(smbus, command);
 207                 if (read_write) {
 208                         TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
 209                         TXFIFO_WR(smbus, 1 | MTXFIFO_READ | MTXFIFO_STOP);
 210                 } else {
 211                         TXFIFO_WR(smbus, MTXFIFO_STOP | data->byte);
 212                 }
 213                 break;
 214         case I2C_SMBUS_WORD_DATA:
 215                 TXFIFO_WR(smbus, addr | MTXFIFO_START);
 216                 TXFIFO_WR(smbus, command);
 217                 if (read_write) {
 218                         TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
 219                         TXFIFO_WR(smbus, 2 | MTXFIFO_READ | MTXFIFO_STOP);
 220                 } else {
 221                         TXFIFO_WR(smbus, data->word & MTXFIFO_DATA_M);
 222                         TXFIFO_WR(smbus, MTXFIFO_STOP | (data->word >> 8));
 223                 }
 224                 break;
 225         case I2C_SMBUS_BLOCK_DATA:
 226                 TXFIFO_WR(smbus, addr | MTXFIFO_START);
 227                 TXFIFO_WR(smbus, command);
 228                 if (read_write) {
 229                         TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
 230                         TXFIFO_WR(smbus, 1 | MTXFIFO_READ);
 231                         rd = RXFIFO_RD(smbus);
 232                         len = min_t(u8, (rd & MRXFIFO_DATA_M),
 233                                     I2C_SMBUS_BLOCK_MAX);
 234                         TXFIFO_WR(smbus, len | MTXFIFO_READ |
 235                                          MTXFIFO_STOP);
 236                 } else {
 237                         len = min_t(u8, data->block[0], I2C_SMBUS_BLOCK_MAX);
 238                         TXFIFO_WR(smbus, len);
 239                         for (i = 1; i < len; i++)
 240                                 TXFIFO_WR(smbus, data->block[i]);
 241                         TXFIFO_WR(smbus, data->block[len] | MTXFIFO_STOP);
 242                 }
 243                 break;
 244         case I2C_SMBUS_PROC_CALL:
 245                 read_write = I2C_SMBUS_READ;
 246                 TXFIFO_WR(smbus, addr | MTXFIFO_START);
 247                 TXFIFO_WR(smbus, command);
 248                 TXFIFO_WR(smbus, data->word & MTXFIFO_DATA_M);
 249                 TXFIFO_WR(smbus, (data->word >> 8) & MTXFIFO_DATA_M);
 250                 TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
 251                 TXFIFO_WR(smbus, 2 | MTXFIFO_STOP | MTXFIFO_READ);
 252                 break;
 253         case I2C_SMBUS_BLOCK_PROC_CALL:
 254                 len = min_t(u8, data->block[0], I2C_SMBUS_BLOCK_MAX - 1);
 255                 read_write = I2C_SMBUS_READ;
 256                 TXFIFO_WR(smbus, addr | MTXFIFO_START);
 257                 TXFIFO_WR(smbus, command);
 258                 TXFIFO_WR(smbus, len);
 259                 for (i = 1; i <= len; i++)
 260                         TXFIFO_WR(smbus, data->block[i]);
 261                 TXFIFO_WR(smbus, addr | I2C_SMBUS_READ);
 262                 TXFIFO_WR(smbus, MTXFIFO_READ | 1);
 263                 rd = RXFIFO_RD(smbus);
 264                 len = min_t(u8, (rd & MRXFIFO_DATA_M),
 265                             I2C_SMBUS_BLOCK_MAX - len);
 266                 TXFIFO_WR(smbus, len | MTXFIFO_READ | MTXFIFO_STOP);
 267                 break;
 268
 269         default:
 270                 dev_warn(&adapter->dev, "Unsupported transaction %d\n", size);
 271                 return -EINVAL;
 272         }
 273
 274         err = pasemi_smb_waitready(smbus);
 275         if (err)
 276                 goto reset_out;
 277
 278         if (read_write == I2C_SMBUS_WRITE)
 279                 return 0;
 280
 281         switch (size) {
 282         case I2C_SMBUS_BYTE:
 283         case I2C_SMBUS_BYTE_DATA:
 284                 rd = RXFIFO_RD(smbus);
 285                 if (rd & MRXFIFO_EMPTY) {
 286                         err = -ENODATA;
 287                         goto reset_out;
 288                 }
 289                 data->byte = rd & MRXFIFO_DATA_M;
 290                 break;
 291         case I2C_SMBUS_WORD_DATA:
 292         case I2C_SMBUS_PROC_CALL:
 293                 rd = RXFIFO_RD(smbus);
 294                 if (rd & MRXFIFO_EMPTY) {
 295                         err = -ENODATA;
 296                         goto reset_out;
 297                 }
 298                 data->word = rd & MRXFIFO_DATA_M;
 299                 rd = RXFIFO_RD(smbus);
 300                 if (rd & MRXFIFO_EMPTY) {
 301                         err = -ENODATA;
 302                         goto reset_out;
 303                 }
 304                 data->word |= (rd & MRXFIFO_DATA_M) << 8;
 305                 break;
 306         case I2C_SMBUS_BLOCK_DATA:
 307         case I2C_SMBUS_BLOCK_PROC_CALL:
 308                 data->block[0] = len;
 309                 for (i = 1; i <= len; i ++) {
 310                         rd = RXFIFO_RD(smbus);
 311                         if (rd & MRXFIFO_EMPTY) {
 312                                 err = -ENODATA;
 313                                 goto reset_out;
 314                         }
 315                         data->block[i] = rd & MRXFIFO_DATA_M;
 316                 }
 317                 break;
 318         }
 319
 320         return 0;
 321
 322  reset_out:
 323         reg_write(smbus, REG_CTL, (CTL_MTR | CTL_MRR |
 324                   (CLK_100K_DIV & CTL_CLK_M)));
 325         return err;
 326 }
 327
 328 static u32 pasemi_smb_func(struct i2c_adapter *adapter)
 329 {
 330         return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
 331                I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
 332                I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_PROC_CALL |
 333                I2C_FUNC_SMBUS_BLOCK_PROC_CALL | I2C_FUNC_I2C;
 334 }
 335
 336 static const struct i2c_algorithm smbus_algorithm = {
 337         .master_xfer    = pasemi_i2c_xfer,
 338         .smbus_xfer     = pasemi_smb_xfer,
 339         .functionality  = pasemi_smb_func,
 340 };
 341
 342 static int __devinit pasemi_smb_probe(struct pci_dev *dev,
 343                                       const struct pci_device_id *id)
 344 {
 345         struct pasemi_smbus *smbus;
 346         int error;
 347
 348         if (!(pci_resource_flags(dev, 0) & IORESOURCE_IO))
 349                 return -ENODEV;
 350
 351         smbus = kzalloc(sizeof(struct pasemi_smbus), GFP_KERNEL);
 352         if (!smbus)
 353                 return -ENOMEM;
 354
 355         smbus->dev = dev;
 356         smbus->base = pci_resource_start(dev, 0);
 357         smbus->size = pci_resource_len(dev, 0);
 358
 359         if (!request_region(smbus->base, smbus->size,
 360                             pasemi_smb_driver.name)) {
 361                 error = -EBUSY;
 362                 goto out_kfree;
 363         }
 364
 365         smbus->adapter.owner = THIS_MODULE;
 366         snprintf(smbus->adapter.name, sizeof(smbus->adapter.name),
 367                  "PA Semi SMBus adapter at 0x%lx", smbus->base);
 368         smbus->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
 369         smbus->adapter.algo = &smbus_algorithm;
 370         smbus->adapter.algo_data = smbus;
 371         smbus->adapter.nr = PCI_FUNC(dev->devfn);
 372
 373         /* set up the sysfs linkage to our parent device */
 374         smbus->adapter.dev.parent = &dev->dev;
 375
 376         reg_write(smbus, REG_CTL, (CTL_MTR | CTL_MRR |
 377                   (CLK_100K_DIV & CTL_CLK_M)));
 378
 379         error = i2c_add_numbered_adapter(&smbus->adapter);
 380         if (error)
 381                 goto out_release_region;
 382
 383         pci_set_drvdata(dev, smbus);
 384
 385         return 0;
 386
 387  out_release_region:
 388         release_region(smbus->base, smbus->size);
 389  out_kfree:
 390         kfree(smbus);
 391         return error;
 392 }
 393
 394 static void __devexit pasemi_smb_remove(struct pci_dev *dev)
 395 {
 396         struct pasemi_smbus *smbus = pci_get_drvdata(dev);
 397
 398         i2c_del_adapter(&smbus->adapter);
 399         release_region(smbus->base, smbus->size);
 400         kfree(smbus);
 401 }
 402
 403 static struct pci_device_id pasemi_smb_ids[] = {
 404         { PCI_DEVICE(0x1959, 0xa003) },
 405         { 0, }
 406 };
 407
 408 MODULE_DEVICE_TABLE(pci, pasemi_smb_ids);
 409
 410 static struct pci_driver pasemi_smb_driver = {
 411         .name           = "i2c-pasemi",
 412         .id_table       = pasemi_smb_ids,
 413         .probe          = pasemi_smb_probe,
 414         .remove         = __devexit_p(pasemi_smb_remove),
 415 };
 416
 417 static int __init pasemi_smb_init(void)
 418 {
 419         return pci_register_driver(&pasemi_smb_driver);
 420 }
 421
 422 static void __exit pasemi_smb_exit(void)
 423 {
 424         pci_unregister_driver(&pasemi_smb_driver);
 425 }
 426
 427 MODULE_LICENSE("GPL");
 428 MODULE_AUTHOR ("Olof Johansson <olof@lixom.net>");
 429 MODULE_DESCRIPTION("PA Semi PWRficient SMBus driver");
 430
 431 module_init(pasemi_smb_init);
 432 module_exit(pasemi_smb_exit);