/*
* ocp.c
*
* (c) Benjamin Herrenschmidt (benh@kernel.crashing.org)
* Mipsys - France
*
" Derived from work (c) Armin Kuster akuster@pacbell.net
*
*
* 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 SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* 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/config.h>
#include <linux/list.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/pm.h>
#include <linux/bootmem.h>
#include <asm/io.h>
#include <asm/ocp.h>
#include <asm/errno.h>
#include <asm/rwsem.h>
#include <asm/semaphore.h>
//#define DBG(x) printk x
#define DBG(x)
extern int mem_init_done;
extern struct ocp_def core_ocp[]; /* Static list of devices, provided by
CPU core */
LIST_HEAD(ocp_devices); /* List of all OCP devices */
LIST_HEAD(ocp_drivers); /* List of all OCP drivers */
DECLARE_RWSEM(ocp_devices_sem); /* Global semaphores for those lists */
DECLARE_MUTEX(ocp_drivers_sem); /* Global semaphores for those lists */
static int ocp_inited;
/**
* ocp_driver_match - Match one driver to one device
* @drv: driver to match
* @dev: device to match
*
* This function returns 0 if the driver and device don't match
*/
static int
ocp_driver_match(struct ocp_driver *drv, struct ocp_device *dev)
{
const struct ocp_device_id *ids = drv->id_table;
if (!ids)
return 0;
while (ids->vendor || ids->function) {
if ((ids->vendor == OCP_ANY_ID
|| ids->vendor == dev->def->vendor)
&& (ids->function == OCP_ANY_ID
|| ids->function == dev->def->function))
return 1;
ids++;
}
return 0;
}
/**
* ocp_bind_drivers - Match all drivers with all devices
* @candidate: driver beeing registered
*
* This function is called on driver registration and device discovery,
* it redo the matching of all "driverless" devices with all possible
* driver candidates.
* The driver beeing registered can be optionally passed in, in which
* case, the function will return -ENODEV is no match have been found
* or if all matches failed with a different code than -EAGAIN
*/
static int
ocp_bind_drivers(struct ocp_driver *candidate)
{
struct list_head *deventry, *drventry;
struct ocp_device *dev;
struct ocp_driver *drv;
int one_again, one_match;
int count = 0;
DBG(("ocp: binding drivers...\n"));
do {
/* We re-do the match loop if we had a sucess match and got one -EAGAIN
*/
one_match = one_again = 0;
down_read(&ocp_devices_sem);
list_for_each(deventry, &ocp_devices) {
dev = list_entry(deventry, struct ocp_device, link);
if (dev->driver != NULL)
continue;
DBG(("ocp: device %s unmatched, trying to match...\n", dev->name));
list_for_each(drventry, &ocp_drivers) {
drv = list_entry(drventry, struct ocp_driver, link);
if (ocp_driver_match(drv, dev)) {
int rc;
/* Hrm... shall we set dev->driver after or before ? */
DBG(("ocp: match with driver %s, calling probe...\n", drv->name));
rc = drv->probe(dev);
DBG(("ocp: probe result: %d\n", rc));
if (rc == 0) {
/* Driver matched, next device */
dev->driver = drv;
one_match = 1;
if (drv == candidate)
count++;
break;
} else if (rc == -EAGAIN) {
/* Driver matched but asked for later call, next device */
one_again = 1;
if (drv == candidate)
count++;
break;
}
}
}
}
up_read(&ocp_devices_sem);
} while(one_match && one_again);
DBG(("ocp: binding drivers... done.\n"));
return count;
}
/**
* ocp_register_driver - Register an OCP driver
* @drv: pointer to statically defined ocp_driver structure
*
* The driver's probe() callback is called either recursively
* by this function or upon later call of ocp_driver_init
*
* NOTE: Probe is called with ocp_drivers_sem held, it shouldn't
* call ocp_register/unregister_driver on his own code path.
* however, it _can_ call ocp_find_device().
*
* NOTE2: Detection of devices is a 2 pass step on this implementation,
* hotswap isn't supported. First, all OCP devices are put in the device
* list, _then_ all drivers are probed on each match.
*
* NOTE3: Drivers are allowed to return -EAGAIN from the probe() routine.
* this will cause them to be called again for this specific device as
* soon as another device have been probed or another driver registered.
* this, gives a simple way for a driver like EMAC to wait for another driver,
* like MAL to be up. There is potentially a small race if MAL happens to
* unregister, but this is hopefully never happening.
*
* This function returns a count of how many devices actually matched
* (wether the probe routine returned 0 or -EAGAIN, a different error
* code isn't considered as a match).
*/
int
ocp_register_driver(struct ocp_driver *drv)
{
int rc = 0;
DBG(("ocp: ocp_register_driver(%s)...\n", drv->name));
/* Add to driver list */
down(&ocp_drivers_sem);
list_add_tail(&drv->link, &ocp_drivers);
/* Check matching devices */
rc = ocp_bind_drivers(drv);
up(&ocp_drivers_sem);
DBG(("ocp: ocp_register_driver(%s)... done, count: %d.\n", drv->name, rc));
return rc;
}
/**
* ocp_unregister_driver - Unregister an OCP driver
* @drv: pointer to statically defined ocp_driver structure
*
* The driver's remove() callback is called recursively
* by this function for any device already registered
*/
void
ocp_unregister_driver(struct ocp_driver *drv)
{
struct ocp_device *dev;
struct list_head *entry;
DBG(("ocp: ocp_unregister_driver(%s)...\n", drv->name));
/* Call remove() routine for all devices using it */
down(&ocp_drivers_sem);
down_read(&ocp_devices_sem);
list_for_each(entry, &ocp_devices) {
dev = list_entry(entry, struct ocp_device, link);
if (dev->driver == drv) {
drv->remove(dev);
dev->driver = NULL;
dev->drvdata = NULL;
}
}
up_read(&ocp_devices_sem);
/* Unlink driver structure */
list_del_init(&drv->link);
up(&ocp_drivers_sem);
DBG(("ocp: ocp_unregister_driver(%s)... done.\n", drv->name));
}
/* Core of ocp_find_device(). Caller must hold ocp_devices_sem */
static struct ocp_device *
__ocp_find_device(unsigned int vendor, unsigned int function, int index)
{
struct list_head *entry;
struct ocp_device *dev, *found = NULL;
DBG(("ocp: __ocp_find_device(vendor: %x, function: %x, index: %d)...\n", vendor, function, index));
list_for_each(entry, &ocp_devices) {
dev = list_entry(entry, struct ocp_device, link);
if (vendor != OCP_ANY_ID && vendor != dev->def->vendor)
continue;
if (function != OCP_ANY_ID && function != dev->def->function)
continue;
if (index != OCP_ANY_INDEX && index != dev->def->index)
continue;
found = dev;
break;
}
DBG(("ocp: __ocp_find_device(vendor: %x, function: %x, index: %d)... done\n", vendor, function, index));
return found;
}
/**
* ocp_find_device - Find a device by function & index
* @vendor: vendor ID of the device (or OCP_ANY_ID)
* @function: function code of the device (or OCP_ANY_ID)
* @idx: index of the device (or OCP_ANY_INDEX)
*
* This function allows a lookup of a given function by it's
* index, it's typically used to find the MAL or ZMII associated
* with an EMAC or similar horrors.
* You can pass vendor, though you usually want OCP_ANY_ID there...
*/
struct ocp_device *
ocp_find_device(unsigned int vendor, unsigned int function, int index)
{
struct ocp_device *dev;
down_read(&ocp_devices_sem);
dev = __ocp_find_device(vendor, function, index);
up_read(&ocp_devices_sem);
return dev;
}
/**
* ocp_get_one_device - Find a def by function & index
* @vendor: vendor ID of the device (or OCP_ANY_ID)
* @function: function code of the device (or OCP_ANY_ID)
* @idx: index of the device (or OCP_ANY_INDEX)
*
* This function allows a lookup of a given ocp_def by it's
* vendor, function, and index. The main purpose for is to
* allow modification of the def before binding to the driver
*/
struct ocp_def *
ocp_get_one_device(unsigned int vendor, unsigned int function, int index)
{
struct ocp_device *dev;
struct ocp_def *found = NULL;
DBG(("ocp: ocp_get_one_device(vendor: %x, function: %x, index: %d)...\n",
vendor, function, index));
dev = ocp_find_device(vendor, function, index);
if (dev)
found = dev->def;
DBG(("ocp: ocp_get_one_device(vendor: %x, function: %x, index: %d)... done.\n",
vendor, function, index));
return found;
}
/**
* ocp_add_one_device - Add a device
* @def: static device definition structure
*
* This function adds a device definition to the
* device list. It may only be called before
* ocp_driver_init() and will return an error
* otherwise.
*/
int
ocp_add_one_device(struct ocp_def *def)
{
struct ocp_device *dev;
DBG(("ocp: ocp_add_one_device(vendor: %x, function: %x, index: %d)...\n", vendor, function, index));
/* Can't be called after ocp driver init */
if (ocp_inited)
return 1;
if (mem_init_done)
dev = kmalloc(sizeof(*dev), GFP_KERNEL);
else
dev = alloc_bootmem(sizeof(*dev));
if (dev == NULL)
return 1;
memset(dev, 0, sizeof(*dev));
dev->def = def;
dev->current_state = 4;
sprintf(dev->name, "OCP device %04x:%04x:%04x",
dev->def->vendor, dev->def->function, dev->def->index);
down_write(&ocp_devices_sem);
list_add_tail(&dev->link, &ocp_devices);
up_write(&ocp_devices_sem);
DBG(("ocp: ocp_add_one_device(vendor: %x, function: %x, index: %d)...done.\n", vendor, function, index));
return 0;
}
/**
* ocp_remove_one_device - Remove a device by function & index
* @vendor: vendor ID of the device (or OCP_ANY_ID)
* @function: function code of the device (or OCP_ANY_ID)
* @idx: index of the device (or OCP_ANY_INDEX)
*
* This function allows removal of a given function by its
* index. It may only be called before ocp_driver_init()
* and will return an error otherwise.
*/
int
ocp_remove_one_device(unsigned int vendor, unsigned int function, int index)
{
struct ocp_device *dev;
int rc = 0;
DBG(("ocp: ocp_remove_one_device(vendor: %x, function: %x, index: %d)...\n", vendor, function, index));
/* Can't be called after ocp driver init */
if (ocp_inited)
return 1;
down_write(&ocp_devices_sem);
dev = __ocp_find_device(vendor, function, index);
if (dev != NULL)
list_del((struct list_head *)dev);
else
rc = 1;
up_write(&ocp_devices_sem);
DBG(("ocp: ocp_remove_one_device(vendor: %x, function: %x, index: %d)... done.\n", vendor, function, index));
return rc;
}
#ifdef CONFIG_PM
/**
* OCP Power management..
*
* This needs to be done centralized, so that we power manage PCI
* devices in the right order: we should not shut down PCI bridges
* before we've shut down the devices behind them, and we should
* not wake up devices before we've woken up the bridge to the
* device.. Eh?
*
* We do not touch devices that don't have a driver that exports
* a suspend/resume function. That is just too dangerous. If the default
* PCI suspend/resume functions work for a device, the driver can
* easily implement them (ie just have a suspend function that calls
* the pci_set_power_state() function).
*
* BenH: Implementation here couldn't work properly. This version
* slightly modified and _might_ be more useable, but real
* PM support will probably have to wait for 2.5
*/
static int ocp_pm_save_state_device(struct ocp_device *dev, u32 state)
{
int error = 0;
if (dev) {
struct ocp_driver *driver = dev->driver;
if (driver && driver->save_state)
error = driver->save_state(dev,state);
}
return error;
}
static int ocp_pm_suspend_device(struct ocp_device *dev, u32 state)
{
int error = 0;
if (dev) {
struct ocp_driver *driver = dev->driver;
if (driver && driver->suspend)
error = driver->suspend(dev,state);
}
return error;
}
static int ocp_pm_resume_device(struct ocp_device *dev)
{
int error = 0;
if (dev) {
struct ocp_driver *driver = dev->driver;
if (driver && driver->resume)
error = driver->resume(dev);
}
return error;
}
static int
ocp_pm_callback(struct pm_dev *pm_device, pm_request_t rqst, void *data)
{
int error = 0;
struct list_head *entry;
struct ocp_device *dev;
down(&ocp_drivers_sem);
down_read(&ocp_devices_sem);
list_for_each(entry, &ocp_devices) {
dev = list_entry(entry, struct ocp_device, link);
switch (rqst) {
case PM_SAVE_STATE:
error = ocp_pm_save_state_device(dev, 3);
break;
case PM_SUSPEND:
error = ocp_pm_suspend_device(dev, 3);
break;
case PM_RESUME:
error = ocp_pm_resume_device(dev);
break;
default: break;
}
if (error)
break;
}
return error;
}
/*
* Is this ever used ?
*/
void
ppc4xx_cpm_fr(u32 bits, int val)
{
unsigned long flags;
save_flags(flags);
cli();
if (val)
mtdcr(DCRN_CPMFR, mfdcr(DCRN_CPMFR) | bits);
else
mtdcr(DCRN_CPMFR, mfdcr(DCRN_CPMFR) & ~bits);
restore_flags(flags);
}
#endif /* CONFIG_PM */
/**
* ocp_early_init - Init OCP device management
*
* This function builds the list of devices before setup_arch.
* This allows platform code to modify the device lists before
* they are bound to drivers (changes to paddr, removing devices
* etc)
*/
int __init
ocp_early_init(void)
{
struct ocp_def *def;
DBG(("ocp: ocp_early_init()...\n"));
/* Fill the devices list */
for (def = core_ocp; def->vendor != OCP_VENDOR_INVALID; def++)
ocp_add_one_device(def);
DBG(("ocp: ocp_early_init()... done.\n"));
return 0;
}
/**
* ocp_driver_init - Init OCP device management
*
* This function is meant to be called once, and only once to initialize
* the OCP device management. Note that it can actually be called at any
* time, it's perfectly legal to register drivers before
* ocp_driver_init() is called
*/
int
ocp_driver_init(void)
{
/* ocp_driver_init is by default an initcall. If your arch requires
* this to be called earlier, then go on, ocp_driver_init is
* non-static for that purpose, and can safely be called twice
*/
if (ocp_inited)
return 0;
ocp_inited = 1;
DBG(("ocp: ocp_driver_init()...\n"));
/* Call drivers probes */
down(&ocp_drivers_sem);
ocp_bind_drivers(NULL);
up(&ocp_drivers_sem);
#ifdef CONFIG_PM
pm_register(PM_SYS_DEV, 0, ocp_pm_callback);
#endif
DBG(("ocp: ocp_driver_init()... done.\n"));
return 0;
}
__initcall(ocp_driver_init);
EXPORT_SYMBOL(ocp_find_device);
EXPORT_SYMBOL(ocp_register_driver);
EXPORT_SYMBOL(ocp_unregister_driver);
![[BACK]](/icons/back.gif){kind=icon}
Return to ocp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / linux-2.4-xfs / arch / ppc / kernel