88pm860x-i2c.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. /*
  2. * I2C driver for Marvell 88PM8607
  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/88pm8607.h>
  16. static inline int pm8607_read_device(struct pm8607_chip *chip,
  17. int reg, int bytes, void *dest)
  18. {
  19. struct i2c_client *i2c = chip->client;
  20. unsigned char data;
  21. int ret;
  22. data = (unsigned char)reg;
  23. ret = i2c_master_send(i2c, &data, 1);
  24. if (ret < 0)
  25. return ret;
  26. ret = i2c_master_recv(i2c, dest, bytes);
  27. if (ret < 0)
  28. return ret;
  29. return 0;
  30. }
  31. static inline int pm8607_write_device(struct pm8607_chip *chip,
  32. int reg, int bytes, void *src)
  33. {
  34. struct i2c_client *i2c = chip->client;
  35. unsigned char buf[bytes + 1];
  36. int ret;
  37. buf[0] = (unsigned char)reg;
  38. memcpy(&buf[1], src, bytes);
  39. ret = i2c_master_send(i2c, buf, bytes + 1);
  40. if (ret < 0)
  41. return ret;
  42. return 0;
  43. }
  44. int pm8607_reg_read(struct pm8607_chip *chip, int reg)
  45. {
  46. unsigned char data;
  47. int ret;
  48. mutex_lock(&chip->io_lock);
  49. ret = chip->read(chip, reg, 1, &data);
  50. mutex_unlock(&chip->io_lock);
  51. if (ret < 0)
  52. return ret;
  53. else
  54. return (int)data;
  55. }
  56. EXPORT_SYMBOL(pm8607_reg_read);
  57. int pm8607_reg_write(struct pm8607_chip *chip, int reg,
  58. unsigned char data)
  59. {
  60. int ret;
  61. mutex_lock(&chip->io_lock);
  62. ret = chip->write(chip, reg, 1, &data);
  63. mutex_unlock(&chip->io_lock);
  64. return ret;
  65. }
  66. EXPORT_SYMBOL(pm8607_reg_write);
  67. int pm8607_bulk_read(struct pm8607_chip *chip, int reg,
  68. int count, unsigned char *buf)
  69. {
  70. int ret;
  71. mutex_lock(&chip->io_lock);
  72. ret = chip->read(chip, reg, count, buf);
  73. mutex_unlock(&chip->io_lock);
  74. return ret;
  75. }
  76. EXPORT_SYMBOL(pm8607_bulk_read);
  77. int pm8607_bulk_write(struct pm8607_chip *chip, int reg,
  78. int count, unsigned char *buf)
  79. {
  80. int ret;
  81. mutex_lock(&chip->io_lock);
  82. ret = chip->write(chip, reg, count, buf);
  83. mutex_unlock(&chip->io_lock);
  84. return ret;
  85. }
  86. EXPORT_SYMBOL(pm8607_bulk_write);
  87. int pm8607_set_bits(struct pm8607_chip *chip, int reg,
  88. unsigned char mask, unsigned char data)
  89. {
  90. unsigned char value;
  91. int ret;
  92. mutex_lock(&chip->io_lock);
  93. ret = chip->read(chip, reg, 1, &value);
  94. if (ret < 0)
  95. goto out;
  96. value &= ~mask;
  97. value |= data;
  98. ret = chip->write(chip, reg, 1, &value);
  99. out:
  100. mutex_unlock(&chip->io_lock);
  101. return ret;
  102. }
  103. EXPORT_SYMBOL(pm8607_set_bits);
  104. static const struct i2c_device_id pm860x_id_table[] = {
  105. { "88PM8607", 0 },
  106. {}
  107. };
  108. MODULE_DEVICE_TABLE(i2c, pm860x_id_table);
  109. static int __devinit pm860x_probe(struct i2c_client *client,
  110. const struct i2c_device_id *id)
  111. {
  112. struct pm8607_platform_data *pdata = client->dev.platform_data;
  113. struct pm8607_chip *chip;
  114. int ret;
  115. chip = kzalloc(sizeof(struct pm8607_chip), GFP_KERNEL);
  116. if (chip == NULL)
  117. return -ENOMEM;
  118. chip->client = client;
  119. chip->dev = &client->dev;
  120. chip->read = pm8607_read_device;
  121. chip->write = pm8607_write_device;
  122. memcpy(&chip->id, id, sizeof(struct i2c_device_id));
  123. i2c_set_clientdata(client, chip);
  124. mutex_init(&chip->io_lock);
  125. dev_set_drvdata(chip->dev, chip);
  126. ret = pm860x_device_init(chip, pdata);
  127. if (ret < 0)
  128. goto out;
  129. return 0;
  130. out:
  131. i2c_set_clientdata(client, NULL);
  132. kfree(chip);
  133. return ret;
  134. }
  135. static int __devexit pm860x_remove(struct i2c_client *client)
  136. {
  137. struct pm8607_chip *chip = i2c_get_clientdata(client);
  138. kfree(chip);
  139. return 0;
  140. }
  141. static struct i2c_driver pm860x_driver = {
  142. .driver = {
  143. .name = "88PM860x",
  144. .owner = THIS_MODULE,
  145. },
  146. .probe = pm860x_probe,
  147. .remove = __devexit_p(pm860x_remove),
  148. .id_table = pm860x_id_table,
  149. };
  150. static int __init pm860x_i2c_init(void)
  151. {
  152. int ret;
  153. ret = i2c_add_driver(&pm860x_driver);
  154. if (ret != 0)
  155. pr_err("Failed to register 88PM860x I2C driver: %d\n", ret);
  156. return ret;
  157. }
  158. subsys_initcall(pm860x_i2c_init);
  159. static void __exit pm860x_i2c_exit(void)
  160. {
  161. i2c_del_driver(&pm860x_driver);
  162. }
  163. module_exit(pm860x_i2c_exit);
  164. MODULE_DESCRIPTION("I2C Driver for Marvell 88PM860x");
  165. MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
  166. MODULE_LICENSE("GPL");