drivers/mca/mca-device.c

   1 /* -*- mode: c; c-basic-offset: 8 -*- */
   2
   3 /*
   4  * MCA device support functions
   5  *
   6  * These functions support the ongoing device access API.
   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.h>
  32 #include <linux/string.h>
  33
  34 /**
  35  *      mca_device_read_stored_pos - read POS register from stored data
  36  *      @mca_dev: device to read from
  37  *      @reg:  register to read from
  38  *
  39  *      Fetch a POS value that was stored at boot time by the kernel
  40  *      when it scanned the MCA space. The register value is returned.
  41  *      Missing or invalid registers report 0.
  42  */
  43 unsigned char mca_device_read_stored_pos(struct mca_device *mca_dev, int reg)
  44 {
  45         if(reg < 0 || reg >= 8)
  46                 return 0;
  47
  48         return mca_dev->pos[reg];
  49 }
  50 EXPORT_SYMBOL(mca_device_read_stored_pos);
  51
  52 /**
  53  *      mca_device_read_pos - read POS register from card
  54  *      @mca_dev: device to read from
  55  *      @reg:  register to read from
  56  *
  57  *      Fetch a POS value directly from the hardware to obtain the
  58  *      current value. This is much slower than
  59  *      mca_device_read_stored_pos and may not be invoked from
  60  *      interrupt context. It handles the deep magic required for
  61  *      onboard devices transparently.
  62  */
  63 unsigned char mca_device_read_pos(struct mca_device *mca_dev, int reg)
  64 {
  65         struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);
  66
  67         return mca_bus->f.mca_read_pos(mca_dev, reg);
  68
  69         return  mca_dev->pos[reg];
  70 }
  71 EXPORT_SYMBOL(mca_device_read_pos);
  72
  73
  74 /**
  75  *      mca_device_write_pos - read POS register from card
  76  *      @mca_dev: device to write pos register to
  77  *      @reg:  register to write to
  78  *      @byte: byte to write to the POS registers
  79  *
  80  *      Store a POS value directly to the hardware. You should not
  81  *      normally need to use this function and should have a very good
  82  *      knowledge of MCA bus before you do so. Doing this wrongly can
  83  *      damage the hardware.
  84  *
  85  *      This function may not be used from interrupt context.
  86  *
  87  */
  88 void mca_device_write_pos(struct mca_device *mca_dev, int reg,
  89                           unsigned char byte)
  90 {
  91         struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);
  92
  93         mca_bus->f.mca_write_pos(mca_dev, reg, byte);
  94 }
  95 EXPORT_SYMBOL(mca_device_write_pos);
  96
  97 /**
  98  *      mca_device_transform_irq - transform the ADF obtained IRQ
  99  *      @mca_device: device whose irq needs transforming
 100  *      @irq: input irq from ADF
 101  *
 102  *      MCA Adapter Definition Files (ADF) contain irq, ioport, memory
 103  *      etc. definitions.  In systems with more than one bus, these need
 104  *      to be transformed through bus mapping functions to get the real
 105  *      system global quantities.
 106  *
 107  *      This function transforms the interrupt number and returns the
 108  *      transformed system global interrupt
 109  */
 110 int mca_device_transform_irq(struct mca_device *mca_dev, int irq)
 111 {
 112         struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);
 113
 114         return mca_bus->f.mca_transform_irq(mca_dev, irq);
 115 }
 116 EXPORT_SYMBOL(mca_device_transform_irq);
 117
 118 /**
 119  *      mca_device_transform_ioport - transform the ADF obtained I/O port
 120  *      @mca_device: device whose port needs transforming
 121  *      @ioport: input I/O port from ADF
 122  *
 123  *      MCA Adapter Definition Files (ADF) contain irq, ioport, memory
 124  *      etc. definitions.  In systems with more than one bus, these need
 125  *      to be transformed through bus mapping functions to get the real
 126  *      system global quantities.
 127  *
 128  *      This function transforms the I/O port number and returns the
 129  *      transformed system global port number.
 130  *
 131  *      This transformation can be assumed to be linear for port ranges.
 132  */
 133 int mca_device_transform_ioport(struct mca_device *mca_dev, int port)
 134 {
 135         struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);
 136
 137         return mca_bus->f.mca_transform_ioport(mca_dev, port);
 138 }
 139 EXPORT_SYMBOL(mca_device_transform_ioport);
 140
 141 /**
 142  *      mca_device_transform_memory - transform the ADF obtained memory
 143  *      @mca_device: device whose memory region needs transforming
 144  *      @mem: memory region start from ADF
 145  *
 146  *      MCA Adapter Definition Files (ADF) contain irq, ioport, memory
 147  *      etc. definitions.  In systems with more than one bus, these need
 148  *      to be transformed through bus mapping functions to get the real
 149  *      system global quantities.
 150  *
 151  *      This function transforms the memory region start and returns the
 152  *      transformed system global memory region (physical).
 153  *
 154  *      This transformation can be assumed to be linear for region ranges.
 155  */
 156 void *mca_device_transform_memory(struct mca_device *mca_dev, void *mem)
 157 {
 158         struct mca_bus *mca_bus = to_mca_bus(mca_dev->dev.parent);
 159
 160         return mca_bus->f.mca_transform_memory(mca_dev, mem);
 161 }
 162 EXPORT_SYMBOL(mca_device_transform_memory);
 163
 164
 165 /**
 166  *      mca_device_claimed - check if claimed by driver
 167  *      @mca_dev:       device to check
 168  *
 169  *      Returns 1 if the slot has been claimed by a driver
 170  */
 171
 172 int mca_device_claimed(struct mca_device *mca_dev)
 173 {
 174         return mca_dev->driver_loaded;
 175 }
 176 EXPORT_SYMBOL(mca_device_claimed);
 177
 178 /**
 179  *      mca_device_set_claim - set the claim value of the driver
 180  *      @mca_dev:       device to set value for
 181  *      @val:           claim value to set (1 claimed, 0 unclaimed)
 182  */
 183 void mca_device_set_claim(struct mca_device *mca_dev, int val)
 184 {
 185         mca_dev->driver_loaded = val;
 186 }
 187 EXPORT_SYMBOL(mca_device_set_claim);
 188
 189 /**
 190  *      mca_device_status - get the status of the device
 191  *      @mca_device:    device to get
 192  *
 193  *      returns an enumeration of the device status:
 194  *
 195  *      MCA_ADAPTER_NORMAL      adapter is OK.
 196  *      MCA_ADAPTER_NONE        no adapter at device (should never happen).
 197  *      MCA_ADAPTER_DISABLED    adapter is disabled.
 198  *      MCA_ADAPTER_ERROR       adapter cannot be initialised.
 199  */
 200 enum MCA_AdapterStatus mca_device_status(struct mca_device *mca_dev)
 201 {
 202         return mca_dev->status;
 203 }
 204 EXPORT_SYMBOL(mca_device_status);
 205
 206 /**
 207  *      mca_device_set_name - set the name of the device
 208  *      @mca_device:    device to set the name of
 209  *      @name:          name to set
 210  */
 211 void mca_device_set_name(struct mca_device *mca_dev, const char *name)
 212 {
 213         if(!mca_dev)
 214                 return;
 215
 216         strlcpy(mca_dev->name, name, sizeof(mca_dev->name));
 217 }
 218 EXPORT_SYMBOL(mca_device_set_name);