Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 1 | /* |
| 2 | * linux/drivers/mfd/aat2870-core.c |
| 3 | * |
| 4 | * Copyright (c) 2011, NVIDIA Corporation. |
| 5 | * Author: Jin Park <jinyoungp@nvidia.com> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU General Public License |
| 9 | * version 2 as published by the Free Software Foundation. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, but |
| 12 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 | * General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| 19 | * 02110-1301 USA |
| 20 | */ |
| 21 | |
| 22 | #include <linux/kernel.h> |
| 23 | #include <linux/module.h> |
| 24 | #include <linux/init.h> |
| 25 | #include <linux/debugfs.h> |
| 26 | #include <linux/slab.h> |
| 27 | #include <linux/uaccess.h> |
| 28 | #include <linux/i2c.h> |
| 29 | #include <linux/delay.h> |
| 30 | #include <linux/gpio.h> |
| 31 | #include <linux/mfd/core.h> |
| 32 | #include <linux/mfd/aat2870.h> |
| 33 | #include <linux/regulator/machine.h> |
| 34 | |
| 35 | static struct aat2870_register aat2870_regs[AAT2870_REG_NUM] = { |
| 36 | /* readable, writeable, value */ |
| 37 | { 0, 1, 0x00 }, /* 0x00 AAT2870_BL_CH_EN */ |
| 38 | { 0, 1, 0x16 }, /* 0x01 AAT2870_BLM */ |
| 39 | { 0, 1, 0x16 }, /* 0x02 AAT2870_BLS */ |
| 40 | { 0, 1, 0x56 }, /* 0x03 AAT2870_BL1 */ |
| 41 | { 0, 1, 0x56 }, /* 0x04 AAT2870_BL2 */ |
| 42 | { 0, 1, 0x56 }, /* 0x05 AAT2870_BL3 */ |
| 43 | { 0, 1, 0x56 }, /* 0x06 AAT2870_BL4 */ |
| 44 | { 0, 1, 0x56 }, /* 0x07 AAT2870_BL5 */ |
| 45 | { 0, 1, 0x56 }, /* 0x08 AAT2870_BL6 */ |
| 46 | { 0, 1, 0x56 }, /* 0x09 AAT2870_BL7 */ |
| 47 | { 0, 1, 0x56 }, /* 0x0A AAT2870_BL8 */ |
| 48 | { 0, 1, 0x00 }, /* 0x0B AAT2870_FLR */ |
| 49 | { 0, 1, 0x03 }, /* 0x0C AAT2870_FM */ |
| 50 | { 0, 1, 0x03 }, /* 0x0D AAT2870_FS */ |
| 51 | { 0, 1, 0x10 }, /* 0x0E AAT2870_ALS_CFG0 */ |
| 52 | { 0, 1, 0x06 }, /* 0x0F AAT2870_ALS_CFG1 */ |
| 53 | { 0, 1, 0x00 }, /* 0x10 AAT2870_ALS_CFG2 */ |
| 54 | { 1, 0, 0x00 }, /* 0x11 AAT2870_AMB */ |
| 55 | { 0, 1, 0x00 }, /* 0x12 AAT2870_ALS0 */ |
| 56 | { 0, 1, 0x00 }, /* 0x13 AAT2870_ALS1 */ |
| 57 | { 0, 1, 0x00 }, /* 0x14 AAT2870_ALS2 */ |
| 58 | { 0, 1, 0x00 }, /* 0x15 AAT2870_ALS3 */ |
| 59 | { 0, 1, 0x00 }, /* 0x16 AAT2870_ALS4 */ |
| 60 | { 0, 1, 0x00 }, /* 0x17 AAT2870_ALS5 */ |
| 61 | { 0, 1, 0x00 }, /* 0x18 AAT2870_ALS6 */ |
| 62 | { 0, 1, 0x00 }, /* 0x19 AAT2870_ALS7 */ |
| 63 | { 0, 1, 0x00 }, /* 0x1A AAT2870_ALS8 */ |
| 64 | { 0, 1, 0x00 }, /* 0x1B AAT2870_ALS9 */ |
| 65 | { 0, 1, 0x00 }, /* 0x1C AAT2870_ALSA */ |
| 66 | { 0, 1, 0x00 }, /* 0x1D AAT2870_ALSB */ |
| 67 | { 0, 1, 0x00 }, /* 0x1E AAT2870_ALSC */ |
| 68 | { 0, 1, 0x00 }, /* 0x1F AAT2870_ALSD */ |
| 69 | { 0, 1, 0x00 }, /* 0x20 AAT2870_ALSE */ |
| 70 | { 0, 1, 0x00 }, /* 0x21 AAT2870_ALSF */ |
| 71 | { 0, 1, 0x00 }, /* 0x22 AAT2870_SUB_SET */ |
| 72 | { 0, 1, 0x00 }, /* 0x23 AAT2870_SUB_CTRL */ |
| 73 | { 0, 1, 0x00 }, /* 0x24 AAT2870_LDO_AB */ |
| 74 | { 0, 1, 0x00 }, /* 0x25 AAT2870_LDO_CD */ |
| 75 | { 0, 1, 0x00 }, /* 0x26 AAT2870_LDO_EN */ |
| 76 | }; |
| 77 | |
| 78 | static struct mfd_cell aat2870_devs[] = { |
| 79 | { |
| 80 | .name = "aat2870-backlight", |
| 81 | .id = AAT2870_ID_BL, |
| 82 | .pdata_size = sizeof(struct aat2870_bl_platform_data), |
| 83 | }, |
| 84 | { |
| 85 | .name = "aat2870-regulator", |
| 86 | .id = AAT2870_ID_LDOA, |
| 87 | .pdata_size = sizeof(struct regulator_init_data), |
| 88 | }, |
| 89 | { |
| 90 | .name = "aat2870-regulator", |
| 91 | .id = AAT2870_ID_LDOB, |
| 92 | .pdata_size = sizeof(struct regulator_init_data), |
| 93 | }, |
| 94 | { |
| 95 | .name = "aat2870-regulator", |
| 96 | .id = AAT2870_ID_LDOC, |
| 97 | .pdata_size = sizeof(struct regulator_init_data), |
| 98 | }, |
| 99 | { |
| 100 | .name = "aat2870-regulator", |
| 101 | .id = AAT2870_ID_LDOD, |
| 102 | .pdata_size = sizeof(struct regulator_init_data), |
| 103 | }, |
| 104 | }; |
| 105 | |
| 106 | static int __aat2870_read(struct aat2870_data *aat2870, u8 addr, u8 *val) |
| 107 | { |
| 108 | int ret; |
| 109 | |
| 110 | if (addr >= AAT2870_REG_NUM) { |
| 111 | dev_err(aat2870->dev, "Invalid address, 0x%02x\n", addr); |
| 112 | return -EINVAL; |
| 113 | } |
| 114 | |
| 115 | if (!aat2870->reg_cache[addr].readable) { |
| 116 | *val = aat2870->reg_cache[addr].value; |
| 117 | goto out; |
| 118 | } |
| 119 | |
| 120 | ret = i2c_master_send(aat2870->client, &addr, 1); |
| 121 | if (ret < 0) |
| 122 | return ret; |
| 123 | if (ret != 1) |
| 124 | return -EIO; |
| 125 | |
| 126 | ret = i2c_master_recv(aat2870->client, val, 1); |
| 127 | if (ret < 0) |
| 128 | return ret; |
| 129 | if (ret != 1) |
| 130 | return -EIO; |
| 131 | |
| 132 | out: |
| 133 | dev_dbg(aat2870->dev, "read: addr=0x%02x, val=0x%02x\n", addr, *val); |
| 134 | return 0; |
| 135 | } |
| 136 | |
| 137 | static int __aat2870_write(struct aat2870_data *aat2870, u8 addr, u8 val) |
| 138 | { |
| 139 | u8 msg[2]; |
| 140 | int ret; |
| 141 | |
| 142 | if (addr >= AAT2870_REG_NUM) { |
| 143 | dev_err(aat2870->dev, "Invalid address, 0x%02x\n", addr); |
| 144 | return -EINVAL; |
| 145 | } |
| 146 | |
| 147 | if (!aat2870->reg_cache[addr].writeable) { |
| 148 | dev_err(aat2870->dev, "Address 0x%02x is not writeable\n", |
| 149 | addr); |
| 150 | return -EINVAL; |
| 151 | } |
| 152 | |
| 153 | msg[0] = addr; |
| 154 | msg[1] = val; |
| 155 | ret = i2c_master_send(aat2870->client, msg, 2); |
| 156 | if (ret < 0) |
| 157 | return ret; |
| 158 | if (ret != 2) |
| 159 | return -EIO; |
| 160 | |
| 161 | aat2870->reg_cache[addr].value = val; |
| 162 | |
| 163 | dev_dbg(aat2870->dev, "write: addr=0x%02x, val=0x%02x\n", addr, val); |
| 164 | return 0; |
| 165 | } |
| 166 | |
| 167 | static int aat2870_read(struct aat2870_data *aat2870, u8 addr, u8 *val) |
| 168 | { |
| 169 | int ret; |
| 170 | |
| 171 | mutex_lock(&aat2870->io_lock); |
| 172 | ret = __aat2870_read(aat2870, addr, val); |
| 173 | mutex_unlock(&aat2870->io_lock); |
| 174 | |
| 175 | return ret; |
| 176 | } |
| 177 | |
| 178 | static int aat2870_write(struct aat2870_data *aat2870, u8 addr, u8 val) |
| 179 | { |
| 180 | int ret; |
| 181 | |
| 182 | mutex_lock(&aat2870->io_lock); |
| 183 | ret = __aat2870_write(aat2870, addr, val); |
| 184 | mutex_unlock(&aat2870->io_lock); |
| 185 | |
| 186 | return ret; |
| 187 | } |
| 188 | |
| 189 | static int aat2870_update(struct aat2870_data *aat2870, u8 addr, u8 mask, |
| 190 | u8 val) |
| 191 | { |
| 192 | int change; |
| 193 | u8 old_val, new_val; |
| 194 | int ret; |
| 195 | |
| 196 | mutex_lock(&aat2870->io_lock); |
| 197 | |
| 198 | ret = __aat2870_read(aat2870, addr, &old_val); |
| 199 | if (ret) |
| 200 | goto out_unlock; |
| 201 | |
| 202 | new_val = (old_val & ~mask) | (val & mask); |
| 203 | change = old_val != new_val; |
| 204 | if (change) |
| 205 | ret = __aat2870_write(aat2870, addr, new_val); |
| 206 | |
| 207 | out_unlock: |
| 208 | mutex_unlock(&aat2870->io_lock); |
| 209 | |
| 210 | return ret; |
| 211 | } |
| 212 | |
| 213 | static inline void aat2870_enable(struct aat2870_data *aat2870) |
| 214 | { |
| 215 | if (aat2870->en_pin >= 0) |
| 216 | gpio_set_value(aat2870->en_pin, 1); |
| 217 | |
| 218 | aat2870->is_enable = 1; |
| 219 | } |
| 220 | |
| 221 | static inline void aat2870_disable(struct aat2870_data *aat2870) |
| 222 | { |
| 223 | if (aat2870->en_pin >= 0) |
| 224 | gpio_set_value(aat2870->en_pin, 0); |
| 225 | |
| 226 | aat2870->is_enable = 0; |
| 227 | } |
| 228 | |
| 229 | #ifdef CONFIG_DEBUG_FS |
| 230 | static ssize_t aat2870_dump_reg(struct aat2870_data *aat2870, char *buf) |
| 231 | { |
| 232 | u8 addr, val; |
| 233 | ssize_t count = 0; |
| 234 | int ret; |
| 235 | |
| 236 | count += sprintf(buf, "aat2870 registers\n"); |
| 237 | for (addr = 0; addr < AAT2870_REG_NUM; addr++) { |
| 238 | count += sprintf(buf + count, "0x%02x: ", addr); |
| 239 | if (count >= PAGE_SIZE - 1) |
| 240 | break; |
| 241 | |
| 242 | ret = aat2870->read(aat2870, addr, &val); |
| 243 | if (ret == 0) |
| 244 | count += snprintf(buf + count, PAGE_SIZE - count, |
| 245 | "0x%02x", val); |
| 246 | else |
| 247 | count += snprintf(buf + count, PAGE_SIZE - count, |
| 248 | "<read fail: %d>", ret); |
| 249 | |
| 250 | if (count >= PAGE_SIZE - 1) |
| 251 | break; |
| 252 | |
| 253 | count += snprintf(buf + count, PAGE_SIZE - count, "\n"); |
| 254 | if (count >= PAGE_SIZE - 1) |
| 255 | break; |
| 256 | } |
| 257 | |
| 258 | /* Truncate count; min() would cause a warning */ |
| 259 | if (count >= PAGE_SIZE) |
| 260 | count = PAGE_SIZE - 1; |
| 261 | |
| 262 | return count; |
| 263 | } |
| 264 | |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 265 | static ssize_t aat2870_reg_read_file(struct file *file, char __user *user_buf, |
| 266 | size_t count, loff_t *ppos) |
| 267 | { |
| 268 | struct aat2870_data *aat2870 = file->private_data; |
| 269 | char *buf; |
| 270 | ssize_t ret; |
| 271 | |
| 272 | buf = kmalloc(PAGE_SIZE, GFP_KERNEL); |
| 273 | if (!buf) |
| 274 | return -ENOMEM; |
| 275 | |
| 276 | ret = aat2870_dump_reg(aat2870, buf); |
| 277 | if (ret >= 0) |
| 278 | ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); |
| 279 | |
| 280 | kfree(buf); |
| 281 | |
| 282 | return ret; |
| 283 | } |
| 284 | |
| 285 | static ssize_t aat2870_reg_write_file(struct file *file, |
| 286 | const char __user *user_buf, size_t count, |
| 287 | loff_t *ppos) |
| 288 | { |
| 289 | struct aat2870_data *aat2870 = file->private_data; |
| 290 | char buf[32]; |
Jin Park | c38d66a | 2011-10-04 12:35:07 +0200 | [diff] [blame] | 291 | ssize_t buf_size; |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 292 | char *start = buf; |
| 293 | unsigned long addr, val; |
| 294 | int ret; |
| 295 | |
| 296 | buf_size = min(count, (sizeof(buf)-1)); |
| 297 | if (copy_from_user(buf, user_buf, buf_size)) { |
| 298 | dev_err(aat2870->dev, "Failed to copy from user\n"); |
| 299 | return -EFAULT; |
| 300 | } |
| 301 | buf[buf_size] = 0; |
| 302 | |
| 303 | while (*start == ' ') |
| 304 | start++; |
| 305 | |
| 306 | addr = simple_strtoul(start, &start, 16); |
| 307 | if (addr >= AAT2870_REG_NUM) { |
| 308 | dev_err(aat2870->dev, "Invalid address, 0x%lx\n", addr); |
| 309 | return -EINVAL; |
| 310 | } |
| 311 | |
| 312 | while (*start == ' ') |
| 313 | start++; |
| 314 | |
Jingoo Han | 8420a24 | 2013-06-04 13:11:50 +0900 | [diff] [blame] | 315 | ret = kstrtoul(start, 16, &val); |
| 316 | if (ret) |
| 317 | return ret; |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 318 | |
| 319 | ret = aat2870->write(aat2870, (u8)addr, (u8)val); |
| 320 | if (ret) |
| 321 | return ret; |
| 322 | |
| 323 | return buf_size; |
| 324 | } |
| 325 | |
| 326 | static const struct file_operations aat2870_reg_fops = { |
Stephen Boyd | 234e340 | 2012-04-05 14:25:11 -0700 | [diff] [blame] | 327 | .open = simple_open, |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 328 | .read = aat2870_reg_read_file, |
| 329 | .write = aat2870_reg_write_file, |
| 330 | }; |
| 331 | |
| 332 | static void aat2870_init_debugfs(struct aat2870_data *aat2870) |
| 333 | { |
| 334 | aat2870->dentry_root = debugfs_create_dir("aat2870", NULL); |
| 335 | if (!aat2870->dentry_root) { |
| 336 | dev_warn(aat2870->dev, |
| 337 | "Failed to create debugfs root directory\n"); |
| 338 | return; |
| 339 | } |
| 340 | |
| 341 | aat2870->dentry_reg = debugfs_create_file("regs", 0644, |
| 342 | aat2870->dentry_root, |
| 343 | aat2870, &aat2870_reg_fops); |
| 344 | if (!aat2870->dentry_reg) |
| 345 | dev_warn(aat2870->dev, |
| 346 | "Failed to create debugfs register file\n"); |
| 347 | } |
| 348 | |
| 349 | static void aat2870_uninit_debugfs(struct aat2870_data *aat2870) |
| 350 | { |
| 351 | debugfs_remove_recursive(aat2870->dentry_root); |
| 352 | } |
| 353 | #else |
| 354 | static inline void aat2870_init_debugfs(struct aat2870_data *aat2870) |
| 355 | { |
| 356 | } |
| 357 | |
| 358 | static inline void aat2870_uninit_debugfs(struct aat2870_data *aat2870) |
| 359 | { |
| 360 | } |
| 361 | #endif /* CONFIG_DEBUG_FS */ |
| 362 | |
| 363 | static int aat2870_i2c_probe(struct i2c_client *client, |
| 364 | const struct i2c_device_id *id) |
| 365 | { |
Jingoo Han | 334a41c | 2013-07-30 17:10:05 +0900 | [diff] [blame] | 366 | struct aat2870_platform_data *pdata = dev_get_platdata(&client->dev); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 367 | struct aat2870_data *aat2870; |
| 368 | int i, j; |
| 369 | int ret = 0; |
| 370 | |
Jingoo Han | 0287714 | 2013-02-20 18:29:53 +0900 | [diff] [blame] | 371 | aat2870 = devm_kzalloc(&client->dev, sizeof(struct aat2870_data), |
| 372 | GFP_KERNEL); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 373 | if (!aat2870) { |
| 374 | dev_err(&client->dev, |
| 375 | "Failed to allocate memory for aat2870\n"); |
Jingoo Han | 0287714 | 2013-02-20 18:29:53 +0900 | [diff] [blame] | 376 | return -ENOMEM; |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | aat2870->dev = &client->dev; |
| 380 | dev_set_drvdata(aat2870->dev, aat2870); |
| 381 | |
| 382 | aat2870->client = client; |
| 383 | i2c_set_clientdata(client, aat2870); |
| 384 | |
| 385 | aat2870->reg_cache = aat2870_regs; |
| 386 | |
| 387 | if (pdata->en_pin < 0) |
| 388 | aat2870->en_pin = -1; |
| 389 | else |
| 390 | aat2870->en_pin = pdata->en_pin; |
| 391 | |
| 392 | aat2870->init = pdata->init; |
| 393 | aat2870->uninit = pdata->uninit; |
| 394 | aat2870->read = aat2870_read; |
| 395 | aat2870->write = aat2870_write; |
| 396 | aat2870->update = aat2870_update; |
| 397 | |
| 398 | mutex_init(&aat2870->io_lock); |
| 399 | |
| 400 | if (aat2870->init) |
| 401 | aat2870->init(aat2870); |
| 402 | |
| 403 | if (aat2870->en_pin >= 0) { |
Jingoo Han | 0287714 | 2013-02-20 18:29:53 +0900 | [diff] [blame] | 404 | ret = devm_gpio_request_one(&client->dev, aat2870->en_pin, |
| 405 | GPIOF_OUT_INIT_HIGH, "aat2870-en"); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 406 | if (ret < 0) { |
| 407 | dev_err(&client->dev, |
| 408 | "Failed to request GPIO %d\n", aat2870->en_pin); |
Jingoo Han | 0287714 | 2013-02-20 18:29:53 +0900 | [diff] [blame] | 409 | return ret; |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 410 | } |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 411 | } |
| 412 | |
| 413 | aat2870_enable(aat2870); |
| 414 | |
| 415 | for (i = 0; i < pdata->num_subdevs; i++) { |
| 416 | for (j = 0; j < ARRAY_SIZE(aat2870_devs); j++) { |
| 417 | if ((pdata->subdevs[i].id == aat2870_devs[j].id) && |
| 418 | !strcmp(pdata->subdevs[i].name, |
| 419 | aat2870_devs[j].name)) { |
| 420 | aat2870_devs[j].platform_data = |
| 421 | pdata->subdevs[i].platform_data; |
| 422 | break; |
| 423 | } |
| 424 | } |
| 425 | } |
| 426 | |
| 427 | ret = mfd_add_devices(aat2870->dev, 0, aat2870_devs, |
Mark Brown | 0848c94 | 2012-09-11 15:16:36 +0800 | [diff] [blame] | 428 | ARRAY_SIZE(aat2870_devs), NULL, 0, NULL); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 429 | if (ret != 0) { |
| 430 | dev_err(aat2870->dev, "Failed to add subdev: %d\n", ret); |
| 431 | goto out_disable; |
| 432 | } |
| 433 | |
| 434 | aat2870_init_debugfs(aat2870); |
| 435 | |
| 436 | return 0; |
| 437 | |
| 438 | out_disable: |
| 439 | aat2870_disable(aat2870); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 440 | return ret; |
| 441 | } |
| 442 | |
| 443 | static int aat2870_i2c_remove(struct i2c_client *client) |
| 444 | { |
| 445 | struct aat2870_data *aat2870 = i2c_get_clientdata(client); |
| 446 | |
| 447 | aat2870_uninit_debugfs(aat2870); |
| 448 | |
| 449 | mfd_remove_devices(aat2870->dev); |
| 450 | aat2870_disable(aat2870); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 451 | if (aat2870->uninit) |
| 452 | aat2870->uninit(aat2870); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 453 | |
| 454 | return 0; |
| 455 | } |
| 456 | |
Mark Brown | 5214e56 | 2011-12-28 17:40:28 +0000 | [diff] [blame] | 457 | #ifdef CONFIG_PM_SLEEP |
| 458 | static int aat2870_i2c_suspend(struct device *dev) |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 459 | { |
Mark Brown | 5214e56 | 2011-12-28 17:40:28 +0000 | [diff] [blame] | 460 | struct i2c_client *client = to_i2c_client(dev); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 461 | struct aat2870_data *aat2870 = i2c_get_clientdata(client); |
| 462 | |
| 463 | aat2870_disable(aat2870); |
| 464 | |
| 465 | return 0; |
| 466 | } |
| 467 | |
Mark Brown | 5214e56 | 2011-12-28 17:40:28 +0000 | [diff] [blame] | 468 | static int aat2870_i2c_resume(struct device *dev) |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 469 | { |
Mark Brown | 5214e56 | 2011-12-28 17:40:28 +0000 | [diff] [blame] | 470 | struct i2c_client *client = to_i2c_client(dev); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 471 | struct aat2870_data *aat2870 = i2c_get_clientdata(client); |
| 472 | struct aat2870_register *reg = NULL; |
| 473 | int i; |
| 474 | |
| 475 | aat2870_enable(aat2870); |
| 476 | |
| 477 | /* restore registers */ |
| 478 | for (i = 0; i < AAT2870_REG_NUM; i++) { |
| 479 | reg = &aat2870->reg_cache[i]; |
| 480 | if (reg->writeable) |
| 481 | aat2870->write(aat2870, i, reg->value); |
| 482 | } |
| 483 | |
| 484 | return 0; |
| 485 | } |
Mark Brown | 5214e56 | 2011-12-28 17:40:28 +0000 | [diff] [blame] | 486 | #endif /* CONFIG_PM_SLEEP */ |
| 487 | |
| 488 | static SIMPLE_DEV_PM_OPS(aat2870_pm_ops, aat2870_i2c_suspend, |
| 489 | aat2870_i2c_resume); |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 490 | |
Axel Lin | d4e9486 | 2011-12-19 20:02:22 +0800 | [diff] [blame] | 491 | static const struct i2c_device_id aat2870_i2c_id_table[] = { |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 492 | { "aat2870", 0 }, |
| 493 | { } |
| 494 | }; |
| 495 | MODULE_DEVICE_TABLE(i2c, aat2870_i2c_id_table); |
| 496 | |
| 497 | static struct i2c_driver aat2870_i2c_driver = { |
| 498 | .driver = { |
| 499 | .name = "aat2870", |
| 500 | .owner = THIS_MODULE, |
Mark Brown | 5214e56 | 2011-12-28 17:40:28 +0000 | [diff] [blame] | 501 | .pm = &aat2870_pm_ops, |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 502 | }, |
| 503 | .probe = aat2870_i2c_probe, |
| 504 | .remove = aat2870_i2c_remove, |
Jin Park | 09d6292 | 2011-07-04 19:48:12 +0200 | [diff] [blame] | 505 | .id_table = aat2870_i2c_id_table, |
| 506 | }; |
| 507 | |
| 508 | static int __init aat2870_init(void) |
| 509 | { |
| 510 | return i2c_add_driver(&aat2870_i2c_driver); |
| 511 | } |
| 512 | subsys_initcall(aat2870_init); |
| 513 | |
| 514 | static void __exit aat2870_exit(void) |
| 515 | { |
| 516 | i2c_del_driver(&aat2870_i2c_driver); |
| 517 | } |
| 518 | module_exit(aat2870_exit); |
| 519 | |
| 520 | MODULE_DESCRIPTION("Core support for the AnalogicTech AAT2870"); |
| 521 | MODULE_LICENSE("GPL"); |
| 522 | MODULE_AUTHOR("Jin Park <jinyoungp@nvidia.com>"); |