armbian/linux
0
0
Fork 0
mirror of https://github.com/armbian/linux.git synced 2026-01-06 10:13:00 -08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "pca963x: Phillips PCA963X 4-bit i2c led driver"

Browse Source 
This reverts commit 24152b5a73.
This commit is contained in:
黄涛
2011-07-30 22:27:01 +08:00
parent e2a7bbb191
commit fe09b9072b
3 changed files with 0 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
drivers/i2c/chips/Kconfig
View File

@@ -26,14 +26,4 @@ config SENSORS_TSL2550
This driver can also be built as a module. If so, the module
will be called tsl2550.
config SENSORS_PCA963X
tristate "Philips PCA963X 4-bit I2C-bus LED"
depends on I2C && EXPERIMENTAL
help
If you say yes here you get support for the Philips PCA963X
4-bit I2C-bus LED.
This driver can also be built as a module. If so, the module
will be called pca963X.
endmenu

1
drivers/i2c/chips/Makefile
View File

@@ -11,7 +11,6 @@
#
obj-$(CONFIG_DS1682) += ds1682.o
obj-$(CONFIG_SENSORS_PCA963X) += pca963x.o
obj-$(CONFIG_SENSORS_TSL2550) += tsl2550.o
ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)

430
drivers/i2c/chips/pca963x.c
View File

@@ -1,430 +0,0 @@
/* 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);