[ARM] pxa/corgi: use SPI-based driver for ads7846, corgi-lcd and max1111 (edb403fb) · Commits · e / devices / android_kernel_oneplus_sm8150

arch/arm/mach-pxa/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -28,7 +28,7 @@ obj-$(CONFIG_MACH_MAINSTONE) += mainstone.o
	obj-$(CONFIG_ARCH_PXA_IDP) += idp.o		obj-$(CONFIG_ARCH_PXA_IDP) += idp.o
	obj-$(CONFIG_MACH_TRIZEPS4) += trizeps4.o		obj-$(CONFIG_MACH_TRIZEPS4) += trizeps4.o
	obj-$(CONFIG_MACH_COLIBRI) += colibri.o		obj-$(CONFIG_MACH_COLIBRI) += colibri.o
	obj-$(CONFIG_PXA_SHARP_C7xx) += corgi.o corgi_ssp.o corgi_lcd.o sharpsl_pm.o corgi_pm.o		obj-$(CONFIG_PXA_SHARP_C7xx) += corgi.o sharpsl_pm.o corgi_pm.o
	obj-$(CONFIG_PXA_SHARP_Cxx00) += spitz.o corgi_ssp.o corgi_lcd.o sharpsl_pm.o spitz_pm.o		obj-$(CONFIG_PXA_SHARP_Cxx00) += spitz.o corgi_ssp.o corgi_lcd.o sharpsl_pm.o spitz_pm.o
	obj-$(CONFIG_MACH_AKITA) += akita-ioexp.o		obj-$(CONFIG_MACH_AKITA) += akita-ioexp.o
	obj-$(CONFIG_MACH_POODLE) += poodle.o		obj-$(CONFIG_MACH_POODLE) += poodle.o

arch/arm/mach-pxa/corgi.c

+131 −162

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,9 @@
	#include <linux/pm.h>		#include <linux/pm.h>
	#include <linux/gpio.h>		#include <linux/gpio.h>
	#include <linux/backlight.h>		#include <linux/backlight.h>
			#include <linux/spi/spi.h>
			#include <linux/spi/ads7846.h>
			#include <linux/spi/corgi_lcd.h>
	#include <video/w100fb.h>		#include <video/w100fb.h>

	#include <asm/setup.h>		#include <asm/setup.h>
	@@ -43,6 +46,7 @@
	#include <mach/irda.h>		#include <mach/irda.h>
	#include <mach/mmc.h>		#include <mach/mmc.h>
	#include <mach/udc.h>		#include <mach/udc.h>
			#include <mach/pxa2xx_spi.h>
	#include <mach/corgi.h>		#include <mach/corgi.h>
	#include <mach/sharpsl.h>		#include <mach/sharpsl.h>

	@@ -151,53 +155,6 @@ static struct scoop_pcmcia_config corgi_pcmcia_config = {

	EXPORT_SYMBOL(corgiscoop_device);		EXPORT_SYMBOL(corgiscoop_device);


	/*
	* Corgi SSP Device
	*
	* Set the parent as the scoop device because a lot of SSP devices
	* also use scoop functions and this makes the power up/down order
	* work correctly.
	*/
	struct platform_device corgissp_device = {
	.name = "corgi-ssp",
	.dev = {
	.parent = &corgiscoop_device.dev,
	},
	.id = -1,
	};

	struct corgissp_machinfo corgi_ssp_machinfo = {
	.port = 1,
	.cs_lcdcon = CORGI_GPIO_LCDCON_CS,
	.cs_ads7846 = CORGI_GPIO_ADS7846_CS,
	.cs_max1111 = CORGI_GPIO_MAX1111_CS,
	.clk_lcdcon = 76,
	.clk_ads7846 = 2,
	.clk_max1111 = 8,
	};


	/*
	* LCD/Framebuffer
	*/
	static void w100_lcdtg_suspend(struct w100fb_par *par)
	{
	corgi_lcdtg_suspend();
	}

	static void w100_lcdtg_init(struct w100fb_par *par)
	{
	corgi_lcdtg_hw_init(par->xres);
	}


	static struct w100_tg_info corgi_lcdtg_info = {
	.change = w100_lcdtg_init,
	.suspend = w100_lcdtg_suspend,
	.resume = w100_lcdtg_init,
	};

	static struct w100_mem_info corgi_fb_mem = {		static struct w100_mem_info corgi_fb_mem = {
	.ext_cntl = 0x00040003,		.ext_cntl = 0x00040003,
	.sdram_mode_reg = 0x00650021,		.sdram_mode_reg = 0x00650021,
	@@ -276,7 +233,6 @@ static struct w100_mode corgi_fb_modes[] = {
	};		};

	static struct w100fb_mach_info corgi_fb_info = {		static struct w100fb_mach_info corgi_fb_info = {
	.tg = &corgi_lcdtg_info,
	.init_mode = INIT_MODE_ROTATED,		.init_mode = INIT_MODE_ROTATED,
	.mem = &corgi_fb_mem,		.mem = &corgi_fb_mem,
	.regs = &corgi_fb_regs,		.regs = &corgi_fb_regs,
	@@ -302,60 +258,10 @@ static struct platform_device corgifb_device = {
	.resource = corgi_fb_resources,		.resource = corgi_fb_resources,
	.dev = {		.dev = {
	.platform_data = &corgi_fb_info,		.platform_data = &corgi_fb_info,
	.parent = &corgissp_device.dev,
	},		},

	};		};


	/*
	* Corgi Backlight Device
	*/
	static void corgi_bl_kick_battery(void)
	{
	void (*kick_batt)(void);

	kick_batt = symbol_get(sharpsl_battery_kick);
	if (kick_batt) {
	kick_batt();
	symbol_put(sharpsl_battery_kick);
	}
	}

	static void corgi_bl_set_intensity(int intensity)
	{
	if (intensity > 0x10)
	intensity += 0x10;

	/* Bits 0-4 are accessed via the SSP interface */
	corgi_ssp_blduty_set(intensity & 0x1f);

	/* Bit 5 is via SCOOP */
	if (intensity & 0x0020)
	set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_BACKLIGHT_CONT);
	else
	reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_BACKLIGHT_CONT);
	}

	static struct generic_bl_info corgi_bl_machinfo = {
	.name = "corgi-bl",
	.max_intensity = 0x2f,
	.default_intensity = 0x1f,
	.limit_mask = 0x0b,
	.set_bl_intensity = corgi_bl_set_intensity,
	.kick_battery = corgi_bl_kick_battery,
	};

	static struct platform_device corgibl_device = {
	.name = "generic-bl",
	.dev = {
	.parent = &corgifb_device.dev,
	.platform_data = &corgi_bl_machinfo,
	},
	.id = -1,
	};


	/*		/*
	* Corgi Keyboard Device		* Corgi Keyboard Device
	*/		*/
	@@ -373,66 +279,6 @@ static struct platform_device corgiled_device = {
	.id = -1,		.id = -1,
	};		};


	/*
	* Corgi Touch Screen Device
	*/
	static unsigned long (get_hsync_invperiod)(struct device dev);

	static void inline sharpsl_wait_sync(int gpio)
	{
	while((GPLR(gpio) & GPIO_bit(gpio)) == 0);
	while((GPLR(gpio) & GPIO_bit(gpio)) != 0);
	}

	static unsigned long corgi_get_hsync_invperiod(void)
	{
	if (!get_hsync_invperiod)
	get_hsync_invperiod = symbol_get(w100fb_get_hsynclen);
	if (!get_hsync_invperiod)
	return 0;

	return get_hsync_invperiod(&corgifb_device.dev);
	}

	static void corgi_put_hsync(void)
	{
	if (get_hsync_invperiod)
	symbol_put(w100fb_get_hsynclen);
	get_hsync_invperiod = NULL;
	}

	static void corgi_wait_hsync(void)
	{
	sharpsl_wait_sync(CORGI_GPIO_HSYNC);
	}

	static struct resource corgits_resources[] = {
	[0] = {
	.start = CORGI_IRQ_GPIO_TP_INT,
	.end = CORGI_IRQ_GPIO_TP_INT,
	.flags = IORESOURCE_IRQ,
	},
	};

	static struct corgits_machinfo corgi_ts_machinfo = {
	.get_hsync_invperiod = corgi_get_hsync_invperiod,
	.put_hsync = corgi_put_hsync,
	.wait_hsync = corgi_wait_hsync,
	};

	static struct platform_device corgits_device = {
	.name = "corgi-ts",
	.dev = {
	.parent = &corgissp_device.dev,
	.platform_data = &corgi_ts_machinfo,
	},
	.id = -1,
	.num_resources = ARRAY_SIZE(corgits_resources),
	.resource = corgits_resources,
	};


	/*		/*
	* MMC/SD Device		* MMC/SD Device
	*		*
	@@ -555,14 +401,137 @@ static struct pxa2xx_udc_mach_info udc_info __initdata = {
	.gpio_pullup = CORGI_GPIO_USB_PULLUP,		.gpio_pullup = CORGI_GPIO_USB_PULLUP,
	};		};

			#if defined(CONFIG_SPI_PXA2XX) \|\| defined(CONFIG_SPI_PXA2XX_MASTER)
			static struct pxa2xx_spi_master corgi_spi_info = {
			.num_chipselect = 3,
			};

			static struct ads7846_platform_data corgi_ads7846_info = {
			.model = 7846,
			.vref_delay_usecs = 100,
			.x_plate_ohms = 419,
			.y_plate_ohms = 486,
			.gpio_pendown = CORGI_GPIO_TP_INT,
			};

			static void corgi_ads7846_cs(u32 command)
			{
			gpio_set_value(CORGI_GPIO_ADS7846_CS, !(command == PXA2XX_CS_ASSERT));
			}

			static struct pxa2xx_spi_chip corgi_ads7846_chip = {
			.cs_control = corgi_ads7846_cs,
			};

			static void corgi_notify_intensity(int intensity)
			{
			/* Bit 5 is via SCOOP */
			if (intensity & 0x0020)
			set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_BACKLIGHT_CONT);
			else
			reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_BACKLIGHT_CONT);
			}

			static void corgi_bl_kick_battery(void)
			{
			void (*kick_batt)(void);

			kick_batt = symbol_get(sharpsl_battery_kick);
			if (kick_batt) {
			kick_batt();
			symbol_put(sharpsl_battery_kick);
			}
			}

			static struct corgi_lcd_platform_data corgi_lcdcon_info = {
			.init_mode = CORGI_LCD_MODE_VGA,
			.max_intensity = 0x2f,
			.default_intensity = 0x1f,
			.limit_mask = 0x0b,
			.notify = corgi_notify_intensity,
			.kick_battery = corgi_bl_kick_battery,
			};

			static void corgi_lcdcon_cs(u32 command)
			{
			gpio_set_value(CORGI_GPIO_LCDCON_CS, !(command == PXA2XX_CS_ASSERT));
			}

			static struct pxa2xx_spi_chip corgi_lcdcon_chip = {
			.cs_control = corgi_lcdcon_cs,
			};

			static void corgi_max1111_cs(u32 command)
			{
			gpio_set_value(CORGI_GPIO_MAX1111_CS, !(command == PXA2XX_CS_ASSERT));
			}

			static struct pxa2xx_spi_chip corgi_max1111_chip = {
			.cs_control = corgi_max1111_cs,
			};

			static struct spi_board_info corgi_spi_devices[] = {
			{
			.modalias = "ads7846",
			.max_speed_hz = 1200000,
			.bus_num = 1,
			.chip_select = 0,
			.platform_data = &corgi_ads7846_info,
			.controller_data= &corgi_ads7846_chip,
			.irq = gpio_to_irq(CORGI_GPIO_TP_INT),
			}, {
			.modalias = "corgi-lcd",
			.max_speed_hz = 50000,
			.bus_num = 1,
			.chip_select = 1,
			.platform_data = &corgi_lcdcon_info,
			.controller_data= &corgi_lcdcon_chip,
			}, {
			.modalias = "max1111",
			.max_speed_hz = 450000,
			.bus_num = 1,
			.chip_select = 2,
			.controller_data= &corgi_max1111_chip,
			},
			};

			static void __init corgi_init_spi(void)
			{
			int err;

			err = gpio_request(CORGI_GPIO_ADS7846_CS, "ADS7846_CS");
			if (err)
			return;

			err = gpio_request(CORGI_GPIO_LCDCON_CS, "LCDCON_CS");
			if (err)
			goto err_free_1;

			err = gpio_request(CORGI_GPIO_MAX1111_CS, "MAX1111_CS");
			if (err)
			goto err_free_2;

			gpio_direction_output(CORGI_GPIO_ADS7846_CS, 1);
			gpio_direction_output(CORGI_GPIO_LCDCON_CS, 1);
			gpio_direction_output(CORGI_GPIO_MAX1111_CS, 1);

			pxa2xx_set_spi_info(1, &corgi_spi_info);
			spi_register_board_info(ARRAY_AND_SIZE(corgi_spi_devices));
			return;

			err_free_2:
			gpio_free(CORGI_GPIO_LCDCON_CS);
			err_free_1:
			gpio_free(CORGI_GPIO_ADS7846_CS);
			}
			#else
			static inline void corgi_init_spi(void) {}
			#endif

	static struct platform_device *devices[] __initdata = {		static struct platform_device *devices[] __initdata = {
	&corgiscoop_device,		&corgiscoop_device,
	&corgissp_device,
	&corgifb_device,		&corgifb_device,
	&corgikbd_device,		&corgikbd_device,
	&corgibl_device,
	&corgits_device,
	&corgiled_device,		&corgiled_device,
	};		};

	@@ -592,7 +561,7 @@ static void __init corgi_init(void)

	pxa2xx_mfp_config(ARRAY_AND_SIZE(corgi_pin_config));		pxa2xx_mfp_config(ARRAY_AND_SIZE(corgi_pin_config));

	corgi_ssp_set_machinfo(&corgi_ssp_machinfo);		corgi_init_spi();

	pxa_set_udc_info(&udc_info);		pxa_set_udc_info(&udc_info);
	pxa_set_mci_info(&corgi_mci_platform_data);		pxa_set_mci_info(&corgi_mci_platform_data);