Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 1 | /* |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 2 | * I2C driver for Marvell 88PM860x |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 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> |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 15 | #include <linux/mfd/88pm860x.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 16 | #include <linux/slab.h> |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 17 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 18 | static inline int pm860x_read_device(struct i2c_client *i2c, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 19 | int reg, int bytes, void *dest) |
| 20 | { |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 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 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 35 | static inline int pm860x_write_device(struct i2c_client *i2c, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 36 | int reg, int bytes, void *src) |
| 37 | { |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 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 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 50 | int pm860x_reg_read(struct i2c_client *i2c, int reg) |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 51 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 52 | struct pm860x_chip *chip = i2c_get_clientdata(i2c); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 53 | unsigned char data; |
| 54 | int ret; |
| 55 | |
| 56 | mutex_lock(&chip->io_lock); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 57 | ret = pm860x_read_device(i2c, reg, 1, &data); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 58 | mutex_unlock(&chip->io_lock); |
| 59 | |
| 60 | if (ret < 0) |
| 61 | return ret; |
| 62 | else |
| 63 | return (int)data; |
| 64 | } |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 65 | EXPORT_SYMBOL(pm860x_reg_read); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 66 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 67 | int pm860x_reg_write(struct i2c_client *i2c, int reg, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 68 | unsigned char data) |
| 69 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 70 | struct pm860x_chip *chip = i2c_get_clientdata(i2c); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 71 | int ret; |
| 72 | |
| 73 | mutex_lock(&chip->io_lock); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 74 | ret = pm860x_write_device(i2c, reg, 1, &data); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 75 | mutex_unlock(&chip->io_lock); |
| 76 | |
| 77 | return ret; |
| 78 | } |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 79 | EXPORT_SYMBOL(pm860x_reg_write); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 80 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 81 | int pm860x_bulk_read(struct i2c_client *i2c, int reg, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 82 | int count, unsigned char *buf) |
| 83 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 84 | struct pm860x_chip *chip = i2c_get_clientdata(i2c); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 85 | int ret; |
| 86 | |
| 87 | mutex_lock(&chip->io_lock); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 88 | ret = pm860x_read_device(i2c, reg, count, buf); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 89 | mutex_unlock(&chip->io_lock); |
| 90 | |
| 91 | return ret; |
| 92 | } |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 93 | EXPORT_SYMBOL(pm860x_bulk_read); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 94 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 95 | int pm860x_bulk_write(struct i2c_client *i2c, int reg, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 96 | int count, unsigned char *buf) |
| 97 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 98 | struct pm860x_chip *chip = i2c_get_clientdata(i2c); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 99 | int ret; |
| 100 | |
| 101 | mutex_lock(&chip->io_lock); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 102 | ret = pm860x_write_device(i2c, reg, count, buf); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 103 | mutex_unlock(&chip->io_lock); |
| 104 | |
| 105 | return ret; |
| 106 | } |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 107 | EXPORT_SYMBOL(pm860x_bulk_write); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 108 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 109 | int pm860x_set_bits(struct i2c_client *i2c, int reg, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 110 | unsigned char mask, unsigned char data) |
| 111 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 112 | struct pm860x_chip *chip = i2c_get_clientdata(i2c); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 113 | unsigned char value; |
| 114 | int ret; |
| 115 | |
| 116 | mutex_lock(&chip->io_lock); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 117 | ret = pm860x_read_device(i2c, reg, 1, &value); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 118 | if (ret < 0) |
| 119 | goto out; |
| 120 | value &= ~mask; |
| 121 | value |= data; |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 122 | ret = pm860x_write_device(i2c, reg, 1, &value); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 123 | out: |
| 124 | mutex_unlock(&chip->io_lock); |
| 125 | return ret; |
| 126 | } |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 127 | EXPORT_SYMBOL(pm860x_set_bits); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 128 | |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 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 | |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 176 | int pm860x_page_reg_read(struct i2c_client *i2c, int reg) |
| 177 | { |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 178 | unsigned char zero = 0; |
| 179 | unsigned char data; |
| 180 | int ret; |
| 181 | |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 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); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 187 | if (ret >= 0) |
| 188 | ret = (int)data; |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 189 | read_device(i2c, 0xFE, 0, &zero); |
| 190 | read_device(i2c, 0xFC, 0, &zero); |
| 191 | i2c_unlock_adapter(i2c->adapter); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 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 | { |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 199 | unsigned char zero; |
| 200 | int ret; |
| 201 | |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 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); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 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 | { |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 217 | unsigned char zero = 0; |
| 218 | int ret; |
| 219 | |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 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); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 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 | { |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 235 | unsigned char zero = 0; |
| 236 | int ret; |
| 237 | |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 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); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 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 | { |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 254 | unsigned char zero; |
| 255 | unsigned char value; |
| 256 | int ret; |
| 257 | |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 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); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 263 | if (ret < 0) |
| 264 | goto out; |
| 265 | value &= ~mask; |
| 266 | value |= data; |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 267 | ret = write_device(i2c, reg, 1, &value); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 268 | out: |
Jett.Zhou | 5bdf741 | 2011-11-11 15:38:26 +0800 | [diff] [blame^] | 269 | read_device(i2c, 0xFE, 0, &zero); |
| 270 | read_device(i2c, 0xFC, 0, &zero); |
| 271 | i2c_unlock_adapter(i2c->adapter); |
Haojian Zhuang | 09b0341 | 2011-03-07 23:43:16 +0800 | [diff] [blame] | 272 | return ret; |
| 273 | } |
| 274 | EXPORT_SYMBOL(pm860x_page_set_bits); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 275 | |
| 276 | static const struct i2c_device_id pm860x_id_table[] = { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 277 | { "88PM860x", 0 }, |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 278 | {} |
| 279 | }; |
| 280 | MODULE_DEVICE_TABLE(i2c, pm860x_id_table); |
| 281 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 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 | |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 303 | static int __devinit pm860x_probe(struct i2c_client *client, |
| 304 | const struct i2c_device_id *id) |
| 305 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 306 | struct pm860x_platform_data *pdata = client->dev.platform_data; |
Haojian Zhuang | e8343dd | 2010-02-03 15:38:12 -0500 | [diff] [blame] | 307 | struct pm860x_chip *chip; |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 308 | |
Haojian Zhuang | e8343dd | 2010-02-03 15:38:12 -0500 | [diff] [blame] | 309 | if (!pdata) { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 310 | pr_info("No platform data in %s!\n", __func__); |
| 311 | return -EINVAL; |
| 312 | } |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 313 | |
Haojian Zhuang | e8343dd | 2010-02-03 15:38:12 -0500 | [diff] [blame] | 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 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 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 | */ |
Haojian Zhuang | e8343dd | 2010-02-03 15:38:12 -0500 | [diff] [blame] | 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); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 336 | i2c_set_clientdata(chip->companion, chip); |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 337 | } |
Haojian Zhuang | e8343dd | 2010-02-03 15:38:12 -0500 | [diff] [blame] | 338 | |
| 339 | pm860x_device_init(chip, pdata); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 340 | return 0; |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | static int __devexit pm860x_remove(struct i2c_client *client) |
| 344 | { |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 345 | struct pm860x_chip *chip = i2c_get_clientdata(client); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 346 | |
Haojian Zhuang | 53dbab7 | 2010-01-08 06:01:24 -0500 | [diff] [blame] | 347 | pm860x_device_exit(chip); |
| 348 | i2c_unregister_device(chip->companion); |
Haojian Zhuang | bbd51b1 | 2010-01-06 17:04:18 -0500 | [diff] [blame] | 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"); |