drivers/mfd/88pm860x-i2c.c

   1 /*
   2  * I2C driver for Marvell 88PM860x
   3  *
   4  * Copyright (C) 2009 Marvell International Ltd.
   5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/i2c.h>
  15 #include <linux/mfd/88pm860x.h>
  16 #include <linux/slab.h>
  17
  18 static inline int pm860x_read_device(struct i2c_client *i2c,
  19                                      int reg, int bytes, void *dest)
  20 {
  21         unsigned char data;
  22         int ret;
  23
  24         data = (unsigned char)reg;
  25         ret = i2c_master_send(i2c, &data, 1);
  26         if (ret < 0)
  27                 return ret;
  28
  29         ret = i2c_master_recv(i2c, dest, bytes);
  30         if (ret < 0)
  31                 return ret;
  32         return 0;
  33 }
  34
  35 static inline int pm860x_write_device(struct i2c_client *i2c,
  36                                       int reg, int bytes, void *src)
  37 {
  38         unsigned char buf[bytes + 1];
  39         int ret;
  40
  41         buf[0] = (unsigned char)reg;
  42         memcpy(&buf[1], src, bytes);
  43
  44         ret = i2c_master_send(i2c, buf, bytes + 1);
  45         if (ret < 0)
  46                 return ret;
  47         return 0;
  48 }
  49
  50 int pm860x_reg_read(struct i2c_client *i2c, int reg)
  51 {
  52         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  53         unsigned char data;
  54         int ret;
  55
  56         mutex_lock(&chip->io_lock);
  57         ret = pm860x_read_device(i2c, reg, 1, &data);
  58         mutex_unlock(&chip->io_lock);
  59
  60         if (ret < 0)
  61                 return ret;
  62         else
  63                 return (int)data;
  64 }
  65 EXPORT_SYMBOL(pm860x_reg_read);
  66
  67 int pm860x_reg_write(struct i2c_client *i2c, int reg,
  68                      unsigned char data)
  69 {
  70         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  71         int ret;
  72
  73         mutex_lock(&chip->io_lock);
  74         ret = pm860x_write_device(i2c, reg, 1, &data);
  75         mutex_unlock(&chip->io_lock);
  76
  77         return ret;
  78 }
  79 EXPORT_SYMBOL(pm860x_reg_write);
  80
  81 int pm860x_bulk_read(struct i2c_client *i2c, int reg,
  82                      int count, unsigned char *buf)
  83 {
  84         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  85         int ret;
  86
  87         mutex_lock(&chip->io_lock);
  88         ret = pm860x_read_device(i2c, reg, count, buf);
  89         mutex_unlock(&chip->io_lock);
  90
  91         return ret;
  92 }
  93 EXPORT_SYMBOL(pm860x_bulk_read);
  94
  95 int pm860x_bulk_write(struct i2c_client *i2c, int reg,
  96                       int count, unsigned char *buf)
  97 {
  98         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  99         int ret;
 100
 101         mutex_lock(&chip->io_lock);
 102         ret = pm860x_write_device(i2c, reg, count, buf);
 103         mutex_unlock(&chip->io_lock);
 104
 105         return ret;
 106 }
 107 EXPORT_SYMBOL(pm860x_bulk_write);
 108
 109 int pm860x_set_bits(struct i2c_client *i2c, int reg,
 110                     unsigned char mask, unsigned char data)
 111 {
 112         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
 113         unsigned char value;
 114         int ret;
 115
 116         mutex_lock(&chip->io_lock);
 117         ret = pm860x_read_device(i2c, reg, 1, &value);
 118         if (ret < 0)
 119                 goto out;
 120         value &= ~mask;
 121         value |= data;
 122         ret = pm860x_write_device(i2c, reg, 1, &value);
 123 out:
 124         mutex_unlock(&chip->io_lock);
 125         return ret;
 126 }
 127 EXPORT_SYMBOL(pm860x_set_bits);
 128
 129 static int read_device(struct i2c_client *i2c, int reg,
 130                        int bytes, void *dest)
 131 {
 132         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX + 3];
 133         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX + 2];
 134         struct i2c_adapter *adap = i2c->adapter;
 135         struct i2c_msg msg[2] = {{i2c->addr, 0, 1, msgbuf0},
 136                                  {i2c->addr, I2C_M_RD, 0, msgbuf1},
 137                                 };
 138         int num = 1, ret = 0;
 139
 140         if (dest == NULL)
 141                 return -EINVAL;
 142         msgbuf0[0] = (unsigned char)reg;        /* command */
 143         msg[1].len = bytes;
 144
 145         /* if data needs to read back, num should be 2 */
 146         if (bytes > 0)
 147                 num = 2;
 148         ret = adap->algo->master_xfer(adap, msg, num);
 149         memcpy(dest, msgbuf1, bytes);
 150         if (ret < 0)
 151                 return ret;
 152         return 0;
 153 }
 154
 155 static int write_device(struct i2c_client *i2c, int reg,
 156                         int bytes, void *src)
 157 {
 158         unsigned char buf[bytes + 1];
 159         struct i2c_adapter *adap = i2c->adapter;
 160         struct i2c_msg msg;
 161         int ret;
 162
 163         buf[0] = (unsigned char)reg;
 164         memcpy(&buf[1], src, bytes);
 165         msg.addr = i2c->addr;
 166         msg.flags = 0;
 167         msg.len = bytes + 1;
 168         msg.buf = buf;
 169
 170         ret = adap->algo->master_xfer(adap, &msg, 1);
 171         if (ret < 0)
 172                 return ret;
 173         return 0;
 174 }
 175
 176 int pm860x_page_reg_read(struct i2c_client *i2c, int reg)
 177 {
 178         unsigned char zero = 0;
 179         unsigned char data;
 180         int ret;
 181
 182         i2c_lock_adapter(i2c->adapter);
 183         read_device(i2c, 0xFA, 0, &zero);
 184         read_device(i2c, 0xFB, 0, &zero);
 185         read_device(i2c, 0xFF, 0, &zero);
 186         ret = read_device(i2c, reg, 1, &data);
 187         if (ret >= 0)
 188                 ret = (int)data;
 189         read_device(i2c, 0xFE, 0, &zero);
 190         read_device(i2c, 0xFC, 0, &zero);
 191         i2c_unlock_adapter(i2c->adapter);
 192         return ret;
 193 }
 194 EXPORT_SYMBOL(pm860x_page_reg_read);
 195
 196 int pm860x_page_reg_write(struct i2c_client *i2c, int reg,
 197                           unsigned char data)
 198 {
 199         unsigned char zero;
 200         int ret;
 201
 202         i2c_lock_adapter(i2c->adapter);
 203         read_device(i2c, 0xFA, 0, &zero);
 204         read_device(i2c, 0xFB, 0, &zero);
 205         read_device(i2c, 0xFF, 0, &zero);
 206         ret = write_device(i2c, reg, 1, &data);
 207         read_device(i2c, 0xFE, 0, &zero);
 208         read_device(i2c, 0xFC, 0, &zero);
 209         i2c_unlock_adapter(i2c->adapter);
 210         return ret;
 211 }
 212 EXPORT_SYMBOL(pm860x_page_reg_write);
 213
 214 int pm860x_page_bulk_read(struct i2c_client *i2c, int reg,
 215                           int count, unsigned char *buf)
 216 {
 217         unsigned char zero = 0;
 218         int ret;
 219
 220         i2c_lock_adapter(i2c->adapter);
 221         read_device(i2c, 0xfa, 0, &zero);
 222         read_device(i2c, 0xfb, 0, &zero);
 223         read_device(i2c, 0xff, 0, &zero);
 224         ret = read_device(i2c, reg, count, buf);
 225         read_device(i2c, 0xFE, 0, &zero);
 226         read_device(i2c, 0xFC, 0, &zero);
 227         i2c_unlock_adapter(i2c->adapter);
 228         return ret;
 229 }
 230 EXPORT_SYMBOL(pm860x_page_bulk_read);
 231
 232 int pm860x_page_bulk_write(struct i2c_client *i2c, int reg,
 233                            int count, unsigned char *buf)
 234 {
 235         unsigned char zero = 0;
 236         int ret;
 237
 238         i2c_lock_adapter(i2c->adapter);
 239         read_device(i2c, 0xFA, 0, &zero);
 240         read_device(i2c, 0xFB, 0, &zero);
 241         read_device(i2c, 0xFF, 0, &zero);
 242         ret = write_device(i2c, reg, count, buf);
 243         read_device(i2c, 0xFE, 0, &zero);
 244         read_device(i2c, 0xFC, 0, &zero);
 245         i2c_unlock_adapter(i2c->adapter);
 246         i2c_unlock_adapter(i2c->adapter);
 247         return ret;
 248 }
 249 EXPORT_SYMBOL(pm860x_page_bulk_write);
 250
 251 int pm860x_page_set_bits(struct i2c_client *i2c, int reg,
 252                          unsigned char mask, unsigned char data)
 253 {
 254         unsigned char zero;
 255         unsigned char value;
 256         int ret;
 257
 258         i2c_lock_adapter(i2c->adapter);
 259         read_device(i2c, 0xFA, 0, &zero);
 260         read_device(i2c, 0xFB, 0, &zero);
 261         read_device(i2c, 0xFF, 0, &zero);
 262         ret = read_device(i2c, reg, 1, &value);
 263         if (ret < 0)
 264                 goto out;
 265         value &= ~mask;
 266         value |= data;
 267         ret = write_device(i2c, reg, 1, &value);
 268 out:
 269         read_device(i2c, 0xFE, 0, &zero);
 270         read_device(i2c, 0xFC, 0, &zero);
 271         i2c_unlock_adapter(i2c->adapter);
 272         return ret;
 273 }
 274 EXPORT_SYMBOL(pm860x_page_set_bits);
 275
 276 static const struct i2c_device_id pm860x_id_table[] = {
 277         { "88PM860x", 0 },
 278         {}
 279 };
 280 MODULE_DEVICE_TABLE(i2c, pm860x_id_table);
 281
 282 static int verify_addr(struct i2c_client *i2c)
 283 {
 284         unsigned short addr_8607[] = {0x30, 0x34};
 285         unsigned short addr_8606[] = {0x10, 0x11};
 286         int size, i;
 287
 288         if (i2c == NULL)
 289                 return 0;
 290         size = ARRAY_SIZE(addr_8606);
 291         for (i = 0; i < size; i++) {
 292                 if (i2c->addr == *(addr_8606 + i))
 293                         return CHIP_PM8606;
 294         }
 295         size = ARRAY_SIZE(addr_8607);
 296         for (i = 0; i < size; i++) {
 297                 if (i2c->addr == *(addr_8607 + i))
 298                         return CHIP_PM8607;
 299         }
 300         return 0;
 301 }
 302
 303 static int __devinit pm860x_probe(struct i2c_client *client,
 304                                   const struct i2c_device_id *id)
 305 {
 306         struct pm860x_platform_data *pdata = client->dev.platform_data;
 307         struct pm860x_chip *chip;
 308
 309         if (!pdata) {
 310                 pr_info("No platform data in %s!\n", __func__);
 311                 return -EINVAL;
 312         }
 313
 314         chip = kzalloc(sizeof(struct pm860x_chip), GFP_KERNEL);
 315         if (chip == NULL)
 316                 return -ENOMEM;
 317
 318         chip->id = verify_addr(client);
 319         chip->client = client;
 320         i2c_set_clientdata(client, chip);
 321         chip->dev = &client->dev;
 322         mutex_init(&chip->io_lock);
 323         dev_set_drvdata(chip->dev, chip);
 324
 325         /*
 326          * Both client and companion client shares same platform driver.
 327          * Driver distinguishes them by pdata->companion_addr.
 328          * pdata->companion_addr is only assigned if companion chip exists.
 329          * At the same time, the companion_addr shouldn't equal to client
 330          * address.
 331          */
 332         if (pdata->companion_addr && (pdata->companion_addr != client->addr)) {
 333                 chip->companion_addr = pdata->companion_addr;
 334                 chip->companion = i2c_new_dummy(chip->client->adapter,
 335                                                 chip->companion_addr);
 336                 i2c_set_clientdata(chip->companion, chip);
 337         }
 338
 339         pm860x_device_init(chip, pdata);
 340         return 0;
 341 }
 342
 343 static int __devexit pm860x_remove(struct i2c_client *client)
 344 {
 345         struct pm860x_chip *chip = i2c_get_clientdata(client);
 346
 347         pm860x_device_exit(chip);
 348         i2c_unregister_device(chip->companion);
 349         kfree(chip);
 350         return 0;
 351 }
 352
 353 static struct i2c_driver pm860x_driver = {
 354         .driver = {
 355                 .name   = "88PM860x",
 356                 .owner  = THIS_MODULE,
 357         },
 358         .probe          = pm860x_probe,
 359         .remove         = __devexit_p(pm860x_remove),
 360         .id_table       = pm860x_id_table,
 361 };
 362
 363 static int __init pm860x_i2c_init(void)
 364 {
 365         int ret;
 366         ret = i2c_add_driver(&pm860x_driver);
 367         if (ret != 0)
 368                 pr_err("Failed to register 88PM860x I2C driver: %d\n", ret);
 369         return ret;
 370 }
 371 subsys_initcall(pm860x_i2c_init);
 372
 373 static void __exit pm860x_i2c_exit(void)
 374 {
 375         i2c_del_driver(&pm860x_driver);
 376 }
 377 module_exit(pm860x_i2c_exit);
 378
 379 MODULE_DESCRIPTION("I2C Driver for Marvell 88PM860x");
 380 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
 381 MODULE_LICENSE("GPL");