drivers/mca/mca-legacy.c

/* -*- mode: c; c-basic-offset: 8 -*- */

/*
 * MCA bus support functions for legacy (2.4) API.
 *
 * Legacy API means the API that operates in terms of MCA slot number
 *
 * (C) 2002 James Bottomley <James.Bottomley@HansenPartnership.com>
 *
**-----------------------------------------------------------------------------
**  
**  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.
**
**-----------------------------------------------------------------------------
 */

#include <linux/module.h>
#include <linux/device.h>
#include <linux/mca-legacy.h>
#include <asm/io.h>

/* NOTE: This structure is stack allocated */
struct mca_find_adapter_info {
	int			id;
	int			slot;
	struct mca_device	*mca_dev;
};

/* The purpose of this iterator is to loop over all the devices and
 * find the one with the smallest slot number that's just greater than
 * or equal to the required slot with a matching id */
static int mca_find_adapter_callback(struct device *dev, void *data)
{
	struct mca_find_adapter_info *info = data;
	struct mca_device *mca_dev = to_mca_device(dev);

	if(mca_dev->pos_id != info->id)
		return 0;

	if(mca_dev->slot < info->slot)
		return 0;

	if(!info->mca_dev || info->mca_dev->slot >= mca_dev->slot)
		info->mca_dev = mca_dev;

	return 0;
}

/**
 *	mca_find_adapter - scan for adapters
 *	@id:	MCA identification to search for
 *	@start:	starting slot
 *
 *	Search the MCA configuration for adapters matching the 16bit
 *	ID given. The first time it should be called with start as zero
 *	and then further calls made passing the return value of the
 *	previous call until %MCA_NOTFOUND is returned.
 *
 *	Disabled adapters are not reported.
 */

int mca_find_adapter(int id, int start)
{
	struct mca_find_adapter_info info;

	if(id == 0xffff)
		return MCA_NOTFOUND;

	info.slot = start;
	info.id = id;
	info.mca_dev = NULL;

	for(;;) {
		bus_for_each_dev(&mca_bus_type, NULL, &info, mca_find_adapter_callback);

		if(info.mca_dev == NULL)
			return MCA_NOTFOUND;

		if(info.mca_dev->status != MCA_ADAPTER_DISABLED)
			break;

		/* OK, found adapter but it was disabled.  Go around
		 * again, excluding the slot we just found */

		info.slot = info.mca_dev->slot + 1;
		info.mca_dev = NULL;
	}
		
	return info.mca_dev->slot;
}
EXPORT_SYMBOL(mca_find_adapter);

/*--------------------------------------------------------------------*/

/**
 *	mca_find_unused_adapter - scan for unused adapters
 *	@id:	MCA identification to search for
 *	@start:	starting slot
 *
 *	Search the MCA configuration for adapters matching the 16bit
 *	ID given. The first time it should be called with start as zero
 *	and then further calls made passing the return value of the
 *	previous call until %MCA_NOTFOUND is returned.
 *
 *	Adapters that have been claimed by drivers and those that
 *	are disabled are not reported. This function thus allows a driver
 *	to scan for further cards when some may already be driven.
 */

int mca_find_unused_adapter(int id, int start)
{
	struct mca_find_adapter_info info = { 0 };

	if (!MCA_bus || id == 0xffff)
		return MCA_NOTFOUND;

	info.slot = start;
	info.id = id;
	info.mca_dev = NULL;

	for(;;) {
		bus_for_each_dev(&mca_bus_type, NULL, &info, mca_find_adapter_callback);

		if(info.mca_dev == NULL)
			return MCA_NOTFOUND;

		if(info.mca_dev->status != MCA_ADAPTER_DISABLED
		   && !info.mca_dev->driver_loaded)
			break;

		/* OK, found adapter but it was disabled or already in
		 * use.  Go around again, excluding the slot we just
		 * found */

		info.slot = info.mca_dev->slot + 1;
		info.mca_dev = NULL;
	}
		
	return info.mca_dev->slot;
}
EXPORT_SYMBOL(mca_find_unused_adapter);

/* NOTE: stack allocated structure */
struct mca_find_device_by_slot_info {
	int			slot;
	struct mca_device 	*mca_dev;
};

static int mca_find_device_by_slot_callback(struct device *dev, void *data)
{
	struct mca_find_device_by_slot_info *info = data;
	struct mca_device *mca_dev = to_mca_device(dev);

	if(mca_dev->slot == info->slot)
		info->mca_dev = mca_dev;

	return 0;
}

struct mca_device *mca_find_device_by_slot(int slot)
{
	struct mca_find_device_by_slot_info info;

	info.slot = slot;
	info.mca_dev = NULL;

	bus_for_each_dev(&mca_bus_type, NULL, &info, mca_find_device_by_slot_callback);

	return info.mca_dev;
}
EXPORT_SYMBOL(mca_find_device_by_slot);

/**
 *	mca_read_stored_pos - read POS register from boot data
 *	@slot: slot number to read from
 *	@reg:  register to read from
 *
 *	Fetch a POS value that was stored at boot time by the kernel
 *	when it scanned the MCA space. The register value is returned.
 *	Missing or invalid registers report 0.
 */
unsigned char mca_read_stored_pos(int slot, int reg)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		return 0;

	return mca_device_read_stored_pos(mca_dev, reg);
}
EXPORT_SYMBOL(mca_read_stored_pos);


/**
 *	mca_read_pos - read POS register from card
 *	@slot: slot number to read from
 *	@reg:  register to read from
 *
 *	Fetch a POS value directly from the hardware to obtain the
 *	current value. This is much slower than mca_read_stored_pos and
 *	may not be invoked from interrupt context. It handles the
 *	deep magic required for onboard devices transparently.
 */

unsigned char mca_read_pos(int slot, int reg)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		return 0;

	return mca_device_read_pos(mca_dev, reg);
}
EXPORT_SYMBOL(mca_read_pos);

		
/**
 *	mca_write_pos - read POS register from card
 *	@slot: slot number to read from
 *	@reg:  register to read from
 *	@byte: byte to write to the POS registers
 *
 *	Store a POS value directly from the hardware. You should not
 *	normally need to use this function and should have a very good
 *	knowledge of MCA bus before you do so. Doing this wrongly can
 *	damage the hardware.
 *
 *	This function may not be used from interrupt context.
 *
 *	Note that this a technically a Bad Thing, as IBM tech stuff says
 *	you should only set POS values through their utilities.
 *	However, some devices such as the 3c523 recommend that you write
 *	back some data to make sure the configuration is consistent.
 *	I'd say that IBM is right, but I like my drivers to work.
 *
 *	This function can't do checks to see if multiple devices end up
 *	with the same resources, so you might see magic smoke if someone
 *	screws up.
 */

void mca_write_pos(int slot, int reg, unsigned char byte)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		return;

	mca_device_write_pos(mca_dev, reg, byte);
}
EXPORT_SYMBOL(mca_write_pos);

/**
 *	mca_set_adapter_name - Set the description of the card
 *	@slot: slot to name
 *	@name: text string for the namen
 *
 *	This function sets the name reported via /proc for this
 *	adapter slot. This is for user information only. Setting a
 *	name deletes any previous name.
 */

void mca_set_adapter_name(int slot, char* name)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		return;

	mca_device_set_name(mca_dev, name);
}
EXPORT_SYMBOL(mca_set_adapter_name);

/**
 *	mca_is_adapter_used - check if claimed by driver
 *	@slot:	slot to check
 *
 *	Returns 1 if the slot has been claimed by a driver
 */

int mca_is_adapter_used(int slot)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		return 0;

	return mca_device_claimed(mca_dev);
}
EXPORT_SYMBOL(mca_is_adapter_used);

/**
 *	mca_mark_as_used - claim an MCA device
 *	@slot:	slot to claim
 *	FIXME:  should we make this threadsafe
 *
 *	Claim an MCA slot for a device driver. If the
 *	slot is already taken the function returns 1,
 *	if it is not taken it is claimed and 0 is
 *	returned.
 */

int mca_mark_as_used(int slot)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		/* FIXME: this is actually a severe error */
		return 1;

	if(mca_device_claimed(mca_dev))
		return 1;

	mca_device_set_claim(mca_dev, 1);

	return 0;
}
EXPORT_SYMBOL(mca_mark_as_used);

/**
 *	mca_mark_as_unused - release an MCA device
 *	@slot:	slot to claim
 *
 *	Release the slot for other drives to use.
 */

void mca_mark_as_unused(int slot)
{
	struct mca_device *mca_dev = mca_find_device_by_slot(slot);

	if(!mca_dev)
		return;

	mca_device_set_claim(mca_dev, 0);
}
EXPORT_SYMBOL(mca_mark_as_unused);

1	/* -- mode: c; c-basic-offset: 8 -- */
2
3	/*
4	* MCA bus support functions for legacy (2.4) API.
5	*
6	* Legacy API means the API that operates in terms of MCA slot number
7	*
8	* (C) 2002 James Bottomley <James.Bottomley@HansenPartnership.com>
9	*
10	**-----------------------------------------------------------------------------
11	**
12	** This program is free software; you can redistribute it and/or modify
13	** it under the terms of the GNU General Public License as published by
14	** the Free Software Foundation; either version 2 of the License, or
15	** (at your option) any later version.
16	**
17	** This program is distributed in the hope that it will be useful,
18	** but WITHOUT ANY WARRANTY; without even the implied warranty of
19	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	** GNU General Public License for more details.
21	**
22	** You should have received a copy of the GNU General Public License
23	** along with this program; if not, write to the Free Software
24	** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25	**
26	**-----------------------------------------------------------------------------
27	*/
28
29	#include <linux/module.h>
30	#include <linux/device.h>
31	#include <linux/mca-legacy.h>
32	#include <asm/io.h>
33
34	/* NOTE: This structure is stack allocated */
35	struct mca_find_adapter_info {
36	int id;
37	int slot;
38	struct mca_device *mca_dev;
39	};
40
41	/* The purpose of this iterator is to loop over all the devices and
42	* find the one with the smallest slot number that's just greater than
43	* or equal to the required slot with a matching id */
44	static int mca_find_adapter_callback(struct device dev, void data)
45	{
46	struct mca_find_adapter_info *info = data;
47	struct mca_device *mca_dev = to_mca_device(dev);
48
49	if(mca_dev->pos_id != info->id)
50	return 0;
51
52	if(mca_dev->slot < info->slot)
53	return 0;
54
55	if(!info->mca_dev \|\| info->mca_dev->slot >= mca_dev->slot)
56	info->mca_dev = mca_dev;
57
58	return 0;
59	}
60
61	/**
62	* mca_find_adapter - scan for adapters
63	* @id: MCA identification to search for
64	* @start: starting slot
65	*
66	* Search the MCA configuration for adapters matching the 16bit
67	* ID given. The first time it should be called with start as zero
68	* and then further calls made passing the return value of the
69	* previous call until %MCA_NOTFOUND is returned.
70	*
71	* Disabled adapters are not reported.
72	*/
73
74	int mca_find_adapter(int id, int start)
75	{
76	struct mca_find_adapter_info info;
77
78	if(id == 0xffff)
79	return MCA_NOTFOUND;
80
81	info.slot = start;
82	info.id = id;
83	info.mca_dev = NULL;
84
85	for(;;) {
86	bus_for_each_dev(&mca_bus_type, NULL, &info, mca_find_adapter_callback);
87
88	if(info.mca_dev == NULL)
89	return MCA_NOTFOUND;
90
91	if(info.mca_dev->status != MCA_ADAPTER_DISABLED)
92	break;
93
94	/* OK, found adapter but it was disabled. Go around
95	* again, excluding the slot we just found */
96
97	info.slot = info.mca_dev->slot + 1;
98	info.mca_dev = NULL;
99	}
100
101	return info.mca_dev->slot;
102	}
103	EXPORT_SYMBOL(mca_find_adapter);
104
105	/--------------------------------------------------------------------/
106
107	/**
108	* mca_find_unused_adapter - scan for unused adapters
109	* @id: MCA identification to search for
110	* @start: starting slot
111	*
112	* Search the MCA configuration for adapters matching the 16bit
113	* ID given. The first time it should be called with start as zero
114	* and then further calls made passing the return value of the
115	* previous call until %MCA_NOTFOUND is returned.
116	*
117	* Adapters that have been claimed by drivers and those that
118	* are disabled are not reported. This function thus allows a driver
119	* to scan for further cards when some may already be driven.
120	*/
121
122	int mca_find_unused_adapter(int id, int start)
123	{
124	struct mca_find_adapter_info info = { 0 };
125
126	if (!MCA_bus \|\| id == 0xffff)
127	return MCA_NOTFOUND;
128
129	info.slot = start;
130	info.id = id;
131	info.mca_dev = NULL;
132
133	for(;;) {
134	bus_for_each_dev(&mca_bus_type, NULL, &info, mca_find_adapter_callback);
135
136	if(info.mca_dev == NULL)
137	return MCA_NOTFOUND;
138
139	if(info.mca_dev->status != MCA_ADAPTER_DISABLED
140	&& !info.mca_dev->driver_loaded)
141	break;
142
143	/* OK, found adapter but it was disabled or already in
144	* use. Go around again, excluding the slot we just
145	* found */
146
147	info.slot = info.mca_dev->slot + 1;
148	info.mca_dev = NULL;
149	}
150
151	return info.mca_dev->slot;
152	}
153	EXPORT_SYMBOL(mca_find_unused_adapter);
154
155	/* NOTE: stack allocated structure */
156	struct mca_find_device_by_slot_info {
157	int slot;
158	struct mca_device *mca_dev;
159	};
160
161	static int mca_find_device_by_slot_callback(struct device dev, void data)
162	{
163	struct mca_find_device_by_slot_info *info = data;
164	struct mca_device *mca_dev = to_mca_device(dev);
165
166	if(mca_dev->slot == info->slot)
167	info->mca_dev = mca_dev;
168
169	return 0;
170	}
171
172	struct mca_device *mca_find_device_by_slot(int slot)
173	{
174	struct mca_find_device_by_slot_info info;
175
176	info.slot = slot;
177	info.mca_dev = NULL;
178
179	bus_for_each_dev(&mca_bus_type, NULL, &info, mca_find_device_by_slot_callback);
180
181	return info.mca_dev;
182	}
183	EXPORT_SYMBOL(mca_find_device_by_slot);
184
185	/**
186	* mca_read_stored_pos - read POS register from boot data
187	* @slot: slot number to read from
188	* @reg: register to read from
189	*
190	* Fetch a POS value that was stored at boot time by the kernel
191	* when it scanned the MCA space. The register value is returned.
192	* Missing or invalid registers report 0.
193	*/
194	unsigned char mca_read_stored_pos(int slot, int reg)
195	{
196	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
197
198	if(!mca_dev)
199	return 0;
200
201	return mca_device_read_stored_pos(mca_dev, reg);
202	}
203	EXPORT_SYMBOL(mca_read_stored_pos);
204
205
206	/**
207	* mca_read_pos - read POS register from card
208	* @slot: slot number to read from
209	* @reg: register to read from
210	*
211	* Fetch a POS value directly from the hardware to obtain the
212	* current value. This is much slower than mca_read_stored_pos and
213	* may not be invoked from interrupt context. It handles the
214	* deep magic required for onboard devices transparently.
215	*/
216
217	unsigned char mca_read_pos(int slot, int reg)
218	{
219	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
220
221	if(!mca_dev)
222	return 0;
223
224	return mca_device_read_pos(mca_dev, reg);
225	}
226	EXPORT_SYMBOL(mca_read_pos);
227
228
229	/**
230	* mca_write_pos - read POS register from card
231	* @slot: slot number to read from
232	* @reg: register to read from
233	* @byte: byte to write to the POS registers
234	*
235	* Store a POS value directly from the hardware. You should not
236	* normally need to use this function and should have a very good
237	* knowledge of MCA bus before you do so. Doing this wrongly can
238	* damage the hardware.
239	*
240	* This function may not be used from interrupt context.
241	*
242	* Note that this a technically a Bad Thing, as IBM tech stuff says
243	* you should only set POS values through their utilities.
244	* However, some devices such as the 3c523 recommend that you write
245	* back some data to make sure the configuration is consistent.
246	* I'd say that IBM is right, but I like my drivers to work.
247	*
248	* This function can't do checks to see if multiple devices end up
249	* with the same resources, so you might see magic smoke if someone
250	* screws up.
251	*/
252
253	void mca_write_pos(int slot, int reg, unsigned char byte)
254	{
255	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
256
257	if(!mca_dev)
258	return;
259
260	mca_device_write_pos(mca_dev, reg, byte);
261	}
262	EXPORT_SYMBOL(mca_write_pos);
263
264	/**
265	* mca_set_adapter_name - Set the description of the card
266	* @slot: slot to name
267	* @name: text string for the namen
268	*
269	* This function sets the name reported via /proc for this
270	* adapter slot. This is for user information only. Setting a
271	* name deletes any previous name.
272	*/
273
274	void mca_set_adapter_name(int slot, char* name)
275	{
276	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
277
278	if(!mca_dev)
279	return;
280
281	mca_device_set_name(mca_dev, name);
282	}
283	EXPORT_SYMBOL(mca_set_adapter_name);
284
285	/**
286	* mca_is_adapter_used - check if claimed by driver
287	* @slot: slot to check
288	*
289	* Returns 1 if the slot has been claimed by a driver
290	*/
291
292	int mca_is_adapter_used(int slot)
293	{
294	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
295
296	if(!mca_dev)
297	return 0;
298
299	return mca_device_claimed(mca_dev);
300	}
301	EXPORT_SYMBOL(mca_is_adapter_used);
302
303	/**
304	* mca_mark_as_used - claim an MCA device
305	* @slot: slot to claim
306	* FIXME: should we make this threadsafe
307	*
308	* Claim an MCA slot for a device driver. If the
309	* slot is already taken the function returns 1,
310	* if it is not taken it is claimed and 0 is
311	* returned.
312	*/
313
314	int mca_mark_as_used(int slot)
315	{
316	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
317
318	if(!mca_dev)
319	/* FIXME: this is actually a severe error */
320	return 1;
321
322	if(mca_device_claimed(mca_dev))
323	return 1;
324
325	mca_device_set_claim(mca_dev, 1);
326
327	return 0;
328	}
329	EXPORT_SYMBOL(mca_mark_as_used);
330
331	/**
332	* mca_mark_as_unused - release an MCA device
333	* @slot: slot to claim
334	*
335	* Release the slot for other drives to use.
336	*/
337
338	void mca_mark_as_unused(int slot)
339	{
340	struct mca_device *mca_dev = mca_find_device_by_slot(slot);
341
342	if(!mca_dev)
343	return;
344
345	mca_device_set_claim(mca_dev, 0);
346	}
347	EXPORT_SYMBOL(mca_mark_as_unused);
348