Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f72de663 authored by Eric Miao's avatar Eric Miao Committed by Russell King
Browse files

[ARM] pxa/akita: use pca953x instead of akita-ioexp 



Use generic pca953x which provides gpiolib interface instead of
akita-specific akita-ioexp with non-standard interface to pins.

Signed-off-by: default avatarDmitry Baryshkov <dbaryshkov@gmail.com>
Cc: Richard Purdie <rpurdie@rpsys.net>
Cc: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: default avatarEric Miao <eric.miao@marvell.com>
Signed-off-by: default avatarRussell King <rmk+kernel@arm.linux.org.uk>
parent 4fe3224f

arch/arm/mach-pxa/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ obj-$(CONFIG_MACH_TRIZEPS4) += trizeps4.o 
obj-$(CONFIG_MACH_COLIBRI)	+= colibri.o

obj-$(CONFIG_PXA_SHARP_C7xx)	+= corgi.o sharpsl_pm.o corgi_pm.o

obj-$(CONFIG_PXA_SHARP_Cxx00)	+= spitz.o sharpsl_pm.o spitz_pm.o

obj-$(CONFIG_MACH_AKITA)	+= akita-ioexp.o

obj-$(CONFIG_MACH_POODLE)	+= poodle.o

obj-$(CONFIG_MACH_PCM027)	+= pcm027.o

obj-$(CONFIG_MACH_PCM990_BASEBOARD)	+= pcm990-baseboard.o

arch/arm/mach-pxa/akita-ioexp.c

deleted100644 → 0
+0 −222
Original line number Diff line number Diff line 
/*

 * Support for the Extra GPIOs on the Sharp SL-C1000 (Akita)

 * (uses a Maxim MAX7310 8 Port IO Expander)

 *

 * Copyright 2005 Openedhand Ltd.

 *

 * Author: Richard Purdie <richard@openedhand.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 *

 */



#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/platform_device.h>

#include <linux/module.h>

#include <linux/i2c.h>

#include <linux/slab.h>

#include <linux/workqueue.h>

#include <mach/akita.h>



/* MAX7310 Regiser Map */

#define MAX7310_INPUT    0x00

#define MAX7310_OUTPUT   0x01

#define MAX7310_POLINV   0x02

#define MAX7310_IODIR    0x03 /* 1 = Input, 0 = Output */

#define MAX7310_TIMEOUT  0x04



/* Addresses to scan */

static const unsigned short normal_i2c[] = { 0x18, I2C_CLIENT_END };



/* I2C Magic */

I2C_CLIENT_INSMOD;



static int max7310_write(struct i2c_client *client, int address, int data);

static struct i2c_client max7310_template;

static void akita_ioexp_work(struct work_struct *private_);



static struct device *akita_ioexp_device;

static unsigned char ioexp_output_value = AKITA_IOEXP_IO_OUT;

DECLARE_WORK(akita_ioexp, akita_ioexp_work);





/*

 * MAX7310 Access

 */

static int max7310_config(struct device *dev, int iomode, int polarity)

{

	int ret;

	struct i2c_client *client = to_i2c_client(dev);



	ret = max7310_write(client, MAX7310_POLINV, polarity);

	if (ret < 0)

		return ret;

	ret = max7310_write(client, MAX7310_IODIR, iomode);

	return ret;

}



static int max7310_set_ouputs(struct device *dev, int outputs)

{

	struct i2c_client *client = to_i2c_client(dev);



	return max7310_write(client, MAX7310_OUTPUT, outputs);

}



/*

 * I2C Functions

 */

static int max7310_write(struct i2c_client *client, int address, int value)

{

	u8 data[2];



	data[0] = address & 0xff;

	data[1] = value & 0xff;



	if (i2c_master_send(client, data, 2) == 2)

		return 0;

	return -1;

}



static int max7310_detect(struct i2c_adapter *adapter, int address, int kind)

{

	struct i2c_client *new_client;

	int err;



	if (!(new_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL)))

		return -ENOMEM;



	max7310_template.adapter = adapter;

	max7310_template.addr = address;



	memcpy(new_client, &max7310_template, sizeof(struct i2c_client));



	if ((err = i2c_attach_client(new_client))) {

		kfree(new_client);

		return err;

	}



	max7310_config(&new_client->dev, AKITA_IOEXP_IO_DIR, 0);

	akita_ioexp_device = &new_client->dev;

	schedule_work(&akita_ioexp);



	return 0;

}



static int max7310_attach_adapter(struct i2c_adapter *adapter)

{

	return i2c_probe(adapter, &addr_data, max7310_detect);

}



static int max7310_detach_client(struct i2c_client *client)

{

	int err;



	akita_ioexp_device = NULL;



	if ((err = i2c_detach_client(client)))

		return err;



	kfree(client);

	return 0;

}



static struct i2c_driver max7310_i2c_driver = {

	.driver = {

		.name	= "akita-max7310",

	},

	.id		= I2C_DRIVERID_AKITAIOEXP,

	.attach_adapter	= max7310_attach_adapter,

	.detach_client	= max7310_detach_client,

};



static struct i2c_client max7310_template = {

	name:   "akita-max7310",

	driver: &max7310_i2c_driver,

};



void akita_set_ioexp(struct device *dev, unsigned char bit)

{

	ioexp_output_value |= bit;



	if (akita_ioexp_device)

		schedule_work(&akita_ioexp);

	return;

}



void akita_reset_ioexp(struct device *dev, unsigned char bit)

{

	ioexp_output_value &= ~bit;



	if (akita_ioexp_device)

		schedule_work(&akita_ioexp);

	return;

}



EXPORT_SYMBOL(akita_set_ioexp);

EXPORT_SYMBOL(akita_reset_ioexp);



static void akita_ioexp_work(struct work_struct *private_)

{

	if (akita_ioexp_device)

		max7310_set_ouputs(akita_ioexp_device, ioexp_output_value);

}





#ifdef CONFIG_PM

static int akita_ioexp_suspend(struct platform_device *pdev, pm_message_t state)

{

	flush_scheduled_work();

	return 0;

}



static int akita_ioexp_resume(struct platform_device *pdev)

{

	schedule_work(&akita_ioexp);

	return 0;

}

#else

#define akita_ioexp_suspend NULL

#define akita_ioexp_resume NULL

#endif



static int __init akita_ioexp_probe(struct platform_device *pdev)

{

	return i2c_add_driver(&max7310_i2c_driver);

}



static int akita_ioexp_remove(struct platform_device *pdev)

{

	i2c_del_driver(&max7310_i2c_driver);

	return 0;

}



static struct platform_driver akita_ioexp_driver = {

	.probe		= akita_ioexp_probe,

	.remove		= akita_ioexp_remove,

	.suspend	= akita_ioexp_suspend,

	.resume		= akita_ioexp_resume,

	.driver		= {

		.name	= "akita-ioexp",

	},

};



static int __init akita_ioexp_init(void)

{

	return platform_driver_register(&akita_ioexp_driver);

}



static void __exit akita_ioexp_exit(void)

{

	platform_driver_unregister(&akita_ioexp_driver);

}



MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");

MODULE_DESCRIPTION("Akita IO-Expander driver");

MODULE_LICENSE("GPL");



fs_initcall(akita_ioexp_init);

module_exit(akita_ioexp_exit);

arch/arm/mach-pxa/include/mach/akita.h

deleted100644 → 0
+0 −32
Original line number Diff line number Diff line 
/*

 * Hardware specific definitions for SL-C1000 (Akita)

 *

 * Copyright (c) 2005 Richard Purdie

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 *

 */



/* Akita IO Expander GPIOs */



#define AKITA_IOEXP_RESERVED_7      (1 << 7)

#define AKITA_IOEXP_IR_ON           (1 << 6)

#define AKITA_IOEXP_AKIN_PULLUP     (1 << 5)

#define AKITA_IOEXP_BACKLIGHT_CONT  (1 << 4)

#define AKITA_IOEXP_BACKLIGHT_ON    (1 << 3)

#define AKITA_IOEXP_MIC_BIAS        (1 << 2)

#define AKITA_IOEXP_RESERVED_1      (1 << 1)

#define AKITA_IOEXP_RESERVED_0      (1 << 0)



/* Direction Bitfield  0=output  1=input */

#define AKITA_IOEXP_IO_DIR	0

/* Default Values */

#define AKITA_IOEXP_IO_OUT	(AKITA_IOEXP_IR_ON | AKITA_IOEXP_AKIN_PULLUP)



extern struct platform_device akitaioexp_device;



void akita_set_ioexp(struct device *dev, unsigned char bitmask);

void akita_reset_ioexp(struct device *dev, unsigned char bitmask);

arch/arm/mach-pxa/include/mach/spitz.h

+11 −0
Original line number Diff line number Diff line
@@ -151,6 +151,17 @@ 
#define SPITZ_GPIO_BACKLIGHT_ON		(SPITZ_SCP2_GPIO_BASE + 7)

#define SPITZ_GPIO_MIC_BIAS		(SPITZ_SCP2_GPIO_BASE + 8)



/* Akita IO Expander GPIOs */

#define AKITA_IOEXP_GPIO_BASE		(NR_BUILTIN_GPIO + 12)

#define AKITA_GPIO_RESERVED_0		(AKITA_IOEXP_GPIO_BASE + 0)

#define AKITA_GPIO_RESERVED_1		(AKITA_IOEXP_GPIO_BASE + 1)

#define AKITA_GPIO_MIC_BIAS		(AKITA_IOEXP_GPIO_BASE + 2)

#define AKITA_GPIO_BACKLIGHT_ON		(AKITA_IOEXP_GPIO_BASE + 3)

#define AKITA_GPIO_BACKLIGHT_CONT	(AKITA_IOEXP_GPIO_BASE + 4)

#define AKITA_GPIO_AKIN_PULLUP		(AKITA_IOEXP_GPIO_BASE + 5)

#define AKITA_GPIO_IR_ON		(AKITA_IOEXP_GPIO_BASE + 6)

#define AKITA_GPIO_RESERVED_7		(AKITA_IOEXP_GPIO_BASE + 7)



/* Spitz IRQ Definitions */



#define SPITZ_IRQ_GPIO_KEY_INT        IRQ_GPIO(SPITZ_GPIO_KEY_INT)

arch/arm/mach-pxa/spitz.c

+16 −21
Original line number Diff line number Diff line
@@ -24,6 +24,8 @@ 
#include <linux/mmc/host.h>

#include <linux/pm.h>

#include <linux/backlight.h>

#include <linux/i2c.h>

#include <linux/i2c/pca953x.h>

#include <linux/spi/spi.h>

#include <linux/spi/ads7846.h>

#include <linux/spi/corgi_lcd.h>
@@ -52,7 +54,6 @@ 
#include <mach/udc.h>

#include <mach/pxafb.h>

#include <mach/pxa2xx_spi.h>

#include <mach/akita.h>

#include <mach/spitz.h>

#include <mach/sharpsl.h>
@@ -313,16 +314,8 @@ static void spitz_notify_intensity(int intensity) 
	}



	if (machine_is_akita()) {

		/* Bit 5 is via IO-Expander */

		if (intensity & 0x0020)

			akita_reset_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_BACKLIGHT_CONT);

		else

			akita_set_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_BACKLIGHT_CONT);



		if (intensity)

			akita_set_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_BACKLIGHT_ON);

		else

			akita_reset_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_BACKLIGHT_ON);

		gpio_set_value(AKITA_GPIO_BACKLIGHT_CONT, !(intensity & 0x20));

		gpio_set_value(AKITA_GPIO_BACKLIGHT_ON, intensity);

		return;

	}

}
@@ -565,10 +558,7 @@ static void spitz_irda_transceiver_mode(struct device *dev, int mode) 
#ifdef CONFIG_MACH_AKITA

static void akita_irda_transceiver_mode(struct device *dev, int mode)

{

	if (mode & IR_OFF)

		akita_set_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_IR_ON);

	else

		akita_reset_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_IR_ON);

	gpio_set_value(AKITA_GPIO_IR_ON, mode & IR_OFF);

	pxa2xx_transceiver_mode(dev, mode);

}

#endif
@@ -679,12 +669,17 @@ static void __init spitz_init(void) 
/*

 * Akita IO Expander

 */

struct platform_device akitaioexp_device = {

	.name		= "akita-ioexp",

	.id		= -1,

static struct pca953x_platform_data akita_ioexp = {

	.gpio_base		= AKITA_IOEXP_GPIO_BASE,

};



EXPORT_SYMBOL_GPL(akitaioexp_device);

static struct i2c_board_info akita_i2c_board_info[] = {

	{

		.type		= "max7310",

		.addr		= 0x18,

		.platform_data	= &akita_ioexp,

	},

};



static void __init akita_init(void)

{
@@ -694,9 +689,9 @@ static void __init akita_init(void) 
	spitz_pcmcia_config.num_devs = 1;

	platform_scoop_config = &spitz_pcmcia_config;



	platform_device_register(&akitaioexp_device);

	pxa_set_i2c_info(NULL);

	i2c_register_board_info(0, ARRAY_AND_SIZE(akita_i2c_board_info));



	spitzscoop_device.dev.parent = &akitaioexp_device.dev;

	common_init();

}

#endif