/* -*- 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; } /** * 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);