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/i2c.h>
  14 #include <linux/regmap.h>
  15 #include <linux/mfd/88pm860x.h>
  16
  17 int pm860x_reg_read(struct i2c_client *i2c, int reg)
  18 {
  19         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  20         struct regmap *map = (i2c == chip->client) ? chip->regmap
  21                                 : chip->regmap_companion;
  22         unsigned int data;
  23         int ret;
  24
  25         ret = regmap_read(map, reg, &data);
  26         if (ret < 0)
  27                 return ret;
  28         else
  29                 return (int)data;
  30 }
  31 EXPORT_SYMBOL(pm860x_reg_read);
  32
  33 int pm860x_reg_write(struct i2c_client *i2c, int reg,
  34                      unsigned char data)
  35 {
  36         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  37         struct regmap *map = (i2c == chip->client) ? chip->regmap
  38                                 : chip->regmap_companion;
  39         int ret;
  40
  41         ret = regmap_write(map, reg, data);
  42         return ret;
  43 }
  44 EXPORT_SYMBOL(pm860x_reg_write);
  45
  46 int pm860x_bulk_read(struct i2c_client *i2c, int reg,
  47                      int count, unsigned char *buf)
  48 {
  49         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  50         struct regmap *map = (i2c == chip->client) ? chip->regmap
  51                                 : chip->regmap_companion;
  52         int ret;
  53
  54         ret = regmap_raw_read(map, reg, buf, count);
  55         return ret;
  56 }
  57 EXPORT_SYMBOL(pm860x_bulk_read);
  58
  59 int pm860x_bulk_write(struct i2c_client *i2c, int reg,
  60                       int count, unsigned char *buf)
  61 {
  62         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  63         struct regmap *map = (i2c == chip->client) ? chip->regmap
  64                                 : chip->regmap_companion;
  65         int ret;
  66
  67         ret = regmap_raw_write(map, reg, buf, count);
  68         return ret;
  69 }
  70 EXPORT_SYMBOL(pm860x_bulk_write);
  71
  72 int pm860x_set_bits(struct i2c_client *i2c, int reg,
  73                     unsigned char mask, unsigned char data)
  74 {
  75         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
  76         struct regmap *map = (i2c == chip->client) ? chip->regmap
  77                                 : chip->regmap_companion;
  78         int ret;
  79
  80         ret = regmap_update_bits(map, reg, mask, data);
  81         return ret;
  82 }
  83 EXPORT_SYMBOL(pm860x_set_bits);
  84
  85 static int read_device(struct i2c_client *i2c, int reg,
  86                        int bytes, void *dest)
  87 {
  88         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX + 3];
  89         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX + 2];
  90         struct i2c_adapter *adap = i2c->adapter;
  91         struct i2c_msg msg[2] = {{i2c->addr, 0, 1, msgbuf0},
  92                                  {i2c->addr, I2C_M_RD, 0, msgbuf1},
  93                                 };
  94         int num = 1, ret = 0;
  95
  96         if (dest == NULL)
  97                 return -EINVAL;
  98         msgbuf0[0] = (unsigned char)reg;        /* command */
  99         msg[1].len = bytes;
 100
 101         /* if data needs to read back, num should be 2 */
 102         if (bytes > 0)
 103                 num = 2;
 104         ret = adap->algo->master_xfer(adap, msg, num);
 105         memcpy(dest, msgbuf1, bytes);
 106         if (ret < 0)
 107                 return ret;
 108         return 0;
 109 }
 110
 111 static int write_device(struct i2c_client *i2c, int reg,
 112                         int bytes, void *src)
 113 {
 114         unsigned char buf[bytes + 1];
 115         struct i2c_adapter *adap = i2c->adapter;
 116         struct i2c_msg msg;
 117         int ret;
 118
 119         buf[0] = (unsigned char)reg;
 120         memcpy(&buf[1], src, bytes);
 121         msg.addr = i2c->addr;
 122         msg.flags = 0;
 123         msg.len = bytes + 1;
 124         msg.buf = buf;
 125
 126         ret = adap->algo->master_xfer(adap, &msg, 1);
 127         if (ret < 0)
 128                 return ret;
 129         return 0;
 130 }
 131
 132 int pm860x_page_reg_read(struct i2c_client *i2c, int reg)
 133 {
 134         unsigned char zero = 0;
 135         unsigned char data;
 136         int ret;
 137
 138         i2c_lock_adapter(i2c->adapter);
 139         read_device(i2c, 0xFA, 0, &zero);
 140         read_device(i2c, 0xFB, 0, &zero);
 141         read_device(i2c, 0xFF, 0, &zero);
 142         ret = read_device(i2c, reg, 1, &data);
 143         if (ret >= 0)
 144                 ret = (int)data;
 145         read_device(i2c, 0xFE, 0, &zero);
 146         read_device(i2c, 0xFC, 0, &zero);
 147         i2c_unlock_adapter(i2c->adapter);
 148         return ret;
 149 }
 150 EXPORT_SYMBOL(pm860x_page_reg_read);
 151
 152 int pm860x_page_reg_write(struct i2c_client *i2c, int reg,
 153                           unsigned char data)
 154 {
 155         unsigned char zero;
 156         int ret;
 157
 158         i2c_lock_adapter(i2c->adapter);
 159         read_device(i2c, 0xFA, 0, &zero);
 160         read_device(i2c, 0xFB, 0, &zero);
 161         read_device(i2c, 0xFF, 0, &zero);
 162         ret = write_device(i2c, reg, 1, &data);
 163         read_device(i2c, 0xFE, 0, &zero);
 164         read_device(i2c, 0xFC, 0, &zero);
 165         i2c_unlock_adapter(i2c->adapter);
 166         return ret;
 167 }
 168 EXPORT_SYMBOL(pm860x_page_reg_write);
 169
 170 int pm860x_page_bulk_read(struct i2c_client *i2c, int reg,
 171                           int count, unsigned char *buf)
 172 {
 173         unsigned char zero = 0;
 174         int ret;
 175
 176         i2c_lock_adapter(i2c->adapter);
 177         read_device(i2c, 0xfa, 0, &zero);
 178         read_device(i2c, 0xfb, 0, &zero);
 179         read_device(i2c, 0xff, 0, &zero);
 180         ret = read_device(i2c, reg, count, buf);
 181         read_device(i2c, 0xFE, 0, &zero);
 182         read_device(i2c, 0xFC, 0, &zero);
 183         i2c_unlock_adapter(i2c->adapter);
 184         return ret;
 185 }
 186 EXPORT_SYMBOL(pm860x_page_bulk_read);
 187
 188 int pm860x_page_bulk_write(struct i2c_client *i2c, int reg,
 189                            int count, unsigned char *buf)
 190 {
 191         unsigned char zero = 0;
 192         int ret;
 193
 194         i2c_lock_adapter(i2c->adapter);
 195         read_device(i2c, 0xFA, 0, &zero);
 196         read_device(i2c, 0xFB, 0, &zero);
 197         read_device(i2c, 0xFF, 0, &zero);
 198         ret = write_device(i2c, reg, count, buf);
 199         read_device(i2c, 0xFE, 0, &zero);
 200         read_device(i2c, 0xFC, 0, &zero);
 201         i2c_unlock_adapter(i2c->adapter);
 202         i2c_unlock_adapter(i2c->adapter);
 203         return ret;
 204 }
 205 EXPORT_SYMBOL(pm860x_page_bulk_write);
 206
 207 int pm860x_page_set_bits(struct i2c_client *i2c, int reg,
 208                          unsigned char mask, unsigned char data)
 209 {
 210         unsigned char zero;
 211         unsigned char value;
 212         int ret;
 213
 214         i2c_lock_adapter(i2c->adapter);
 215         read_device(i2c, 0xFA, 0, &zero);
 216         read_device(i2c, 0xFB, 0, &zero);
 217         read_device(i2c, 0xFF, 0, &zero);
 218         ret = read_device(i2c, reg, 1, &value);
 219         if (ret < 0)
 220                 goto out;
 221         value &= ~mask;
 222         value |= data;
 223         ret = write_device(i2c, reg, 1, &value);
 224 out:
 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_set_bits);