i2o: move to staging

The I2O layer deals with a technology that to say the least didn't catch on
in the market.

The only relevant products are some of the AMI MegaRAID - which supported I2O
and its native mode (The native mode is faster and runs on Linux), an
obscure crypto ethernet card that's now so many years out of date nobody
would use it, the old DPT controllers, which speak their own dialect and
have their own driver - and ermm.. thats about it.

We also know the code isn't in good shape as recently a patch was proposed
and queried as buggy, which in turn showed the existing code was broken
already by prior "clean up" and nobody had noticed that either.

It's coding style robot code nothing more. Like some forgotten corridor
cleaned relentlessly by a lost Roomba but where no user has trodden in years.

Move it to staging and then to /dev/null.

The headers remain as they are shared with dpt_i2o.

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 0 insertions, 382 deletions

diff --git a/drivers/message/i2o/driver.c b/drivers/message/i2o/driver.c
deleted file mode 100644
index 1b18a0d1d05b..000000000000
--- a/drivers/message/i2o/driver.c
+++ /dev/null
@@ -1,382 +0,0 @@
-/*
- *      Functions to handle I2O drivers (OSMs) and I2O bus type for sysfs
- *
- *      Copyright (C) 2004      Markus Lidel <Markus.Lidel@shadowconnect.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.
- *
- *      Fixes/additions:
- *              Markus Lidel <Markus.Lidel@shadowconnect.com>
- *                      initial version.
- */
-
-#include <linux/device.h>
-#include <linux/module.h>
-#include <linux/rwsem.h>
-#include <linux/i2o.h>
-#include <linux/workqueue.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include "core.h"
-
-#define OSM_NAME        "i2o"
-
-/* max_drivers - Maximum I2O drivers (OSMs) which could be registered */
-static unsigned int i2o_max_drivers = I2O_MAX_DRIVERS;
-module_param_named(max_drivers, i2o_max_drivers, uint, 0);
-MODULE_PARM_DESC(max_drivers, "maximum number of OSM's to support");
-
-/* I2O drivers lock and array */
-static spinlock_t i2o_drivers_lock;
-static struct i2o_driver **i2o_drivers;
-
-/**
- *      i2o_bus_match - Tell if I2O device class id matches the class ids of the I2O driver (OSM)
- *      @dev: device which should be verified
- *      @drv: the driver to match against
- *
- *      Used by the bus to check if the driver wants to handle the device.
- *
- *      Returns 1 if the class ids of the driver match the class id of the
- *      device, otherwise 0.
- */
-static int i2o_bus_match(struct device *dev, struct device_driver *drv)
-{
-        struct i2o_device *i2o_dev = to_i2o_device(dev);
-        struct i2o_driver *i2o_drv = to_i2o_driver(drv);
-        struct i2o_class_id *ids = i2o_drv->classes;
-
-        if (ids)
-                while (ids->class_id != I2O_CLASS_END) {
-                        if (ids->class_id == i2o_dev->lct_data.class_id)
-                                return 1;
-                        ids++;
-                }
-        return 0;
-};
-
-/* I2O bus type */
-struct bus_type i2o_bus_type = {
-        .name = "i2o",
-        .match = i2o_bus_match,
-        .dev_groups = i2o_device_groups,
-};
-
-/**
- *      i2o_driver_register - Register a I2O driver (OSM) in the I2O core
- *      @drv: I2O driver which should be registered
- *
- *      Registers the OSM drv in the I2O core and creates an event queues if
- *      necessary.
- *
- *      Returns 0 on success or negative error code on failure.
- */
-int i2o_driver_register(struct i2o_driver *drv)
-{
-        struct i2o_controller *c;
-        int i;
-        int rc = 0;
-        unsigned long flags;
-
-        osm_debug("Register driver %s\n", drv->name);
-
-        if (drv->event) {
-                drv->event_queue = alloc_workqueue("%s", WQ_MEM_RECLAIM, 1,
-                                                   drv->name);
-                if (!drv->event_queue) {
-                        osm_err("Could not initialize event queue for driver "
-                                "%s\n", drv->name);
-                        return -EFAULT;
-                }
-                osm_debug("Event queue initialized for driver %s\n", drv->name);
-        } else
-                drv->event_queue = NULL;
-
-        drv->driver.name = drv->name;
-        drv->driver.bus = &i2o_bus_type;
-
-        spin_lock_irqsave(&i2o_drivers_lock, flags);
-
-        for (i = 0; i2o_drivers[i]; i++)
-                if (i >= i2o_max_drivers) {
-                        osm_err("too many drivers registered, increase "
-                                "max_drivers\n");
-                        spin_unlock_irqrestore(&i2o_drivers_lock, flags);
-                        rc = -EFAULT;
-                        goto out;
-                }
-
-        drv->context = i;
-        i2o_drivers[i] = drv;
-
-        spin_unlock_irqrestore(&i2o_drivers_lock, flags);
-
-        osm_debug("driver %s gets context id %d\n", drv->name, drv->context);
-
-        list_for_each_entry(c, &i2o_controllers, list) {
-                struct i2o_device *i2o_dev;
-
-                i2o_driver_notify_controller_add(drv, c);
-                list_for_each_entry(i2o_dev, &c->devices, list)
-                    i2o_driver_notify_device_add(drv, i2o_dev);
-        }
-
-        rc = driver_register(&drv->driver);
-        if (rc)
-                goto out;
-
-        return 0;
-out:
-        if (drv->event_queue) {
-                destroy_workqueue(drv->event_queue);
-                drv->event_queue = NULL;
-        }
-
-        return rc;
-};
-
-/**
- *      i2o_driver_unregister - Unregister a I2O driver (OSM) from the I2O core
- *      @drv: I2O driver which should be unregistered
- *
- *      Unregisters the OSM drv from the I2O core and cleanup event queues if
- *      necessary.
- */
-void i2o_driver_unregister(struct i2o_driver *drv)
-{
-        struct i2o_controller *c;
-        unsigned long flags;
-
-        osm_debug("unregister driver %s\n", drv->name);
-
-        driver_unregister(&drv->driver);
-
-        list_for_each_entry(c, &i2o_controllers, list) {
-                struct i2o_device *i2o_dev;
-
-                list_for_each_entry(i2o_dev, &c->devices, list)
-                    i2o_driver_notify_device_remove(drv, i2o_dev);
-
-                i2o_driver_notify_controller_remove(drv, c);
-        }
-
-        spin_lock_irqsave(&i2o_drivers_lock, flags);
-        i2o_drivers[drv->context] = NULL;
-        spin_unlock_irqrestore(&i2o_drivers_lock, flags);
-
-        if (drv->event_queue) {
-                destroy_workqueue(drv->event_queue);
-                drv->event_queue = NULL;
-                osm_debug("event queue removed for %s\n", drv->name);
-        }
-};
-
-/**
- *      i2o_driver_dispatch - dispatch an I2O reply message
- *      @c: I2O controller of the message
- *      @m: I2O message number
- *
- *      The reply is delivered to the driver from which the original message
- *      was. This function is only called from interrupt context.
- *
- *      Returns 0 on success and the message should not be flushed. Returns > 0
- *      on success and if the message should be flushed afterwords. Returns
- *      negative error code on failure (the message will be flushed too).
- */
-int i2o_driver_dispatch(struct i2o_controller *c, u32 m)
-{
-        struct i2o_driver *drv;
-        struct i2o_message *msg = i2o_msg_out_to_virt(c, m);
-        u32 context = le32_to_cpu(msg->u.s.icntxt);
-        unsigned long flags;
-
-        if (unlikely(context >= i2o_max_drivers)) {
-                osm_warn("%s: Spurious reply to unknown driver %d\n", c->name,
-                         context);
-                return -EIO;
-        }
-
-        spin_lock_irqsave(&i2o_drivers_lock, flags);
-        drv = i2o_drivers[context];
-        spin_unlock_irqrestore(&i2o_drivers_lock, flags);
-
-        if (unlikely(!drv)) {
-                osm_warn("%s: Spurious reply to unknown driver %d\n", c->name,
-                         context);
-                return -EIO;
-        }
-
-        if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_UTIL_EVT_REGISTER) {
-                struct i2o_device *dev, *tmp;
-                struct i2o_event *evt;
-                u16 size;
-                u16 tid = le32_to_cpu(msg->u.head[1]) & 0xfff;
-
-                osm_debug("event received from device %d\n", tid);
-
-                if (!drv->event)
-                        return -EIO;
-
-                /* cut of header from message size (in 32-bit words) */
-                size = (le32_to_cpu(msg->u.head[0]) >> 16) - 5;
-
-                evt = kzalloc(size * 4 + sizeof(*evt), GFP_ATOMIC);
-                if (!evt)
-                        return -ENOMEM;
-
-                evt->size = size;
-                evt->tcntxt = le32_to_cpu(msg->u.s.tcntxt);
-                evt->event_indicator = le32_to_cpu(msg->body[0]);
-                memcpy(&evt->data, &msg->body[1], size * 4);
-
-                list_for_each_entry_safe(dev, tmp, &c->devices, list)
-                    if (dev->lct_data.tid == tid) {
-                        evt->i2o_dev = dev;
-                        break;
-                }
-
-                INIT_WORK(&evt->work, drv->event);
-                queue_work(drv->event_queue, &evt->work);
-                return 1;
-        }
-
-        if (unlikely(!drv->reply)) {
-                osm_debug("%s: Reply to driver %s, but no reply function"
-                          " defined!\n", c->name, drv->name);
-                return -EIO;
-        }
-
-        return drv->reply(c, m, msg);
-}
-
-/**
- *      i2o_driver_notify_controller_add_all - Send notify of added controller
- *      @c: newly added controller
- *
- *      Send notifications to all registered drivers that a new controller was
- *      added.
- */
-void i2o_driver_notify_controller_add_all(struct i2o_controller *c)
-{
-        int i;
-        struct i2o_driver *drv;
-
-        for (i = 0; i < i2o_max_drivers; i++) {
-                drv = i2o_drivers[i];
-
-                if (drv)
-                        i2o_driver_notify_controller_add(drv, c);
-        }
-}
-
-/**
- *      i2o_driver_notify_controller_remove_all - Send notify of removed controller
- *      @c: controller that is being removed
- *
- *      Send notifications to all registered drivers that a controller was
- *      removed.
- */
-void i2o_driver_notify_controller_remove_all(struct i2o_controller *c)
-{
-        int i;
-        struct i2o_driver *drv;
-
-        for (i = 0; i < i2o_max_drivers; i++) {
-                drv = i2o_drivers[i];
-
-                if (drv)
-                        i2o_driver_notify_controller_remove(drv, c);
-        }
-}
-
-/**
- *      i2o_driver_notify_device_add_all - Send notify of added device
- *      @i2o_dev: newly added I2O device
- *
- *      Send notifications to all registered drivers that a device was added.
- */
-void i2o_driver_notify_device_add_all(struct i2o_device *i2o_dev)
-{
-        int i;
-        struct i2o_driver *drv;
-
-        for (i = 0; i < i2o_max_drivers; i++) {
-                drv = i2o_drivers[i];
-
-                if (drv)
-                        i2o_driver_notify_device_add(drv, i2o_dev);
-        }
-}
-
-/**
- *      i2o_driver_notify_device_remove_all - Send notify of removed device
- *      @i2o_dev: device that is being removed
- *
- *      Send notifications to all registered drivers that a device was removed.
- */
-void i2o_driver_notify_device_remove_all(struct i2o_device *i2o_dev)
-{
-        int i;
-        struct i2o_driver *drv;
-
-        for (i = 0; i < i2o_max_drivers; i++) {
-                drv = i2o_drivers[i];
-
-                if (drv)
-                        i2o_driver_notify_device_remove(drv, i2o_dev);
-        }
-}
-
-/**
- *      i2o_driver_init - initialize I2O drivers (OSMs)
- *
- *      Registers the I2O bus and allocate memory for the array of OSMs.
- *
- *      Returns 0 on success or negative error code on failure.
- */
-int __init i2o_driver_init(void)
-{
-        int rc = 0;
-
-        spin_lock_init(&i2o_drivers_lock);
-
-        if ((i2o_max_drivers < 2) || (i2o_max_drivers > 64)) {
-                osm_warn("max_drivers set to %d, but must be >=2 and <= 64\n",
-                         i2o_max_drivers);
-                i2o_max_drivers = I2O_MAX_DRIVERS;
-        }
-        osm_info("max drivers = %d\n", i2o_max_drivers);
-
-        i2o_drivers =
-            kcalloc(i2o_max_drivers, sizeof(*i2o_drivers), GFP_KERNEL);
-        if (!i2o_drivers)
-                return -ENOMEM;
-
-        rc = bus_register(&i2o_bus_type);
-
-        if (rc < 0)
-                kfree(i2o_drivers);
-
-        return rc;
-};
-
-/**
- *      i2o_driver_exit - clean up I2O drivers (OSMs)
- *
- *      Unregisters the I2O bus and frees driver array.
- */
-void i2o_driver_exit(void)
-{
-        bus_unregister(&i2o_bus_type);
-        kfree(i2o_drivers);
-};
-
-EXPORT_SYMBOL(i2o_driver_register);
-EXPORT_SYMBOL(i2o_driver_unregister);
-EXPORT_SYMBOL(i2o_driver_notify_controller_add_all);
-EXPORT_SYMBOL(i2o_driver_notify_controller_remove_all);
-EXPORT_SYMBOL(i2o_driver_notify_device_add_all);
-EXPORT_SYMBOL(i2o_driver_notify_device_remove_all);