11 files changed, 233 insertions, 55 deletions

diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index eb26d2aca8b4..dde6ce963a19 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -944,32 +944,6 @@ static const struct i2c_algorithm i2c_pxa_pio_algorithm = {
         .functionality  = i2c_pxa_functionality,
 };
 
-static void i2c_pxa_enable(struct platform_device *dev)
-{
-        if (cpu_is_pxa27x()) {
-                switch (dev->id) {
-                case 0:
-                        pxa_gpio_mode(GPIO117_I2CSCL_MD);
-                        pxa_gpio_mode(GPIO118_I2CSDA_MD);
-                        break;
-                case 1:
-                        local_irq_disable();
-                        PCFR |= PCFR_PI2CEN;
-                        local_irq_enable();
-                        break;
-                }
-        }
-}
-
-static void i2c_pxa_disable(struct platform_device *dev)
-{
-        if (cpu_is_pxa27x() && dev->id == 1) {
-                local_irq_disable();
-                PCFR &= ~PCFR_PI2CEN;
-                local_irq_enable();
-        }
-}
-
 #define res_len(r)              ((r)->end - (r)->start + 1)
 static int i2c_pxa_probe(struct platform_device *dev)
 {
@@ -1035,7 +1009,6 @@ static int i2c_pxa_probe(struct platform_device *dev)
 #endif
 
         clk_enable(i2c->clk);
-        i2c_pxa_enable(dev);
 
         if (plat) {
                 i2c->adap.class = plat->class;
@@ -1079,7 +1052,6 @@ eadapt:
                 free_irq(irq, i2c);
 ereqirq:
         clk_disable(i2c->clk);
-        i2c_pxa_disable(dev);
         iounmap(i2c->reg_base);
 eremap:
         clk_put(i2c->clk);
@@ -1102,7 +1074,6 @@ static int __exit i2c_pxa_remove(struct platform_device *dev)
 
         clk_disable(i2c->clk);
         clk_put(i2c->clk);
-        i2c_pxa_disable(dev);
 
         iounmap(i2c->reg_base);
         release_mem_region(i2c->iobase, i2c->iosize);
diff --git a/drivers/pcmcia/pxa2xx_cm_x270.c b/drivers/pcmcia/pxa2xx_cm_x270.c
index e7ab060ff118..f123fce65f2e 100644
--- a/drivers/pcmcia/pxa2xx_cm_x270.c
+++ b/drivers/pcmcia/pxa2xx_cm_x270.c
@@ -18,6 +18,7 @@
 
 #include <pcmcia/ss.h>
 #include <asm/hardware.h>
+#include <asm/mach-types.h>
 
 #include <asm/arch/pxa-regs.h>
 #include <asm/arch/pxa2xx-gpio.h>
@@ -130,7 +131,7 @@ static void cmx270_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
 }
 
 
-static struct pcmcia_low_level cmx270_pcmcia_ops = {
+static struct pcmcia_low_level cmx270_pcmcia_ops __initdata = {
         .owner                  = THIS_MODULE,
         .hw_init                = cmx270_pcmcia_hw_init,
         .hw_shutdown            = cmx270_pcmcia_shutdown,
@@ -147,15 +148,21 @@ static int __init cmx270_pcmcia_init(void)
 {
         int ret;
 
+        if (!machine_is_armcore())
+                return -ENODEV;
+
         cmx270_pcmcia_device = platform_device_alloc("pxa2xx-pcmcia", -1);
 
         if (!cmx270_pcmcia_device)
                 return -ENOMEM;
 
-        cmx270_pcmcia_device->dev.platform_data = &cmx270_pcmcia_ops;
+        ret = platform_device_add_data(cmx270_pcmcia_device, &cmx270_pcmcia_ops,
+                                       sizeof(cmx270_pcmcia_ops));
 
-        printk(KERN_INFO "Registering cm-x270 PCMCIA interface.\n");
-        ret = platform_device_add(cmx270_pcmcia_device);
+        if (ret == 0) {
+                printk(KERN_INFO "Registering cm-x270 PCMCIA interface.\n");
+                ret = platform_device_add(cmx270_pcmcia_device);
+        }
 
         if (ret)
                 platform_device_put(cmx270_pcmcia_device);
diff --git a/drivers/pcmcia/pxa2xx_mainstone.c b/drivers/pcmcia/pxa2xx_mainstone.c
index 145b85e0f02c..92d1cc33808c 100644
--- a/drivers/pcmcia/pxa2xx_mainstone.c
+++ b/drivers/pcmcia/pxa2xx_mainstone.c
@@ -22,6 +22,7 @@
 #include <pcmcia/ss.h>
 
 #include <asm/hardware.h>
+#include <asm/mach-types.h>
 #include <asm/irq.h>
 
 #include <asm/arch/pxa-regs.h>
@@ -136,7 +137,7 @@ static void mst_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
 {
 }
 
-static struct pcmcia_low_level mst_pcmcia_ops = {
+static struct pcmcia_low_level mst_pcmcia_ops __initdata = {
         .owner                  = THIS_MODULE,
         .hw_init                = mst_pcmcia_hw_init,
         .hw_shutdown            = mst_pcmcia_hw_shutdown,
@@ -153,13 +154,17 @@ static int __init mst_pcmcia_init(void)
 {
         int ret;
 
+        if (!machine_is_mainstone())
+                return -ENODEV;
+
         mst_pcmcia_device = platform_device_alloc("pxa2xx-pcmcia", -1);
         if (!mst_pcmcia_device)
                 return -ENOMEM;
 
-        mst_pcmcia_device->dev.platform_data = &mst_pcmcia_ops;
-
-        ret = platform_device_add(mst_pcmcia_device);
+        ret = platform_device_add_data(mst_pcmcia_device, &mst_pcmcia_ops,
+                                       sizeof(mst_pcmcia_ops));
+        if (ret == 0)
+                ret = platform_device_add(mst_pcmcia_device);
 
         if (ret)
                 platform_device_put(mst_pcmcia_device);
diff --git a/drivers/pcmcia/pxa2xx_sharpsl.c b/drivers/pcmcia/pxa2xx_sharpsl.c
index d5c33bd78d68..d71f93d45833 100644
--- a/drivers/pcmcia/pxa2xx_sharpsl.c
+++ b/drivers/pcmcia/pxa2xx_sharpsl.c
@@ -222,7 +222,7 @@ static void sharpsl_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
         sharpsl_pcmcia_init_reset(skt);
 }
 
-static struct pcmcia_low_level sharpsl_pcmcia_ops = {
+static struct pcmcia_low_level sharpsl_pcmcia_ops __initdata = {
         .owner                  = THIS_MODULE,
         .hw_init                = sharpsl_pcmcia_hw_init,
         .hw_shutdown            = sharpsl_pcmcia_hw_shutdown,
@@ -261,10 +261,12 @@ static int __init sharpsl_pcmcia_init(void)
         if (!sharpsl_pcmcia_device)
                 return -ENOMEM;
 
-        sharpsl_pcmcia_device->dev.platform_data = &sharpsl_pcmcia_ops;
-        sharpsl_pcmcia_device->dev.parent = platform_scoop_config->devs[0].dev;
-
-        ret = platform_device_add(sharpsl_pcmcia_device);
+        ret = platform_device_add_data(sharpsl_pcmcia_device,
+                        &sharpsl_pcmcia_ops, sizeof(sharpsl_pcmcia_ops));
+        if (ret == 0) {
+                sharpsl_pcmcia_device->dev.parent = platform_scoop_config->devs[0].dev;
+                ret = platform_device_add(sharpsl_pcmcia_device);
+        }
 
         if (ret)
                 platform_device_put(sharpsl_pcmcia_device);
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 499b7a23f351..40d6b580f152 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -38,7 +38,7 @@
 #include <linux/usb.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
-
+#include <asm/arch/pxa2xx-regs.h> /* FIXME: for PSSR */
 #include <asm/arch/udc.h>
 
 #include "pxa27x_udc.h"
@@ -2359,7 +2359,8 @@ static int pxa_udc_resume(struct platform_device *_dev)
          * Software must configure the USB OTG pad, UDC, and UHC
          * to the state they were in before entering sleep mode.
          */
-        PSSR |= PSSR_OTGPH;
+        if (cpu_is_pxa27x())
+                PSSR |= PSSR_OTGPH;
 
         return 0;
 }
diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h
index 97453db924ff..1d1b7936ee11 100644
--- a/drivers/usb/gadget/pxa27x_udc.h
+++ b/drivers/usb/gadget/pxa27x_udc.h
@@ -484,12 +484,4 @@ static inline struct pxa_udc *to_gadget_udc(struct usb_gadget *gadget)
 #define ep_warn(ep, fmt, arg...) \
         dev_warn(ep->dev->dev, "%s:%s:" fmt, EPNAME(ep), __func__, ## arg)
 
-/*
- * Cannot include pxa-regs.h, as register names are similar.
- * So PSSR is redefined here. This should be removed once UDC registers will
- * be gone from pxa-regs.h.
- */
-#define PSSR            __REG(0x40F00004)       /* Power Manager Sleep Status */
-#define PSSR_OTGPH      (1 << 6)                /* OTG Peripheral Hold */
-
 #endif /* __LINUX_USB_GADGET_PXA27X_H */
diff --git a/drivers/usb/gadget/pxa2xx_udc.c b/drivers/usb/gadget/pxa2xx_udc.c
index 08f699b1fc57..63db96adc0b0 100644
--- a/drivers/usb/gadget/pxa2xx_udc.c
+++ b/drivers/usb/gadget/pxa2xx_udc.c
@@ -46,19 +46,25 @@
 #include <linux/err.h>
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
+#include <linux/io.h>
 
 #include <asm/byteorder.h>
 #include <asm/dma.h>
 #include <asm/gpio.h>
-#include <asm/io.h>
 #include <asm/system.h>
 #include <asm/mach-types.h>
 #include <asm/unaligned.h>
-#include <asm/hardware.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
+/*
+ * This driver is PXA25x only.  Grab the right register definitions.
+ */
+#ifdef CONFIG_ARCH_PXA
+#include <asm/arch/pxa25x-udc.h>
+#endif
+
 #include <asm/mach/udc_pxa2xx.h>
 
 
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 70b0d4b459e7..08b27d6bbd43 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -27,6 +27,7 @@
 #include <asm/mach-types.h>
 #include <asm/hardware.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-regs.h> /* FIXME: for PSSR */
 #include <asm/arch/ohci.h>
 
 #define PXA_UHC_MAX_PORTNUM    3
@@ -104,7 +105,7 @@ static int pxa27x_start_hc(struct device *dev)
         UHCHIE = (UHCHIE_UPRIE | UHCHIE_RWIE);
 
         /* Clear any OTG Pin Hold */
-        if (PSSR & PSSR_OTGPH)
+        if (cpu_is_pxa27x() && (PSSR & PSSR_OTGPH))
                 PSSR |= PSSR_OTGPH;
 
         return 0;
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index dcd8073c2369..30bf7f2f1635 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -112,3 +112,10 @@ config BACKLIGHT_CARILLO_RANCH
         help
           If you have a Intel LE80578 (Carillo Ranch) say Y to enable the
           backlight driver.
+
+config BACKLIGHT_PWM
+        tristate "Generic PWM based Backlight Driver"
+        depends on BACKLIGHT_CLASS_DEVICE && HAVE_PWM
+        help
+          If you have a LCD backlight adjustable by PWM, say Y to enable
+          this driver.
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 33f6c7cecc73..b51a7cd12500 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -10,3 +10,4 @@ obj-$(CONFIG_BACKLIGHT_LOCOMO)	+= locomolcd.o
 obj-$(CONFIG_BACKLIGHT_OMAP1)   += omap1_bl.o
 obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
 obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
+obj-$(CONFIG_BACKLIGHT_PWM)     += pwm_bl.o
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
new file mode 100644
index 000000000000..6338d0e2fe07
--- /dev/null
+++ b/drivers/video/backlight/pwm_bl.c
@@ -0,0 +1,185 @@
+/*
+ * linux/drivers/video/backlight/pwm_bl.c
+ *
+ * simple PWM based backlight control, board code has to setup
+ * 1) pin configuration so PWM waveforms can output
+ * 2) platform_data casts to the PWM id (0/1/2/3 on PXA)
+ *
+ * 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/fb.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/pwm.h>
+#include <linux/pwm_backlight.h>
+
+struct pwm_bl_data {
+        struct pwm_device       *pwm;
+        unsigned int            period;
+        int                     (*notify)(int brightness);
+};
+
+static int pwm_backlight_update_status(struct backlight_device *bl)
+{
+        struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
+        int brightness = bl->props.brightness;
+        int max = bl->props.max_brightness;
+
+        if (bl->props.power != FB_BLANK_UNBLANK)
+                brightness = 0;
+
+        if (bl->props.fb_blank != FB_BLANK_UNBLANK)
+                brightness = 0;
+
+        if (pb->notify)
+                brightness = pb->notify(brightness);
+
+        if (brightness == 0) {
+                pwm_config(pb->pwm, 0, pb->period);
+                pwm_disable(pb->pwm);
+        } else {
+                pwm_config(pb->pwm, brightness * pb->period / max, pb->period);
+                pwm_enable(pb->pwm);
+        }
+        return 0;
+}
+
+static int pwm_backlight_get_brightness(struct backlight_device *bl)
+{
+        return bl->props.brightness;
+}
+
+static struct backlight_ops pwm_backlight_ops = {
+        .update_status  = pwm_backlight_update_status,
+        .get_brightness = pwm_backlight_get_brightness,
+};
+
+static int pwm_backlight_probe(struct platform_device *pdev)
+{
+        struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
+        struct backlight_device *bl;
+        struct pwm_bl_data *pb;
+        int ret;
+
+        if (!data)
+                return -EINVAL;
+
+        if (data->init) {
+                ret = data->init(&pdev->dev);
+                if (ret < 0)
+                        return ret;
+        }
+
+        pb = kzalloc(sizeof(*pb), GFP_KERNEL);
+        if (!pb) {
+                ret = -ENOMEM;
+                goto err_alloc;
+        }
+
+        pb->period = data->pwm_period_ns;
+        pb->notify = data->notify;
+
+        pb->pwm = pwm_request(data->pwm_id, "backlight");
+        if (IS_ERR(pb->pwm)) {
+                dev_err(&pdev->dev, "unable to request PWM for backlight\n");
+                ret = PTR_ERR(pb->pwm);
+                goto err_pwm;
+        }
+
+        bl = backlight_device_register(pdev->name, &pdev->dev,
+                        pb, &pwm_backlight_ops);
+        if (IS_ERR(bl)) {
+                dev_err(&pdev->dev, "failed to register backlight\n");
+                ret = PTR_ERR(bl);
+                goto err_bl;
+        }
+
+        bl->props.max_brightness = data->max_brightness;
+        bl->props.brightness = data->dft_brightness;
+        backlight_update_status(bl);
+
+        platform_set_drvdata(pdev, bl);
+        return 0;
+
+err_bl:
+        pwm_free(pb->pwm);
+err_pwm:
+        kfree(pb);
+err_alloc:
+        if (data->exit)
+                data->exit(&pdev->dev);
+        return ret;
+}
+
+static int pwm_backlight_remove(struct platform_device *pdev)
+{
+        struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
+        struct backlight_device *bl = platform_get_drvdata(pdev);
+        struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
+
+        backlight_device_unregister(bl);
+        pwm_config(pb->pwm, 0, pb->period);
+        pwm_disable(pb->pwm);
+        pwm_free(pb->pwm);
+        kfree(pb);
+        if (data->exit)
+                data->exit(&pdev->dev);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pwm_backlight_suspend(struct platform_device *pdev,
+                                 pm_message_t state)
+{
+        struct backlight_device *bl = platform_get_drvdata(pdev);
+        struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
+
+        pwm_config(pb->pwm, 0, pb->period);
+        pwm_disable(pb->pwm);
+        return 0;
+}
+
+static int pwm_backlight_resume(struct platform_device *pdev)
+{
+        struct backlight_device *bl = platform_get_drvdata(pdev);
+
+        backlight_update_status(bl);
+        return 0;
+}
+#else
+#define pwm_backlight_suspend   NULL
+#define pwm_backlight_resume    NULL
+#endif
+
+static struct platform_driver pwm_backlight_driver = {
+        .driver         = {
+                .name   = "pwm-backlight",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = pwm_backlight_probe,
+        .remove         = pwm_backlight_remove,
+        .suspend        = pwm_backlight_suspend,
+        .resume         = pwm_backlight_resume,
+};
+
+static int __init pwm_backlight_init(void)
+{
+        return platform_driver_register(&pwm_backlight_driver);
+}
+module_init(pwm_backlight_init);
+
+static void __exit pwm_backlight_exit(void)
+{
+        platform_driver_unregister(&pwm_backlight_driver);
+}
+module_exit(pwm_backlight_exit);
+
+MODULE_DESCRIPTION("PWM based Backlight Driver");
+MODULE_LICENSE("GPL");