--- /dev/null
+/* pca963x.c - 4-bit I2C-bus LED driver
+ *
+ * Copyright (C) 2008 HTC Corporation.
+ * Author: Shan-Fu Chiou <sfchiou@gmail.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/leds.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+
+static uint8_t address[] = { 0x02, 0x03, 0x04 };
+static DEFINE_SPINLOCK(pca963x_lock);
+
+enum op_t {
+ OP_SET_BLINK,
+ OP_SET_GRPPWM,
+ OP_SET_GRPFREQ,
+ OP_SET_BLUE_BRIGHTNESS,
+ OP_SET_GREEN_BRIGHTNESS,
+ OP_SET_RED_BRIGHTNESS,
+};
+
+enum power_mode {
+ MODE_SLEEP,
+ MODE_NORMAL,
+};
+
+struct pca963x_t {
+ uint8_t colors[3];
+ uint8_t blink;
+ uint8_t grppwm;
+ uint8_t grpfreq;
+};
+
+struct pca963x_data {
+ struct pca963x_t data;
+ uint8_t dirty;
+ uint8_t status;
+ enum power_mode mode;
+ struct work_struct work;
+ struct i2c_client *client;
+ struct led_classdev leds[3]; /* blue, green, red */
+};
+
+static ssize_t pca963x_blink_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ if (((pca963x->dirty >> OP_SET_BLINK) & 0x01))
+ flush_scheduled_work();
+ return sprintf(buf, "%u\n", pca963x->data.blink);
+}
+
+static ssize_t pca963x_blink_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ int val = -1;
+
+ sscanf(buf, "%u", &val);
+ if (val < 0 || val > 1)
+ return -EINVAL;
+
+ spin_lock(&pca963x_lock);
+ pca963x->dirty |= 1 << OP_SET_BLINK;
+ pca963x->data.blink = val;
+ spin_unlock(&pca963x_lock);
+ schedule_work(&pca963x->work);
+
+ return count;
+}
+
+static DEVICE_ATTR(blink, 0644, pca963x_blink_show, pca963x_blink_store);
+
+static ssize_t pca963x_grpfreq_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ if (((pca963x->dirty >> OP_SET_GRPFREQ) & 0x01))
+ flush_scheduled_work();
+ return sprintf(buf, "%u\n", pca963x->data.grpfreq);
+}
+
+static ssize_t pca963x_grpfreq_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ if (val > 0xff)
+ return -EINVAL;
+
+ spin_lock(&pca963x_lock);
+ pca963x->dirty |= 1 << OP_SET_GRPFREQ;
+ pca963x->data.grpfreq = val;
+ spin_unlock(&pca963x_lock);
+ schedule_work(&pca963x->work);
+
+ return count;
+}
+
+static DEVICE_ATTR(grpfreq, 0644, pca963x_grpfreq_show, pca963x_grpfreq_store);
+
+static ssize_t pca963x_grppwm_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ if (((pca963x->dirty >> OP_SET_GRPPWM) & 0x01))
+ flush_scheduled_work();
+ return sprintf(buf, "%u\n", pca963x->data.grppwm);
+}
+
+static ssize_t pca963x_grppwm_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ if (val > 0xff)
+ return -EINVAL;
+
+ spin_lock(&pca963x_lock);
+ pca963x->dirty |= 1 << OP_SET_GRPPWM;
+ pca963x->data.grppwm = val;
+ spin_unlock(&pca963x_lock);
+ schedule_work(&pca963x->work);
+
+ return count;
+}
+
+static DEVICE_ATTR(grppwm, 0644, pca963x_grppwm_show, pca963x_grppwm_store);
+
+static void led_brightness_set(struct led_classdev *led_cdev,
+ enum led_brightness brightness)
+{
+ struct pca963x_data *pca963x;
+ int idx = 2;
+
+ spin_lock(&pca963x_lock);
+ if (!strcmp(led_cdev->name, "blue")) {
+ idx = 0;
+ } else if (!strcmp(led_cdev->name, "green")) {
+ idx = 1;
+ } else {
+ idx = 2;
+ }
+ pca963x = container_of(led_cdev, struct pca963x_data, leds[idx]);
+ pca963x->data.colors[idx] = brightness;
+ pca963x->dirty |= (1 << (OP_SET_BLUE_BRIGHTNESS + idx));
+ spin_unlock(&pca963x_lock);
+
+ schedule_work(&pca963x->work);
+
+}
+
+static void pca963x_update_brightness(struct pca963x_data *pca963x, int idx,
+ int brightness)
+{
+ if (brightness > LED_OFF) {
+ if (brightness == LED_FULL) {
+ pca963x->status &= ~(1 << idx);
+ pca963x->status |= (1 << (idx + 4));
+ } else {
+ pca963x->status |= (1 << idx);
+ pca963x->status &= ~(1 << (idx + 4));
+ }
+ } else {
+ pca963x->status &= ~(1 << idx);
+ pca963x->status &= ~(1 << (idx + 4));
+ }
+ i2c_smbus_write_byte_data(pca963x->client, address[idx], brightness);
+}
+
+static void pca963x_work_func(struct work_struct *work)
+{
+ int ret;
+ uint8_t dirty = 0;
+ struct pca963x_t work_data;
+ struct pca963x_data *pca963x =
+ container_of(work, struct pca963x_data, work);
+
+ spin_lock(&pca963x_lock);
+ work_data = pca963x->data;
+ dirty = pca963x->dirty;
+ pca963x->dirty = 0;
+ spin_unlock(&pca963x_lock);
+
+ ret = i2c_smbus_read_byte_data(pca963x->client, 0x00);
+ /* check if should switch to normal mode */
+ if (!pca963x->mode) {
+ i2c_smbus_write_byte_data(pca963x->client, 0x00, 0x01);
+ pca963x->mode = MODE_NORMAL;
+ i2c_smbus_write_byte_data(pca963x->client, 0x08, 0xFF);
+ }
+
+ if ((dirty >> OP_SET_BLINK) & 0x01) {
+ ret = i2c_smbus_read_byte_data(pca963x->client, 0x01);
+ if (work_data.blink) /* enable blinking */
+ i2c_smbus_write_byte_data(pca963x->client, 0x01,
+ ret | 0x20);
+ else {
+ /* set group duty cycle control to default */
+ i2c_smbus_write_byte_data(pca963x->client, 0x06, 0xFF);
+ /* set group frequency to default */
+ i2c_smbus_write_byte_data(pca963x->client, 0x07, 0x00);
+ /* enable dimming */
+ i2c_smbus_write_byte_data(pca963x->client, 0x01,
+ ret & 0xDF);
+ }
+ }
+
+ if ((dirty >> OP_SET_GRPPWM) & 0x01) {
+ i2c_smbus_write_byte_data(pca963x->client, 0x06,
+ work_data.grppwm);
+ }
+
+ if ((dirty >> OP_SET_GRPFREQ) & 0x01) {
+ i2c_smbus_write_byte_data(pca963x->client, 0x07,
+ work_data.grpfreq);
+ }
+
+ if ((dirty >> OP_SET_BLUE_BRIGHTNESS) & 0x01)
+ pca963x_update_brightness(pca963x, 0, work_data.colors[0]);
+
+ if ((dirty >> OP_SET_GREEN_BRIGHTNESS) & 0x01)
+ pca963x_update_brightness(pca963x, 1, work_data.colors[1]);
+
+ if ((dirty >> OP_SET_RED_BRIGHTNESS) & 0x01)
+ pca963x_update_brightness(pca963x, 2, work_data.colors[2]);
+
+ /* check if could go to low power mode */
+ if (((pca963x->status & 0x0F) == 0) && (!work_data.blink)) {
+ i2c_smbus_write_byte_data(pca963x->client, 0x08, 0xAA);
+ i2c_smbus_write_byte_data(pca963x->client, 0x00, 0x11);
+ pca963x->mode = MODE_SLEEP;
+ }
+}
+
+static void set_pca963x_default(struct i2c_client *client)
+{
+ i2c_smbus_write_byte_data(client, 0x00, 0x01);
+ i2c_smbus_write_byte_data(client, 0x01, 0x00);
+ /* set all LEDx brightness off */
+ i2c_smbus_write_byte_data(client, address[0], LED_OFF);
+ i2c_smbus_write_byte_data(client, address[1], LED_OFF);
+ i2c_smbus_write_byte_data(client, address[2], LED_OFF);
+ /* set group duty cycle control to default */
+ i2c_smbus_write_byte_data(client, 0x06, 0xFF);
+ /* set group frequency to default */
+ i2c_smbus_write_byte_data(client, 0x07, 0x00);
+ /*
+ * set LEDx individual brightness and group dimming/blinking
+ * can be controlled by * its PWMx register and GRPPWM registers.
+ */
+ i2c_smbus_write_byte_data(client, 0x08, 0xFF);
+ /* low power mode. oscillator off */
+ i2c_smbus_write_byte_data(client, 0x00, 0x11);
+}
+
+static int pca963x_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ int ret = 0;
+
+ struct pca963x_data *pca963x;
+
+ if (!i2c_check_functionality(client->adapter,
+ I2C_FUNC_SMBUS_BYTE_DATA)) {
+ ret = -ENODEV;
+ goto exit;
+ }
+
+ pca963x = kzalloc(sizeof(struct pca963x_data), GFP_KERNEL);
+ if (pca963x == NULL) {
+ ret = -ENOMEM;
+ goto err_alloc_failed;
+ }
+
+ INIT_WORK(&pca963x->work, pca963x_work_func);
+
+ pca963x->client = client;
+
+ pca963x->leds[0].name = "blue";
+ pca963x->leds[0].brightness = LED_OFF;
+ pca963x->leds[0].brightness_set = led_brightness_set;
+
+ pca963x->leds[1].name = "green";
+ pca963x->leds[1].brightness = LED_OFF;
+ pca963x->leds[1].brightness_set = led_brightness_set;
+
+ pca963x->leds[2].name = "red";
+ pca963x->leds[2].brightness = LED_OFF;
+ pca963x->leds[2].brightness_set = led_brightness_set;
+
+ pca963x->dirty = 0;
+ pca963x->status = 0;
+
+ pca963x->data.colors[0] = LED_OFF;
+ pca963x->data.colors[1] = LED_OFF;
+ pca963x->data.colors[2] = LED_OFF;
+ pca963x->data.blink = 0;
+ pca963x->data.grppwm = 0;
+ pca963x->data.grpfreq = 0;
+ i2c_set_clientdata(client, pca963x);
+
+ set_pca963x_default(client);
+ pca963x->mode = MODE_SLEEP;
+
+ /* blue */
+ ret = led_classdev_register(&client->dev, &pca963x->leds[0]);
+ if (ret < 0) {
+ printk(KERN_ERR "pca963x: led_classdev_register failed\n");
+ goto err_led0_classdev_register_failed;
+ }
+ /* green */
+ ret = led_classdev_register(&client->dev, &pca963x->leds[1]);
+ if (ret < 0) {
+ printk(KERN_ERR "pca963x: led_classdev_register failed\n");
+ goto err_led1_classdev_register_failed;
+ }
+ /* red */
+ ret = led_classdev_register(&client->dev, &pca963x->leds[2]);
+ if (ret < 0) {
+ printk(KERN_ERR "pca963x: led_classdev_register failed\n");
+ goto err_led2_classdev_register_failed;
+ }
+
+ ret = device_create_file(&client->dev, &dev_attr_blink);
+ ret = device_create_file(&client->dev, &dev_attr_grppwm);
+ ret = device_create_file(&client->dev, &dev_attr_grpfreq);
+
+ return 0;
+
+err_led2_classdev_register_failed:
+ led_classdev_unregister(&pca963x->leds[2]);
+err_led1_classdev_register_failed:
+ led_classdev_unregister(&pca963x->leds[1]);
+err_led0_classdev_register_failed:
+ led_classdev_unregister(&pca963x->leds[0]);
+err_alloc_failed:
+ kfree(pca963x);
+exit:
+ return ret;
+}
+
+static int pca963x_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+ flush_scheduled_work();
+ return 0;
+}
+
+static int pca963x_remove(struct i2c_client *client)
+{
+ struct pca963x_data *pca963x = i2c_get_clientdata(client);
+
+ cancel_work_sync(&pca963x->work);
+ device_remove_file(&client->dev, &dev_attr_blink);
+ device_remove_file(&client->dev, &dev_attr_grppwm);
+ device_remove_file(&client->dev, &dev_attr_grpfreq);
+ set_pca963x_default(client);
+ led_classdev_unregister(&pca963x->leds[0]);
+ led_classdev_unregister(&pca963x->leds[1]);
+ led_classdev_unregister(&pca963x->leds[2]);
+
+ kfree(pca963x);
+ return 0;
+}
+
+static const struct i2c_device_id pca963x_id[] = {
+ { "pca963x", 0 },
+ { }
+};
+
+static struct i2c_driver pca963x_driver = {
+ .driver = {
+ .name = "pca963x",
+ },
+ .probe = pca963x_probe,
+ .suspend = pca963x_suspend,
+ .remove = pca963x_remove,
+ .id_table = pca963x_id,
+};
+
+static int __init pca963x_init(void)
+{
+ return i2c_add_driver(&pca963x_driver);
+}
+
+static void __exit pca963x_exit(void)
+{
+ i2c_del_driver(&pca963x_driver);
+}
+
+MODULE_AUTHOR("Shan-Fu Chiou <sfchiou@gmail.com>");
+MODULE_DESCRIPTION("pca963x driver");
+MODULE_LICENSE("GPL");
+
+module_init(pca963x_init);
+module_exit(pca963x_exit);
projects / firefly-linux-kernel-4.4.55.git / commitdiff