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
184 /**
185 * mca_read_stored_pos - read POS register from boot data
186 * @slot: slot number to read from
187 * @reg: register to read from
188 *
189 * Fetch a POS value that was stored at boot time by the kernel
190 * when it scanned the MCA space. The register value is returned.
191 * Missing or invalid registers report 0.
192 */
193 unsigned char mca_read_stored_pos(int slot, int reg)
194 {
195 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
196
197 if(!mca_dev)
198 return 0;
199
200 return mca_device_read_stored_pos(mca_dev, reg);
201 }
202 EXPORT_SYMBOL(mca_read_stored_pos);
203
204
205 /**
206 * mca_read_pos - read POS register from card
207 * @slot: slot number to read from
208 * @reg: register to read from
209 *
210 * Fetch a POS value directly from the hardware to obtain the
211 * current value. This is much slower than mca_read_stored_pos and
212 * may not be invoked from interrupt context. It handles the
213 * deep magic required for onboard devices transparently.
214 */
215
216 unsigned char mca_read_pos(int slot, int reg)
217 {
218 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
219
220 if(!mca_dev)
221 return 0;
222
223 return mca_device_read_pos(mca_dev, reg);
224 }
225 EXPORT_SYMBOL(mca_read_pos);
226
227
228 /**
229 * mca_write_pos - read POS register from card
230 * @slot: slot number to read from
231 * @reg: register to read from
232 * @byte: byte to write to the POS registers
233 *
234 * Store a POS value directly from the hardware. You should not
235 * normally need to use this function and should have a very good
236 * knowledge of MCA bus before you do so. Doing this wrongly can
237 * damage the hardware.
238 *
239 * This function may not be used from interrupt context.
240 *
241 * Note that this a technically a Bad Thing, as IBM tech stuff says
242 * you should only set POS values through their utilities.
243 * However, some devices such as the 3c523 recommend that you write
244 * back some data to make sure the configuration is consistent.
245 * I'd say that IBM is right, but I like my drivers to work.
246 *
247 * This function can't do checks to see if multiple devices end up
248 * with the same resources, so you might see magic smoke if someone
249 * screws up.
250 */
251
252 void mca_write_pos(int slot, int reg, unsigned char byte)
253 {
254 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
255
256 if(!mca_dev)
257 return;
258
259 mca_device_write_pos(mca_dev, reg, byte);
260 }
261 EXPORT_SYMBOL(mca_write_pos);
262
263 /**
264 * mca_set_adapter_name - Set the description of the card
265 * @slot: slot to name
266 * @name: text string for the namen
267 *
268 * This function sets the name reported via /proc for this
269 * adapter slot. This is for user information only. Setting a
270 * name deletes any previous name.
271 */
272
273 void mca_set_adapter_name(int slot, char* name)
274 {
275 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
276
277 if(!mca_dev)
278 return;
279
280 mca_device_set_name(mca_dev, name);
281 }
282 EXPORT_SYMBOL(mca_set_adapter_name);
283
284 /**
285 * mca_is_adapter_used - check if claimed by driver
286 * @slot: slot to check
287 *
288 * Returns 1 if the slot has been claimed by a driver
289 */
290
291 int mca_is_adapter_used(int slot)
292 {
293 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
294
295 if(!mca_dev)
296 return 0;
297
298 return mca_device_claimed(mca_dev);
299 }
300 EXPORT_SYMBOL(mca_is_adapter_used);
301
302 /**
303 * mca_mark_as_used - claim an MCA device
304 * @slot: slot to claim
305 * FIXME: should we make this threadsafe
306 *
307 * Claim an MCA slot for a device driver. If the
308 * slot is already taken the function returns 1,
309 * if it is not taken it is claimed and 0 is
310 * returned.
311 */
312
313 int mca_mark_as_used(int slot)
314 {
315 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
316
317 if(!mca_dev)
318 /* FIXME: this is actually a severe error */
319 return 1;
320
321 if(mca_device_claimed(mca_dev))
322 return 1;
323
324 mca_device_set_claim(mca_dev, 1);
325
326 return 0;
327 }
328 EXPORT_SYMBOL(mca_mark_as_used);
329
330 /**
331 * mca_mark_as_unused - release an MCA device
332 * @slot: slot to claim
333 *
334 * Release the slot for other drives to use.
335 */
336
337 void mca_mark_as_unused(int slot)
338 {
339 struct mca_device *mca_dev = mca_find_device_by_slot(slot);
340
341 if(!mca_dev)
342 return;
343
344 mca_device_set_claim(mca_dev, 0);
345 }
346 EXPORT_SYMBOL(mca_mark_as_unused);
347
348
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.