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 */
 43unsigned 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}
 50EXPORT_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 */
 63unsigned 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}
 71EXPORT_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 */
 88void 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}
 95EXPORT_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 */
110int 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}
116EXPORT_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 */
133int 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}
139EXPORT_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 */
156void *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}
162EXPORT_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
172int mca_device_claimed(struct mca_device *mca_dev)
173{
174	return mca_dev->driver_loaded;
175}
176EXPORT_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 */
183void mca_device_set_claim(struct mca_device *mca_dev, int val)
184{
185	mca_dev->driver_loaded = val;
186}
187EXPORT_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 */
200enum MCA_AdapterStatus mca_device_status(struct mca_device *mca_dev)
201{
202	return mca_dev->status;
203}
204EXPORT_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 */
211void 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}
218EXPORT_SYMBOL(mca_device_set_name);