Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit dd37739f47ea278a57d66b2afe20243f0a6294a0

Authored by Jesper Juhl 2011-06-24 06:35:17 +0800

Committed by Paul Mundt 2011-06-24 16:16:51 +0800

1 parent 20733d59d5

Exists in master and in 6 other branches

Remove unneeded version.h includes from drivers/video/

It was pointed out by 'make versioncheck' that some includes of
linux/version.h are not needed in drivers/video/.
This patch removes them.

Signed-off-by: Jesper Juhl <jj@chaosbits.net>
Acked-by: Mike Frysinger <vapier@gentoo.org>
Signed-off-by: Paul Mundt <lethal@linux-sh.org>

Showing 4 changed files with 0 additions and 5 deletions Inline Diff

drivers/video/backlight/adp8860_bl.c
drivers/video/backlight/adp8870_bl.c
drivers/video/pxa3xx-gcu.c
drivers/video/xilinxfb.c

drivers/video/backlight/adp8860_bl.c

Diff comments View file @ dd37739

 /*
  * Backlight driver for Analog Devices ADP8860 Backlight Devices
  *
  * Copyright 2009-2010 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
 #include <linux/module.h>
-#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 #include <linux/fb.h>
 #include <linux/backlight.h>
 #include <linux/leds.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/i2c/adp8860.h>
 #define ADP8860_EXT_FEATURES
 #define ADP8860_USE_LEDS
 #define ADP8860_MFDVID 0x00 /* Manufacturer and device ID */
 #define ADP8860_MDCR 0x01 /* Device mode and status */
 #define ADP8860_MDCR2 0x02 /* Device mode and Status Register 2 */
 #define ADP8860_INTR_EN 0x03 /* Interrupts enable */
 #define ADP8860_CFGR 0x04 /* Configuration register */
 #define ADP8860_BLSEN 0x05 /* Sink enable backlight or independent */
 #define ADP8860_BLOFF 0x06 /* Backlight off timeout */
 #define ADP8860_BLDIM 0x07 /* Backlight dim timeout */
 #define ADP8860_BLFR 0x08 /* Backlight fade in and out rates */
 #define ADP8860_BLMX1 0x09 /* Backlight (Brightness Level 1-daylight) maximum current */
 #define ADP8860_BLDM1 0x0A /* Backlight (Brightness Level 1-daylight) dim current */
 #define ADP8860_BLMX2 0x0B /* Backlight (Brightness Level 2-office) maximum current */
 #define ADP8860_BLDM2 0x0C /* Backlight (Brightness Level 2-office) dim current */
 #define ADP8860_BLMX3 0x0D /* Backlight (Brightness Level 3-dark) maximum current */
 #define ADP8860_BLDM3 0x0E /* Backlight (Brightness Level 3-dark) dim current */
 #define ADP8860_ISCFR 0x0F /* Independent sink current fade control register */
 #define ADP8860_ISCC 0x10 /* Independent sink current control register */
 #define ADP8860_ISCT1 0x11 /* Independent Sink Current Timer Register LED[7:5] */
 #define ADP8860_ISCT2 0x12 /* Independent Sink Current Timer Register LED[4:1] */
 #define ADP8860_ISCF 0x13 /* Independent sink current fade register */
 #define ADP8860_ISC7 0x14 /* Independent Sink Current LED7 */
 #define ADP8860_ISC6 0x15 /* Independent Sink Current LED6 */
 #define ADP8860_ISC5 0x16 /* Independent Sink Current LED5 */
 #define ADP8860_ISC4 0x17 /* Independent Sink Current LED4 */
 #define ADP8860_ISC3 0x18 /* Independent Sink Current LED3 */
 #define ADP8860_ISC2 0x19 /* Independent Sink Current LED2 */
 #define ADP8860_ISC1 0x1A /* Independent Sink Current LED1 */
 #define ADP8860_CCFG 0x1B /* Comparator configuration */
 #define ADP8860_CCFG2 0x1C /* Second comparator configuration */
 #define ADP8860_L2_TRP 0x1D /* L2 comparator reference */
 #define ADP8860_L2_HYS 0x1E /* L2 hysteresis */
 #define ADP8860_L3_TRP 0x1F /* L3 comparator reference */
 #define ADP8860_L3_HYS 0x20 /* L3 hysteresis */
 #define ADP8860_PH1LEVL 0x21 /* First phototransistor ambient light level-low byte register */
 #define ADP8860_PH1LEVH 0x22 /* First phototransistor ambient light level-high byte register */
 #define ADP8860_PH2LEVL 0x23 /* Second phototransistor ambient light level-low byte register */
 #define ADP8860_PH2LEVH 0x24 /* Second phototransistor ambient light level-high byte register */
 #define ADP8860_MANUFID		0x0  /* Analog Devices ADP8860 Manufacturer ID */
 #define ADP8861_MANUFID		0x4  /* Analog Devices ADP8861 Manufacturer ID */
 #define ADP8863_MANUFID		0x2  /* Analog Devices ADP8863 Manufacturer ID */
 #define ADP8860_DEVID(x)	((x) & 0xF)
 #define ADP8860_MANID(x)	((x) >> 4)
 /* MDCR Device mode and status */
 #define INT_CFG			(1 << 6)
 #define NSTBY			(1 << 5)
 #define DIM_EN			(1 << 4)
 #define GDWN_DIS		(1 << 3)
 #define SIS_EN			(1 << 2)
 #define CMP_AUTOEN		(1 << 1)
 #define BLEN			(1 << 0)
 /* ADP8860_CCFG Main ALS comparator level enable */
 #define L3_EN			(1 << 1)
 #define L2_EN			(1 << 0)
 #define CFGR_BLV_SHIFT		3
 #define CFGR_BLV_MASK		0x3
 #define ADP8860_FLAG_LED_MASK	0xFF
 #define FADE_VAL(in, out)	((0xF & (in)) | ((0xF & (out)) << 4))
 #define BL_CFGR_VAL(law, blv)	((((blv) & CFGR_BLV_MASK) << CFGR_BLV_SHIFT) | ((0x3 & (law)) << 1))
 #define ALS_CCFG_VAL(filt)	((0x7 & filt) << 5)
 enum {
 	adp8860,
 	adp8861,
 	adp8863
 };
 struct adp8860_led {
 	struct led_classdev	cdev;
 	struct work_struct	work;
 	struct i2c_client	*client;
 	enum led_brightness	new_brightness;
 	int			id;
 	int			flags;
 };
 struct adp8860_bl {
 	struct i2c_client *client;
 	struct backlight_device *bl;
 	struct adp8860_led *led;
 	struct adp8860_backlight_platform_data *pdata;
 	struct mutex lock;
 	unsigned long cached_daylight_max;
 	int id;
 	int revid;
 	int current_brightness;
 	unsigned en_ambl_sens:1;
 	unsigned gdwn_dis:1;
 };
 static int adp8860_read(struct i2c_client *client, int reg, uint8_t *val)
 {
 	int ret;
 	ret = i2c_smbus_read_byte_data(client, reg);
 	if (ret < 0) {
 		dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
 		return ret;
 	}
 	*val = (uint8_t)ret;
 	return 0;
 }
 static int adp8860_write(struct i2c_client *client, u8 reg, u8 val)
 {
 	return i2c_smbus_write_byte_data(client, reg, val);
 }
 static int adp8860_set_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
 {
 	struct adp8860_bl *data = i2c_get_clientdata(client);
 	uint8_t reg_val;
 	int ret;
 	mutex_lock(&data->lock);
 	ret = adp8860_read(client, reg, &reg_val);
 	if (!ret && ((reg_val & bit_mask) == 0)) {
 		reg_val |= bit_mask;
 		ret = adp8860_write(client, reg, reg_val);
 	}
 	mutex_unlock(&data->lock);
 	return ret;
 }
 static int adp8860_clr_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
 {
 	struct adp8860_bl *data = i2c_get_clientdata(client);
 	uint8_t reg_val;
 	int ret;
 	mutex_lock(&data->lock);
 	ret = adp8860_read(client, reg, &reg_val);
 	if (!ret && (reg_val & bit_mask)) {
 		reg_val &= ~bit_mask;
 		ret = adp8860_write(client, reg, reg_val);
 	}
 	mutex_unlock(&data->lock);
 	return ret;
 }
 /*
  * Independent sink / LED
  */
 #if defined(ADP8860_USE_LEDS)
 static void adp8860_led_work(struct work_struct *work)
 {
 	struct adp8860_led *led = container_of(work, struct adp8860_led, work);
 	adp8860_write(led->client, ADP8860_ISC1 - led->id + 1,
 			 led->new_brightness >> 1);
 }
 static void adp8860_led_set(struct led_classdev *led_cdev,
 			   enum led_brightness value)
 {
 	struct adp8860_led *led;
 	led = container_of(led_cdev, struct adp8860_led, cdev);
 	led->new_brightness = value;
 	schedule_work(&led->work);
 }
 static int adp8860_led_setup(struct adp8860_led *led)
 {
 	struct i2c_client *client = led->client;
 	int ret = 0;
 	ret = adp8860_write(client, ADP8860_ISC1 - led->id + 1, 0);
 	ret |= adp8860_set_bits(client, ADP8860_ISCC, 1 << (led->id - 1));
 	if (led->id > 4)
 		ret |= adp8860_set_bits(client, ADP8860_ISCT1,
 				(led->flags & 0x3) << ((led->id - 5) * 2));
 	else
 		ret |= adp8860_set_bits(client, ADP8860_ISCT2,
 				(led->flags & 0x3) << ((led->id - 1) * 2));
 	return ret;
 }
 static int __devinit adp8860_led_probe(struct i2c_client *client)
 {
 	struct adp8860_backlight_platform_data *pdata =
 		client->dev.platform_data;
 	struct adp8860_bl *data = i2c_get_clientdata(client);
 	struct adp8860_led *led, *led_dat;
 	struct led_info *cur_led;
 	int ret, i;
 	led = kzalloc(sizeof(*led) * pdata->num_leds, GFP_KERNEL);
 	if (led == NULL) {
 		dev_err(&client->dev, "failed to alloc memory\n");
 		return -ENOMEM;
 	}
 	ret = adp8860_write(client, ADP8860_ISCFR, pdata->led_fade_law);
 	ret = adp8860_write(client, ADP8860_ISCT1,
 			(pdata->led_on_time & 0x3) << 6);
 	ret |= adp8860_write(client, ADP8860_ISCF,
 			FADE_VAL(pdata->led_fade_in, pdata->led_fade_out));
 	if (ret) {
 		dev_err(&client->dev, "failed to write\n");
 		goto err_free;
 	}
 	for (i = 0; i < pdata->num_leds; ++i) {
 		cur_led = &pdata->leds[i];
 		led_dat = &led[i];
 		led_dat->id = cur_led->flags & ADP8860_FLAG_LED_MASK;
 		if (led_dat->id > 7 || led_dat->id < 1) {
 			dev_err(&client->dev, "Invalid LED ID %d\n",
 				led_dat->id);
 			goto err;
 		}
 		if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) {
 			dev_err(&client->dev, "LED %d used by Backlight\n",
 				led_dat->id);
 			goto err;
 		}
 		led_dat->cdev.name = cur_led->name;
 		led_dat->cdev.default_trigger = cur_led->default_trigger;
 		led_dat->cdev.brightness_set = adp8860_led_set;
 		led_dat->cdev.brightness = LED_OFF;
 		led_dat->flags = cur_led->flags >> FLAG_OFFT_SHIFT;
 		led_dat->client = client;
 		led_dat->new_brightness = LED_OFF;
 		INIT_WORK(&led_dat->work, adp8860_led_work);
 		ret = led_classdev_register(&client->dev, &led_dat->cdev);
 		if (ret) {
 			dev_err(&client->dev, "failed to register LED %d\n",
 				led_dat->id);
 			goto err;
 		}
 		ret = adp8860_led_setup(led_dat);
 		if (ret) {
 			dev_err(&client->dev, "failed to write\n");
 			i++;
 			goto err;
 		}
 	}
 	data->led = led;
 	return 0;
  err:
 	for (i = i - 1; i >= 0; --i) {
 		led_classdev_unregister(&led[i].cdev);
 		cancel_work_sync(&led[i].work);
 	}
  err_free:
 	kfree(led);
 	return ret;
 }
 static int __devexit adp8860_led_remove(struct i2c_client *client)
 {
 	struct adp8860_backlight_platform_data *pdata =
 		client->dev.platform_data;
 	struct adp8860_bl *data = i2c_get_clientdata(client);
 	int i;
 	for (i = 0; i < pdata->num_leds; i++) {
 		led_classdev_unregister(&data->led[i].cdev);
 		cancel_work_sync(&data->led[i].work);
 	}
 	kfree(data->led);
 	return 0;
 }
 #else
 static int __devinit adp8860_led_probe(struct i2c_client *client)
 {
 	return 0;
 }
 static int __devexit adp8860_led_remove(struct i2c_client *client)
 {
 	return 0;
 }
 #endif
 static int adp8860_bl_set(struct backlight_device *bl, int brightness)
 {
 	struct adp8860_bl *data = bl_get_data(bl);
 	struct i2c_client *client = data->client;
 	int ret = 0;
 	if (data->en_ambl_sens) {
 		if ((brightness > 0) && (brightness < ADP8860_MAX_BRIGHTNESS)) {
 			/* Disable Ambient Light auto adjust */
 			ret |= adp8860_clr_bits(client, ADP8860_MDCR,
 					CMP_AUTOEN);
 			ret |= adp8860_write(client, ADP8860_BLMX1, brightness);
 		} else {
 			/*
 			 * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust
 			 * restore daylight l1 sysfs brightness
 			 */
 			ret |= adp8860_write(client, ADP8860_BLMX1,
 					 data->cached_daylight_max);
 			ret |= adp8860_set_bits(client, ADP8860_MDCR,
 					 CMP_AUTOEN);
 		}
 	} else
 		ret |= adp8860_write(client, ADP8860_BLMX1, brightness);
 	if (data->current_brightness && brightness == 0)
 		ret |= adp8860_set_bits(client,
 				ADP8860_MDCR, DIM_EN);
 	else if (data->current_brightness == 0 && brightness)
 		ret |= adp8860_clr_bits(client,
 				ADP8860_MDCR, DIM_EN);
 	if (!ret)
 		data->current_brightness = brightness;
 	return ret;
 }
 static int adp8860_bl_update_status(struct backlight_device *bl)
 {
 	int brightness = bl->props.brightness;
 	if (bl->props.power != FB_BLANK_UNBLANK)
 		brightness = 0;
 	if (bl->props.fb_blank != FB_BLANK_UNBLANK)
 		brightness = 0;
 	return adp8860_bl_set(bl, brightness);
 }
 static int adp8860_bl_get_brightness(struct backlight_device *bl)
 {
 	struct adp8860_bl *data = bl_get_data(bl);
 	return data->current_brightness;
 }
 static const struct backlight_ops adp8860_bl_ops = {
 	.update_status	= adp8860_bl_update_status,
 	.get_brightness	= adp8860_bl_get_brightness,
 };
 static int adp8860_bl_setup(struct backlight_device *bl)
 {
 	struct adp8860_bl *data = bl_get_data(bl);
 	struct i2c_client *client = data->client;
 	struct adp8860_backlight_platform_data *pdata = data->pdata;
 	int ret = 0;
 	ret |= adp8860_write(client, ADP8860_BLSEN, ~pdata->bl_led_assign);
 	ret |= adp8860_write(client, ADP8860_BLMX1, pdata->l1_daylight_max);
 	ret |= adp8860_write(client, ADP8860_BLDM1, pdata->l1_daylight_dim);
 	if (data->en_ambl_sens) {
 		data->cached_daylight_max = pdata->l1_daylight_max;
 		ret |= adp8860_write(client, ADP8860_BLMX2,
 						pdata->l2_office_max);
 		ret |= adp8860_write(client, ADP8860_BLDM2,
 						pdata->l2_office_dim);
 		ret |= adp8860_write(client, ADP8860_BLMX3,
 						pdata->l3_dark_max);
 		ret |= adp8860_write(client, ADP8860_BLDM3,
 						pdata->l3_dark_dim);
 		ret |= adp8860_write(client, ADP8860_L2_TRP, pdata->l2_trip);
 		ret |= adp8860_write(client, ADP8860_L2_HYS, pdata->l2_hyst);
 		ret |= adp8860_write(client, ADP8860_L3_TRP, pdata->l3_trip);
 		ret |= adp8860_write(client, ADP8860_L3_HYS, pdata->l3_hyst);
 		ret |= adp8860_write(client, ADP8860_CCFG, L2_EN | L3_EN |
 						ALS_CCFG_VAL(pdata->abml_filt));
 	}
 	ret |= adp8860_write(client, ADP8860_CFGR,
 			BL_CFGR_VAL(pdata->bl_fade_law, 0));
 	ret |= adp8860_write(client, ADP8860_BLFR, FADE_VAL(pdata->bl_fade_in,
 			pdata->bl_fade_out));
 	ret |= adp8860_set_bits(client, ADP8860_MDCR, BLEN | DIM_EN | NSTBY |
 			(data->gdwn_dis ? GDWN_DIS : 0));
 	return ret;
 }
 static ssize_t adp8860_show(struct device *dev, char *buf, int reg)
 {
 	struct adp8860_bl *data = dev_get_drvdata(dev);
 	int error;
 	uint8_t reg_val;
 	mutex_lock(&data->lock);
 	error = adp8860_read(data->client, reg, &reg_val);
 	mutex_unlock(&data->lock);
 	if (error < 0)
 		return error;
 	return sprintf(buf, "%u\n", reg_val);
 }
 static ssize_t adp8860_store(struct device *dev, const char *buf,
 			 size_t count, int reg)
 {
 	struct adp8860_bl *data = dev_get_drvdata(dev);
 	unsigned long val;
 	int ret;
 	ret = strict_strtoul(buf, 10, &val);
 	if (ret)
 		return ret;
 	mutex_lock(&data->lock);
 	adp8860_write(data->client, reg, val);
 	mutex_unlock(&data->lock);
 	return count;
 }
 static ssize_t adp8860_bl_l3_dark_max_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	return adp8860_show(dev, buf, ADP8860_BLMX3);
 }
 static ssize_t adp8860_bl_l3_dark_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	return adp8860_store(dev, buf, count, ADP8860_BLMX3);
 }
 static DEVICE_ATTR(l3_dark_max, 0664, adp8860_bl_l3_dark_max_show,
 			adp8860_bl_l3_dark_max_store);
 static ssize_t adp8860_bl_l2_office_max_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	return adp8860_show(dev, buf, ADP8860_BLMX2);
 }
 static ssize_t adp8860_bl_l2_office_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	return adp8860_store(dev, buf, count, ADP8860_BLMX2);
 }
 static DEVICE_ATTR(l2_office_max, 0664, adp8860_bl_l2_office_max_show,
 			adp8860_bl_l2_office_max_store);
 static ssize_t adp8860_bl_l1_daylight_max_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8860_show(dev, buf, ADP8860_BLMX1);
 }
 static ssize_t adp8860_bl_l1_daylight_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	struct adp8860_bl *data = dev_get_drvdata(dev);
 	int ret = strict_strtoul(buf, 10, &data->cached_daylight_max);
 	if (ret)
 		return ret;
 	return adp8860_store(dev, buf, count, ADP8860_BLMX1);
 }
 static DEVICE_ATTR(l1_daylight_max, 0664, adp8860_bl_l1_daylight_max_show,
 			adp8860_bl_l1_daylight_max_store);
 static ssize_t adp8860_bl_l3_dark_dim_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8860_show(dev, buf, ADP8860_BLDM3);
 }
 static ssize_t adp8860_bl_l3_dark_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8860_store(dev, buf, count, ADP8860_BLDM3);
 }
 static DEVICE_ATTR(l3_dark_dim, 0664, adp8860_bl_l3_dark_dim_show,
 			adp8860_bl_l3_dark_dim_store);
 static ssize_t adp8860_bl_l2_office_dim_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8860_show(dev, buf, ADP8860_BLDM2);
 }
 static ssize_t adp8860_bl_l2_office_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8860_store(dev, buf, count, ADP8860_BLDM2);
 }
 static DEVICE_ATTR(l2_office_dim, 0664, adp8860_bl_l2_office_dim_show,
 			adp8860_bl_l2_office_dim_store);
 static ssize_t adp8860_bl_l1_daylight_dim_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	return adp8860_show(dev, buf, ADP8860_BLDM1);
 }
 static ssize_t adp8860_bl_l1_daylight_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8860_store(dev, buf, count, ADP8860_BLDM1);
 }
 static DEVICE_ATTR(l1_daylight_dim, 0664, adp8860_bl_l1_daylight_dim_show,
 			adp8860_bl_l1_daylight_dim_store);
 #ifdef ADP8860_EXT_FEATURES
 static ssize_t adp8860_bl_ambient_light_level_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	struct adp8860_bl *data = dev_get_drvdata(dev);
 	int error;
 	uint8_t reg_val;
 	uint16_t ret_val;
 	mutex_lock(&data->lock);
 	error = adp8860_read(data->client, ADP8860_PH1LEVL, &reg_val);
 	ret_val = reg_val;
 	error |= adp8860_read(data->client, ADP8860_PH1LEVH, &reg_val);
 	mutex_unlock(&data->lock);
 	if (error < 0)
 		return error;
 	/* Return 13-bit conversion value for the first light sensor */
 	ret_val += (reg_val & 0x1F) << 8;
 	return sprintf(buf, "%u\n", ret_val);
 }
 static DEVICE_ATTR(ambient_light_level, 0444,
 		adp8860_bl_ambient_light_level_show, NULL);
 static ssize_t adp8860_bl_ambient_light_zone_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	struct adp8860_bl *data = dev_get_drvdata(dev);
 	int error;
 	uint8_t reg_val;
 	mutex_lock(&data->lock);
 	error = adp8860_read(data->client, ADP8860_CFGR, &reg_val);
 	mutex_unlock(&data->lock);
 	if (error < 0)
 		return error;
 	return sprintf(buf, "%u\n",
 		((reg_val >> CFGR_BLV_SHIFT) & CFGR_BLV_MASK) + 1);
 }
 static ssize_t adp8860_bl_ambient_light_zone_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	struct adp8860_bl *data = dev_get_drvdata(dev);
 	unsigned long val;
 	uint8_t reg_val;
 	int ret;
 	ret = strict_strtoul(buf, 10, &val);
 	if (ret)
 		return ret;
 	if (val == 0) {
 		/* Enable automatic ambient light sensing */
 		adp8860_set_bits(data->client, ADP8860_MDCR, CMP_AUTOEN);
 	} else if ((val > 0) && (val <= 3)) {
 		/* Disable automatic ambient light sensing */
 		adp8860_clr_bits(data->client, ADP8860_MDCR, CMP_AUTOEN);
 		/* Set user supplied ambient light zone */
 		mutex_lock(&data->lock);
 		adp8860_read(data->client, ADP8860_CFGR, &reg_val);
 		reg_val &= ~(CFGR_BLV_MASK << CFGR_BLV_SHIFT);
 		reg_val |= (val - 1) << CFGR_BLV_SHIFT;
 		adp8860_write(data->client, ADP8860_CFGR, reg_val);
 		mutex_unlock(&data->lock);
 	}
 	return count;
 }
 static DEVICE_ATTR(ambient_light_zone, 0664,
 		adp8860_bl_ambient_light_zone_show,
 		adp8860_bl_ambient_light_zone_store);
 #endif
 static struct attribute *adp8860_bl_attributes[] = {
 	&dev_attr_l3_dark_max.attr,
 	&dev_attr_l3_dark_dim.attr,
 	&dev_attr_l2_office_max.attr,
 	&dev_attr_l2_office_dim.attr,
 	&dev_attr_l1_daylight_max.attr,
 	&dev_attr_l1_daylight_dim.attr,
 #ifdef ADP8860_EXT_FEATURES
 	&dev_attr_ambient_light_level.attr,
 	&dev_attr_ambient_light_zone.attr,
 #endif
 	NULL
 };
 static const struct attribute_group adp8860_bl_attr_group = {
 	.attrs = adp8860_bl_attributes,
 };
 static int __devinit adp8860_probe(struct i2c_client *client,
 					const struct i2c_device_id *id)
 {
 	struct backlight_device *bl;
 	struct adp8860_bl *data;
 	struct adp8860_backlight_platform_data *pdata =
 		client->dev.platform_data;
 	struct backlight_properties props;
 	uint8_t reg_val;
 	int ret;
 	if (!i2c_check_functionality(client->adapter,
 					I2C_FUNC_SMBUS_BYTE_DATA)) {
 		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
 		return -EIO;
 	}
 	if (!pdata) {
 		dev_err(&client->dev, "no platform data?\n");
 		return -EINVAL;
 	}
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
 	if (data == NULL)
 		return -ENOMEM;
 	ret = adp8860_read(client, ADP8860_MFDVID, &reg_val);
 	if (ret < 0)
 		goto out2;
 	switch (ADP8860_MANID(reg_val)) {
 	case ADP8863_MANUFID:
 		data->gdwn_dis = !!pdata->gdwn_dis;
 	case ADP8860_MANUFID:
 		data->en_ambl_sens = !!pdata->en_ambl_sens;
 		break;
 	case ADP8861_MANUFID:
 		data->gdwn_dis = !!pdata->gdwn_dis;
 		break;
 	default:
 		dev_err(&client->dev, "failed to probe\n");
 		ret = -ENODEV;
 		goto out2;
 	}
 	/* It's confirmed that the DEVID field is actually a REVID */
 	data->revid = ADP8860_DEVID(reg_val);
 	data->client = client;
 	data->pdata = pdata;
 	data->id = id->driver_data;
 	data->current_brightness = 0;
 	i2c_set_clientdata(client, data);
 	memset(&props, 0, sizeof(props));
 	props.type = BACKLIGHT_RAW;
 	props.max_brightness = ADP8860_MAX_BRIGHTNESS;
 	mutex_init(&data->lock);
 	bl = backlight_device_register(dev_driver_string(&client->dev),
 			&client->dev, data, &adp8860_bl_ops, &props);
 	if (IS_ERR(bl)) {
 		dev_err(&client->dev, "failed to register backlight\n");
 		ret = PTR_ERR(bl);
 		goto out2;
 	}
 	bl->props.max_brightness =
 		bl->props.brightness = ADP8860_MAX_BRIGHTNESS;
 	data->bl = bl;
 	if (data->en_ambl_sens)
 		ret = sysfs_create_group(&bl->dev.kobj,
 			&adp8860_bl_attr_group);
 	if (ret) {
 		dev_err(&client->dev, "failed to register sysfs\n");
 		goto out1;
 	}
 	ret = adp8860_bl_setup(bl);
 	if (ret) {
 		ret = -EIO;
 		goto out;
 	}
 	backlight_update_status(bl);
 	dev_info(&client->dev, "%s Rev.%d Backlight\n",
 		client->name, data->revid);
 	if (pdata->num_leds)
 		adp8860_led_probe(client);
 	return 0;
 out:
 	if (data->en_ambl_sens)
 		sysfs_remove_group(&data->bl->dev.kobj,
 			&adp8860_bl_attr_group);
 out1:
 	backlight_device_unregister(bl);
 out2:
 	kfree(data);
 	return ret;
 }
 static int __devexit adp8860_remove(struct i2c_client *client)
 {
 	struct adp8860_bl *data = i2c_get_clientdata(client);
 	adp8860_clr_bits(client, ADP8860_MDCR, NSTBY);
 	if (data->led)
 		adp8860_led_remove(client);
 	if (data->en_ambl_sens)
 		sysfs_remove_group(&data->bl->dev.kobj,
 			&adp8860_bl_attr_group);
 	backlight_device_unregister(data->bl);
 	kfree(data);
 	return 0;
 }
 #ifdef CONFIG_PM
 static int adp8860_i2c_suspend(struct i2c_client *client, pm_message_t message)
 {
 	adp8860_clr_bits(client, ADP8860_MDCR, NSTBY);
 	return 0;
 }
 static int adp8860_i2c_resume(struct i2c_client *client)
 {
 	adp8860_set_bits(client, ADP8860_MDCR, NSTBY);
 	return 0;
 }
 #else
 #define adp8860_i2c_suspend NULL
 #define adp8860_i2c_resume NULL
 #endif
 static const struct i2c_device_id adp8860_id[] = {
 	{ "adp8860", adp8860 },
 	{ "adp8861", adp8861 },
 	{ "adp8863", adp8863 },
 	{ }
 };
 MODULE_DEVICE_TABLE(i2c, adp8860_id);
 static struct i2c_driver adp8860_driver = {
 	.driver = {
 		.name = KBUILD_MODNAME,
 	},
 	.probe    = adp8860_probe,
 	.remove   = __devexit_p(adp8860_remove),
 	.suspend = adp8860_i2c_suspend,
 	.resume  = adp8860_i2c_resume,
 	.id_table = adp8860_id,
 };
 static int __init adp8860_init(void)
 {
 	return i2c_add_driver(&adp8860_driver);
 }
 module_init(adp8860_init);
 static void __exit adp8860_exit(void)
 {
 	i2c_del_driver(&adp8860_driver);
 }
 module_exit(adp8860_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADP8860 Backlight driver");
 MODULE_ALIAS("i2c:adp8860-backlight");

drivers/video/backlight/adp8870_bl.c

Diff comments View file @ dd37739

 /*
  * Backlight driver for Analog Devices ADP8870 Backlight Devices
  *
  * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
 #include <linux/module.h>
-#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 #include <linux/fb.h>
 #include <linux/backlight.h>
 #include <linux/leds.h>
 #include <linux/workqueue.h>
 #include <linux/slab.h>
 #include <linux/i2c/adp8870.h>
 #define ADP8870_EXT_FEATURES
 #define ADP8870_USE_LEDS
 #define ADP8870_MFDVID	0x00  /* Manufacturer and device ID */
 #define ADP8870_MDCR	0x01  /* Device mode and status */
 #define ADP8870_INT_STAT 0x02  /* Interrupts status */
 #define ADP8870_INT_EN	0x03  /* Interrupts enable */
 #define ADP8870_CFGR	0x04  /* Configuration register */
 #define ADP8870_BLSEL	0x05  /* Sink enable backlight or independent */
 #define ADP8870_PWMLED	0x06  /* PWM Enable Selection Register */
 #define ADP8870_BLOFF	0x07  /* Backlight off timeout */
 #define ADP8870_BLDIM	0x08  /* Backlight dim timeout */
 #define ADP8870_BLFR	0x09  /* Backlight fade in and out rates */
 #define ADP8870_BLMX1	0x0A  /* Backlight (Brightness Level 1-daylight) maximum current */
 #define ADP8870_BLDM1	0x0B  /* Backlight (Brightness Level 1-daylight) dim current */
 #define ADP8870_BLMX2	0x0C  /* Backlight (Brightness Level 2-bright) maximum current */
 #define ADP8870_BLDM2	0x0D  /* Backlight (Brightness Level 2-bright) dim current */
 #define ADP8870_BLMX3	0x0E  /* Backlight (Brightness Level 3-office) maximum current */
 #define ADP8870_BLDM3	0x0F  /* Backlight (Brightness Level 3-office) dim current */
 #define ADP8870_BLMX4	0x10  /* Backlight (Brightness Level 4-indoor) maximum current */
 #define ADP8870_BLDM4	0x11  /* Backlight (Brightness Level 4-indoor) dim current */
 #define ADP8870_BLMX5	0x12  /* Backlight (Brightness Level 5-dark) maximum current */
 #define ADP8870_BLDM5	0x13  /* Backlight (Brightness Level 5-dark) dim current */
 #define ADP8870_ISCLAW	0x1A  /* Independent sink current fade law register */
 #define ADP8870_ISCC	0x1B  /* Independent sink current control register */
 #define ADP8870_ISCT1	0x1C  /* Independent Sink Current Timer Register LED[7:5] */
 #define ADP8870_ISCT2	0x1D  /* Independent Sink Current Timer Register LED[4:1] */
 #define ADP8870_ISCF	0x1E  /* Independent sink current fade register */
 #define ADP8870_ISC1	0x1F  /* Independent Sink Current LED1 */
 #define ADP8870_ISC2	0x20  /* Independent Sink Current LED2 */
 #define ADP8870_ISC3	0x21  /* Independent Sink Current LED3 */
 #define ADP8870_ISC4	0x22  /* Independent Sink Current LED4 */
 #define ADP8870_ISC5	0x23  /* Independent Sink Current LED5 */
 #define ADP8870_ISC6	0x24  /* Independent Sink Current LED6 */
 #define ADP8870_ISC7	0x25  /* Independent Sink Current LED7 (Brightness Level 1-daylight) */
 #define ADP8870_ISC7_L2	0x26  /* Independent Sink Current LED7 (Brightness Level 2-bright) */
 #define ADP8870_ISC7_L3	0x27  /* Independent Sink Current LED7 (Brightness Level 3-office) */
 #define ADP8870_ISC7_L4	0x28  /* Independent Sink Current LED7 (Brightness Level 4-indoor) */
 #define ADP8870_ISC7_L5	0x29  /* Independent Sink Current LED7 (Brightness Level 5-dark) */
 #define ADP8870_CMP_CTL	0x2D  /* ALS Comparator Control Register */
 #define ADP8870_ALS1_EN	0x2E  /* Main ALS comparator level enable */
 #define ADP8870_ALS2_EN	0x2F  /* Second ALS comparator level enable */
 #define ADP8870_ALS1_STAT 0x30  /* Main ALS Comparator Status Register */
 #define ADP8870_ALS2_STAT 0x31  /* Second ALS Comparator Status Register */
 #define ADP8870_L2TRP	0x32  /* L2 comparator reference */
 #define ADP8870_L2HYS	0x33  /* L2 hysteresis */
 #define ADP8870_L3TRP	0x34  /* L3 comparator reference */
 #define ADP8870_L3HYS	0x35  /* L3 hysteresis */
 #define ADP8870_L4TRP	0x36  /* L4 comparator reference */
 #define ADP8870_L4HYS	0x37  /* L4 hysteresis */
 #define ADP8870_L5TRP	0x38  /* L5 comparator reference */
 #define ADP8870_L5HYS	0x39  /* L5 hysteresis */
 #define ADP8870_PH1LEVL	0x40  /* First phototransistor ambient light level-low byte register */
 #define ADP8870_PH1LEVH	0x41  /* First phototransistor ambient light level-high byte register */
 #define ADP8870_PH2LEVL	0x42  /* Second phototransistor ambient light level-low byte register */
 #define ADP8870_PH2LEVH	0x43  /* Second phototransistor ambient light level-high byte register */
 #define ADP8870_MANUFID		0x3  /* Analog Devices AD8870 Manufacturer and device ID */
 #define ADP8870_DEVID(x)	((x) & 0xF)
 #define ADP8870_MANID(x)	((x) >> 4)
 /* MDCR Device mode and status */
 #define D7ALSEN			(1 << 7)
 #define INT_CFG			(1 << 6)
 #define NSTBY			(1 << 5)
 #define DIM_EN			(1 << 4)
 #define GDWN_DIS		(1 << 3)
 #define SIS_EN			(1 << 2)
 #define CMP_AUTOEN		(1 << 1)
 #define BLEN			(1 << 0)
 /* ADP8870_ALS1_EN Main ALS comparator level enable */
 #define L5_EN			(1 << 3)
 #define L4_EN			(1 << 2)
 #define L3_EN			(1 << 1)
 #define L2_EN			(1 << 0)
 #define CFGR_BLV_SHIFT		3
 #define CFGR_BLV_MASK		0x7
 #define ADP8870_FLAG_LED_MASK	0xFF
 #define FADE_VAL(in, out)	((0xF & (in)) | ((0xF & (out)) << 4))
 #define BL_CFGR_VAL(law, blv)	((((blv) & CFGR_BLV_MASK) << CFGR_BLV_SHIFT) | ((0x3 & (law)) << 1))
 #define ALS_CMPR_CFG_VAL(filt)	((0x7 & (filt)) << 1)
 struct adp8870_bl {
 	struct i2c_client *client;
 	struct backlight_device *bl;
 	struct adp8870_led *led;
 	struct adp8870_backlight_platform_data *pdata;
 	struct mutex lock;
 	unsigned long cached_daylight_max;
 	int id;
 	int revid;
 	int current_brightness;
 };
 struct adp8870_led {
 	struct led_classdev	cdev;
 	struct work_struct	work;
 	struct i2c_client	*client;
 	enum led_brightness	new_brightness;
 	int			id;
 	int			flags;
 };
 static int adp8870_read(struct i2c_client *client, int reg, uint8_t *val)
 {
 	int ret;
 	ret = i2c_smbus_read_byte_data(client, reg);
 	if (ret < 0) {
 		dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
 		return ret;
 	}
 	*val = ret;
 	return 0;
 }
 static int adp8870_write(struct i2c_client *client, u8 reg, u8 val)
 {
 	int ret = i2c_smbus_write_byte_data(client, reg, val);
 	if (ret)
 		dev_err(&client->dev, "failed to write\n");
 	return ret;
 }
 static int adp8870_set_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
 {
 	struct adp8870_bl *data = i2c_get_clientdata(client);
 	uint8_t reg_val;
 	int ret;
 	mutex_lock(&data->lock);
 	ret = adp8870_read(client, reg, &reg_val);
 	if (!ret && ((reg_val & bit_mask) == 0)) {
 		reg_val |= bit_mask;
 		ret = adp8870_write(client, reg, reg_val);
 	}
 	mutex_unlock(&data->lock);
 	return ret;
 }
 static int adp8870_clr_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
 {
 	struct adp8870_bl *data = i2c_get_clientdata(client);
 	uint8_t reg_val;
 	int ret;
 	mutex_lock(&data->lock);
 	ret = adp8870_read(client, reg, &reg_val);
 	if (!ret && (reg_val & bit_mask)) {
 		reg_val &= ~bit_mask;
 		ret = adp8870_write(client, reg, reg_val);
 	}
 	mutex_unlock(&data->lock);
 	return ret;
 }
 /*
  * Independent sink / LED
  */
 #if defined(ADP8870_USE_LEDS)
 static void adp8870_led_work(struct work_struct *work)
 {
 	struct adp8870_led *led = container_of(work, struct adp8870_led, work);
 	adp8870_write(led->client, ADP8870_ISC1 + led->id - 1,
 			 led->new_brightness >> 1);
 }
 static void adp8870_led_set(struct led_classdev *led_cdev,
 			   enum led_brightness value)
 {
 	struct adp8870_led *led;
 	led = container_of(led_cdev, struct adp8870_led, cdev);
 	led->new_brightness = value;
 	/*
 	 * Use workqueue for IO since I2C operations can sleep.
 	 */
 	schedule_work(&led->work);
 }
 static int adp8870_led_setup(struct adp8870_led *led)
 {
 	struct i2c_client *client = led->client;
 	int ret = 0;
 	ret = adp8870_write(client, ADP8870_ISC1 + led->id - 1, 0);
 	if (ret)
 		return ret;
 	ret = adp8870_set_bits(client, ADP8870_ISCC, 1 << (led->id - 1));
 	if (ret)
 		return ret;
 	if (led->id > 4)
 		ret = adp8870_set_bits(client, ADP8870_ISCT1,
 				(led->flags & 0x3) << ((led->id - 5) * 2));
 	else
 		ret = adp8870_set_bits(client, ADP8870_ISCT2,
 				(led->flags & 0x3) << ((led->id - 1) * 2));
 	return ret;
 }
 static int __devinit adp8870_led_probe(struct i2c_client *client)
 {
 	struct adp8870_backlight_platform_data *pdata =
 		client->dev.platform_data;
 	struct adp8870_bl *data = i2c_get_clientdata(client);
 	struct adp8870_led *led, *led_dat;
 	struct led_info *cur_led;
 	int ret, i;
 	led = kcalloc(pdata->num_leds, sizeof(*led), GFP_KERNEL);
 	if (led == NULL) {
 		dev_err(&client->dev, "failed to alloc memory\n");
 		return -ENOMEM;
 	}
 	ret = adp8870_write(client, ADP8870_ISCLAW, pdata->led_fade_law);
 	if (ret)
 		goto err_free;
 	ret = adp8870_write(client, ADP8870_ISCT1,
 			(pdata->led_on_time & 0x3) << 6);
 	if (ret)
 		goto err_free;
 	ret = adp8870_write(client, ADP8870_ISCF,
 			FADE_VAL(pdata->led_fade_in, pdata->led_fade_out));
 	if (ret)
 		goto err_free;
 	for (i = 0; i < pdata->num_leds; ++i) {
 		cur_led = &pdata->leds[i];
 		led_dat = &led[i];
 		led_dat->id = cur_led->flags & ADP8870_FLAG_LED_MASK;
 		if (led_dat->id > 7 || led_dat->id < 1) {
 			dev_err(&client->dev, "Invalid LED ID %d\n",
 				led_dat->id);
 			goto err;
 		}
 		if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) {
 			dev_err(&client->dev, "LED %d used by Backlight\n",
 				led_dat->id);
 			goto err;
 		}
 		led_dat->cdev.name = cur_led->name;
 		led_dat->cdev.default_trigger = cur_led->default_trigger;
 		led_dat->cdev.brightness_set = adp8870_led_set;
 		led_dat->cdev.brightness = LED_OFF;
 		led_dat->flags = cur_led->flags >> FLAG_OFFT_SHIFT;
 		led_dat->client = client;
 		led_dat->new_brightness = LED_OFF;
 		INIT_WORK(&led_dat->work, adp8870_led_work);
 		ret = led_classdev_register(&client->dev, &led_dat->cdev);
 		if (ret) {
 			dev_err(&client->dev, "failed to register LED %d\n",
 				led_dat->id);
 			goto err;
 		}
 		ret = adp8870_led_setup(led_dat);
 		if (ret) {
 			dev_err(&client->dev, "failed to write\n");
 			i++;
 			goto err;
 		}
 	}
 	data->led = led;
 	return 0;
  err:
 	for (i = i - 1; i >= 0; --i) {
 		led_classdev_unregister(&led[i].cdev);
 		cancel_work_sync(&led[i].work);
 	}
  err_free:
 	kfree(led);
 	return ret;
 }
 static int __devexit adp8870_led_remove(struct i2c_client *client)
 {
 	struct adp8870_backlight_platform_data *pdata =
 		client->dev.platform_data;
 	struct adp8870_bl *data = i2c_get_clientdata(client);
 	int i;
 	for (i = 0; i < pdata->num_leds; i++) {
 		led_classdev_unregister(&data->led[i].cdev);
 		cancel_work_sync(&data->led[i].work);
 	}
 	kfree(data->led);
 	return 0;
 }
 #else
 static int __devinit adp8870_led_probe(struct i2c_client *client)
 {
 	return 0;
 }
 static int __devexit adp8870_led_remove(struct i2c_client *client)
 {
 	return 0;
 }
 #endif
 static int adp8870_bl_set(struct backlight_device *bl, int brightness)
 {
 	struct adp8870_bl *data = bl_get_data(bl);
 	struct i2c_client *client = data->client;
 	int ret = 0;
 	if (data->pdata->en_ambl_sens) {
 		if ((brightness > 0) && (brightness < ADP8870_MAX_BRIGHTNESS)) {
 			/* Disable Ambient Light auto adjust */
 			ret = adp8870_clr_bits(client, ADP8870_MDCR,
 					CMP_AUTOEN);
 			if (ret)
 				return ret;
 			ret = adp8870_write(client, ADP8870_BLMX1, brightness);
 			if (ret)
 				return ret;
 		} else {
 			/*
 			 * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust
 			 * restore daylight l1 sysfs brightness
 			 */
 			ret = adp8870_write(client, ADP8870_BLMX1,
 					 data->cached_daylight_max);
 			if (ret)
 				return ret;
 			ret = adp8870_set_bits(client, ADP8870_MDCR,
 					 CMP_AUTOEN);
 			if (ret)
 				return ret;
 		}
 	} else {
 		ret = adp8870_write(client, ADP8870_BLMX1, brightness);
 		if (ret)
 			return ret;
 	}
 	if (data->current_brightness && brightness == 0)
 		ret = adp8870_set_bits(client,
 				ADP8870_MDCR, DIM_EN);
 	else if (data->current_brightness == 0 && brightness)
 		ret = adp8870_clr_bits(client,
 				ADP8870_MDCR, DIM_EN);
 	if (!ret)
 		data->current_brightness = brightness;
 	return ret;
 }
 static int adp8870_bl_update_status(struct backlight_device *bl)
 {
 	int brightness = bl->props.brightness;
 	if (bl->props.power != FB_BLANK_UNBLANK)
 		brightness = 0;
 	if (bl->props.fb_blank != FB_BLANK_UNBLANK)
 		brightness = 0;
 	return adp8870_bl_set(bl, brightness);
 }
 static int adp8870_bl_get_brightness(struct backlight_device *bl)
 {
 	struct adp8870_bl *data = bl_get_data(bl);
 	return data->current_brightness;
 }
 static const struct backlight_ops adp8870_bl_ops = {
 	.update_status	= adp8870_bl_update_status,
 	.get_brightness	= adp8870_bl_get_brightness,
 };
 static int adp8870_bl_setup(struct backlight_device *bl)
 {
 	struct adp8870_bl *data = bl_get_data(bl);
 	struct i2c_client *client = data->client;
 	struct adp8870_backlight_platform_data *pdata = data->pdata;
 	int ret = 0;
 	ret = adp8870_write(client, ADP8870_BLSEL, ~pdata->bl_led_assign);
 	if (ret)
 		return ret;
 	ret = adp8870_write(client, ADP8870_PWMLED, pdata->pwm_assign);
 	if (ret)
 		return ret;
 	ret = adp8870_write(client, ADP8870_BLMX1, pdata->l1_daylight_max);
 	if (ret)
 		return ret;
 	ret = adp8870_write(client, ADP8870_BLDM1, pdata->l1_daylight_dim);
 	if (ret)
 		return ret;
 	if (pdata->en_ambl_sens) {
 		data->cached_daylight_max = pdata->l1_daylight_max;
 		ret = adp8870_write(client, ADP8870_BLMX2,
 						pdata->l2_bright_max);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLDM2,
 						pdata->l2_bright_dim);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLMX3,
 						pdata->l3_office_max);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLDM3,
 						pdata->l3_office_dim);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLMX4,
 						pdata->l4_indoor_max);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLDM4,
 						pdata->l4_indor_dim);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLMX5,
 						pdata->l5_dark_max);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_BLDM5,
 						pdata->l5_dark_dim);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L2TRP, pdata->l2_trip);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L2HYS, pdata->l2_hyst);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L3TRP, pdata->l3_trip);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L3HYS, pdata->l3_hyst);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L4TRP, pdata->l4_trip);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L4HYS, pdata->l4_hyst);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L5TRP, pdata->l5_trip);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_L5HYS, pdata->l5_hyst);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_ALS1_EN, L5_EN | L4_EN |
 						L3_EN | L2_EN);
 		if (ret)
 			return ret;
 		ret = adp8870_write(client, ADP8870_CMP_CTL,
 			ALS_CMPR_CFG_VAL(pdata->abml_filt));
 		if (ret)
 			return ret;
 	}
 	ret = adp8870_write(client, ADP8870_CFGR,
 			BL_CFGR_VAL(pdata->bl_fade_law, 0));
 	if (ret)
 		return ret;
 	ret = adp8870_write(client, ADP8870_BLFR, FADE_VAL(pdata->bl_fade_in,
 			pdata->bl_fade_out));
 	if (ret)
 		return ret;
 	/*
 	 * ADP8870 Rev0 requires GDWN_DIS bit set
 	 */
 	ret = adp8870_set_bits(client, ADP8870_MDCR, BLEN | DIM_EN | NSTBY |
 			(data->revid == 0 ? GDWN_DIS : 0));
 	return ret;
 }
 static ssize_t adp8870_show(struct device *dev, char *buf, int reg)
 {
 	struct adp8870_bl *data = dev_get_drvdata(dev);
 	int error;
 	uint8_t reg_val;
 	mutex_lock(&data->lock);
 	error = adp8870_read(data->client, reg, &reg_val);
 	mutex_unlock(&data->lock);
 	if (error < 0)
 		return error;
 	return sprintf(buf, "%u\n", reg_val);
 }
 static ssize_t adp8870_store(struct device *dev, const char *buf,
 			 size_t count, int reg)
 {
 	struct adp8870_bl *data = dev_get_drvdata(dev);
 	unsigned long val;
 	int ret;
 	ret = strict_strtoul(buf, 10, &val);
 	if (ret)
 		return ret;
 	mutex_lock(&data->lock);
 	adp8870_write(data->client, reg, val);
 	mutex_unlock(&data->lock);
 	return count;
 }
 static ssize_t adp8870_bl_l5_dark_max_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLMX5);
 }
 static ssize_t adp8870_bl_l5_dark_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLMX5);
 }
 static DEVICE_ATTR(l5_dark_max, 0664, adp8870_bl_l5_dark_max_show,
 			adp8870_bl_l5_dark_max_store);
 static ssize_t adp8870_bl_l4_indoor_max_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLMX4);
 }
 static ssize_t adp8870_bl_l4_indoor_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLMX4);
 }
 static DEVICE_ATTR(l4_indoor_max, 0664, adp8870_bl_l4_indoor_max_show,
 			adp8870_bl_l4_indoor_max_store);
 static ssize_t adp8870_bl_l3_office_max_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLMX3);
 }
 static ssize_t adp8870_bl_l3_office_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLMX3);
 }
 static DEVICE_ATTR(l3_office_max, 0664, adp8870_bl_l3_office_max_show,
 			adp8870_bl_l3_office_max_store);
 static ssize_t adp8870_bl_l2_bright_max_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLMX2);
 }
 static ssize_t adp8870_bl_l2_bright_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLMX2);
 }
 static DEVICE_ATTR(l2_bright_max, 0664, adp8870_bl_l2_bright_max_show,
 			adp8870_bl_l2_bright_max_store);
 static ssize_t adp8870_bl_l1_daylight_max_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLMX1);
 }
 static ssize_t adp8870_bl_l1_daylight_max_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	struct adp8870_bl *data = dev_get_drvdata(dev);
 	int ret = strict_strtoul(buf, 10, &data->cached_daylight_max);
 	if (ret)
 		return ret;
 	return adp8870_store(dev, buf, count, ADP8870_BLMX1);
 }
 static DEVICE_ATTR(l1_daylight_max, 0664, adp8870_bl_l1_daylight_max_show,
 			adp8870_bl_l1_daylight_max_store);
 static ssize_t adp8870_bl_l5_dark_dim_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLDM5);
 }
 static ssize_t adp8870_bl_l5_dark_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLDM5);
 }
 static DEVICE_ATTR(l5_dark_dim, 0664, adp8870_bl_l5_dark_dim_show,
 			adp8870_bl_l5_dark_dim_store);
 static ssize_t adp8870_bl_l4_indoor_dim_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLDM4);
 }
 static ssize_t adp8870_bl_l4_indoor_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLDM4);
 }
 static DEVICE_ATTR(l4_indoor_dim, 0664, adp8870_bl_l4_indoor_dim_show,
 			adp8870_bl_l4_indoor_dim_store);
 static ssize_t adp8870_bl_l3_office_dim_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLDM3);
 }
 static ssize_t adp8870_bl_l3_office_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLDM3);
 }
 static DEVICE_ATTR(l3_office_dim, 0664, adp8870_bl_l3_office_dim_show,
 			adp8870_bl_l3_office_dim_store);
 static ssize_t adp8870_bl_l2_bright_dim_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLDM2);
 }
 static ssize_t adp8870_bl_l2_bright_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLDM2);
 }
 static DEVICE_ATTR(l2_bright_dim, 0664, adp8870_bl_l2_bright_dim_show,
 			adp8870_bl_l2_bright_dim_store);
 static ssize_t adp8870_bl_l1_daylight_dim_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	return adp8870_show(dev, buf, ADP8870_BLDM1);
 }
 static ssize_t adp8870_bl_l1_daylight_dim_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	return adp8870_store(dev, buf, count, ADP8870_BLDM1);
 }
 static DEVICE_ATTR(l1_daylight_dim, 0664, adp8870_bl_l1_daylight_dim_show,
 			adp8870_bl_l1_daylight_dim_store);
 #ifdef ADP8870_EXT_FEATURES
 static ssize_t adp8870_bl_ambient_light_level_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	struct adp8870_bl *data = dev_get_drvdata(dev);
 	int error;
 	uint8_t reg_val;
 	uint16_t ret_val;
 	mutex_lock(&data->lock);
 	error = adp8870_read(data->client, ADP8870_PH1LEVL, &reg_val);
 	if (error < 0) {
 		mutex_unlock(&data->lock);
 		return error;
 	}
 	ret_val = reg_val;
 	error = adp8870_read(data->client, ADP8870_PH1LEVH, &reg_val);
 	mutex_unlock(&data->lock);
 	if (error < 0)
 		return error;
 	/* Return 13-bit conversion value for the first light sensor */
 	ret_val += (reg_val & 0x1F) << 8;
 	return sprintf(buf, "%u\n", ret_val);
 }
 static DEVICE_ATTR(ambient_light_level, 0444,
 		adp8870_bl_ambient_light_level_show, NULL);
 static ssize_t adp8870_bl_ambient_light_zone_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	struct adp8870_bl *data = dev_get_drvdata(dev);
 	int error;
 	uint8_t reg_val;
 	mutex_lock(&data->lock);
 	error = adp8870_read(data->client, ADP8870_CFGR, &reg_val);
 	mutex_unlock(&data->lock);
 	if (error < 0)
 		return error;
 	return sprintf(buf, "%u\n",
 		((reg_val >> CFGR_BLV_SHIFT) & CFGR_BLV_MASK) + 1);
 }
 static ssize_t adp8870_bl_ambient_light_zone_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	struct adp8870_bl *data = dev_get_drvdata(dev);
 	unsigned long val;
 	uint8_t reg_val;
 	int ret;
 	ret = strict_strtoul(buf, 10, &val);
 	if (ret)
 		return ret;
 	if (val == 0) {
 		/* Enable automatic ambient light sensing */
 		adp8870_set_bits(data->client, ADP8870_MDCR, CMP_AUTOEN);
 	} else if ((val > 0) && (val < 6)) {
 		/* Disable automatic ambient light sensing */
 		adp8870_clr_bits(data->client, ADP8870_MDCR, CMP_AUTOEN);
 		/* Set user supplied ambient light zone */
 		mutex_lock(&data->lock);
 		adp8870_read(data->client, ADP8870_CFGR, &reg_val);
 		reg_val &= ~(CFGR_BLV_MASK << CFGR_BLV_SHIFT);
 		reg_val |= (val - 1) << CFGR_BLV_SHIFT;
 		adp8870_write(data->client, ADP8870_CFGR, reg_val);
 		mutex_unlock(&data->lock);
 	}
 	return count;
 }
 static DEVICE_ATTR(ambient_light_zone, 0664,
 		adp8870_bl_ambient_light_zone_show,
 		adp8870_bl_ambient_light_zone_store);
 #endif
 static struct attribute *adp8870_bl_attributes[] = {
 	&dev_attr_l5_dark_max.attr,
 	&dev_attr_l5_dark_dim.attr,
 	&dev_attr_l4_indoor_max.attr,
 	&dev_attr_l4_indoor_dim.attr,
 	&dev_attr_l3_office_max.attr,
 	&dev_attr_l3_office_dim.attr,
 	&dev_attr_l2_bright_max.attr,
 	&dev_attr_l2_bright_dim.attr,
 	&dev_attr_l1_daylight_max.attr,
 	&dev_attr_l1_daylight_dim.attr,
 #ifdef ADP8870_EXT_FEATURES
 	&dev_attr_ambient_light_level.attr,
 	&dev_attr_ambient_light_zone.attr,
 #endif
 	NULL
 };
 static const struct attribute_group adp8870_bl_attr_group = {
 	.attrs = adp8870_bl_attributes,
 };
 static int __devinit adp8870_probe(struct i2c_client *client,
 					const struct i2c_device_id *id)
 {
 	struct backlight_properties props;
 	struct backlight_device *bl;
 	struct adp8870_bl *data;
 	struct adp8870_backlight_platform_data *pdata =
 		client->dev.platform_data;
 	uint8_t reg_val;
 	int ret;
 	if (!i2c_check_functionality(client->adapter,
 					I2C_FUNC_SMBUS_BYTE_DATA)) {
 		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
 		return -EIO;
 	}
 	if (!pdata) {
 		dev_err(&client->dev, "no platform data?\n");
 		return -EINVAL;
 	}
 	ret = adp8870_read(client, ADP8870_MFDVID, &reg_val);
 	if (ret < 0)
 		return -EIO;
 	if (ADP8870_MANID(reg_val) != ADP8870_MANUFID) {
 		dev_err(&client->dev, "failed to probe\n");
 		return -ENODEV;
 	}
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
 	if (data == NULL)
 		return -ENOMEM;
 	data->revid = ADP8870_DEVID(reg_val);
 	data->client = client;
 	data->pdata = pdata;
 	data->id = id->driver_data;
 	data->current_brightness = 0;
 	i2c_set_clientdata(client, data);
 	mutex_init(&data->lock);
 	memset(&props, 0, sizeof(props));
 	props.type = BACKLIGHT_RAW;
 	props.max_brightness = props.brightness = ADP8870_MAX_BRIGHTNESS;
 	bl = backlight_device_register(dev_driver_string(&client->dev),
 			&client->dev, data, &adp8870_bl_ops, &props);
 	if (IS_ERR(bl)) {
 		dev_err(&client->dev, "failed to register backlight\n");
 		ret = PTR_ERR(bl);
 		goto out2;
 	}
 	data->bl = bl;
 	if (pdata->en_ambl_sens)
 		ret = sysfs_create_group(&bl->dev.kobj,
 			&adp8870_bl_attr_group);
 	if (ret) {
 		dev_err(&client->dev, "failed to register sysfs\n");
 		goto out1;
 	}
 	ret = adp8870_bl_setup(bl);
 	if (ret) {
 		ret = -EIO;
 		goto out;
 	}
 	backlight_update_status(bl);
 	dev_info(&client->dev, "Rev.%d Backlight\n", data->revid);
 	if (pdata->num_leds)
 		adp8870_led_probe(client);
 	return 0;
 out:
 	if (data->pdata->en_ambl_sens)
 		sysfs_remove_group(&data->bl->dev.kobj,
 			&adp8870_bl_attr_group);
 out1:
 	backlight_device_unregister(bl);
 out2:
 	i2c_set_clientdata(client, NULL);
 	kfree(data);
 	return ret;
 }
 static int __devexit adp8870_remove(struct i2c_client *client)
 {
 	struct adp8870_bl *data = i2c_get_clientdata(client);
 	adp8870_clr_bits(client, ADP8870_MDCR, NSTBY);
 	if (data->led)
 		adp8870_led_remove(client);
 	if (data->pdata->en_ambl_sens)
 		sysfs_remove_group(&data->bl->dev.kobj,
 			&adp8870_bl_attr_group);
 	backlight_device_unregister(data->bl);
 	i2c_set_clientdata(client, NULL);
 	kfree(data);
 	return 0;
 }
 #ifdef CONFIG_PM
 static int adp8870_i2c_suspend(struct i2c_client *client, pm_message_t message)
 {
 	adp8870_clr_bits(client, ADP8870_MDCR, NSTBY);
 	return 0;
 }
 static int adp8870_i2c_resume(struct i2c_client *client)
 {
 	adp8870_set_bits(client, ADP8870_MDCR, NSTBY);
 	return 0;
 }
 #else
 #define adp8870_i2c_suspend NULL
 #define adp8870_i2c_resume NULL
 #endif
 static const struct i2c_device_id adp8870_id[] = {
 	{ "adp8870", 0 },
 	{ }
 };
 MODULE_DEVICE_TABLE(i2c, adp8870_id);
 static struct i2c_driver adp8870_driver = {
 	.driver = {
 		.name = KBUILD_MODNAME,
 	},
 	.probe    = adp8870_probe,
 	.remove   = __devexit_p(adp8870_remove),
 	.suspend = adp8870_i2c_suspend,
 	.resume  = adp8870_i2c_resume,
 	.id_table = adp8870_id,
 };
 static int __init adp8870_init(void)
 {
 	return i2c_add_driver(&adp8870_driver);
 }
 module_init(adp8870_init);
 static void __exit adp8870_exit(void)
 {
 	i2c_del_driver(&adp8870_driver);
 }
 module_exit(adp8870_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADP8870 Backlight driver");
 MODULE_ALIAS("platform:adp8870-backlight");

drivers/video/pxa3xx-gcu.c

Diff comments View file @ dd37739

 /*
  *  pxa3xx-gcu.c - Linux kernel module for PXA3xx graphics controllers
  *
  *  This driver needs a DirectFB counterpart in user space, communication
  *  is handled via mmap()ed memory areas and an ioctl.
  *
  *  Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
  *  Copyright (c) 2009 Janine Kropp <nin@directfb.org>
  *  Copyright (c) 2009 Denis Oliver Kropp <dok@directfb.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 /*
  * WARNING: This controller is attached to System Bus 2 of the PXA which
  * needs its arbiter to be enabled explicitly (CKENB & 1<<9).
  * There is currently no way to do this from Linux, so you need to teach
  * your bootloader for now.
  */
 #include <linux/module.h>
-#include <linux/version.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/miscdevice.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/uaccess.h>
 #include <linux/ioctl.h>
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/fs.h>
 #include <linux/io.h>
 #include "pxa3xx-gcu.h"
 #define DRV_NAME	"pxa3xx-gcu"
 #define MISCDEV_MINOR	197
 #define REG_GCCR	0x00
 #define GCCR_SYNC_CLR	(1 << 9)
 #define GCCR_BP_RST	(1 << 8)
 #define GCCR_ABORT	(1 << 6)
 #define GCCR_STOP	(1 << 4)
 #define REG_GCISCR	0x04
 #define REG_GCIECR	0x08
 #define REG_GCRBBR	0x20
 #define REG_GCRBLR	0x24
 #define REG_GCRBHR	0x28
 #define REG_GCRBTR	0x2C
 #define REG_GCRBEXHR	0x30
 #define IE_EOB		(1 << 0)
 #define IE_EEOB		(1 << 5)
 #define IE_ALL		0xff
 #define SHARED_SIZE	PAGE_ALIGN(sizeof(struct pxa3xx_gcu_shared))
 /* #define PXA3XX_GCU_DEBUG */
 /* #define PXA3XX_GCU_DEBUG_TIMER */
 #ifdef PXA3XX_GCU_DEBUG
 #define QDUMP(msg)					\
 	do {						\
 		QPRINT(priv, KERN_DEBUG, msg);		\
 	} while (0)
 #else
 #define QDUMP(msg)	do {} while (0)
 #endif
 #define QERROR(msg)					\
 	do {						\
 		QPRINT(priv, KERN_ERR, msg);		\
 	} while (0)
 struct pxa3xx_gcu_batch {
 	struct pxa3xx_gcu_batch *next;
 	u32			*ptr;
 	dma_addr_t		 phys;
 	unsigned long		 length;
 };
 struct pxa3xx_gcu_priv {
 	void __iomem		 *mmio_base;
 	struct clk		 *clk;
 	struct pxa3xx_gcu_shared *shared;
 	dma_addr_t		  shared_phys;
 	struct resource		 *resource_mem;
 	struct miscdevice	  misc_dev;
 	struct file_operations	  misc_fops;
 	wait_queue_head_t	  wait_idle;
 	wait_queue_head_t	  wait_free;
 	spinlock_t		  spinlock;
 	struct timeval 		  base_time;
 	struct pxa3xx_gcu_batch *free;
 	struct pxa3xx_gcu_batch *ready;
 	struct pxa3xx_gcu_batch *ready_last;
 	struct pxa3xx_gcu_batch *running;
 };
 static inline unsigned long
 gc_readl(struct pxa3xx_gcu_priv *priv, unsigned int off)
 {
 	return __raw_readl(priv->mmio_base + off);
 }
 static inline void
 gc_writel(struct pxa3xx_gcu_priv *priv, unsigned int off, unsigned long val)
 {
 	__raw_writel(val, priv->mmio_base + off);
 }
 #define QPRINT(priv, level, msg)					\
 	do {								\
 		struct timeval tv;					\
 		struct pxa3xx_gcu_shared *shared = priv->shared;	\
 		u32 base = gc_readl(priv, REG_GCRBBR);			\
 									\
 		do_gettimeofday(&tv);					\
 									\
 		printk(level "%ld.%03ld.%03ld - %-17s: %-21s (%s, "	\
 			"STATUS "					\
 			"0x%02lx, B 0x%08lx [%ld], E %5ld, H %5ld, "	\
 			"T %5ld)\n",					\
 			tv.tv_sec - priv->base_time.tv_sec,		\
 			tv.tv_usec / 1000, tv.tv_usec % 1000,		\
 			__func__, msg,					\
 			shared->hw_running ? "running" : "   idle",	\
 			gc_readl(priv, REG_GCISCR),			\
 			gc_readl(priv, REG_GCRBBR),			\
 			gc_readl(priv, REG_GCRBLR),			\
 			(gc_readl(priv, REG_GCRBEXHR) - base) / 4,	\
 			(gc_readl(priv, REG_GCRBHR) - base) / 4,	\
 			(gc_readl(priv, REG_GCRBTR) - base) / 4);	\
 	} while (0)
 static void
 pxa3xx_gcu_reset(struct pxa3xx_gcu_priv *priv)
 {
 	QDUMP("RESET");
 	/* disable interrupts */
 	gc_writel(priv, REG_GCIECR, 0);
 	/* reset hardware */
 	gc_writel(priv, REG_GCCR, GCCR_ABORT);
 	gc_writel(priv, REG_GCCR, 0);
 	memset(priv->shared, 0, SHARED_SIZE);
 	priv->shared->buffer_phys = priv->shared_phys;
 	priv->shared->magic = PXA3XX_GCU_SHARED_MAGIC;
 	do_gettimeofday(&priv->base_time);
 	/* set up the ring buffer pointers */
 	gc_writel(priv, REG_GCRBLR, 0);
 	gc_writel(priv, REG_GCRBBR, priv->shared_phys);
 	gc_writel(priv, REG_GCRBTR, priv->shared_phys);
 	/* enable all IRQs except EOB */
 	gc_writel(priv, REG_GCIECR, IE_ALL & ~IE_EOB);
 }
 static void
 dump_whole_state(struct pxa3xx_gcu_priv *priv)
 {
 	struct pxa3xx_gcu_shared *sh = priv->shared;
 	u32 base = gc_readl(priv, REG_GCRBBR);
 	QDUMP("DUMP");
 	printk(KERN_DEBUG "== PXA3XX-GCU DUMP ==\n"
 		"%s, STATUS 0x%02lx, B 0x%08lx [%ld], E %5ld, H %5ld, T %5ld\n",
 		sh->hw_running ? "running" : "idle   ",
 		gc_readl(priv, REG_GCISCR),
 		gc_readl(priv, REG_GCRBBR),
 		gc_readl(priv, REG_GCRBLR),
 		(gc_readl(priv, REG_GCRBEXHR) - base) / 4,
 		(gc_readl(priv, REG_GCRBHR) - base) / 4,
 		(gc_readl(priv, REG_GCRBTR) - base) / 4);
 }
 static void
 flush_running(struct pxa3xx_gcu_priv *priv)
 {
 	struct pxa3xx_gcu_batch *running = priv->running;
 	struct pxa3xx_gcu_batch *next;
 	while (running) {
 		next = running->next;
 		running->next = priv->free;
 		priv->free = running;
 		running = next;
 	}
 	priv->running = NULL;
 }
 static void
 run_ready(struct pxa3xx_gcu_priv *priv)
 {
 	unsigned int num = 0;
 	struct pxa3xx_gcu_shared *shared = priv->shared;
 	struct pxa3xx_gcu_batch	*ready = priv->ready;
 	QDUMP("Start");
 	BUG_ON(!ready);
 	shared->buffer[num++] = 0x05000000;
 	while (ready) {
 		shared->buffer[num++] = 0x00000001;
 		shared->buffer[num++] = ready->phys;
 		ready = ready->next;
 	}
 	shared->buffer[num++] = 0x05000000;
 	priv->running = priv->ready;
 	priv->ready = priv->ready_last = NULL;
 	gc_writel(priv, REG_GCRBLR, 0);
 	shared->hw_running = 1;
 	/* ring base address */
 	gc_writel(priv, REG_GCRBBR, shared->buffer_phys);
 	/* ring tail address */
 	gc_writel(priv, REG_GCRBTR, shared->buffer_phys + num * 4);
 	/* ring length */
 	gc_writel(priv, REG_GCRBLR, ((num + 63) & ~63) * 4);
 }
 static irqreturn_t
 pxa3xx_gcu_handle_irq(int irq, void *ctx)
 {
 	struct pxa3xx_gcu_priv *priv = ctx;
 	struct pxa3xx_gcu_shared *shared = priv->shared;
 	u32 status = gc_readl(priv, REG_GCISCR) & IE_ALL;
 	QDUMP("-Interrupt");
 	if (!status)
 		return IRQ_NONE;
 	spin_lock(&priv->spinlock);
 	shared->num_interrupts++;
 	if (status & IE_EEOB) {
 		QDUMP(" [EEOB]");
 		flush_running(priv);
 		wake_up_all(&priv->wait_free);
 		if (priv->ready) {
 			run_ready(priv);
 		} else {
 			/* There is no more data prepared by the userspace.
 			 * Set hw_running = 0 and wait for the next userspace
 			 * kick-off */
 			shared->num_idle++;
 			shared->hw_running = 0;
 			QDUMP(" '-> Idle.");
 			/* set ring buffer length to zero */
 			gc_writel(priv, REG_GCRBLR, 0);
 			wake_up_all(&priv->wait_idle);
 		}
 		shared->num_done++;
 	} else {
 		QERROR(" [???]");
 		dump_whole_state(priv);
 	}
 	/* Clear the interrupt */
 	gc_writel(priv, REG_GCISCR, status);
 	spin_unlock(&priv->spinlock);
 	return IRQ_HANDLED;
 }
 static int
 pxa3xx_gcu_wait_idle(struct pxa3xx_gcu_priv *priv)
 {
 	int ret = 0;
 	QDUMP("Waiting for idle...");
 	/* Does not need to be atomic. There's a lock in user space,
 	 * but anyhow, this is just for statistics. */
 	priv->shared->num_wait_idle++;
 	while (priv->shared->hw_running) {
 		int num = priv->shared->num_interrupts;
 		u32 rbexhr = gc_readl(priv, REG_GCRBEXHR);
 		ret = wait_event_interruptible_timeout(priv->wait_idle,
 					!priv->shared->hw_running, HZ*4);
 		if (ret < 0)
 			break;
 		if (ret > 0)
 			continue;
 		if (gc_readl(priv, REG_GCRBEXHR) == rbexhr &&
 		    priv->shared->num_interrupts == num) {
 			QERROR("TIMEOUT");
 			ret = -ETIMEDOUT;
 			break;
 		}
 	}
 	QDUMP("done");
 	return ret;
 }
 static int
 pxa3xx_gcu_wait_free(struct pxa3xx_gcu_priv *priv)
 {
 	int ret = 0;
 	QDUMP("Waiting for free...");
 	/* Does not need to be atomic. There's a lock in user space,
 	 * but anyhow, this is just for statistics. */
 	priv->shared->num_wait_free++;
 	while (!priv->free) {
 		u32 rbexhr = gc_readl(priv, REG_GCRBEXHR);
 		ret = wait_event_interruptible_timeout(priv->wait_free,
 						       priv->free, HZ*4);
 		if (ret < 0)
 			break;
 		if (ret > 0)
 			continue;
 		if (gc_readl(priv, REG_GCRBEXHR) == rbexhr) {
 			QERROR("TIMEOUT");
 			ret = -ETIMEDOUT;
 			break;
 		}
 	}
 	QDUMP("done");
 	return ret;
 }
 /* Misc device layer */
 static ssize_t
 pxa3xx_gcu_misc_write(struct file *filp, const char *buff,
 		      size_t count, loff_t *offp)
 {
 	int ret;
 	unsigned long flags;
 	struct pxa3xx_gcu_batch	*buffer;
 	struct pxa3xx_gcu_priv *priv =
 		container_of(filp->f_op, struct pxa3xx_gcu_priv, misc_fops);
 	int words = count / 4;
 	/* Does not need to be atomic. There's a lock in user space,
 	 * but anyhow, this is just for statistics. */
 	priv->shared->num_writes++;
 	priv->shared->num_words += words;
 	/* Last word reserved for batch buffer end command */
 	if (words >= PXA3XX_GCU_BATCH_WORDS)
 		return -E2BIG;
 	/* Wait for a free buffer */
 	if (!priv->free) {
 		ret = pxa3xx_gcu_wait_free(priv);
 		if (ret < 0)
 			return ret;
 	}
 	/*
 	 * Get buffer from free list
 	 */
 	spin_lock_irqsave(&priv->spinlock, flags);
 	buffer = priv->free;
 	priv->free = buffer->next;
 	spin_unlock_irqrestore(&priv->spinlock, flags);
 	/* Copy data from user into buffer */
 	ret = copy_from_user(buffer->ptr, buff, words * 4);
 	if (ret) {
 		spin_lock_irqsave(&priv->spinlock, flags);
 		buffer->next = priv->free;
 		priv->free = buffer;
 		spin_unlock_irqrestore(&priv->spinlock, flags);
 		return -EFAULT;
 	}
 	buffer->length = words;
 	/* Append batch buffer end command */
 	buffer->ptr[words] = 0x01000000;
 	/*
 	 * Add buffer to ready list
 	 */
 	spin_lock_irqsave(&priv->spinlock, flags);
 	buffer->next = NULL;
 	if (priv->ready) {
 		BUG_ON(priv->ready_last == NULL);
 		priv->ready_last->next = buffer;
 	} else
 		priv->ready = buffer;
 	priv->ready_last = buffer;
 	if (!priv->shared->hw_running)
 		run_ready(priv);
 	spin_unlock_irqrestore(&priv->spinlock, flags);
 	return words * 4;
 }
 static long
 pxa3xx_gcu_misc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
 	unsigned long flags;
 	struct pxa3xx_gcu_priv *priv =
 		container_of(filp->f_op, struct pxa3xx_gcu_priv, misc_fops);
 	switch (cmd) {
 	case PXA3XX_GCU_IOCTL_RESET:
 		spin_lock_irqsave(&priv->spinlock, flags);
 		pxa3xx_gcu_reset(priv);
 		spin_unlock_irqrestore(&priv->spinlock, flags);
 		return 0;
 	case PXA3XX_GCU_IOCTL_WAIT_IDLE:
 		return pxa3xx_gcu_wait_idle(priv);
 	}
 	return -ENOSYS;
 }
 static int
 pxa3xx_gcu_misc_mmap(struct file *filp, struct vm_area_struct *vma)
 {
 	unsigned int size = vma->vm_end - vma->vm_start;
 	struct pxa3xx_gcu_priv *priv =
 		container_of(filp->f_op, struct pxa3xx_gcu_priv, misc_fops);
 	switch (vma->vm_pgoff) {
 	case 0:
 		/* hand out the shared data area */
 		if (size != SHARED_SIZE)
 			return -EINVAL;
 		return dma_mmap_coherent(NULL, vma,
 			priv->shared, priv->shared_phys, size);
 	case SHARED_SIZE >> PAGE_SHIFT:
 		/* hand out the MMIO base for direct register access
 		 * from userspace */
 		if (size != resource_size(priv->resource_mem))
 			return -EINVAL;
 		vma->vm_flags |= VM_IO;
 		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 		return io_remap_pfn_range(vma, vma->vm_start,
 				priv->resource_mem->start >> PAGE_SHIFT,
 				size, vma->vm_page_prot);
 	}
 	return -EINVAL;
 }
 #ifdef PXA3XX_GCU_DEBUG_TIMER
 static struct timer_list pxa3xx_gcu_debug_timer;
 static void pxa3xx_gcu_debug_timedout(unsigned long ptr)
 {
 	struct pxa3xx_gcu_priv *priv = (struct pxa3xx_gcu_priv *) ptr;
 	QERROR("Timer DUMP");
 	/* init the timer structure */
 	init_timer(&pxa3xx_gcu_debug_timer);
 	pxa3xx_gcu_debug_timer.function = pxa3xx_gcu_debug_timedout;
 	pxa3xx_gcu_debug_timer.data = ptr;
 	pxa3xx_gcu_debug_timer.expires = jiffies + 5*HZ; /* one second */
 	add_timer(&pxa3xx_gcu_debug_timer);
 }
 static void pxa3xx_gcu_init_debug_timer(void)
 {
 	pxa3xx_gcu_debug_timedout((unsigned long) &pxa3xx_gcu_debug_timer);
 }
 #else
 static inline void pxa3xx_gcu_init_debug_timer(void) {}
 #endif
 static int
 add_buffer(struct platform_device *dev,
 	   struct pxa3xx_gcu_priv *priv)
 {
 	struct pxa3xx_gcu_batch *buffer;
 	buffer = kzalloc(sizeof(struct pxa3xx_gcu_batch), GFP_KERNEL);
 	if (!buffer)
 		return -ENOMEM;
 	buffer->ptr = dma_alloc_coherent(&dev->dev, PXA3XX_GCU_BATCH_WORDS * 4,
 					 &buffer->phys, GFP_KERNEL);
 	if (!buffer->ptr) {
 		kfree(buffer);
 		return -ENOMEM;
 	}
 	buffer->next = priv->free;
 	priv->free = buffer;
 	return 0;
 }
 static void
 free_buffers(struct platform_device *dev,
 	     struct pxa3xx_gcu_priv *priv)
 {
 	struct pxa3xx_gcu_batch *next, *buffer = priv->free;
 	while (buffer) {
 		next = buffer->next;
 		dma_free_coherent(&dev->dev, PXA3XX_GCU_BATCH_WORDS * 4,
 				  buffer->ptr, buffer->phys);
 		kfree(buffer);
 		buffer = next;
 	}
 	priv->free = NULL;
 }
 static int __devinit
 pxa3xx_gcu_probe(struct platform_device *dev)
 {
 	int i, ret, irq;
 	struct resource *r;
 	struct pxa3xx_gcu_priv *priv;
 	priv = kzalloc(sizeof(struct pxa3xx_gcu_priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 	for (i = 0; i < 8; i++) {
 		ret = add_buffer(dev, priv);
 		if (ret) {
 			dev_err(&dev->dev, "failed to allocate DMA memory\n");
 			goto err_free_priv;
 		}
 	}
 	init_waitqueue_head(&priv->wait_idle);
 	init_waitqueue_head(&priv->wait_free);
 	spin_lock_init(&priv->spinlock);
 	/* we allocate the misc device structure as part of our own allocation,
 	 * so we can get a pointer to our priv structure later on with
 	 * container_of(). This isn't really necessary as we have a fixed minor
 	 * number anyway, but this is to avoid statics. */
 	priv->misc_fops.owner	= THIS_MODULE;
 	priv->misc_fops.write	= pxa3xx_gcu_misc_write;
 	priv->misc_fops.unlocked_ioctl = pxa3xx_gcu_misc_ioctl;
 	priv->misc_fops.mmap	= pxa3xx_gcu_misc_mmap;
 	priv->misc_dev.minor	= MISCDEV_MINOR,
 	priv->misc_dev.name	= DRV_NAME,
 	priv->misc_dev.fops	= &priv->misc_fops,
 	/* register misc device */
 	ret = misc_register(&priv->misc_dev);
 	if (ret < 0) {
 		dev_err(&dev->dev, "misc_register() for minor %d failed\n",
 			MISCDEV_MINOR);
 		goto err_free_priv;
 	}
 	/* handle IO resources */
 	r = platform_get_resource(dev, IORESOURCE_MEM, 0);
 	if (r == NULL) {
 		dev_err(&dev->dev, "no I/O memory resource defined\n");
 		ret = -ENODEV;
 		goto err_misc_deregister;
 	}
 	if (!request_mem_region(r->start, resource_size(r), dev->name)) {
 		dev_err(&dev->dev, "failed to request I/O memory\n");
 		ret = -EBUSY;
 		goto err_misc_deregister;
 	}
 	priv->mmio_base = ioremap_nocache(r->start, resource_size(r));
 	if (!priv->mmio_base) {
 		dev_err(&dev->dev, "failed to map I/O memory\n");
 		ret = -EBUSY;
 		goto err_free_mem_region;
 	}
 	/* allocate dma memory */
 	priv->shared = dma_alloc_coherent(&dev->dev, SHARED_SIZE,
 					  &priv->shared_phys, GFP_KERNEL);
 	if (!priv->shared) {
 		dev_err(&dev->dev, "failed to allocate DMA memory\n");
 		ret = -ENOMEM;
 		goto err_free_io;
 	}
 	/* enable the clock */
 	priv->clk = clk_get(&dev->dev, NULL);
 	if (IS_ERR(priv->clk)) {
 		dev_err(&dev->dev, "failed to get clock\n");
 		ret = -ENODEV;
 		goto err_free_dma;
 	}
 	ret = clk_enable(priv->clk);
 	if (ret < 0) {
 		dev_err(&dev->dev, "failed to enable clock\n");
 		goto err_put_clk;
 	}
 	/* request the IRQ */
 	irq = platform_get_irq(dev, 0);
 	if (irq < 0) {
 		dev_err(&dev->dev, "no IRQ defined\n");
 		ret = -ENODEV;
 		goto err_put_clk;
 	}
 	ret = request_irq(irq, pxa3xx_gcu_handle_irq,
 			  IRQF_DISABLED, DRV_NAME, priv);
 	if (ret) {
 		dev_err(&dev->dev, "request_irq failed\n");
 		ret = -EBUSY;
 		goto err_put_clk;
 	}
 	platform_set_drvdata(dev, priv);
 	priv->resource_mem = r;
 	pxa3xx_gcu_reset(priv);
 	pxa3xx_gcu_init_debug_timer();
 	dev_info(&dev->dev, "registered @0x%p, DMA 0x%p (%d bytes), IRQ %d\n",
 			(void *) r->start, (void *) priv->shared_phys,
 			SHARED_SIZE, irq);
 	return 0;
 err_put_clk:
 	clk_disable(priv->clk);
 	clk_put(priv->clk);
 err_free_dma:
 	dma_free_coherent(&dev->dev, SHARED_SIZE,
 			priv->shared, priv->shared_phys);
 err_free_io:
 	iounmap(priv->mmio_base);
 err_free_mem_region:
 	release_mem_region(r->start, resource_size(r));
 err_misc_deregister:
 	misc_deregister(&priv->misc_dev);
 err_free_priv:
 	platform_set_drvdata(dev, NULL);
 	free_buffers(dev, priv);
 	kfree(priv);
 	return ret;
 }
 static int __devexit
 pxa3xx_gcu_remove(struct platform_device *dev)
 {
 	struct pxa3xx_gcu_priv *priv = platform_get_drvdata(dev);
 	struct resource *r = priv->resource_mem;
 	pxa3xx_gcu_wait_idle(priv);
 	misc_deregister(&priv->misc_dev);
 	dma_free_coherent(&dev->dev, SHARED_SIZE,
 			priv->shared, priv->shared_phys);
 	iounmap(priv->mmio_base);
 	release_mem_region(r->start, resource_size(r));
 	platform_set_drvdata(dev, NULL);
 	clk_disable(priv->clk);
 	free_buffers(dev, priv);
 	kfree(priv);
 	return 0;
 }
 static struct platform_driver pxa3xx_gcu_driver = {
 	.probe	  = pxa3xx_gcu_probe,
 	.remove	 = __devexit_p(pxa3xx_gcu_remove),
 	.driver	 = {
 		.owner  = THIS_MODULE,
 		.name   = DRV_NAME,
 	},
 };
 static int __init
 pxa3xx_gcu_init(void)
 {
 	return platform_driver_register(&pxa3xx_gcu_driver);
 }
 static void __exit
 pxa3xx_gcu_exit(void)
 {
 	platform_driver_unregister(&pxa3xx_gcu_driver);
 }
 module_init(pxa3xx_gcu_init);
 module_exit(pxa3xx_gcu_exit);
 MODULE_DESCRIPTION("PXA3xx graphics controller unit driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(MISCDEV_MINOR);
 MODULE_AUTHOR("Janine Kropp <nin@directfb.org>, "
 		"Denis Oliver Kropp <dok@directfb.org>, "
 		"Daniel Mack <daniel@caiaq.de>");

drivers/video/xilinxfb.c

Diff comments View file @ dd37739

 /*
  * Xilinx TFT frame buffer driver
  *
  * Author: MontaVista Software, Inc.
  *         source@mvista.com
  *
  * 2002-2007 (c) MontaVista Software, Inc.
  * 2007 (c) Secret Lab Technologies, Ltd.
  * 2009 (c) Xilinx Inc.
  *
  * This file is licensed under the terms of the GNU General Public License
  * version 2.  This program is licensed "as is" without any warranty of any
  * kind, whether express or implied.
  */
 /*
  * This driver was based on au1100fb.c by MontaVista rewritten for 2.6
  * by Embedded Alley Solutions <source@embeddedalley.com>, which in turn
  * was based on skeletonfb.c, Skeleton for a frame buffer device by
  * Geert Uytterhoeven.
  */
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/version.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
 #include <linux/of_address.h>
 #include <linux/io.h>
 #include <linux/xilinxfb.h>
 #include <linux/slab.h>
 #ifdef CONFIG_PPC_DCR
 #include <asm/dcr.h>
 #endif
 #define DRIVER_NAME		"xilinxfb"
 /*
  * Xilinx calls it "PLB TFT LCD Controller" though it can also be used for
  * the VGA port on the Xilinx ML40x board. This is a hardware display
  * controller for a 640x480 resolution TFT or VGA screen.
  *
  * The interface to the framebuffer is nice and simple.  There are two
  * control registers.  The first tells the LCD interface where in memory
  * the frame buffer is (only the 11 most significant bits are used, so
  * don't start thinking about scrolling).  The second allows the LCD to
  * be turned on or off as well as rotated 180 degrees.
  *
  * In case of direct PLB access the second control register will be at
  * an offset of 4 as compared to the DCR access where the offset is 1
  * i.e. REG_CTRL. So this is taken care in the function
  * xilinx_fb_out_be32 where it left shifts the offset 2 times in case of
  * direct PLB access.
  */
 #define NUM_REGS	2
 #define REG_FB_ADDR	0
 #define REG_CTRL	1
 #define REG_CTRL_ENABLE	 0x0001
 #define REG_CTRL_ROTATE	 0x0002
 /*
  * The hardware only handles a single mode: 640x480 24 bit true
  * color. Each pixel gets a word (32 bits) of memory.  Within each word,
  * the 8 most significant bits are ignored, the next 8 bits are the red
  * level, the next 8 bits are the green level and the 8 least
  * significant bits are the blue level.  Each row of the LCD uses 1024
  * words, but only the first 640 pixels are displayed with the other 384
  * words being ignored.  There are 480 rows.
  */
 #define BYTES_PER_PIXEL	4
 #define BITS_PER_PIXEL	(BYTES_PER_PIXEL * 8)
 #define RED_SHIFT	16
 #define GREEN_SHIFT	8
 #define BLUE_SHIFT	0
 #define PALETTE_ENTRIES_NO	16	/* passed to fb_alloc_cmap() */
 /*
  * Default xilinxfb configuration
  */
 static struct xilinxfb_platform_data xilinx_fb_default_pdata = {
 	.xres = 640,
 	.yres = 480,
 	.xvirt = 1024,
 	.yvirt = 480,
 };
 /*
  * Here are the default fb_fix_screeninfo and fb_var_screeninfo structures
  */
 static struct fb_fix_screeninfo xilinx_fb_fix = {
 	.id =		"Xilinx",
 	.type =		FB_TYPE_PACKED_PIXELS,
 	.visual =	FB_VISUAL_TRUECOLOR,
 	.accel =	FB_ACCEL_NONE
 };
 static struct fb_var_screeninfo xilinx_fb_var = {
 	.bits_per_pixel =	BITS_PER_PIXEL,
 	.red =		{ RED_SHIFT, 8, 0 },
 	.green =	{ GREEN_SHIFT, 8, 0 },
 	.blue =		{ BLUE_SHIFT, 8, 0 },
 	.transp =	{ 0, 0, 0 },
 	.activate =	FB_ACTIVATE_NOW
 };
 #define PLB_ACCESS_FLAG	0x1		/* 1 = PLB, 0 = DCR */
 struct xilinxfb_drvdata {
 	struct fb_info	info;		/* FB driver info record */
 	phys_addr_t	regs_phys;	/* phys. address of the control
 						registers */
 	void __iomem	*regs;		/* virt. address of the control
 						registers */
 #ifdef CONFIG_PPC_DCR
 	dcr_host_t      dcr_host;
 	unsigned int    dcr_len;
 #endif
 	void		*fb_virt;	/* virt. address of the frame buffer */
 	dma_addr_t	fb_phys;	/* phys. address of the frame buffer */
 	int		fb_alloced;	/* Flag, was the fb memory alloced? */
 	u8 		flags;		/* features of the driver */
 	u32		reg_ctrl_default;
 	u32		pseudo_palette[PALETTE_ENTRIES_NO];
 					/* Fake palette of 16 colors */
 };
 #define to_xilinxfb_drvdata(_info) \
 	container_of(_info, struct xilinxfb_drvdata, info)
 /*
  * The XPS TFT Controller can be accessed through PLB or DCR interface.
  * To perform the read/write on the registers we need to check on
  * which bus its connected and call the appropriate write API.
  */
 static void xilinx_fb_out_be32(struct xilinxfb_drvdata *drvdata, u32 offset,
 				u32 val)
 {
 	if (drvdata->flags & PLB_ACCESS_FLAG)
 		out_be32(drvdata->regs + (offset << 2), val);
 #ifdef CONFIG_PPC_DCR
 	else
 		dcr_write(drvdata->dcr_host, offset, val);
 #endif
 }
 static int
 xilinx_fb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
 	unsigned transp, struct fb_info *fbi)
 {
 	u32 *palette = fbi->pseudo_palette;
 	if (regno >= PALETTE_ENTRIES_NO)
 		return -EINVAL;
 	if (fbi->var.grayscale) {
 		/* Convert color to grayscale.
 		 * grayscale = 0.30*R + 0.59*G + 0.11*B */
 		red = green = blue =
 			(red * 77 + green * 151 + blue * 28 + 127) >> 8;
 	}
 	/* fbi->fix.visual is always FB_VISUAL_TRUECOLOR */
 	/* We only handle 8 bits of each color. */
 	red >>= 8;
 	green >>= 8;
 	blue >>= 8;
 	palette[regno] = (red << RED_SHIFT) | (green << GREEN_SHIFT) |
 			 (blue << BLUE_SHIFT);
 	return 0;
 }
 static int
 xilinx_fb_blank(int blank_mode, struct fb_info *fbi)
 {
 	struct xilinxfb_drvdata *drvdata = to_xilinxfb_drvdata(fbi);
 	switch (blank_mode) {
 	case FB_BLANK_UNBLANK:
 		/* turn on panel */
 		xilinx_fb_out_be32(drvdata, REG_CTRL, drvdata->reg_ctrl_default);
 		break;
 	case FB_BLANK_NORMAL:
 	case FB_BLANK_VSYNC_SUSPEND:
 	case FB_BLANK_HSYNC_SUSPEND:
 	case FB_BLANK_POWERDOWN:
 		/* turn off panel */
 		xilinx_fb_out_be32(drvdata, REG_CTRL, 0);
 	default:
 		break;
 	}
 	return 0; /* success */
 }
 static struct fb_ops xilinxfb_ops =
 {
 	.owner			= THIS_MODULE,
 	.fb_setcolreg		= xilinx_fb_setcolreg,
 	.fb_blank		= xilinx_fb_blank,
 	.fb_fillrect		= cfb_fillrect,
 	.fb_copyarea		= cfb_copyarea,
 	.fb_imageblit		= cfb_imageblit,
 };
 /* ---------------------------------------------------------------------
  * Bus independent setup/teardown
  */
 static int xilinxfb_assign(struct device *dev,
 			   struct xilinxfb_drvdata *drvdata,
 			   unsigned long physaddr,
 			   struct xilinxfb_platform_data *pdata)
 {
 	int rc;
 	int fbsize = pdata->xvirt * pdata->yvirt * BYTES_PER_PIXEL;
 	if (drvdata->flags & PLB_ACCESS_FLAG) {
 		/*
 		 * Map the control registers in if the controller
 		 * is on direct PLB interface.
 		 */
 		if (!request_mem_region(physaddr, 8, DRIVER_NAME)) {
 			dev_err(dev, "Couldn't lock memory region at 0x%08lX\n",
 				physaddr);
 			rc = -ENODEV;
 			goto err_region;
 		}
 		drvdata->regs_phys = physaddr;
 		drvdata->regs = ioremap(physaddr, 8);
 		if (!drvdata->regs) {
 			dev_err(dev, "Couldn't lock memory region at 0x%08lX\n",
 				physaddr);
 			rc = -ENODEV;
 			goto err_map;
 		}
 	}
 	/* Allocate the framebuffer memory */
 	if (pdata->fb_phys) {
 		drvdata->fb_phys = pdata->fb_phys;
 		drvdata->fb_virt = ioremap(pdata->fb_phys, fbsize);
 	} else {
 		drvdata->fb_alloced = 1;
 		drvdata->fb_virt = dma_alloc_coherent(dev, PAGE_ALIGN(fbsize),
 					&drvdata->fb_phys, GFP_KERNEL);
 	}
 	if (!drvdata->fb_virt) {
 		dev_err(dev, "Could not allocate frame buffer memory\n");
 		rc = -ENOMEM;
 		if (drvdata->flags & PLB_ACCESS_FLAG)
 			goto err_fbmem;
 		else
 			goto err_region;
 	}
 	/* Clear (turn to black) the framebuffer */
 	memset_io((void __iomem *)drvdata->fb_virt, 0, fbsize);
 	/* Tell the hardware where the frame buffer is */
 	xilinx_fb_out_be32(drvdata, REG_FB_ADDR, drvdata->fb_phys);
 	/* Turn on the display */
 	drvdata->reg_ctrl_default = REG_CTRL_ENABLE;
 	if (pdata->rotate_screen)
 		drvdata->reg_ctrl_default |= REG_CTRL_ROTATE;
 	xilinx_fb_out_be32(drvdata, REG_CTRL,
 					drvdata->reg_ctrl_default);
 	/* Fill struct fb_info */
 	drvdata->info.device = dev;
 	drvdata->info.screen_base = (void __iomem *)drvdata->fb_virt;
 	drvdata->info.fbops = &xilinxfb_ops;
 	drvdata->info.fix = xilinx_fb_fix;
 	drvdata->info.fix.smem_start = drvdata->fb_phys;
 	drvdata->info.fix.smem_len = fbsize;
 	drvdata->info.fix.line_length = pdata->xvirt * BYTES_PER_PIXEL;
 	drvdata->info.pseudo_palette = drvdata->pseudo_palette;
 	drvdata->info.flags = FBINFO_DEFAULT;
 	drvdata->info.var = xilinx_fb_var;
 	drvdata->info.var.height = pdata->screen_height_mm;
 	drvdata->info.var.width = pdata->screen_width_mm;
 	drvdata->info.var.xres = pdata->xres;
 	drvdata->info.var.yres = pdata->yres;
 	drvdata->info.var.xres_virtual = pdata->xvirt;
 	drvdata->info.var.yres_virtual = pdata->yvirt;
 	/* Allocate a colour map */
 	rc = fb_alloc_cmap(&drvdata->info.cmap, PALETTE_ENTRIES_NO, 0);
 	if (rc) {
 		dev_err(dev, "Fail to allocate colormap (%d entries)\n",
 			PALETTE_ENTRIES_NO);
 		goto err_cmap;
 	}
 	/* Register new frame buffer */
 	rc = register_framebuffer(&drvdata->info);
 	if (rc) {
 		dev_err(dev, "Could not register frame buffer\n");
 		goto err_regfb;
 	}
 	if (drvdata->flags & PLB_ACCESS_FLAG) {
 		/* Put a banner in the log (for DEBUG) */
 		dev_dbg(dev, "regs: phys=%lx, virt=%p\n", physaddr,
 					drvdata->regs);
 	}
 	/* Put a banner in the log (for DEBUG) */
 	dev_dbg(dev, "fb: phys=%llx, virt=%p, size=%x\n",
 		(unsigned long long)drvdata->fb_phys, drvdata->fb_virt, fbsize);
 	return 0;	/* success */
 err_regfb:
 	fb_dealloc_cmap(&drvdata->info.cmap);
 err_cmap:
 	if (drvdata->fb_alloced)
 		dma_free_coherent(dev, PAGE_ALIGN(fbsize), drvdata->fb_virt,
 			drvdata->fb_phys);
 	else
 		iounmap(drvdata->fb_virt);
 	/* Turn off the display */
 	xilinx_fb_out_be32(drvdata, REG_CTRL, 0);
 err_fbmem:
 	if (drvdata->flags & PLB_ACCESS_FLAG)
 		iounmap(drvdata->regs);
 err_map:
 	if (drvdata->flags & PLB_ACCESS_FLAG)
 		release_mem_region(physaddr, 8);
 err_region:
 	kfree(drvdata);
 	dev_set_drvdata(dev, NULL);
 	return rc;
 }
 static int xilinxfb_release(struct device *dev)
 {
 	struct xilinxfb_drvdata *drvdata = dev_get_drvdata(dev);
 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
 	xilinx_fb_blank(VESA_POWERDOWN, &drvdata->info);
 #endif
 	unregister_framebuffer(&drvdata->info);
 	fb_dealloc_cmap(&drvdata->info.cmap);
 	if (drvdata->fb_alloced)
 		dma_free_coherent(dev, PAGE_ALIGN(drvdata->info.fix.smem_len),
 				  drvdata->fb_virt, drvdata->fb_phys);
 	else
 		iounmap(drvdata->fb_virt);
 	/* Turn off the display */
 	xilinx_fb_out_be32(drvdata, REG_CTRL, 0);
 	/* Release the resources, as allocated based on interface */
 	if (drvdata->flags & PLB_ACCESS_FLAG) {
 		iounmap(drvdata->regs);
 		release_mem_region(drvdata->regs_phys, 8);
 	}
 #ifdef CONFIG_PPC_DCR
 	else
 		dcr_unmap(drvdata->dcr_host, drvdata->dcr_len);
 #endif
 	kfree(drvdata);
 	dev_set_drvdata(dev, NULL);
 	return 0;
 }
 /* ---------------------------------------------------------------------
  * OF bus binding
  */
 static int __devinit xilinxfb_of_probe(struct platform_device *op)
 {
 	const u32 *prop;
 	u32 *p;
 	u32 tft_access;
 	struct xilinxfb_platform_data pdata;
 	struct resource res;
 	int size, rc;
 	struct xilinxfb_drvdata *drvdata;
 	/* Copy with the default pdata (not a ptr reference!) */
 	pdata = xilinx_fb_default_pdata;
 	/* Allocate the driver data region */
 	drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
 	if (!drvdata) {
 		dev_err(&op->dev, "Couldn't allocate device private record\n");
 		return -ENOMEM;
 	}
 	/*
 	 * To check whether the core is connected directly to DCR or PLB
 	 * interface and initialize the tft_access accordingly.
 	 */
 	p = (u32 *)of_get_property(op->dev.of_node, "xlnx,dcr-splb-slave-if", NULL);
 	tft_access = p ? *p : 0;
 	/*
 	 * Fill the resource structure if its direct PLB interface
 	 * otherwise fill the dcr_host structure.
 	 */
 	if (tft_access) {
 		drvdata->flags |= PLB_ACCESS_FLAG;
 		rc = of_address_to_resource(op->dev.of_node, 0, &res);
 		if (rc) {
 			dev_err(&op->dev, "invalid address\n");
 			goto err;
 		}
 	}
 #ifdef CONFIG_PPC_DCR
 	else {
 		int start;
 		res.start = 0;
 		start = dcr_resource_start(op->dev.of_node, 0);
 		drvdata->dcr_len = dcr_resource_len(op->dev.of_node, 0);
 		drvdata->dcr_host = dcr_map(op->dev.of_node, start, drvdata->dcr_len);
 		if (!DCR_MAP_OK(drvdata->dcr_host)) {
 			dev_err(&op->dev, "invalid DCR address\n");
 			goto err;
 		}
 	}
 #endif
 	prop = of_get_property(op->dev.of_node, "phys-size", &size);
 	if ((prop) && (size >= sizeof(u32)*2)) {
 		pdata.screen_width_mm = prop[0];
 		pdata.screen_height_mm = prop[1];
 	}
 	prop = of_get_property(op->dev.of_node, "resolution", &size);
 	if ((prop) && (size >= sizeof(u32)*2)) {
 		pdata.xres = prop[0];
 		pdata.yres = prop[1];
 	}
 	prop = of_get_property(op->dev.of_node, "virtual-resolution", &size);
 	if ((prop) && (size >= sizeof(u32)*2)) {
 		pdata.xvirt = prop[0];
 		pdata.yvirt = prop[1];
 	}
 	if (of_find_property(op->dev.of_node, "rotate-display", NULL))
 		pdata.rotate_screen = 1;
 	dev_set_drvdata(&op->dev, drvdata);
 	return xilinxfb_assign(&op->dev, drvdata, res.start, &pdata);
  err:
 	kfree(drvdata);
 	return -ENODEV;
 }
 static int __devexit xilinxfb_of_remove(struct platform_device *op)
 {
 	return xilinxfb_release(&op->dev);
 }
 /* Match table for of_platform binding */
 static struct of_device_id xilinxfb_of_match[] __devinitdata = {
 	{ .compatible = "xlnx,xps-tft-1.00.a", },
 	{ .compatible = "xlnx,xps-tft-2.00.a", },
 	{ .compatible = "xlnx,xps-tft-2.01.a", },
 	{ .compatible = "xlnx,plb-tft-cntlr-ref-1.00.a", },
 	{ .compatible = "xlnx,plb-dvi-cntlr-ref-1.00.c", },
 	{},
 };
 MODULE_DEVICE_TABLE(of, xilinxfb_of_match);
 static struct platform_driver xilinxfb_of_driver = {
 	.probe = xilinxfb_of_probe,
 	.remove = __devexit_p(xilinxfb_of_remove),
 	.driver = {
 		.name = DRIVER_NAME,
 		.owner = THIS_MODULE,
 		.of_match_table = xilinxfb_of_match,
 	},
 };
 /* ---------------------------------------------------------------------
  * Module setup and teardown
  */
 static int __init
 xilinxfb_init(void)
 {
 	return platform_driver_register(&xilinxfb_of_driver);
 }
 static void __exit
 xilinxfb_cleanup(void)
 {
 	platform_driver_unregister(&xilinxfb_of_driver);
 }
 module_init(xilinxfb_init);
 module_exit(xilinxfb_cleanup);
 MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
 MODULE_DESCRIPTION("Xilinx TFT frame buffer driver");
 MODULE_LICENSE("GPL");