4 files changed, 552 insertions, 0 deletions

diff --git a/drivers/leds/leds-alix2.c b/drivers/leds/leds-alix2.c
new file mode 100644
index 00000000000..f59ffadf512
--- /dev/null
+++ b/drivers/leds/leds-alix2.c
@@ -0,0 +1,239 @@
+/*
+ * LEDs driver for PCEngines ALIX.2 and ALIX.3
+ *
+ * Copyright (C) 2008 Constantin Baranov <const@mimas.ru>
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/leds.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/string.h>
+#include <linux/pci.h>
+
+static int force = 0;
+module_param(force, bool, 0444);
+MODULE_PARM_DESC(force, "Assume system has ALIX.2/ALIX.3 style LEDs");
+
+#define MSR_LBAR_GPIO           0x5140000C
+#define CS5535_GPIO_SIZE        256
+
+static u32 gpio_base;
+
+static struct pci_device_id divil_pci[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_NS,  PCI_DEVICE_ID_NS_CS5535_ISA) },
+        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
+        { } /* NULL entry */
+};
+MODULE_DEVICE_TABLE(pci, divil_pci);
+
+struct alix_led {
+        struct led_classdev cdev;
+        unsigned short port;
+        unsigned int on_value;
+        unsigned int off_value;
+};
+
+static void alix_led_set(struct led_classdev *led_cdev,
+                         enum led_brightness brightness)
+{
+        struct alix_led *led_dev =
+                container_of(led_cdev, struct alix_led, cdev);
+
+        if (brightness)
+                outl(led_dev->on_value, gpio_base + led_dev->port);
+        else
+                outl(led_dev->off_value, gpio_base + led_dev->port);
+}
+
+static struct alix_led alix_leds[] = {
+        {
+                .cdev = {
+                        .name = "alix:1",
+                        .brightness_set = alix_led_set,
+                },
+                .port = 0x00,
+                .on_value = 1 << 22,
+                .off_value = 1 << 6,
+        },
+        {
+                .cdev = {
+                        .name = "alix:2",
+                        .brightness_set = alix_led_set,
+                },
+                .port = 0x80,
+                .on_value = 1 << 25,
+                .off_value = 1 << 9,
+        },
+        {
+                .cdev = {
+                        .name = "alix:3",
+                        .brightness_set = alix_led_set,
+                },
+                .port = 0x80,
+                .on_value = 1 << 27,
+                .off_value = 1 << 11,
+        },
+};
+
+static int __init alix_led_probe(struct platform_device *pdev)
+{
+        int i;
+        int ret;
+
+        for (i = 0; i < ARRAY_SIZE(alix_leds); i++) {
+                alix_leds[i].cdev.flags |= LED_CORE_SUSPENDRESUME;
+                ret = led_classdev_register(&pdev->dev, &alix_leds[i].cdev);
+                if (ret < 0)
+                        goto fail;
+        }
+        return 0;
+
+fail:
+        while (--i >= 0)
+                led_classdev_unregister(&alix_leds[i].cdev);
+        return ret;
+}
+
+static int alix_led_remove(struct platform_device *pdev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(alix_leds); i++)
+                led_classdev_unregister(&alix_leds[i].cdev);
+        return 0;
+}
+
+static struct platform_driver alix_led_driver = {
+        .remove = alix_led_remove,
+        .driver = {
+                .name = KBUILD_MODNAME,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init alix_present(unsigned long bios_phys,
+                                const char *alix_sig,
+                                size_t alix_sig_len)
+{
+        const size_t bios_len = 0x00010000;
+        const char *bios_virt;
+        const char *scan_end;
+        const char *p;
+        char name[64];
+
+        if (force) {
+                printk(KERN_NOTICE "%s: forced to skip BIOS test, "
+                       "assume system has ALIX.2 style LEDs\n",
+                       KBUILD_MODNAME);
+                return 1;
+        }
+
+        bios_virt = phys_to_virt(bios_phys);
+        scan_end = bios_virt + bios_len - (alix_sig_len + 2);
+        for (p = bios_virt; p < scan_end; p++) {
+                const char *tail;
+                char *a;
+
+                if (memcmp(p, alix_sig, alix_sig_len) != 0)
+                        continue;
+
+                memcpy(name, p, sizeof(name));
+
+                /* remove the first \0 character from string */
+                a = strchr(name, '\0');
+                if (a)
+                        *a = ' ';
+
+                /* cut the string at a newline */
+                a = strchr(name, '\r');
+                if (a)
+                        *a = '\0';
+
+                tail = p + alix_sig_len;
+                if ((tail[0] == '2' || tail[0] == '3')) {
+                        printk(KERN_INFO
+                               "%s: system is recognized as \"%s\"\n",
+                               KBUILD_MODNAME, name);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+static struct platform_device *pdev;
+
+static int __init alix_pci_led_init(void)
+{
+        u32 low, hi;
+
+        if (pci_dev_present(divil_pci) == 0) {
+                printk(KERN_WARNING KBUILD_MODNAME": DIVIL not found\n");
+                return -ENODEV;
+        }
+
+        /* Grab the GPIO I/O range */
+        rdmsr(MSR_LBAR_GPIO, low, hi);
+
+        /* Check the mask and whether GPIO is enabled (sanity check) */
+        if (hi != 0x0000f001) {
+                printk(KERN_WARNING KBUILD_MODNAME": GPIO not enabled\n");
+                return -ENODEV;
+        }
+
+        /* Mask off the IO base address */
+        gpio_base = low & 0x0000ff00;
+
+        if (!request_region(gpio_base, CS5535_GPIO_SIZE, KBUILD_MODNAME)) {
+                printk(KERN_ERR KBUILD_MODNAME": can't allocate I/O for GPIO\n");
+                return -ENODEV;
+        }
+
+        /* Set GPIO function to output */
+        outl(1 << 6, gpio_base + 0x04);
+        outl(1 << 9, gpio_base + 0x84);
+        outl(1 << 11, gpio_base + 0x84);
+
+        return 0;
+}
+
+static int __init alix_led_init(void)
+{
+        int ret = -ENODEV;
+        const char tinybios_sig[] = "PC Engines ALIX.";
+        const char coreboot_sig[] = "PC Engines\0ALIX.";
+
+        if (alix_present(0xf0000, tinybios_sig, sizeof(tinybios_sig) - 1) ||
+            alix_present(0x500, coreboot_sig, sizeof(coreboot_sig) - 1))
+                ret = alix_pci_led_init();
+
+        if (ret < 0)
+                return ret;
+
+        pdev = platform_device_register_simple(KBUILD_MODNAME, -1, NULL, 0);
+        if (!IS_ERR(pdev)) {
+                ret = platform_driver_probe(&alix_led_driver, alix_led_probe);
+                if (ret)
+                        platform_device_unregister(pdev);
+        } else
+                ret = PTR_ERR(pdev);
+
+        return ret;
+}
+
+static void __exit alix_led_exit(void)
+{
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&alix_led_driver);
+        release_region(gpio_base, CS5535_GPIO_SIZE);
+}
+
+module_init(alix_led_init);
+module_exit(alix_led_exit);
+
+MODULE_AUTHOR("Constantin Baranov <const@mimas.ru>");
+MODULE_DESCRIPTION("PCEngines ALIX.2 and ALIX.3 LED driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-ams-delta.c b/drivers/leds/leds-ams-delta.c
new file mode 100644
index 00000000000..8c00937bf7e
--- /dev/null
+++ b/drivers/leds/leds-ams-delta.c
@@ -0,0 +1,137 @@
+/*
+ * LEDs driver for Amstrad Delta (E3)
+ *
+ * Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
+ *
+ * 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 <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/leds.h>
+#include <plat/board-ams-delta.h>
+
+/*
+ * Our context
+ */
+struct ams_delta_led {
+        struct led_classdev     cdev;
+        u8                      bitmask;
+};
+
+static void ams_delta_led_set(struct led_classdev *led_cdev,
+                enum led_brightness value)
+{
+        struct ams_delta_led *led_dev =
+                container_of(led_cdev, struct ams_delta_led, cdev);
+
+        if (value)
+                ams_delta_latch1_write(led_dev->bitmask, led_dev->bitmask);
+        else
+                ams_delta_latch1_write(led_dev->bitmask, 0);
+}
+
+static struct ams_delta_led ams_delta_leds[] = {
+        {
+                .cdev           = {
+                        .name           = "ams-delta::camera",
+                        .brightness_set = ams_delta_led_set,
+                },
+                .bitmask        = AMS_DELTA_LATCH1_LED_CAMERA,
+        },
+        {
+                .cdev           = {
+                        .name           = "ams-delta::advert",
+                        .brightness_set = ams_delta_led_set,
+                },
+                .bitmask        = AMS_DELTA_LATCH1_LED_ADVERT,
+        },
+        {
+                .cdev           = {
+                        .name           = "ams-delta::email",
+                        .brightness_set = ams_delta_led_set,
+                },
+                .bitmask        = AMS_DELTA_LATCH1_LED_EMAIL,
+        },
+        {
+                .cdev           = {
+                        .name           = "ams-delta::handsfree",
+                        .brightness_set = ams_delta_led_set,
+                },
+                .bitmask        = AMS_DELTA_LATCH1_LED_HANDSFREE,
+        },
+        {
+                .cdev           = {
+                        .name           = "ams-delta::voicemail",
+                        .brightness_set = ams_delta_led_set,
+                },
+                .bitmask        = AMS_DELTA_LATCH1_LED_VOICEMAIL,
+        },
+        {
+                .cdev           = {
+                        .name           = "ams-delta::voice",
+                        .brightness_set = ams_delta_led_set,
+                },
+                .bitmask        = AMS_DELTA_LATCH1_LED_VOICE,
+        },
+};
+
+static int ams_delta_led_probe(struct platform_device *pdev)
+{
+        int i, ret;
+
+        for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i++) {
+                ams_delta_leds[i].cdev.flags |= LED_CORE_SUSPENDRESUME;
+                ret = led_classdev_register(&pdev->dev,
+                                &ams_delta_leds[i].cdev);
+                if (ret < 0)
+                        goto fail;
+        }
+
+        return 0;
+fail:
+        while (--i >= 0)
+                led_classdev_unregister(&ams_delta_leds[i].cdev);
+        return ret;     
+}
+
+static int ams_delta_led_remove(struct platform_device *pdev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i++)
+                led_classdev_unregister(&ams_delta_leds[i].cdev);
+
+        return 0;
+}
+
+static struct platform_driver ams_delta_led_driver = {
+        .probe          = ams_delta_led_probe,
+        .remove         = ams_delta_led_remove,
+        .driver         = {
+                .name = "ams-delta-led",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init ams_delta_led_init(void)
+{
+        return platform_driver_register(&ams_delta_led_driver);
+}
+
+static void __exit ams_delta_led_exit(void)
+{
+        platform_driver_unregister(&ams_delta_led_driver);
+}
+
+module_init(ams_delta_led_init);
+module_exit(ams_delta_led_exit);
+
+MODULE_AUTHOR("Jonathan McDowell <noodles@earth.li>");
+MODULE_DESCRIPTION("Amstrad Delta LED driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ams-delta-led");
diff --git a/drivers/leds/leds-net5501.c b/drivers/leds/leds-net5501.c
new file mode 100644
index 00000000000..7e764b8365e
--- /dev/null
+++ b/drivers/leds/leds-net5501.c
@@ -0,0 +1,96 @@
+/*
+ * Soekris board support code
+ *
+ * Copyright (C) 2008-2009 Tower Technologies
+ * Written by Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/string.h>
+#include <linux/leds.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+
+#include <asm/geode.h>
+
+static const struct gpio_led net5501_leds[] = {
+        {
+                .name = "error",
+                .gpio = 6,
+                .default_trigger = "default-on",
+        },
+};
+
+static struct gpio_led_platform_data net5501_leds_data = {
+        .num_leds = ARRAY_SIZE(net5501_leds),
+        .leds = net5501_leds,
+};
+
+static struct platform_device net5501_leds_dev = {
+        .name = "leds-gpio",
+        .id = -1,
+        .dev.platform_data = &net5501_leds_data,
+};
+
+static void __init init_net5501(void)
+{
+        platform_device_register(&net5501_leds_dev);
+}
+
+struct soekris_board {
+        u16     offset;
+        char    *sig;
+        u8      len;
+        void    (*init)(void);
+};
+
+static struct soekris_board __initdata boards[] = {
+        { 0xb7b, "net5501", 7, init_net5501 },  /* net5501 v1.33/1.33c */
+        { 0xb1f, "net5501", 7, init_net5501 },  /* net5501 v1.32i */
+};
+
+static int __init soekris_init(void)
+{
+        int i;
+        unsigned char *rombase, *bios;
+
+        if (!is_geode())
+                return 0;
+
+        rombase = ioremap(0xffff0000, 0xffff);
+        if (!rombase) {
+                printk(KERN_INFO "Soekris net5501 LED driver failed to get rombase");
+                return 0;
+        }
+
+        bios = rombase + 0x20;  /* null terminated */
+
+        if (strncmp(bios, "comBIOS", 7))
+                goto unmap;
+
+        for (i = 0; i < ARRAY_SIZE(boards); i++) {
+                unsigned char *model = rombase + boards[i].offset;
+
+                if (strncmp(model, boards[i].sig, boards[i].len) == 0) {
+                        printk(KERN_INFO "Soekris %s: %s\n", model, bios);
+
+                        if (boards[i].init)
+                                boards[i].init();
+                        break;
+                }
+        }
+
+unmap:
+        iounmap(rombase);
+        return 0;
+}
+
+arch_initcall(soekris_init);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/leds/ledtrig-sleep.c b/drivers/leds/ledtrig-sleep.c
new file mode 100644
index 00000000000..f1640421215
--- /dev/null
+++ b/drivers/leds/ledtrig-sleep.c
@@ -0,0 +1,80 @@
+/* drivers/leds/ledtrig-sleep.c
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * 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/earlysuspend.h>
+#include <linux/leds.h>
+#include <linux/suspend.h>
+
+static int ledtrig_sleep_pm_callback(struct notifier_block *nfb,
+                                        unsigned long action,
+                                        void *ignored);
+
+DEFINE_LED_TRIGGER(ledtrig_sleep)
+static struct notifier_block ledtrig_sleep_pm_notifier = {
+        .notifier_call = ledtrig_sleep_pm_callback,
+        .priority = 0,
+};
+
+static void ledtrig_sleep_early_suspend(struct early_suspend *h)
+{
+        led_trigger_event(ledtrig_sleep, LED_FULL);
+}
+
+static void ledtrig_sleep_early_resume(struct early_suspend *h)
+{
+        led_trigger_event(ledtrig_sleep, LED_OFF);
+}
+
+static struct early_suspend ledtrig_sleep_early_suspend_handler = {
+        .suspend = ledtrig_sleep_early_suspend,
+        .resume = ledtrig_sleep_early_resume,
+};
+
+static int ledtrig_sleep_pm_callback(struct notifier_block *nfb,
+                                        unsigned long action,
+                                        void *ignored)
+{
+        switch (action) {
+        case PM_HIBERNATION_PREPARE:
+        case PM_SUSPEND_PREPARE:
+                led_trigger_event(ledtrig_sleep, LED_OFF);
+                return NOTIFY_OK;
+        case PM_POST_HIBERNATION:
+        case PM_POST_SUSPEND:
+                led_trigger_event(ledtrig_sleep, LED_FULL);
+                return NOTIFY_OK;
+        }
+
+        return NOTIFY_DONE;
+}
+
+static int __init ledtrig_sleep_init(void)
+{
+        led_trigger_register_simple("sleep", &ledtrig_sleep);
+        register_pm_notifier(&ledtrig_sleep_pm_notifier);
+        register_early_suspend(&ledtrig_sleep_early_suspend_handler);
+        return 0;
+}
+
+static void __exit ledtrig_sleep_exit(void)
+{
+        unregister_early_suspend(&ledtrig_sleep_early_suspend_handler);
+        unregister_pm_notifier(&ledtrig_sleep_pm_notifier);
+        led_trigger_unregister_simple(ledtrig_sleep);
+}
+
+module_init(ledtrig_sleep_init);
+module_exit(ledtrig_sleep_exit);
+