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

ocp.c

/*
 * ocp.c
 *
 *      (c) Benjamin Herrenschmidt (benh@kernel.crashing.org)
 *          Mipsys - France
 *
 *          Derived from work (c) Armin Kuster akuster@pacbell.net
 *
 *          Additional support and port to 2.6 LDM/sysfs by
 *          Matt Porter <mporter@kernel.crashing.org>
 *          Copyright 2004 MontaVista Software, Inc.
 *
 *  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.
 *
 *  OCP (On Chip Peripheral) is a software emulated "bus" with a
 *  pseudo discovery method for dumb peripherals. Usually these type
 *  of peripherals are found on embedded SoC (System On a Chip)
 *  processors or highly integrated system controllers that have
 *  a host bridge and many peripherals.  Common examples where
 *  this is already used include the PPC4xx, PPC85xx, MPC52xx,
 *  and MV64xxx parts.
 *
 *  This subsystem creates a standard OCP bus type within the
 *  device model.  The devices on the OCP bus are seeded by an
 *  an initial OCP device array created by the arch-specific
 *  Device entries can be added/removed/modified through OCP
 *  helper functions to accommodate system and  board-specific
 *  parameters commonly found in embedded systems. OCP also
 *  provides a standard method for devices to describe extended
 *  attributes about themselves to the system.  A standard access
 *  method allows OCP drivers to obtain the information, both
 *  SoC-specific and system/board-specific, needed for operation.
 */

#include <linux/module.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 <linux/device.h>
#include <linux/rwsem.h>

#include <asm/io.h>
#include <asm/ocp.h>
#include <asm/errno.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 */
DECLARE_RWSEM(ocp_devices_sem);           /* Global semaphores for those lists */

static int ocp_inited;

/* Sysfs support */
#define OCP_DEF_ATTR(field, format_string)                        \
static ssize_t                                              \
show_##field(struct device *dev, struct device_attribute *attr, char *buf)                      \
{                                                     \
      struct ocp_device *odev = to_ocp_dev(dev);                  \
                                                      \
      return sprintf(buf, format_string, odev->def->field);       \
}                                                     \
static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);

OCP_DEF_ATTR(vendor, "0x%04x\n");
OCP_DEF_ATTR(function, "0x%04x\n");
OCP_DEF_ATTR(index, "0x%04x\n");
#ifdef CONFIG_PTE_64BIT
OCP_DEF_ATTR(paddr, "0x%016Lx\n");
#else
OCP_DEF_ATTR(paddr, "0x%08lx\n");
#endif
OCP_DEF_ATTR(irq, "%d\n");
OCP_DEF_ATTR(pm, "%lu\n");

void ocp_create_sysfs_dev_files(struct ocp_device *odev)
{
      struct device *dev = &odev->dev;

      /* Current OCP device def attributes */
      device_create_file(dev, &dev_attr_vendor);
      device_create_file(dev, &dev_attr_function);
      device_create_file(dev, &dev_attr_index);
      device_create_file(dev, &dev_attr_paddr);
      device_create_file(dev, &dev_attr_irq);
      device_create_file(dev, &dev_attr_pm);
      /* Current OCP device additions attributes */
      if (odev->def->additions && odev->def->show)
            odev->def->show(dev);
}

/**
 *    ocp_device_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_device_match(struct device *dev, struct device_driver *drv)
{
      struct ocp_device *ocp_dev = to_ocp_dev(dev);
      struct ocp_driver *ocp_drv = to_ocp_drv(drv);
      const struct ocp_device_id *ids = ocp_drv->id_table;

      if (!ids)
            return 0;

      while (ids->vendor || ids->function) {
            if ((ids->vendor == OCP_ANY_ID
                 || ids->vendor == ocp_dev->def->vendor)
                && (ids->function == OCP_ANY_ID
                  || ids->function == ocp_dev->def->function))
                    return 1;
            ids++;
      }
      return 0;
}

static int
ocp_device_probe(struct device *dev)
{
      int error = 0;
      struct ocp_driver *drv;
      struct ocp_device *ocp_dev;

      drv = to_ocp_drv(dev->driver);
      ocp_dev = to_ocp_dev(dev);

      if (drv->probe) {
            error = drv->probe(ocp_dev);
            if (error >= 0) {
                  ocp_dev->driver = drv;
                  error = 0;
            }
      }
      return error;
}

static int
ocp_device_remove(struct device *dev)
{
      struct ocp_device *ocp_dev = to_ocp_dev(dev);

      if (ocp_dev->driver) {
            if (ocp_dev->driver->remove)
                  ocp_dev->driver->remove(ocp_dev);
            ocp_dev->driver = NULL;
      }
      return 0;
}

static int
ocp_device_suspend(struct device *dev, pm_message_t state)
{
      struct ocp_device *ocp_dev = to_ocp_dev(dev);
      struct ocp_driver *ocp_drv = to_ocp_drv(dev->driver);

      if (dev->driver && ocp_drv->suspend)
            return ocp_drv->suspend(ocp_dev, state);
      return 0;
}

static int
ocp_device_resume(struct device *dev)
{
      struct ocp_device *ocp_dev = to_ocp_dev(dev);
      struct ocp_driver *ocp_drv = to_ocp_drv(dev->driver);

      if (dev->driver && ocp_drv->resume)
            return ocp_drv->resume(ocp_dev);
      return 0;
}

struct bus_type ocp_bus_type = {
      .name = "ocp",
      .match = ocp_device_match,
      .probe = ocp_device_probe,
      .remove = ocp_device_remove,
      .suspend = ocp_device_suspend,
      .resume = ocp_device_resume,
};

/**
 *    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: 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.
 */
int
ocp_register_driver(struct ocp_driver *drv)
{
      /* initialize common driver fields */
      drv->driver.name = drv->name;
      drv->driver.bus = &ocp_bus_type;

      /* register with core */
      return driver_register(&drv->driver);
}

/**
 *    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)
{
      DBG(("ocp: ocp_unregister_driver(%s)...\n", drv->name));

      driver_unregister(&drv->driver);

      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()...\n"));

      /* 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()...done\n"));

      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;

      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);
      list_del((struct list_head *)dev);
      up_write(&ocp_devices_sem);

      DBG(("ocp: ocp_remove_one_device(vendor: %x, function: %x, index: %d)... done.\n", vendor, function, index));

      return 0;
}

/**
 *    ocp_for_each_device     -     Iterate over OCP devices
 *    @callback: routine to execute for each ocp device.
 *    @arg: user data to be passed to callback routine.
 *
 *    This routine holds the ocp_device semaphore, so the
 *    callback routine cannot modify the ocp_device list.
 */
void
ocp_for_each_device(void(*callback)(struct ocp_device *, void *arg), void *arg)
{
      struct list_head *entry;

      if (callback) {
            down_read(&ocp_devices_sem);
            list_for_each(entry, &ocp_devices)
                  callback(list_entry(entry, struct ocp_device, link),
                        arg);
            up_read(&ocp_devices_sem);
      }
}

/**
 *    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 via OCP bus registration.
 */
static int __init
ocp_driver_init(void)
{
      int ret = 0, index = 0;
      struct device *ocp_bus;
      struct list_head *entry;
      struct ocp_device *dev;

      if (ocp_inited)
            return ret;
      ocp_inited = 1;

      DBG(("ocp: ocp_driver_init()...\n"));

      /* Allocate/register primary OCP bus */
      ocp_bus = kzalloc(sizeof(struct device), GFP_KERNEL);
      if (ocp_bus == NULL)
            return 1;
      strcpy(ocp_bus->bus_id, "ocp");

      bus_register(&ocp_bus_type);

      device_register(ocp_bus);

      /* Put each OCP device into global device list */
      list_for_each(entry, &ocp_devices) {
            dev = list_entry(entry, struct ocp_device, link);
            sprintf(dev->dev.bus_id, "%2.2x", index);
            dev->dev.parent = ocp_bus;
            dev->dev.bus = &ocp_bus_type;
            device_register(&dev->dev);
            ocp_create_sysfs_dev_files(dev);
            index++;
      }

      DBG(("ocp: ocp_driver_init()... done.\n"));

      return 0;
}

postcore_initcall(ocp_driver_init);

EXPORT_SYMBOL(ocp_bus_type);
EXPORT_SYMBOL(ocp_find_device);
EXPORT_SYMBOL(ocp_register_driver);
EXPORT_SYMBOL(ocp_unregister_driver);

Generated by  Doxygen 1.6.0   Back to index