From patchwork Wed Nov 10 12:47:58 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Trilok Soni X-Patchwork-Id: 314162 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by demeter1.kernel.org (8.14.4/8.14.3) with ESMTP id oAACo6rI012330 for ; Wed, 10 Nov 2010 12:50:08 GMT Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755881Ab0KJMtb (ORCPT ); Wed, 10 Nov 2010 07:49:31 -0500 Received: from wolverine01.qualcomm.com ([199.106.114.254]:19080 "EHLO wolverine01.qualcomm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755896Ab0KJMsk (ORCPT ); Wed, 10 Nov 2010 07:48:40 -0500 X-IronPort-AV: E=McAfee;i="5400,1158,6162"; a="61428852" Received: from pdmz-ns-mip.qualcomm.com (HELO mostmsg01.qualcomm.com) ([199.106.114.10]) by wolverine01.qualcomm.com with ESMTP/TLS/ADH-AES256-SHA; 10 Nov 2010 04:48:40 -0800 Received: from localhost.localdomain (pdmz-snip-v218.qualcomm.com [192.168.218.1]) by mostmsg01.qualcomm.com (Postfix) with ESMTPA id 2C4F910004B5; Wed, 10 Nov 2010 04:48:31 -0800 (PST) From: Trilok Soni To: linux-kernel@vger.kernel.org Cc: linux-input@vger.kernel.org, rtc-linux@googlegroups.com, linux-arm-msm@vger.kernel.org, Trilok Soni , Richard Purdie Subject: [RFC v1 PATCH 3/6] led: pmic8058: Add PMIC8058 leds driver Date: Wed, 10 Nov 2010 18:17:58 +0530 Message-Id: <1289393281-4459-4-git-send-email-tsoni@codeaurora.org> X-Mailer: git-send-email 1.7.0.2 In-Reply-To: <1289393281-4459-1-git-send-email-tsoni@codeaurora.org> References: <1289393281-4459-1-git-send-email-tsoni@codeaurora.org> Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org X-Greylist: IP, sender and recipient auto-whitelisted, not delayed by milter-greylist-4.2.3 (demeter1.kernel.org [140.211.167.41]); Wed, 10 Nov 2010 12:50:08 +0000 (UTC) diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig index cc2a88d..e1ebcad 100644 --- a/drivers/leds/Kconfig +++ b/drivers/leds/Kconfig @@ -214,6 +214,17 @@ config LEDS_PCA955X LED driver chips accessed via the I2C bus. Supported devices include PCA9550, PCA9551, PCA9552, and PCA9553. +config LEDS_PMIC8058 + tristate "LED Support for Qualcomm PMIC8058" + depends on PMIC8058 + help + This option enables support for LEDs connected over PMIC8058 + (Power Management IC) chip on Qualcomm reference boards, + for example SURF and FFAs. + + To compile this driver as a module, choose M here: the module will + be called leds-pmic8058. + config LEDS_WM831X_STATUS tristate "LED support for status LEDs on WM831x PMICs" depends on MFD_WM831X diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile index 9c96db4..6c51883 100644 --- a/drivers/leds/Makefile +++ b/drivers/leds/Makefile @@ -21,6 +21,7 @@ obj-$(CONFIG_LEDS_COBALT_QUBE) += leds-cobalt-qube.o obj-$(CONFIG_LEDS_COBALT_RAQ) += leds-cobalt-raq.o obj-$(CONFIG_LEDS_SUNFIRE) += leds-sunfire.o obj-$(CONFIG_LEDS_PCA9532) += leds-pca9532.o +obj-$(CONFIG_LEDS_PMIC8058) += leds-pmic8058.o obj-$(CONFIG_LEDS_GPIO) += leds-gpio.o obj-$(CONFIG_LEDS_LP3944) += leds-lp3944.o obj-$(CONFIG_LEDS_CLEVO_MAIL) += leds-clevo-mail.o diff --git a/drivers/leds/leds-pmic8058.c b/drivers/leds/leds-pmic8058.c new file mode 100644 index 0000000..2933eb0 --- /dev/null +++ b/drivers/leds/leds-pmic8058.c @@ -0,0 +1,405 @@ +/* Copyright (c) 2010, Code Aurora Forum. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define SSBI_REG_ADDR_DRV_KEYPAD 0x48 +#define PM8058_DRV_KEYPAD_BL_MASK 0xf0 +#define PM8058_DRV_KEYPAD_BL_SHIFT 0x04 + +#define SSBI_REG_ADDR_FLASH_DRV0 0x49 +#define PM8058_DRV_FLASH_MASK 0xf0 +#define PM8058_DRV_FLASH_SHIFT 0x04 + +#define SSBI_REG_ADDR_FLASH_DRV1 0xFB + +#define SSBI_REG_ADDR_LED_CTRL_BASE 0x131 +#define SSBI_REG_ADDR_LED_CTRL(n) (SSBI_REG_ADDR_LED_CTRL_BASE + (n)) +#define PM8058_DRV_LED_CTRL_MASK 0xf8 +#define PM8058_DRV_LED_CTRL_SHIFT 0x03 + +#define MAX_FLASH_LED_CURRENT 300 +#define MAX_LC_LED_CURRENT 40 +#define MAX_KP_BL_LED_CURRENT 300 + +#define MAX_KEYPAD_BL_LEVEL (1 << 4) +#define MAX_LED_DRV_LEVEL 20 /* 2 * 20 mA */ + +#define PMIC8058_LED_OFFSET(id) ((id) - PMIC8058_ID_LED_0) + +#define PMIC8058_MAX_LEDS 7 + +/** + * struct pmic8058_led_data - internal led data structure + * @led_classdev - led class device + * @id - led index + * @led_brightness - led brightness levels + * @pm_chip - parent MFD core device + * @work - workqueue for led + * @lock - to protect the transactions + * @value_lock - to protect the register value writes + * @reg_kp - cached value of keypad led backlight register + * @reg_led_ctrl - cached values of low-current led registers + * @reg_flash_led0 - cached value of first flash led control register + * @reg_flash_led1 - cached value of second flash led control register + */ +struct pmic8058_led_data { + struct led_classdev cdev; + int id; + enum led_brightness brightness; + struct pm8058_chip *pm_chip; + struct work_struct work; + struct mutex lock; + spinlock_t value_lock; + u8 reg_kp; + u8 reg_led_ctrl[3]; + u8 reg_flash_led0; + u8 reg_flash_led1; +}; + +#define PM8058_MAX_LEDS 7 + +static void led_kp_set(struct pmic8058_led_data *led, enum led_brightness value) +{ + int rc; + u8 level; + unsigned long flags; + + spin_lock_irqsave(&led->value_lock, flags); + level = (value << PM8058_DRV_KEYPAD_BL_SHIFT) & + PM8058_DRV_KEYPAD_BL_MASK; + + led->reg_kp &= ~PM8058_DRV_KEYPAD_BL_MASK; + led->reg_kp |= level; + spin_unlock_irqrestore(&led->value_lock, flags); + + rc = pm8058_write(led->pm_chip, SSBI_REG_ADDR_DRV_KEYPAD, + &led->reg_kp, 1); + if (rc < 0) + dev_err(led->cdev.dev, "can't set keypad backlight level\n"); +} + +static enum led_brightness led_kp_get(struct pmic8058_led_data *led) +{ + if ((led->reg_kp & PM8058_DRV_KEYPAD_BL_MASK) >> + PM8058_DRV_KEYPAD_BL_SHIFT) + return LED_FULL; + else + return LED_OFF; +} + +static void led_lc_set(struct pmic8058_led_data *led, enum led_brightness value) +{ + unsigned long flags; + int rc, offset; + u8 level, tmp; + + spin_lock_irqsave(&led->value_lock, flags); + + level = (led->brightness << PM8058_DRV_LED_CTRL_SHIFT) & + PM8058_DRV_LED_CTRL_MASK; + + offset = PMIC8058_LED_OFFSET(led->id); + tmp = led->reg_led_ctrl[offset]; + + tmp &= ~PM8058_DRV_LED_CTRL_MASK; + tmp |= level; + spin_unlock_irqrestore(&led->value_lock, flags); + + rc = pm8058_write(led->pm_chip, SSBI_REG_ADDR_LED_CTRL(offset), + &tmp, 1); + if (rc) { + dev_err(led->cdev.dev, "can't set (%d) led value\n", + led->id); + return; + } + + spin_lock_irqsave(&led->value_lock, flags); + led->reg_led_ctrl[offset] = tmp; + spin_unlock_irqrestore(&led->value_lock, flags); +} + +static enum led_brightness led_lc_get(struct pmic8058_led_data *led) +{ + int offset; + u8 value; + + offset = PMIC8058_LED_OFFSET(led->id); + value = led->reg_led_ctrl[offset]; + + if ((value & PM8058_DRV_LED_CTRL_MASK) >> + PM8058_DRV_LED_CTRL_SHIFT) + return LED_FULL; + else + return LED_OFF; +} + +static void +led_flash_set(struct pmic8058_led_data *led, enum led_brightness value) +{ + int rc; + u8 level; + unsigned long flags; + u8 reg_flash_led; + u16 reg_addr; + + spin_lock_irqsave(&led->value_lock, flags); + level = (value << PM8058_DRV_FLASH_SHIFT) & + PM8058_DRV_FLASH_MASK; + + if (led->id == PMIC8058_ID_FLASH_LED_0) { + led->reg_flash_led0 &= ~PM8058_DRV_FLASH_MASK; + led->reg_flash_led0 |= level; + reg_flash_led = led->reg_flash_led0; + reg_addr = SSBI_REG_ADDR_FLASH_DRV0; + } else { + led->reg_flash_led1 &= ~PM8058_DRV_FLASH_MASK; + led->reg_flash_led1 |= level; + reg_flash_led = led->reg_flash_led1; + reg_addr = SSBI_REG_ADDR_FLASH_DRV1; + } + spin_unlock_irqrestore(&led->value_lock, flags); + + rc = pm8058_write(led->pm_chip, reg_addr, ®_flash_led, 1); + if (rc < 0) + dev_err(led->cdev.dev, "can't set flash led%d level\n", + led->id); +} + +static void pmic8058_led_work(struct work_struct *work) +{ + struct pmic8058_led_data *led = container_of(work, + struct pmic8058_led_data, work); + + mutex_lock(&led->lock); + + switch (led->id) { + case PMIC8058_ID_LED_KB_LIGHT: + led_kp_set(led, led->brightness); + break; + case PMIC8058_ID_LED_0: + case PMIC8058_ID_LED_1: + case PMIC8058_ID_LED_2: + led_lc_set(led, led->brightness); + break; + case PMIC8058_ID_FLASH_LED_0: + case PMIC8058_ID_FLASH_LED_1: + led_flash_set(led, led->brightness); + break; + } + + mutex_unlock(&led->lock); +} + +static void pmic8058_led_set(struct led_classdev *led_cdev, + enum led_brightness value) +{ + struct pmic8058_led_data *led; + unsigned long flags; + + led = container_of(led_cdev, struct pmic8058_led_data, cdev); + + spin_lock_irqsave(&led->value_lock, flags); + led->brightness = value; + schedule_work(&led->work); + spin_unlock_irqrestore(&led->value_lock, flags); +} + +static enum led_brightness pmic8058_led_get(struct led_classdev *led_cdev) +{ + struct pmic8058_led_data *led; + + led = container_of(led_cdev, struct pmic8058_led_data, cdev); + + switch (led->id) { + case PMIC8058_ID_LED_KB_LIGHT: + return led_kp_get(led); + case PMIC8058_ID_LED_0: + case PMIC8058_ID_LED_1: + case PMIC8058_ID_LED_2: + return led_lc_get(led); + } + return LED_OFF; +} + +static int pmic8058_led_probe(struct platform_device *pdev) +{ + struct pmic8058_leds_platform_data *pdata = pdev->dev.platform_data; + struct pmic8058_led_data *led_dat; + struct pmic8058_led *curr_led; + int rc, i = 0; + struct pm8058_chip *pm_chip; + u8 reg_kp; + u8 reg_led_ctrl[3]; + u8 reg_flash_led0; + u8 reg_flash_led1; + static struct pmic8058_led_data *led; + + pm_chip = platform_get_drvdata(pdev); + if (pm_chip == NULL) { + dev_err(&pdev->dev, "no parent data passed in\n"); + return -EFAULT; + } + + if (pdata == NULL) { + dev_err(&pdev->dev, "platform data not supplied\n"); + return -EINVAL; + } + + if (pdata->num_leds > PMIC8058_MAX_LEDS) { + dev_err(&pdev->dev, "can't handle more than %d LEDS\n", + PMIC8058_MAX_LEDS); + return -EFAULT; + } + + led = kzalloc(sizeof(*led) * pdata->num_leds, GFP_KERNEL); + if (led == NULL) { + dev_err(&pdev->dev, "failed to alloc memory\n"); + return -ENOMEM; + } + + rc = pm8058_read(pm_chip, SSBI_REG_ADDR_DRV_KEYPAD, ®_kp, + 1); + if (rc) { + dev_err(&pdev->dev, "can't get keypad backlight level\n"); + goto err_reg_read; + } + + rc = pm8058_read(pm_chip, SSBI_REG_ADDR_LED_CTRL_BASE, + reg_led_ctrl, 3); + if (rc) { + dev_err(&pdev->dev, "can't get led levels\n"); + goto err_reg_read; + } + + rc = pm8058_read(pm_chip, SSBI_REG_ADDR_FLASH_DRV0, + ®_flash_led0, 1); + if (rc) { + dev_err(&pdev->dev, "can't read flash led0\n"); + goto err_reg_read; + } + + rc = pm8058_read(pm_chip, SSBI_REG_ADDR_FLASH_DRV1, + ®_flash_led1, 1); + if (rc) { + dev_err(&pdev->dev, "can't get flash led1\n"); + goto err_reg_read; + } + + for (i = 0; i < pdata->num_leds; i++) { + curr_led = &pdata->leds[i]; + led_dat = &led[curr_led->id]; + + led_dat->cdev.name = curr_led->name; + led_dat->cdev.default_trigger = curr_led->default_trigger; + led_dat->cdev.brightness_set = pmic8058_led_set; + led_dat->cdev.brightness_get = pmic8058_led_get; + led_dat->cdev.brightness = LED_OFF; + led_dat->cdev.max_brightness = curr_led->max_brightness; + led_dat->cdev.flags = LED_CORE_SUSPENDRESUME; + + led_dat->id = curr_led->id; + led_dat->reg_kp = reg_kp; + memcpy(led->reg_led_ctrl, reg_led_ctrl, + sizeof(reg_led_ctrl)); + led_dat->reg_flash_led0 = reg_flash_led0; + led_dat->reg_flash_led1 = reg_flash_led1; + + if (!((led_dat->id >= PMIC8058_ID_LED_KB_LIGHT) && + (led_dat->id <= PMIC8058_ID_FLASH_LED_1))) { + dev_err(&pdev->dev, "invalid LED ID (%d) specified\n", + led_dat->id); + rc = -EINVAL; + goto fail_id_check; + } + + led_dat->pm_chip = pm_chip; + + mutex_init(&led_dat->lock); + spin_lock_init(&led_dat->value_lock); + INIT_WORK(&led_dat->work, pmic8058_led_work); + + rc = led_classdev_register(&pdev->dev, &led_dat->cdev); + if (rc) { + dev_err(&pdev->dev, "unable to register led %d\n", + led_dat->id); + goto fail_id_check; + } + } + + platform_set_drvdata(pdev, led); + + return 0; + +err_reg_read: + kfree(led); +fail_id_check: + if (i > 0) { + for (i = i - 1; i >= 0; i--) + led_classdev_unregister(&led[i].cdev); + } + return rc; +} + +static int __devexit pmic8058_led_remove(struct platform_device *pdev) +{ + int i; + struct pmic8058_leds_platform_data *pdata = pdev->dev.platform_data; + struct pmic8058_led_data *led = platform_get_drvdata(pdev); + + for (i = 0; i < pdata->num_leds; i++) { + mutex_destroy(&led[led->id].lock); + led_classdev_unregister(&led[led->id].cdev); + cancel_work_sync(&led[led->id].work); + } + + return 0; +} + +static struct platform_driver pmic8058_led_driver = { + .probe = pmic8058_led_probe, + .remove = __devexit_p(pmic8058_led_remove), + .driver = { + .name = "pm8058-led", + .owner = THIS_MODULE, + }, +}; + +static int __init pmic8058_led_init(void) +{ + return platform_driver_register(&pmic8058_led_driver); +} +module_init(pmic8058_led_init); + +static void __exit pmic8058_led_exit(void) +{ + platform_driver_unregister(&pmic8058_led_driver); +} +module_exit(pmic8058_led_exit); + +MODULE_DESCRIPTION("PMIC8058 LEDs driver"); +MODULE_LICENSE("GPL v2"); +MODULE_VERSION("1.0"); +MODULE_ALIAS("platform:pmic8058-led"); +MODULE_AUTHOR("Trilok Soni "); diff --git a/include/linux/leds-pmic8058.h b/include/linux/leds-pmic8058.h new file mode 100644 index 0000000..c54c7e6 --- /dev/null +++ b/include/linux/leds-pmic8058.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2010, Code Aurora Forum. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __LEDS_PMIC8058_H__ +#define __LEDS_PMIC8058_H__ + +/** + * enum pmic8058_leds - PMIC8058 supported led ids + * @PMIC8058_ID_LED_KB_LIGHT - keyboard backlight led + * @PMIC8058_ID_LED_0 - First low current led + * @PMIC8058_ID_LED_1 - Second low current led + * @PMIC8058_ID_LED_2 - Third low current led + * @PMIC8058_ID_FLASH_LED_0 - First flash led + * @PMIC8058_ID_FLASH_LED_0 - Second flash led + */ +enum pmic8058_leds { + PMIC8058_ID_LED_KB_LIGHT = 1, + PMIC8058_ID_LED_0, + PMIC8058_ID_LED_1, + PMIC8058_ID_LED_2, + PMIC8058_ID_FLASH_LED_0, + PMIC8058_ID_FLASH_LED_1, +}; + +/** + * struct pmic8058_led - per led data + * @name - name of the led + * @default_trigger - default trigger which needs to e attached + * @max_brightness - maximum brightness level supported by the led + * @id - supported led id + */ +struct pmic8058_led { + const char *name; + const char *default_trigger; + unsigned max_brightness; + int id; +}; + +/** + * struct pmic8058_leds_platform_data - platform data for leds + * @num_leds - number of leds + * @leds - array of struct pmic8058_led + */ +struct pmic8058_leds_platform_data { + int num_leds; + struct pmic8058_led *leds; +}; + +#endif /* __LEDS_PMIC8058_H__ */