[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / zorro / zorro-driver.c

/*
 *  Zorro Driver Services
 *
 *  Copyright (C) 2003 Geert Uytterhoeven
 *
 *  Loosely based on drivers/pci/pci-driver.c
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License.  See the file COPYING in the main directory of this archive
 *  for more details.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/zorro.h>


    /**
     *  zorro_match_device - Tell if a Zorro device structure has a matching
     *                       Zorro device id structure
     *  @ids: array of Zorro device id structures to search in
     *  @dev: the Zorro device structure to match against
     *
     *  Used by a driver to check whether a Zorro device present in the
     *  system is in its list of supported devices. Returns the matching
     *  zorro_device_id structure or %NULL if there is no match.
     */

const struct zorro_device_id *
zorro_match_device(const struct zorro_device_id *ids,
		   const struct zorro_dev *z)
{
	while (ids->id) {
		if (ids->id == ZORRO_WILDCARD || ids->id == z->id)
			return ids;
		ids++;
	}
	return NULL;
}
EXPORT_SYMBOL(zorro_match_device);


static int zorro_device_probe(struct device *dev)
{
	int error = 0;
	struct zorro_driver *drv = to_zorro_driver(dev->driver);
	struct zorro_dev *z = to_zorro_dev(dev);

	if (!z->driver && drv->probe) {
		const struct zorro_device_id *id;

		id = zorro_match_device(drv->id_table, z);
		if (id)
			error = drv->probe(z, id);
		if (error >= 0) {
			z->driver = drv;
			error = 0;
		}
	}
	return error;
}


static int zorro_device_remove(struct device *dev)
{
	struct zorro_dev *z = to_zorro_dev(dev);
	struct zorro_driver *drv = to_zorro_driver(dev->driver);

	if (drv) {
		if (drv->remove)
			drv->remove(z);
		z->driver = NULL;
	}
	return 0;
}


    /**
     *  zorro_register_driver - register a new Zorro driver
     *  @drv: the driver structure to register
     *
     *  Adds the driver structure to the list of registered drivers
     *  Returns zero or a negative error value.
     */

int zorro_register_driver(struct zorro_driver *drv)
{
	/* initialize common driver fields */
	drv->driver.name = drv->name;
	drv->driver.bus = &zorro_bus_type;

	/* register with core */
	return driver_register(&drv->driver);
}
EXPORT_SYMBOL(zorro_register_driver);


    /**
     *  zorro_unregister_driver - unregister a zorro driver
     *  @drv: the driver structure to unregister
     *
     *  Deletes the driver structure from the list of registered Zorro drivers,
     *  gives it a chance to clean up by calling its remove() function for
     *  each device it was responsible for, and marks those devices as
     *  driverless.
     */

void zorro_unregister_driver(struct zorro_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(zorro_unregister_driver);


    /**
     *  zorro_bus_match - Tell if a Zorro device structure has a matching Zorro
     *                    device id structure
     *  @ids: array of Zorro device id structures to search in
     *  @dev: the Zorro device structure to match against
     *
     *  Used by a driver to check whether a Zorro device present in the
     *  system is in its list of supported devices.Returns the matching
     *  zorro_device_id structure or %NULL if there is no match.
     */

static int zorro_bus_match(struct device *dev, struct device_driver *drv)
{
	struct zorro_dev *z = to_zorro_dev(dev);
	struct zorro_driver *zorro_drv = to_zorro_driver(drv);
	const struct zorro_device_id *ids = zorro_drv->id_table;

	if (!ids)
		return 0;

	while (ids->id) {
		if (ids->id == ZORRO_WILDCARD || ids->id == z->id)
			return 1;
		ids++;
	}
	return 0;
}

static int zorro_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct zorro_dev *z;

	if (!dev)
		return -ENODEV;

	z = to_zorro_dev(dev);
	if (!z)
		return -ENODEV;

	if (add_uevent_var(env, "ZORRO_ID=%08X", z->id) ||
	    add_uevent_var(env, "ZORRO_SLOT_NAME=%s", dev_name(dev)) ||
	    add_uevent_var(env, "ZORRO_SLOT_ADDR=%04X", z->slotaddr) ||
	    add_uevent_var(env, "MODALIAS=" ZORRO_DEVICE_MODALIAS_FMT, z->id))
		return -ENOMEM;

	return 0;
}

struct bus_type zorro_bus_type = {
	.name	= "zorro",
	.match	= zorro_bus_match,
	.uevent	= zorro_uevent,
	.probe	= zorro_device_probe,
	.remove	= zorro_device_remove,
};
EXPORT_SYMBOL(zorro_bus_type);


static int __init zorro_driver_init(void)
{
	return bus_register(&zorro_bus_type);
}

postcore_initcall(zorro_driver_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Zorro Driver Services
	3	*
	4	* Copyright (C) 2003 Geert Uytterhoeven
	5	*
	6	* Loosely based on drivers/pci/pci-driver.c
	7	*
	8	* This file is subject to the terms and conditions of the GNU General Public
	9	* License. See the file COPYING in the main directory of this archive
	10	* for more details.
	11	*/
	12
	13	#include <linux/init.h>
	14	#include <linux/module.h>
	15	#include <linux/zorro.h>
	16
	17
	18	/**
	19	* zorro_match_device - Tell if a Zorro device structure has a matching
	20	* Zorro device id structure
	21	* @ids: array of Zorro device id structures to search in
	22	* @dev: the Zorro device structure to match against
	23	*
	24	* Used by a driver to check whether a Zorro device present in the
	25	* system is in its list of supported devices. Returns the matching
	26	* zorro_device_id structure or %NULL if there is no match.
	27	*/
	28
	29	const struct zorro_device_id *
	30	zorro_match_device(const struct zorro_device_id *ids,
	31	const struct zorro_dev *z)
	32	{
	33	while (ids->id) {
	34	if (ids->id == ZORRO_WILDCARD \|\| ids->id == z->id)
	35	return ids;
	36	ids++;
	37	}
	38	return NULL;
	39	}
d996e9dc	40	EXPORT_SYMBOL(zorro_match_device);
1da177e4 LT	41
	42
	43	static int zorro_device_probe(struct device *dev)
	44	{
	45	int error = 0;
	46	struct zorro_driver *drv = to_zorro_driver(dev->driver);
	47	struct zorro_dev *z = to_zorro_dev(dev);
	48
	49	if (!z->driver && drv->probe) {
	50	const struct zorro_device_id *id;
	51
	52	id = zorro_match_device(drv->id_table, z);
	53	if (id)
	54	error = drv->probe(z, id);
	55	if (error >= 0) {
	56	z->driver = drv;
	57	error = 0;
	58	}
	59	}
	60	return error;
	61	}
	62
	63
2f9b0b5e GU	64	static int zorro_device_remove(struct device *dev)
	65	{
	66	struct zorro_dev *z = to_zorro_dev(dev);
	67	struct zorro_driver *drv = to_zorro_driver(dev->driver);
	68
	69	if (drv) {
	70	if (drv->remove)
	71	drv->remove(z);
	72	z->driver = NULL;
	73	}
	74	return 0;
	75	}
	76
	77
1da177e4 LT	78	/**
	79	* zorro_register_driver - register a new Zorro driver
	80	* @drv: the driver structure to register
	81	*
	82	* Adds the driver structure to the list of registered drivers
33d8675e	83	* Returns zero or a negative error value.
1da177e4 LT	84	*/
	85
	86	int zorro_register_driver(struct zorro_driver *drv)
	87	{
1da177e4 LT	88	/* initialize common driver fields */
	89	drv->driver.name = drv->name;
	90	drv->driver.bus = &zorro_bus_type;
1da177e4 LT	91
1da177e4 LT	92	/* register with core */
33d8675e	93	return driver_register(&drv->driver);
1da177e4	94	}
d996e9dc	95	EXPORT_SYMBOL(zorro_register_driver);
1da177e4 LT	96
	97
	98	/**
	99	* zorro_unregister_driver - unregister a zorro driver
	100	* @drv: the driver structure to unregister
	101	*
	102	* Deletes the driver structure from the list of registered Zorro drivers,
	103	* gives it a chance to clean up by calling its remove() function for
	104	* each device it was responsible for, and marks those devices as
	105	* driverless.
	106	*/
	107
	108	void zorro_unregister_driver(struct zorro_driver *drv)
	109	{
	110	driver_unregister(&drv->driver);
	111	}
d996e9dc	112	EXPORT_SYMBOL(zorro_unregister_driver);
1da177e4 LT	113
	114
	115	/**
	116	* zorro_bus_match - Tell if a Zorro device structure has a matching Zorro
	117	* device id structure
	118	* @ids: array of Zorro device id structures to search in
	119	* @dev: the Zorro device structure to match against
	120	*
	121	* Used by a driver to check whether a Zorro device present in the
	122	* system is in its list of supported devices.Returns the matching
	123	* zorro_device_id structure or %NULL if there is no match.
	124	*/
	125
	126	static int zorro_bus_match(struct device dev, struct device_driver drv)
	127	{
	128	struct zorro_dev *z = to_zorro_dev(dev);
	129	struct zorro_driver *zorro_drv = to_zorro_driver(drv);
	130	const struct zorro_device_id *ids = zorro_drv->id_table;
	131
	132	if (!ids)
	133	return 0;
	134
	135	while (ids->id) {
	136	if (ids->id == ZORRO_WILDCARD \|\| ids->id == z->id)
	137	return 1;
	138	ids++;
	139	}
	140	return 0;
	141	}
	142
bf54a2b3 GU	143	static int zorro_uevent(struct device dev, struct kobj_uevent_env env)
bf54a2b3 GU	144	{
bf54a2b3 GU	145	struct zorro_dev *z;
	146
	147	if (!dev)
	148	return -ENODEV;
	149
	150	z = to_zorro_dev(dev);
	151	if (!z)
	152	return -ENODEV;
	153
	154	if (add_uevent_var(env, "ZORRO_ID=%08X", z->id) \|\|
	155	add_uevent_var(env, "ZORRO_SLOT_NAME=%s", dev_name(dev)) \|\|
	156	add_uevent_var(env, "ZORRO_SLOT_ADDR=%04X", z->slotaddr) \|\|
	157	add_uevent_var(env, "MODALIAS=" ZORRO_DEVICE_MODALIAS_FMT, z->id))
	158	return -ENOMEM;
	159
	160	return 0;
bf54a2b3	161	}
1da177e4 LT	162
	163	struct bus_type zorro_bus_type = {
	164	.name = "zorro",
b6a01e9b	165	.match = zorro_bus_match,
bf54a2b3	166	.uevent = zorro_uevent,
b6a01e9b	167	.probe = zorro_device_probe,
2f9b0b5e	168	.remove = zorro_device_remove,
1da177e4	169	};
d996e9dc	170	EXPORT_SYMBOL(zorro_bus_type);
1da177e4 LT	171
	172
	173	static int __init zorro_driver_init(void)
	174	{
	175	return bus_register(&zorro_bus_type);
	176	}
	177
	178	postcore_initcall(zorro_driver_init);
	179