linux/drivers/mfd/max8925-i2c.c
<<
>>
Prefs
   1/*
   2 * I2C driver for Maxim MAX8925
   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/max8925.h>
  16#include <linux/slab.h>
  17
  18#define RTC_I2C_ADDR            0x68
  19#define ADC_I2C_ADDR            0x47
  20
  21static inline int max8925_read_device(struct i2c_client *i2c,
  22                                      int reg, int bytes, void *dest)
  23{
  24        int ret;
  25
  26        if (bytes > 1)
  27                ret = i2c_smbus_read_i2c_block_data(i2c, reg, bytes, dest);
  28        else {
  29                ret = i2c_smbus_read_byte_data(i2c, reg);
  30                if (ret < 0)
  31                        return ret;
  32                *(unsigned char *)dest = (unsigned char)ret;
  33        }
  34        return ret;
  35}
  36
  37static inline int max8925_write_device(struct i2c_client *i2c,
  38                                       int reg, int bytes, void *src)
  39{
  40        unsigned char buf[bytes + 1];
  41        int ret;
  42
  43        buf[0] = (unsigned char)reg;
  44        memcpy(&buf[1], src, bytes);
  45
  46        ret = i2c_master_send(i2c, buf, bytes + 1);
  47        if (ret < 0)
  48                return ret;
  49        return 0;
  50}
  51
  52int max8925_reg_read(struct i2c_client *i2c, int reg)
  53{
  54        struct max8925_chip *chip = i2c_get_clientdata(i2c);
  55        unsigned char data = 0;
  56        int ret;
  57
  58        mutex_lock(&chip->io_lock);
  59        ret = max8925_read_device(i2c, reg, 1, &data);
  60        mutex_unlock(&chip->io_lock);
  61
  62        if (ret < 0)
  63                return ret;
  64        else
  65                return (int)data;
  66}
  67EXPORT_SYMBOL(max8925_reg_read);
  68
  69int max8925_reg_write(struct i2c_client *i2c, int reg,
  70                unsigned char data)
  71{
  72        struct max8925_chip *chip = i2c_get_clientdata(i2c);
  73        int ret;
  74
  75        mutex_lock(&chip->io_lock);
  76        ret = max8925_write_device(i2c, reg, 1, &data);
  77        mutex_unlock(&chip->io_lock);
  78
  79        return ret;
  80}
  81EXPORT_SYMBOL(max8925_reg_write);
  82
  83int max8925_bulk_read(struct i2c_client *i2c, int reg,
  84                int count, unsigned char *buf)
  85{
  86        struct max8925_chip *chip = i2c_get_clientdata(i2c);
  87        int ret;
  88
  89        mutex_lock(&chip->io_lock);
  90        ret = max8925_read_device(i2c, reg, count, buf);
  91        mutex_unlock(&chip->io_lock);
  92
  93        return ret;
  94}
  95EXPORT_SYMBOL(max8925_bulk_read);
  96
  97int max8925_bulk_write(struct i2c_client *i2c, int reg,
  98                int count, unsigned char *buf)
  99{
 100        struct max8925_chip *chip = i2c_get_clientdata(i2c);
 101        int ret;
 102
 103        mutex_lock(&chip->io_lock);
 104        ret = max8925_write_device(i2c, reg, count, buf);
 105        mutex_unlock(&chip->io_lock);
 106
 107        return ret;
 108}
 109EXPORT_SYMBOL(max8925_bulk_write);
 110
 111int max8925_set_bits(struct i2c_client *i2c, int reg,
 112                unsigned char mask, unsigned char data)
 113{
 114        struct max8925_chip *chip = i2c_get_clientdata(i2c);
 115        unsigned char value;
 116        int ret;
 117
 118        mutex_lock(&chip->io_lock);
 119        ret = max8925_read_device(i2c, reg, 1, &value);
 120        if (ret < 0)
 121                goto out;
 122        value &= ~mask;
 123        value |= data;
 124        ret = max8925_write_device(i2c, reg, 1, &value);
 125out:
 126        mutex_unlock(&chip->io_lock);
 127        return ret;
 128}
 129EXPORT_SYMBOL(max8925_set_bits);
 130
 131
 132static const struct i2c_device_id max8925_id_table[] = {
 133        { "max8925", 0 },
 134        { },
 135};
 136MODULE_DEVICE_TABLE(i2c, max8925_id_table);
 137
 138static int max8925_dt_init(struct device_node *np, struct device *dev,
 139                           struct max8925_platform_data *pdata)
 140{
 141        int ret;
 142
 143        ret = of_property_read_u32(np, "maxim,tsc-irq", &pdata->tsc_irq);
 144        if (ret) {
 145                dev_err(dev, "Not found maxim,tsc-irq property\n");
 146                return -EINVAL;
 147        }
 148        return 0;
 149}
 150
 151static int max8925_probe(struct i2c_client *client,
 152                                   const struct i2c_device_id *id)
 153{
 154        struct max8925_platform_data *pdata = dev_get_platdata(&client->dev);
 155        static struct max8925_chip *chip;
 156        struct device_node *node = client->dev.of_node;
 157
 158        if (node && !pdata) {
 159                /* parse DT to get platform data */
 160                pdata = devm_kzalloc(&client->dev,
 161                                     sizeof(struct max8925_platform_data),
 162                                     GFP_KERNEL);
 163                if (!pdata)
 164                        return -ENOMEM;
 165
 166                if (max8925_dt_init(node, &client->dev, pdata))
 167                        return -EINVAL;
 168        } else if (!pdata) {
 169                pr_info("%s: platform data is missing\n", __func__);
 170                return -EINVAL;
 171        }
 172
 173        chip = devm_kzalloc(&client->dev,
 174                            sizeof(struct max8925_chip), GFP_KERNEL);
 175        if (chip == NULL)
 176                return -ENOMEM;
 177        chip->i2c = client;
 178        chip->dev = &client->dev;
 179        i2c_set_clientdata(client, chip);
 180        dev_set_drvdata(chip->dev, chip);
 181        mutex_init(&chip->io_lock);
 182
 183        chip->rtc = i2c_new_dummy(chip->i2c->adapter, RTC_I2C_ADDR);
 184        i2c_set_clientdata(chip->rtc, chip);
 185
 186        chip->adc = i2c_new_dummy(chip->i2c->adapter, ADC_I2C_ADDR);
 187        i2c_set_clientdata(chip->adc, chip);
 188
 189        device_init_wakeup(&client->dev, 1);
 190
 191        max8925_device_init(chip, pdata);
 192
 193        return 0;
 194}
 195
 196static int max8925_remove(struct i2c_client *client)
 197{
 198        struct max8925_chip *chip = i2c_get_clientdata(client);
 199
 200        max8925_device_exit(chip);
 201        i2c_unregister_device(chip->adc);
 202        i2c_unregister_device(chip->rtc);
 203        return 0;
 204}
 205
 206#ifdef CONFIG_PM_SLEEP
 207static int max8925_suspend(struct device *dev)
 208{
 209        struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 210        struct max8925_chip *chip = i2c_get_clientdata(client);
 211
 212        if (device_may_wakeup(dev) && chip->wakeup_flag)
 213                enable_irq_wake(chip->core_irq);
 214        return 0;
 215}
 216
 217static int max8925_resume(struct device *dev)
 218{
 219        struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 220        struct max8925_chip *chip = i2c_get_clientdata(client);
 221
 222        if (device_may_wakeup(dev) && chip->wakeup_flag)
 223                disable_irq_wake(chip->core_irq);
 224        return 0;
 225}
 226#endif
 227
 228static SIMPLE_DEV_PM_OPS(max8925_pm_ops, max8925_suspend, max8925_resume);
 229
 230static const struct of_device_id max8925_dt_ids[] = {
 231        { .compatible = "maxim,max8925", },
 232        {},
 233};
 234MODULE_DEVICE_TABLE(of, max8925_dt_ids);
 235
 236static struct i2c_driver max8925_driver = {
 237        .driver = {
 238                .name   = "max8925",
 239                .owner  = THIS_MODULE,
 240                .pm     = &max8925_pm_ops,
 241                .of_match_table = of_match_ptr(max8925_dt_ids),
 242        },
 243        .probe          = max8925_probe,
 244        .remove         = max8925_remove,
 245        .id_table       = max8925_id_table,
 246};
 247
 248static int __init max8925_i2c_init(void)
 249{
 250        int ret;
 251        ret = i2c_add_driver(&max8925_driver);
 252        if (ret != 0)
 253                pr_err("Failed to register MAX8925 I2C driver: %d\n", ret);
 254        return ret;
 255}
 256subsys_initcall(max8925_i2c_init);
 257
 258static void __exit max8925_i2c_exit(void)
 259{
 260        i2c_del_driver(&max8925_driver);
 261}
 262module_exit(max8925_i2c_exit);
 263
 264MODULE_DESCRIPTION("I2C Driver for Maxim 8925");
 265MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
 266MODULE_LICENSE("GPL");
 267
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.