[linux-2.6-block.git] / drivers / gpio / gpio-sch311x.c

/*
 * GPIO driver for the SMSC SCH311x Super-I/O chips
 *
 * Copyright (C) 2013 Bruno Randolf <br1@einfach.org>
 *
 * SuperIO functions and chip detection:
 * (c) Copyright 2008 Wim Van Sebroeck <wim@iguana.be>.
 *
 * 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.
 */

#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/bitops.h>
#include <linux/io.h>

#define DRV_NAME			"gpio-sch311x"

#define SCH311X_GPIO_CONF_OUT		0x00
#define SCH311X_GPIO_CONF_IN		0x01
#define SCH311X_GPIO_CONF_INVERT	0x02
#define SCH311X_GPIO_CONF_OPEN_DRAIN	0x80

#define SIO_CONFIG_KEY_ENTER		0x55
#define SIO_CONFIG_KEY_EXIT		0xaa

#define GP1				0x4b

static int sch311x_ioports[] = { 0x2e, 0x4e, 0x162e, 0x164e };

static struct platform_device *sch311x_gpio_pdev;

struct sch311x_pdev_data {		/* platform device data */
	unsigned short runtime_reg;	/* runtime register base address */
};

struct sch311x_gpio_block {		/* one GPIO block runtime data */
	struct gpio_chip chip;
	unsigned short data_reg;	/* from definition below */
	unsigned short *config_regs;	/* pointer to definition below */
	unsigned short runtime_reg;	/* runtime register */
	spinlock_t lock;		/* lock for this GPIO block */
};

struct sch311x_gpio_priv {		/* driver private data */
	struct sch311x_gpio_block blocks[6];
};

struct sch311x_gpio_block_def {		/* register address definitions */
	unsigned short data_reg;
	unsigned short config_regs[8];
	unsigned short base;
};

/* Note: some GPIOs are not available, these are marked with 0x00 */

static struct sch311x_gpio_block_def sch311x_gpio_blocks[] = {
	{
		.data_reg = 0x4b,	/* GP1 */
		.config_regs = {0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2a, 0x2b},
		.base = 10,
	},
	{
		.data_reg = 0x4c,	/* GP2 */
		.config_regs = {0x00, 0x2c, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x32},
		.base = 20,
	},
	{
		.data_reg = 0x4d,	/* GP3 */
		.config_regs = {0x33, 0x34, 0x35, 0x36, 0x37, 0x00, 0x39, 0x3a},
		.base = 30,
	},
	{
		.data_reg = 0x4e,	/* GP4 */
		.config_regs = {0x3b, 0x00, 0x3d, 0x00, 0x6e, 0x6f, 0x72, 0x73},
		.base = 40,
	},
	{
		.data_reg = 0x4f,	/* GP5 */
		.config_regs = {0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46},
		.base = 50,
	},
	{
		.data_reg = 0x50,	/* GP6 */
		.config_regs = {0x47, 0x48, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59},
		.base = 60,
	},
};

/*
 *	Super-IO functions
 */

static inline int sch311x_sio_enter(int sio_config_port)
{
	/* Don't step on other drivers' I/O space by accident. */
	if (!request_muxed_region(sio_config_port, 2, DRV_NAME)) {
		pr_err(DRV_NAME "I/O address 0x%04x already in use\n",
		       sio_config_port);
		return -EBUSY;
	}

	outb(SIO_CONFIG_KEY_ENTER, sio_config_port);
	return 0;
}

static inline void sch311x_sio_exit(int sio_config_port)
{
	outb(SIO_CONFIG_KEY_EXIT, sio_config_port);
	release_region(sio_config_port, 2);
}

static inline int sch311x_sio_inb(int sio_config_port, int reg)
{
	outb(reg, sio_config_port);
	return inb(sio_config_port + 1);
}

static inline void sch311x_sio_outb(int sio_config_port, int reg, int val)
{
	outb(reg, sio_config_port);
	outb(val, sio_config_port + 1);
}


/*
 *	GPIO functions
 */

static int sch311x_gpio_request(struct gpio_chip *chip, unsigned offset)
{
	struct sch311x_gpio_block *block = gpiochip_get_data(chip);

	if (block->config_regs[offset] == 0) /* GPIO is not available */
		return -ENODEV;

	if (!request_region(block->runtime_reg + block->config_regs[offset],
			    1, DRV_NAME)) {
		dev_err(chip->parent, "Failed to request region 0x%04x.\n",
			block->runtime_reg + block->config_regs[offset]);
		return -EBUSY;
	}
	return 0;
}

static void sch311x_gpio_free(struct gpio_chip *chip, unsigned offset)
{
	struct sch311x_gpio_block *block = gpiochip_get_data(chip);

	if (block->config_regs[offset] == 0) /* GPIO is not available */
		return;

	release_region(block->runtime_reg + block->config_regs[offset], 1);
}

static int sch311x_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
	unsigned char data;

	spin_lock(&block->lock);
	data = inb(block->runtime_reg + block->data_reg);
	spin_unlock(&block->lock);

	return !!(data & BIT(offset));
}

static void __sch311x_gpio_set(struct sch311x_gpio_block *block,
			       unsigned offset, int value)
{
	unsigned char data = inb(block->runtime_reg + block->data_reg);
	if (value)
		data |= BIT(offset);
	else
		data &= ~BIT(offset);
	outb(data, block->runtime_reg + block->data_reg);
}

static void sch311x_gpio_set(struct gpio_chip *chip, unsigned offset,
			     int value)
{
	struct sch311x_gpio_block *block = gpiochip_get_data(chip);

	spin_lock(&block->lock);
	 __sch311x_gpio_set(block, offset, value);
	spin_unlock(&block->lock);
}

static int sch311x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
{
	struct sch311x_gpio_block *block = gpiochip_get_data(chip);

	spin_lock(&block->lock);
	outb(SCH311X_GPIO_CONF_IN, block->runtime_reg +
	     block->config_regs[offset]);
	spin_unlock(&block->lock);

	return 0;
}

static int sch311x_gpio_direction_out(struct gpio_chip *chip, unsigned offset,
				      int value)
{
	struct sch311x_gpio_block *block = gpiochip_get_data(chip);

	spin_lock(&block->lock);

	outb(SCH311X_GPIO_CONF_OUT, block->runtime_reg +
	     block->config_regs[offset]);

	__sch311x_gpio_set(block, offset, value);

	spin_unlock(&block->lock);
	return 0;
}

static int sch311x_gpio_probe(struct platform_device *pdev)
{
	struct sch311x_pdev_data *pdata = dev_get_platdata(&pdev->dev);
	struct sch311x_gpio_priv *priv;
	struct sch311x_gpio_block *block;
	int err, i;

	/* we can register all GPIO data registers at once */
	if (!devm_request_region(&pdev->dev, pdata->runtime_reg + GP1, 6,
		DRV_NAME)) {
		dev_err(&pdev->dev, "Failed to request region 0x%04x-0x%04x.\n",
			pdata->runtime_reg + GP1, pdata->runtime_reg + GP1 + 5);
		return -EBUSY;
	}

	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	platform_set_drvdata(pdev, priv);

	for (i = 0; i < ARRAY_SIZE(priv->blocks); i++) {
		block = &priv->blocks[i];

		spin_lock_init(&block->lock);

		block->chip.label = DRV_NAME;
		block->chip.owner = THIS_MODULE;
		block->chip.request = sch311x_gpio_request;
		block->chip.free = sch311x_gpio_free;
		block->chip.direction_input = sch311x_gpio_direction_in;
		block->chip.direction_output = sch311x_gpio_direction_out;
		block->chip.get = sch311x_gpio_get;
		block->chip.set = sch311x_gpio_set;
		block->chip.ngpio = 8;
		block->chip.parent = &pdev->dev;
		block->chip.base = sch311x_gpio_blocks[i].base;
		block->config_regs = sch311x_gpio_blocks[i].config_regs;
		block->data_reg = sch311x_gpio_blocks[i].data_reg;
		block->runtime_reg = pdata->runtime_reg;

		err = gpiochip_add_data(&block->chip, block);
		if (err < 0) {
			dev_err(&pdev->dev,
				"Could not register gpiochip, %d\n", err);
			goto exit_err;
		}
		dev_info(&pdev->dev,
			 "SMSC SCH311x GPIO block %d registered.\n", i);
	}

	return 0;

exit_err:
	/* release already registered chips */
	for (--i; i >= 0; i--)
		gpiochip_remove(&priv->blocks[i].chip);
	return err;
}

static int sch311x_gpio_remove(struct platform_device *pdev)
{
	struct sch311x_gpio_priv *priv = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < ARRAY_SIZE(priv->blocks); i++) {
		gpiochip_remove(&priv->blocks[i].chip);
		dev_info(&pdev->dev,
			 "SMSC SCH311x GPIO block %d unregistered.\n", i);
	}
	return 0;
}

static struct platform_driver sch311x_gpio_driver = {
	.driver.name	= DRV_NAME,
	.driver.owner	= THIS_MODULE,
	.probe		= sch311x_gpio_probe,
	.remove		= sch311x_gpio_remove,
};


/*
 *	Init & exit routines
 */

static int __init sch311x_detect(int sio_config_port, unsigned short *addr)
{
	int err = 0, reg;
	unsigned short base_addr;
	unsigned char dev_id;

	err = sch311x_sio_enter(sio_config_port);
	if (err)
		return err;

	/* Check device ID. */
	reg = sch311x_sio_inb(sio_config_port, 0x20);
	switch (reg) {
	case 0x7c: /* SCH3112 */
		dev_id = 2;
		break;
	case 0x7d: /* SCH3114 */
		dev_id = 4;
		break;
	case 0x7f: /* SCH3116 */
		dev_id = 6;
		break;
	default:
		err = -ENODEV;
		goto exit;
	}

	/* Select logical device A (runtime registers) */
	sch311x_sio_outb(sio_config_port, 0x07, 0x0a);

	/* Check if Logical Device Register is currently active */
	if ((sch311x_sio_inb(sio_config_port, 0x30) & 0x01) == 0)
		pr_info("Seems that LDN 0x0a is not active...\n");

	/* Get the base address of the runtime registers */
	base_addr = (sch311x_sio_inb(sio_config_port, 0x60) << 8) |
			   sch311x_sio_inb(sio_config_port, 0x61);
	if (!base_addr) {
		pr_err("Base address not set\n");
		err = -ENODEV;
		goto exit;
	}
	*addr = base_addr;

	pr_info("Found an SMSC SCH311%d chip at 0x%04x\n", dev_id, base_addr);

exit:
	sch311x_sio_exit(sio_config_port);
	return err;
}

static int __init sch311x_gpio_pdev_add(const unsigned short addr)
{
	struct sch311x_pdev_data pdata;
	int err;

	pdata.runtime_reg = addr;

	sch311x_gpio_pdev = platform_device_alloc(DRV_NAME, -1);
	if (!sch311x_gpio_pdev)
		return -ENOMEM;

	err = platform_device_add_data(sch311x_gpio_pdev,
				       &pdata, sizeof(pdata));
	if (err) {
		pr_err(DRV_NAME "Platform data allocation failed\n");
		goto err;
	}

	err = platform_device_add(sch311x_gpio_pdev);
	if (err) {
		pr_err(DRV_NAME "Device addition failed\n");
		goto err;
	}
	return 0;

err:
	platform_device_put(sch311x_gpio_pdev);
	return err;
}

static int __init sch311x_gpio_init(void)
{
	int err, i;
	unsigned short addr = 0;

	for (i = 0; i < ARRAY_SIZE(sch311x_ioports); i++)
		if (sch311x_detect(sch311x_ioports[i], &addr) == 0)
			break;

	if (!addr)
		return -ENODEV;

	err = platform_driver_register(&sch311x_gpio_driver);
	if (err)
		return err;

	err = sch311x_gpio_pdev_add(addr);
	if (err)
		goto unreg_platform_driver;

	return 0;

unreg_platform_driver:
	platform_driver_unregister(&sch311x_gpio_driver);
	return err;
}

static void __exit sch311x_gpio_exit(void)
{
	platform_device_unregister(sch311x_gpio_pdev);
	platform_driver_unregister(&sch311x_gpio_driver);
}

module_init(sch311x_gpio_init);
module_exit(sch311x_gpio_exit);

MODULE_AUTHOR("Bruno Randolf <br1@einfach.org>");
MODULE_DESCRIPTION("SMSC SCH311x GPIO Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:gpio-sch311x");
Commit	Line	Data
12262bef BR	1	/*
	2	* GPIO driver for the SMSC SCH311x Super-I/O chips
	3	*
	4	* Copyright (C) 2013 Bruno Randolf <br1@einfach.org>
	5	*
	6	* SuperIO functions and chip detection:
	7	* (c) Copyright 2008 Wim Van Sebroeck <wim@iguana.be>.
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*/
	14
13441457	15	#include <linux/ioport.h>
12262bef BR	16	#include <linux/module.h>
	17	#include <linux/kernel.h>
	18	#include <linux/init.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/gpio.h>
	21	#include <linux/bitops.h>
523639e6	22	#include <linux/io.h>
12262bef BR	23
	24	#define DRV_NAME "gpio-sch311x"
	25
	26	#define SCH311X_GPIO_CONF_OUT 0x00
	27	#define SCH311X_GPIO_CONF_IN 0x01
	28	#define SCH311X_GPIO_CONF_INVERT 0x02
	29	#define SCH311X_GPIO_CONF_OPEN_DRAIN 0x80
	30
	31	#define SIO_CONFIG_KEY_ENTER 0x55
	32	#define SIO_CONFIG_KEY_EXIT 0xaa
	33
	34	#define GP1 0x4b
	35
	36	static int sch311x_ioports[] = { 0x2e, 0x4e, 0x162e, 0x164e };
	37
	38	static struct platform_device *sch311x_gpio_pdev;
	39
	40	struct sch311x_pdev_data { /* platform device data */
	41	unsigned short runtime_reg; /* runtime register base address */
	42	};
	43
	44	struct sch311x_gpio_block { /* one GPIO block runtime data */
	45	struct gpio_chip chip;
	46	unsigned short data_reg; /* from definition below */
	47	unsigned short config_regs; / pointer to definition below */
	48	unsigned short runtime_reg; /* runtime register */
	49	spinlock_t lock; /* lock for this GPIO block */
	50	};
	51
	52	struct sch311x_gpio_priv { /* driver private data */
	53	struct sch311x_gpio_block blocks[6];
	54	};
	55
	56	struct sch311x_gpio_block_def { /* register address definitions */
	57	unsigned short data_reg;
	58	unsigned short config_regs[8];
	59	unsigned short base;
	60	};
	61
	62	/* Note: some GPIOs are not available, these are marked with 0x00 */
	63
	64	static struct sch311x_gpio_block_def sch311x_gpio_blocks[] = {
	65	{
	66	.data_reg = 0x4b, /* GP1 */
	67	.config_regs = {0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2a, 0x2b},
	68	.base = 10,
	69	},
	70	{
	71	.data_reg = 0x4c, /* GP2 */
	72	.config_regs = {0x00, 0x2c, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x32},
	73	.base = 20,
	74	},
	75	{
	76	.data_reg = 0x4d, /* GP3 */
	77	.config_regs = {0x33, 0x34, 0x35, 0x36, 0x37, 0x00, 0x39, 0x3a},
	78	.base = 30,
	79	},
	80	{
	81	.data_reg = 0x4e, /* GP4 */
	82	.config_regs = {0x3b, 0x00, 0x3d, 0x00, 0x6e, 0x6f, 0x72, 0x73},
	83	.base = 40,
	84	},
	85	{
	86	.data_reg = 0x4f, /* GP5 */
87	.config_regs = {0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46},
88	.base = 50,
89	},
90	{
91	.data_reg = 0x50, /* GP6 */
92	.config_regs = {0x47, 0x48, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59},
93	.base = 60,
94	},
95	};
96
12262bef BR	97	/*
	98	* Super-IO functions
	99	*/
	100
	101	static inline int sch311x_sio_enter(int sio_config_port)
	102	{
	103	/* Don't step on other drivers' I/O space by accident. */
	104	if (!request_muxed_region(sio_config_port, 2, DRV_NAME)) {
	105	pr_err(DRV_NAME "I/O address 0x%04x already in use\n",
	106	sio_config_port);
	107	return -EBUSY;
	108	}
	109
	110	outb(SIO_CONFIG_KEY_ENTER, sio_config_port);
	111	return 0;
	112	}
	113
	114	static inline void sch311x_sio_exit(int sio_config_port)
	115	{
	116	outb(SIO_CONFIG_KEY_EXIT, sio_config_port);
	117	release_region(sio_config_port, 2);
	118	}
	119
	120	static inline int sch311x_sio_inb(int sio_config_port, int reg)
	121	{
	122	outb(reg, sio_config_port);
	123	return inb(sio_config_port + 1);
	124	}
	125
	126	static inline void sch311x_sio_outb(int sio_config_port, int reg, int val)
	127	{
	128	outb(reg, sio_config_port);
	129	outb(val, sio_config_port + 1);
	130	}
	131
	132
	133	/*
	134	* GPIO functions
	135	*/
	136
	137	static int sch311x_gpio_request(struct gpio_chip *chip, unsigned offset)
	138	{
8ca7f1fa	139	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
12262bef BR	140
	141	if (block->config_regs[offset] == 0) /* GPIO is not available */
	142	return -ENODEV;
	143
	144	if (!request_region(block->runtime_reg + block->config_regs[offset],
	145	1, DRV_NAME)) {
58383c78	146	dev_err(chip->parent, "Failed to request region 0x%04x.\n",
12262bef BR	147	block->runtime_reg + block->config_regs[offset]);
	148	return -EBUSY;
	149	}
	150	return 0;
	151	}
	152
	153	static void sch311x_gpio_free(struct gpio_chip *chip, unsigned offset)
	154	{
8ca7f1fa	155	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
12262bef BR	156
	157	if (block->config_regs[offset] == 0) /* GPIO is not available */
	158	return;
	159
	160	release_region(block->runtime_reg + block->config_regs[offset], 1);
	161	}
	162
	163	static int sch311x_gpio_get(struct gpio_chip *chip, unsigned offset)
	164	{
8ca7f1fa	165	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
12262bef BR	166	unsigned char data;
	167
	168	spin_lock(&block->lock);
	169	data = inb(block->runtime_reg + block->data_reg);
	170	spin_unlock(&block->lock);
	171
	172	return !!(data & BIT(offset));
	173	}
	174
	175	static void __sch311x_gpio_set(struct sch311x_gpio_block *block,
	176	unsigned offset, int value)
	177	{
	178	unsigned char data = inb(block->runtime_reg + block->data_reg);
	179	if (value)
	180	data \|= BIT(offset);
	181	else
	182	data &= ~BIT(offset);
	183	outb(data, block->runtime_reg + block->data_reg);
	184	}
	185
	186	static void sch311x_gpio_set(struct gpio_chip *chip, unsigned offset,
	187	int value)
	188	{
8ca7f1fa	189	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
12262bef BR	190
	191	spin_lock(&block->lock);
	192	__sch311x_gpio_set(block, offset, value);
	193	spin_unlock(&block->lock);
	194	}
	195
	196	static int sch311x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
	197	{
8ca7f1fa	198	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
12262bef BR	199
	200	spin_lock(&block->lock);
	201	outb(SCH311X_GPIO_CONF_IN, block->runtime_reg +
	202	block->config_regs[offset]);
	203	spin_unlock(&block->lock);
	204
	205	return 0;
	206	}
	207
	208	static int sch311x_gpio_direction_out(struct gpio_chip *chip, unsigned offset,
	209	int value)
	210	{
8ca7f1fa	211	struct sch311x_gpio_block *block = gpiochip_get_data(chip);
12262bef BR	212
	213	spin_lock(&block->lock);
	214
	215	outb(SCH311X_GPIO_CONF_OUT, block->runtime_reg +
	216	block->config_regs[offset]);
	217
	218	__sch311x_gpio_set(block, offset, value);
	219
	220	spin_unlock(&block->lock);
	221	return 0;
	222	}
	223
	224	static int sch311x_gpio_probe(struct platform_device *pdev)
	225	{
ab128afc	226	struct sch311x_pdev_data *pdata = dev_get_platdata(&pdev->dev);
12262bef BR	227	struct sch311x_gpio_priv *priv;
	228	struct sch311x_gpio_block *block;
	229	int err, i;
	230
	231	/* we can register all GPIO data registers at once */
13441457 WBG	232	if (!devm_request_region(&pdev->dev, pdata->runtime_reg + GP1, 6,
13441457 WBG	233	DRV_NAME)) {
12262bef BR	234	dev_err(&pdev->dev, "Failed to request region 0x%04x-0x%04x.\n",
	235	pdata->runtime_reg + GP1, pdata->runtime_reg + GP1 + 5);
	236	return -EBUSY;
	237	}
	238
	239	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	240	if (!priv)
	241	return -ENOMEM;
	242
	243	platform_set_drvdata(pdev, priv);
	244
	245	for (i = 0; i < ARRAY_SIZE(priv->blocks); i++) {
	246	block = &priv->blocks[i];
	247
	248	spin_lock_init(&block->lock);
	249
	250	block->chip.label = DRV_NAME;
	251	block->chip.owner = THIS_MODULE;
	252	block->chip.request = sch311x_gpio_request;
	253	block->chip.free = sch311x_gpio_free;
	254	block->chip.direction_input = sch311x_gpio_direction_in;
	255	block->chip.direction_output = sch311x_gpio_direction_out;
	256	block->chip.get = sch311x_gpio_get;
	257	block->chip.set = sch311x_gpio_set;
	258	block->chip.ngpio = 8;
58383c78	259	block->chip.parent = &pdev->dev;
12262bef BR	260	block->chip.base = sch311x_gpio_blocks[i].base;
	261	block->config_regs = sch311x_gpio_blocks[i].config_regs;
	262	block->data_reg = sch311x_gpio_blocks[i].data_reg;
	263	block->runtime_reg = pdata->runtime_reg;
	264
8ca7f1fa	265	err = gpiochip_add_data(&block->chip, block);
12262bef BR	266	if (err < 0) {
	267	dev_err(&pdev->dev,
	268	"Could not register gpiochip, %d\n", err);
	269	goto exit_err;
	270	}
	271	dev_info(&pdev->dev,
	272	"SMSC SCH311x GPIO block %d registered.\n", i);
	273	}
	274
	275	return 0;
	276
	277	exit_err:
12262bef BR	278	/* release already registered chips */
	279	for (--i; i >= 0; i--)
	280	gpiochip_remove(&priv->blocks[i].chip);
	281	return err;
	282	}
	283
	284	static int sch311x_gpio_remove(struct platform_device *pdev)
	285	{
12262bef	286	struct sch311x_gpio_priv *priv = platform_get_drvdata(pdev);
9f5132ae	287	int i;
12262bef	288
12262bef	289	for (i = 0; i < ARRAY_SIZE(priv->blocks); i++) {
9f5132ae	290	gpiochip_remove(&priv->blocks[i].chip);
12262bef BR	291	dev_info(&pdev->dev,
	292	"SMSC SCH311x GPIO block %d unregistered.\n", i);
	293	}
	294	return 0;
	295	}
	296
	297	static struct platform_driver sch311x_gpio_driver = {
	298	.driver.name = DRV_NAME,
	299	.driver.owner = THIS_MODULE,
	300	.probe = sch311x_gpio_probe,
	301	.remove = sch311x_gpio_remove,
	302	};
	303
	304
	305	/*
	306	* Init & exit routines
	307	*/
	308
	309	static int __init sch311x_detect(int sio_config_port, unsigned short *addr)
	310	{
	311	int err = 0, reg;
	312	unsigned short base_addr;
	313	unsigned char dev_id;
	314
	315	err = sch311x_sio_enter(sio_config_port);
	316	if (err)
	317	return err;
	318
7e9fcc9d	319	/* Check device ID. */
12262bef	320	reg = sch311x_sio_inb(sio_config_port, 0x20);
7e9fcc9d AL	321	switch (reg) {
	322	case 0x7c: /* SCH3112 */
	323	dev_id = 2;
	324	break;
	325	case 0x7d: /* SCH3114 */
	326	dev_id = 4;
	327	break;
	328	case 0x7f: /* SCH3116 */
	329	dev_id = 6;
	330	break;
	331	default:
12262bef BR	332	err = -ENODEV;
	333	goto exit;
	334	}
12262bef BR	335
	336	/* Select logical device A (runtime registers) */
	337	sch311x_sio_outb(sio_config_port, 0x07, 0x0a);
	338
	339	/* Check if Logical Device Register is currently active */
	340	if ((sch311x_sio_inb(sio_config_port, 0x30) & 0x01) == 0)
	341	pr_info("Seems that LDN 0x0a is not active...\n");
	342
	343	/* Get the base address of the runtime registers */
	344	base_addr = (sch311x_sio_inb(sio_config_port, 0x60) << 8) \|
	345	sch311x_sio_inb(sio_config_port, 0x61);
	346	if (!base_addr) {
	347	pr_err("Base address not set\n");
	348	err = -ENODEV;
	349	goto exit;
	350	}
	351	*addr = base_addr;
	352
	353	pr_info("Found an SMSC SCH311%d chip at 0x%04x\n", dev_id, base_addr);
	354
	355	exit:
	356	sch311x_sio_exit(sio_config_port);
	357	return err;
	358	}
	359
	360	static int __init sch311x_gpio_pdev_add(const unsigned short addr)
	361	{
	362	struct sch311x_pdev_data pdata;
	363	int err;
	364
	365	pdata.runtime_reg = addr;
	366
	367	sch311x_gpio_pdev = platform_device_alloc(DRV_NAME, -1);
	368	if (!sch311x_gpio_pdev)
	369	return -ENOMEM;
	370
	371	err = platform_device_add_data(sch311x_gpio_pdev,
	372	&pdata, sizeof(pdata));
	373	if (err) {
	374	pr_err(DRV_NAME "Platform data allocation failed\n");
	375	goto err;
	376	}
	377
	378	err = platform_device_add(sch311x_gpio_pdev);
	379	if (err) {
	380	pr_err(DRV_NAME "Device addition failed\n");
	381	goto err;
	382	}
	383	return 0;
	384
	385	err:
	386	platform_device_put(sch311x_gpio_pdev);
	387	return err;
	388	}
	389
	390	static int __init sch311x_gpio_init(void)
	391	{
	392	int err, i;
	393	unsigned short addr = 0;
	394
	395	for (i = 0; i < ARRAY_SIZE(sch311x_ioports); i++)
	396	if (sch311x_detect(sch311x_ioports[i], &addr) == 0)
	397	break;
	398
399	if (!addr)
400	return -ENODEV;
401
402	err = platform_driver_register(&sch311x_gpio_driver);
403	if (err)
404	return err;
405
406	err = sch311x_gpio_pdev_add(addr);
407	if (err)
408	goto unreg_platform_driver;
409
410	return 0;
411
412	unreg_platform_driver:
413	platform_driver_unregister(&sch311x_gpio_driver);
414	return err;
415	}
416
417	static void __exit sch311x_gpio_exit(void)
418	{
419	platform_device_unregister(sch311x_gpio_pdev);
420	platform_driver_unregister(&sch311x_gpio_driver);
421	}
422
423	module_init(sch311x_gpio_init);
424	module_exit(sch311x_gpio_exit);
425
426	MODULE_AUTHOR("Bruno Randolf <br1@einfach.org>");
427	MODULE_DESCRIPTION("SMSC SCH311x GPIO Driver");
428	MODULE_LICENSE("GPL");
429	MODULE_ALIAS("platform:gpio-sch311x");