Logo Search packages:      
Sourcecode: linux version File versions  Download package

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;
}

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


Generated by  Doxygen 1.6.0   Back to index