From 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 16 Apr 2005 15:20:36 -0700 Subject: Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip! --- drivers/video/backlight/Kconfig | 52 +++++++ drivers/video/backlight/Makefile | 5 + drivers/video/backlight/backlight.c | 264 ++++++++++++++++++++++++++++++++++++ drivers/video/backlight/corgi_bl.c | 198 +++++++++++++++++++++++++++ drivers/video/backlight/lcd.c | 263 +++++++++++++++++++++++++++++++++++ 5 files changed, 782 insertions(+) create mode 100644 drivers/video/backlight/Kconfig create mode 100644 drivers/video/backlight/Makefile create mode 100644 drivers/video/backlight/backlight.c create mode 100644 drivers/video/backlight/corgi_bl.c create mode 100644 drivers/video/backlight/lcd.c (limited to 'drivers/video/backlight') diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig new file mode 100644 index 0000000..996d543 --- /dev/null +++ b/drivers/video/backlight/Kconfig @@ -0,0 +1,52 @@ +# +# Backlight & LCD drivers configuration +# + +menuconfig BACKLIGHT_LCD_SUPPORT + bool "Backlight & LCD device support" + help + Enable this to be able to choose the drivers for controlling the + backlight and the LCD panel on some platforms, for example on PDAs. + +config BACKLIGHT_CLASS_DEVICE + tristate "Lowlevel Backlight controls" + depends on BACKLIGHT_LCD_SUPPORT + default m + help + This framework adds support for low-level control of the LCD + backlight. This includes support for brightness and power. + + To have support for your specific LCD panel you will have to + select the proper drivers which depend on this option. + +config BACKLIGHT_DEVICE + bool + depends on BACKLIGHT_CLASS_DEVICE + default y + +config LCD_CLASS_DEVICE + tristate "Lowlevel LCD controls" + depends on BACKLIGHT_LCD_SUPPORT + default m + help + This framework adds support for low-level control of LCD. + Some framebuffer devices connect to platform-specific LCD modules + in order to have a platform-specific way to control the flat panel + (contrast and applying power to the LCD (not to the backlight!)). + + To have support for your specific LCD panel you will have to + select the proper drivers which depend on this option. + +config LCD_DEVICE + bool + depends on LCD_CLASS_DEVICE + default y + +config BACKLIGHT_CORGI + tristate "Sharp Corgi Backlight Driver (SL-C7xx Series)" + depends on BACKLIGHT_DEVICE && PXA_SHARPSL + default y + help + If you have a Sharp Zaurus SL-C7xx, say y to enable the + backlight driver. + diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile new file mode 100644 index 0000000..9aae884 --- /dev/null +++ b/drivers/video/backlight/Makefile @@ -0,0 +1,5 @@ +# Backlight & LCD drivers + +obj-$(CONFIG_LCD_CLASS_DEVICE) += lcd.o +obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o +obj-$(CONFIG_BACKLIGHT_CORGI) += corgi_bl.o diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c new file mode 100644 index 0000000..acc81cb --- /dev/null +++ b/drivers/video/backlight/backlight.c @@ -0,0 +1,264 @@ +/* + * Backlight Lowlevel Control Abstraction + * + * Copyright (C) 2003,2004 Hewlett-Packard Company + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static ssize_t backlight_show_power(struct class_device *cdev, char *buf) +{ + int rc; + struct backlight_device *bd = to_backlight_device(cdev); + + down(&bd->sem); + if (likely(bd->props && bd->props->get_power)) + rc = sprintf(buf, "%d\n", bd->props->get_power(bd)); + else + rc = -ENXIO; + up(&bd->sem); + + return rc; +} + +static ssize_t backlight_store_power(struct class_device *cdev, const char *buf, size_t count) +{ + int rc, power; + char *endp; + struct backlight_device *bd = to_backlight_device(cdev); + + power = simple_strtoul(buf, &endp, 0); + if (*endp && !isspace(*endp)) + return -EINVAL; + + down(&bd->sem); + if (likely(bd->props && bd->props->set_power)) { + pr_debug("backlight: set power to %d\n", power); + bd->props->set_power(bd, power); + rc = count; + } else + rc = -ENXIO; + up(&bd->sem); + + return rc; +} + +static ssize_t backlight_show_brightness(struct class_device *cdev, char *buf) +{ + int rc; + struct backlight_device *bd = to_backlight_device(cdev); + + down(&bd->sem); + if (likely(bd->props && bd->props->get_brightness)) + rc = sprintf(buf, "%d\n", bd->props->get_brightness(bd)); + else + rc = -ENXIO; + up(&bd->sem); + + return rc; +} + +static ssize_t backlight_store_brightness(struct class_device *cdev, const char *buf, size_t count) +{ + int rc, brightness; + char *endp; + struct backlight_device *bd = to_backlight_device(cdev); + + brightness = simple_strtoul(buf, &endp, 0); + if (*endp && !isspace(*endp)) + return -EINVAL; + + down(&bd->sem); + if (likely(bd->props && bd->props->set_brightness)) { + pr_debug("backlight: set brightness to %d\n", brightness); + bd->props->set_brightness(bd, brightness); + rc = count; + } else + rc = -ENXIO; + up(&bd->sem); + + return rc; +} + +static ssize_t backlight_show_max_brightness(struct class_device *cdev, char *buf) +{ + int rc; + struct backlight_device *bd = to_backlight_device(cdev); + + down(&bd->sem); + if (likely(bd->props)) + rc = sprintf(buf, "%d\n", bd->props->max_brightness); + else + rc = -ENXIO; + up(&bd->sem); + + return rc; +} + +static void backlight_class_release(struct class_device *dev) +{ + struct backlight_device *bd = to_backlight_device(dev); + kfree(bd); +} + +static struct class backlight_class = { + .name = "backlight", + .release = backlight_class_release, +}; + +#define DECLARE_ATTR(_name,_mode,_show,_store) \ +{ \ + .attr = { .name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE }, \ + .show = _show, \ + .store = _store, \ +} + +static struct class_device_attribute bl_class_device_attributes[] = { + DECLARE_ATTR(power, 0644, backlight_show_power, backlight_store_power), + DECLARE_ATTR(brightness, 0644, backlight_show_brightness, backlight_store_brightness), + DECLARE_ATTR(max_brightness, 0444, backlight_show_max_brightness, NULL), +}; + +/* This callback gets called when something important happens inside a + * framebuffer driver. We're looking if that important event is blanking, + * and if it is, we're switching backlight power as well ... + */ +static int fb_notifier_callback(struct notifier_block *self, + unsigned long event, void *data) +{ + struct backlight_device *bd; + struct fb_event *evdata =(struct fb_event *)data; + + /* If we aren't interested in this event, skip it immediately ... */ + if (event != FB_EVENT_BLANK) + return 0; + + bd = container_of(self, struct backlight_device, fb_notif); + down(&bd->sem); + if (bd->props) + if (!bd->props->check_fb || bd->props->check_fb(evdata->info)) + bd->props->set_power(bd, *(int *)evdata->data); + up(&bd->sem); + return 0; +} + +/** + * backlight_device_register - create and register a new object of + * backlight_device class. + * @name: the name of the new object(must be the same as the name of the + * respective framebuffer device). + * @devdata: an optional pointer to be stored in the class_device. The + * methods may retrieve it by using class_get_devdata(&bd->class_dev). + * @bp: the backlight properties structure. + * + * Creates and registers new backlight class_device. Returns either an + * ERR_PTR() or a pointer to the newly allocated device. + */ +struct backlight_device *backlight_device_register(const char *name, void *devdata, + struct backlight_properties *bp) +{ + int i, rc; + struct backlight_device *new_bd; + + pr_debug("backlight_device_alloc: name=%s\n", name); + + new_bd = kmalloc(sizeof(struct backlight_device), GFP_KERNEL); + if (unlikely(!new_bd)) + return ERR_PTR(ENOMEM); + + init_MUTEX(&new_bd->sem); + new_bd->props = bp; + memset(&new_bd->class_dev, 0, sizeof(new_bd->class_dev)); + new_bd->class_dev.class = &backlight_class; + strlcpy(new_bd->class_dev.class_id, name, KOBJ_NAME_LEN); + class_set_devdata(&new_bd->class_dev, devdata); + + rc = class_device_register(&new_bd->class_dev); + if (unlikely(rc)) { +error: kfree(new_bd); + return ERR_PTR(rc); + } + + memset(&new_bd->fb_notif, 0, sizeof(new_bd->fb_notif)); + new_bd->fb_notif.notifier_call = fb_notifier_callback; + + rc = fb_register_client(&new_bd->fb_notif); + if (unlikely(rc)) + goto error; + + for (i = 0; i < ARRAY_SIZE(bl_class_device_attributes); i++) { + rc = class_device_create_file(&new_bd->class_dev, + &bl_class_device_attributes[i]); + if (unlikely(rc)) { + while (--i >= 0) + class_device_remove_file(&new_bd->class_dev, + &bl_class_device_attributes[i]); + class_device_unregister(&new_bd->class_dev); + /* No need to kfree(new_bd) since release() method was called */ + return ERR_PTR(rc); + } + } + + return new_bd; +} +EXPORT_SYMBOL(backlight_device_register); + +/** + * backlight_device_unregister - unregisters a backlight device object. + * @bd: the backlight device object to be unregistered and freed. + * + * Unregisters a previously registered via backlight_device_register object. + */ +void backlight_device_unregister(struct backlight_device *bd) +{ + int i; + + if (!bd) + return; + + pr_debug("backlight_device_unregister: name=%s\n", bd->class_dev.class_id); + + for (i = 0; i < ARRAY_SIZE(bl_class_device_attributes); i++) + class_device_remove_file(&bd->class_dev, + &bl_class_device_attributes[i]); + + down(&bd->sem); + bd->props = NULL; + up(&bd->sem); + + fb_unregister_client(&bd->fb_notif); + + class_device_unregister(&bd->class_dev); +} +EXPORT_SYMBOL(backlight_device_unregister); + +static void __exit backlight_class_exit(void) +{ + class_unregister(&backlight_class); +} + +static int __init backlight_class_init(void) +{ + return class_register(&backlight_class); +} + +/* + * if this is compiled into the kernel, we need to ensure that the + * class is registered before users of the class try to register lcd's + */ +postcore_initcall(backlight_class_init); +module_exit(backlight_class_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Jamey Hicks , Andrew Zabolotny "); +MODULE_DESCRIPTION("Backlight Lowlevel Control Abstraction"); diff --git a/drivers/video/backlight/corgi_bl.c b/drivers/video/backlight/corgi_bl.c new file mode 100644 index 0000000..3c026b0 --- /dev/null +++ b/drivers/video/backlight/corgi_bl.c @@ -0,0 +1,198 @@ +/* + * Backlight Driver for Sharp Corgi + * + * Copyright (c) 2004-2005 Richard Purdie + * + * Based on Sharp's 2.4 Backlight Driver + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define CORGI_MAX_INTENSITY 0x3e +#define CORGI_DEFAULT_INTENSITY 0x1f +#define CORGI_LIMIT_MASK 0x0b + +static int corgibl_powermode = FB_BLANK_UNBLANK; +static int current_intensity = 0; +static int corgibl_limit = 0; +static spinlock_t bl_lock = SPIN_LOCK_UNLOCKED; + +static void corgibl_send_intensity(int intensity) +{ + unsigned long flags; + void (*corgi_kick_batt)(void); + + if (corgibl_powermode != FB_BLANK_UNBLANK) { + intensity = 0; + } else { + if (corgibl_limit) + intensity &= CORGI_LIMIT_MASK; + } + + /* Skip 0x20 as it will blank the display */ + if (intensity >= 0x20) + intensity++; + + spin_lock_irqsave(&bl_lock, flags); + /* Bits 0-4 are accessed via the SSP interface */ + corgi_ssp_blduty_set(intensity & 0x1f); + /* Bit 5 is via SCOOP */ + if (intensity & 0x0020) + set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_BACKLIGHT_CONT); + else + reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_BACKLIGHT_CONT); + spin_unlock_irqrestore(&bl_lock, flags); +} + +static void corgibl_blank(int blank) +{ + switch(blank) { + + case FB_BLANK_NORMAL: + case FB_BLANK_VSYNC_SUSPEND: + case FB_BLANK_HSYNC_SUSPEND: + case FB_BLANK_POWERDOWN: + if (corgibl_powermode == FB_BLANK_UNBLANK) { + corgibl_send_intensity(0); + corgibl_powermode = blank; + } + break; + case FB_BLANK_UNBLANK: + if (corgibl_powermode != FB_BLANK_UNBLANK) { + corgibl_powermode = blank; + corgibl_send_intensity(current_intensity); + } + break; + } +} + +#ifdef CONFIG_PM +static int corgibl_suspend(struct device *dev, u32 state, u32 level) +{ + if (level == SUSPEND_POWER_DOWN) + corgibl_blank(FB_BLANK_POWERDOWN); + return 0; +} + +static int corgibl_resume(struct device *dev, u32 level) +{ + if (level == RESUME_POWER_ON) + corgibl_blank(FB_BLANK_UNBLANK); + return 0; +} +#else +#define corgibl_suspend NULL +#define corgibl_resume NULL +#endif + + +static int corgibl_set_power(struct backlight_device *bd, int state) +{ + corgibl_blank(state); + return 0; +} + +static int corgibl_get_power(struct backlight_device *bd) +{ + return corgibl_powermode; +} + +static int corgibl_set_intensity(struct backlight_device *bd, int intensity) +{ + if (intensity > CORGI_MAX_INTENSITY) + intensity = CORGI_MAX_INTENSITY; + corgibl_send_intensity(intensity); + current_intensity=intensity; + return 0; +} + +static int corgibl_get_intensity(struct backlight_device *bd) +{ + return current_intensity; +} + +/* + * Called when the battery is low to limit the backlight intensity. + * If limit==0 clear any limit, otherwise limit the intensity + */ +void corgibl_limit_intensity(int limit) +{ + corgibl_limit = (limit ? 1 : 0); + corgibl_send_intensity(current_intensity); +} +EXPORT_SYMBOL(corgibl_limit_intensity); + + +static struct backlight_properties corgibl_data = { + .owner = THIS_MODULE, + .get_power = corgibl_get_power, + .set_power = corgibl_set_power, + .max_brightness = CORGI_MAX_INTENSITY, + .get_brightness = corgibl_get_intensity, + .set_brightness = corgibl_set_intensity, +}; + +static struct backlight_device *corgi_backlight_device; + +static int __init corgibl_probe(struct device *dev) +{ + corgi_backlight_device = backlight_device_register ("corgi-bl", + NULL, &corgibl_data); + if (IS_ERR (corgi_backlight_device)) + return PTR_ERR (corgi_backlight_device); + + corgibl_set_intensity(NULL, CORGI_DEFAULT_INTENSITY); + + printk("Corgi Backlight Driver Initialized.\n"); + return 0; +} + +static int corgibl_remove(struct device *dev) +{ + backlight_device_unregister(corgi_backlight_device); + + corgibl_set_intensity(NULL, 0); + + printk("Corgi Backlight Driver Unloaded\n"); + return 0; +} + +static struct device_driver corgibl_driver = { + .name = "corgi-bl", + .bus = &platform_bus_type, + .probe = corgibl_probe, + .remove = corgibl_remove, + .suspend = corgibl_suspend, + .resume = corgibl_resume, +}; + +static int __init corgibl_init(void) +{ + return driver_register(&corgibl_driver); +} + +static void __exit corgibl_exit(void) +{ + driver_unregister(&corgibl_driver); +} + +module_init(corgibl_init); +module_exit(corgibl_exit); + +MODULE_AUTHOR("Richard Purdie "); +MODULE_DESCRIPTION("Corgi Backlight Driver"); +MODULE_LICENSE("GPLv2"); diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c new file mode 100644 index 0000000..470e6f0 --- /dev/null +++ b/drivers/video/backlight/lcd.c @@ -0,0 +1,263 @@ +/* + * LCD Lowlevel Control Abstraction + * + * Copyright (C) 2003,2004 Hewlett-Packard Company + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static ssize_t lcd_show_power(struct class_device *cdev, char *buf) +{ + int rc; + struct lcd_device *ld = to_lcd_device(cdev); + + down(&ld->sem); + if (likely(ld->props && ld->props->get_power)) + rc = sprintf(buf, "%d\n", ld->props->get_power(ld)); + else + rc = -ENXIO; + up(&ld->sem); + + return rc; +} + +static ssize_t lcd_store_power(struct class_device *cdev, const char *buf, size_t count) +{ + int rc, power; + char *endp; + struct lcd_device *ld = to_lcd_device(cdev); + + power = simple_strtoul(buf, &endp, 0); + if (*endp && !isspace(*endp)) + return -EINVAL; + + down(&ld->sem); + if (likely(ld->props && ld->props->set_power)) { + pr_debug("lcd: set power to %d\n", power); + ld->props->set_power(ld, power); + rc = count; + } else + rc = -ENXIO; + up(&ld->sem); + + return rc; +} + +static ssize_t lcd_show_contrast(struct class_device *cdev, char *buf) +{ + int rc; + struct lcd_device *ld = to_lcd_device(cdev); + + down(&ld->sem); + if (likely(ld->props && ld->props->get_contrast)) + rc = sprintf(buf, "%d\n", ld->props->get_contrast(ld)); + else + rc = -ENXIO; + up(&ld->sem); + + return rc; +} + +static ssize_t lcd_store_contrast(struct class_device *cdev, const char *buf, size_t count) +{ + int rc, contrast; + char *endp; + struct lcd_device *ld = to_lcd_device(cdev); + + contrast = simple_strtoul(buf, &endp, 0); + if (*endp && !isspace(*endp)) + return -EINVAL; + + down(&ld->sem); + if (likely(ld->props && ld->props->set_contrast)) { + pr_debug("lcd: set contrast to %d\n", contrast); + ld->props->set_contrast(ld, contrast); + rc = count; + } else + rc = -ENXIO; + up(&ld->sem); + + return rc; +} + +static ssize_t lcd_show_max_contrast(struct class_device *cdev, char *buf) +{ + int rc; + struct lcd_device *ld = to_lcd_device(cdev); + + down(&ld->sem); + if (likely(ld->props)) + rc = sprintf(buf, "%d\n", ld->props->max_contrast); + else + rc = -ENXIO; + up(&ld->sem); + + return rc; +} + +static void lcd_class_release(struct class_device *dev) +{ + struct lcd_device *ld = to_lcd_device(dev); + kfree(ld); +} + +static struct class lcd_class = { + .name = "lcd", + .release = lcd_class_release, +}; + +#define DECLARE_ATTR(_name,_mode,_show,_store) \ +{ \ + .attr = { .name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE }, \ + .show = _show, \ + .store = _store, \ +} + +static struct class_device_attribute lcd_class_device_attributes[] = { + DECLARE_ATTR(power, 0644, lcd_show_power, lcd_store_power), + DECLARE_ATTR(contrast, 0644, lcd_show_contrast, lcd_store_contrast), + DECLARE_ATTR(max_contrast, 0444, lcd_show_max_contrast, NULL), +}; + +/* This callback gets called when something important happens inside a + * framebuffer driver. We're looking if that important event is blanking, + * and if it is, we're switching lcd power as well ... + */ +static int fb_notifier_callback(struct notifier_block *self, + unsigned long event, void *data) +{ + struct lcd_device *ld; + struct fb_event *evdata =(struct fb_event *)data; + + /* If we aren't interested in this event, skip it immediately ... */ + if (event != FB_EVENT_BLANK) + return 0; + + ld = container_of(self, struct lcd_device, fb_notif); + down(&ld->sem); + if (ld->props) + if (!ld->props->check_fb || ld->props->check_fb(evdata->info)) + ld->props->set_power(ld, *(int *)evdata->data); + up(&ld->sem); + return 0; +} + +/** + * lcd_device_register - register a new object of lcd_device class. + * @name: the name of the new object(must be the same as the name of the + * respective framebuffer device). + * @devdata: an optional pointer to be stored in the class_device. The + * methods may retrieve it by using class_get_devdata(ld->class_dev). + * @lp: the lcd properties structure. + * + * Creates and registers a new lcd class_device. Returns either an ERR_PTR() + * or a pointer to the newly allocated device. + */ +struct lcd_device *lcd_device_register(const char *name, void *devdata, + struct lcd_properties *lp) +{ + int i, rc; + struct lcd_device *new_ld; + + pr_debug("lcd_device_register: name=%s\n", name); + + new_ld = kmalloc(sizeof(struct lcd_device), GFP_KERNEL); + if (unlikely(!new_ld)) + return ERR_PTR(ENOMEM); + + init_MUTEX(&new_ld->sem); + new_ld->props = lp; + memset(&new_ld->class_dev, 0, sizeof(new_ld->class_dev)); + new_ld->class_dev.class = &lcd_class; + strlcpy(new_ld->class_dev.class_id, name, KOBJ_NAME_LEN); + class_set_devdata(&new_ld->class_dev, devdata); + + rc = class_device_register(&new_ld->class_dev); + if (unlikely(rc)) { +error: kfree(new_ld); + return ERR_PTR(rc); + } + + memset(&new_ld->fb_notif, 0, sizeof(new_ld->fb_notif)); + new_ld->fb_notif.notifier_call = fb_notifier_callback; + + rc = fb_register_client(&new_ld->fb_notif); + if (unlikely(rc)) + goto error; + + for (i = 0; i < ARRAY_SIZE(lcd_class_device_attributes); i++) { + rc = class_device_create_file(&new_ld->class_dev, + &lcd_class_device_attributes[i]); + if (unlikely(rc)) { + while (--i >= 0) + class_device_remove_file(&new_ld->class_dev, + &lcd_class_device_attributes[i]); + class_device_unregister(&new_ld->class_dev); + /* No need to kfree(new_ld) since release() method was called */ + return ERR_PTR(rc); + } + } + + return new_ld; +} +EXPORT_SYMBOL(lcd_device_register); + +/** + * lcd_device_unregister - unregisters a object of lcd_device class. + * @ld: the lcd device object to be unregistered and freed. + * + * Unregisters a previously registered via lcd_device_register object. + */ +void lcd_device_unregister(struct lcd_device *ld) +{ + int i; + + if (!ld) + return; + + pr_debug("lcd_device_unregister: name=%s\n", ld->class_dev.class_id); + + for (i = 0; i < ARRAY_SIZE(lcd_class_device_attributes); i++) + class_device_remove_file(&ld->class_dev, + &lcd_class_device_attributes[i]); + + down(&ld->sem); + ld->props = NULL; + up(&ld->sem); + + fb_unregister_client(&ld->fb_notif); + + class_device_unregister(&ld->class_dev); +} +EXPORT_SYMBOL(lcd_device_unregister); + +static void __exit lcd_class_exit(void) +{ + class_unregister(&lcd_class); +} + +static int __init lcd_class_init(void) +{ + return class_register(&lcd_class); +} + +/* + * if this is compiled into the kernel, we need to ensure that the + * class is registered before users of the class try to register lcd's + */ +postcore_initcall(lcd_class_init); +module_exit(lcd_class_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Jamey Hicks , Andrew Zabolotny "); +MODULE_DESCRIPTION("LCD Lowlevel Control Abstraction"); -- cgit v1.1