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

mca-device.c

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

/*
 * MCA device support functions
 *
 * These functions support the ongoing device access API.
 *
 * (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.h>
#include <linux/string.h>

/**
 *    mca_device_read_stored_pos - read POS register from stored data
 *    @mca_dev: device 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_device_read_stored_pos(struct mca_device *mca_dev, int reg)
{
      if(reg < 0 || reg >= 8)
            return 0;

      return mca_dev->pos[reg];
}
EXPORT_SYMBOL(mca_device_read_stored_pos);

/**
 *    mca_device_read_pos - read POS register from card
 *    @mca_dev: device 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_device_read_stored_pos and may not be invoked from
 *    interrupt context. It handles the deep magic required for
 *    onboard devices transparently.
 */
unsigned char mca_device_read_pos(struct mca_device *mca_dev, int reg)
{
      struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);

      return mca_bus->f.mca_read_pos(mca_dev, reg);

      return      mca_dev->pos[reg];
}
EXPORT_SYMBOL(mca_device_read_pos);


/**
 *    mca_device_write_pos - read POS register from card
 *    @mca_dev: device to write pos register to
 *    @reg:  register to write to
 *    @byte: byte to write to the POS registers
 *
 *    Store a POS value directly to 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.
 *
 */
void mca_device_write_pos(struct mca_device *mca_dev, int reg,
                    unsigned char byte)
{
      struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);

      mca_bus->f.mca_write_pos(mca_dev, reg, byte);
}
EXPORT_SYMBOL(mca_device_write_pos);

/**
 *    mca_device_transform_irq - transform the ADF obtained IRQ
 *    @mca_device: device whose irq needs transforming
 *    @irq: input irq from ADF
 *
 *    MCA Adapter Definition Files (ADF) contain irq, ioport, memory
 *    etc. definitions.  In systems with more than one bus, these need
 *    to be transformed through bus mapping functions to get the real
 *    system global quantities.
 *
 *    This function transforms the interrupt number and returns the
 *    transformed system global interrupt
 */
int mca_device_transform_irq(struct mca_device *mca_dev, int irq)
{
      struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);

      return mca_bus->f.mca_transform_irq(mca_dev, irq);
}
EXPORT_SYMBOL(mca_device_transform_irq);

/**
 *    mca_device_transform_ioport - transform the ADF obtained I/O port
 *    @mca_device: device whose port needs transforming
 *    @ioport: input I/O port from ADF
 *
 *    MCA Adapter Definition Files (ADF) contain irq, ioport, memory
 *    etc. definitions.  In systems with more than one bus, these need
 *    to be transformed through bus mapping functions to get the real
 *    system global quantities.
 *
 *    This function transforms the I/O port number and returns the
 *    transformed system global port number.
 *
 *    This transformation can be assumed to be linear for port ranges.
 */
int mca_device_transform_ioport(struct mca_device *mca_dev, int port)
{
      struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);

      return mca_bus->f.mca_transform_ioport(mca_dev, port);
}
EXPORT_SYMBOL(mca_device_transform_ioport);

/**
 *    mca_device_transform_memory - transform the ADF obtained memory
 *    @mca_device: device whose memory region needs transforming
 *    @mem: memory region start from ADF
 *
 *    MCA Adapter Definition Files (ADF) contain irq, ioport, memory
 *    etc. definitions.  In systems with more than one bus, these need
 *    to be transformed through bus mapping functions to get the real
 *    system global quantities.
 *
 *    This function transforms the memory region start and returns the
 *    transformed system global memory region (physical).
 *
 *    This transformation can be assumed to be linear for region ranges.
 */
void *mca_device_transform_memory(struct mca_device *mca_dev, void *mem)
{
      struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);

      return mca_bus->f.mca_transform_memory(mca_dev, mem);
}
EXPORT_SYMBOL(mca_device_transform_memory);


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

int mca_device_claimed(struct mca_device *mca_dev)
{
      return mca_dev->driver_loaded;
}
EXPORT_SYMBOL(mca_device_claimed);

/**
 *    mca_device_set_claim - set the claim value of the driver
 *    @mca_dev:   device to set value for
 *    @val:       claim value to set (1 claimed, 0 unclaimed)
 */
void mca_device_set_claim(struct mca_device *mca_dev, int val)
{
      mca_dev->driver_loaded = val;
}
EXPORT_SYMBOL(mca_device_set_claim);

/**
 *    mca_device_status - get the status of the device
 *    @mca_device:      device to get
 *
 *    returns an enumeration of the device status:
 *
 *    MCA_ADAPTER_NORMAL      adapter is OK.
 *    MCA_ADAPTER_NONE  no adapter at device (should never happen).
 *    MCA_ADAPTER_DISABLED    adapter is disabled.
 *    MCA_ADAPTER_ERROR adapter cannot be initialised.
 */
enum MCA_AdapterStatus mca_device_status(struct mca_device *mca_dev)
{
      return mca_dev->status;
}
EXPORT_SYMBOL(mca_device_status);

/**
 *    mca_device_set_name - set the name of the device
 *    @mca_device:      device to set the name of
 *    @name:            name to set
 */
void mca_device_set_name(struct mca_device *mca_dev, const char *name)
{
      if(!mca_dev)
            return;

      strlcpy(mca_dev->name, name, sizeof(mca_dev->name));
}
EXPORT_SYMBOL(mca_device_set_name);

Generated by  Doxygen 1.6.0   Back to index