1 files changed, 255 insertions, 0 deletions

diff --git a/drivers/s390/scsi/zfcp_unit.c b/drivers/s390/scsi/zfcp_unit.c
new file mode 100644
index 000000000000..e210c41ee389
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_unit.c
@@ -0,0 +1,255 @@
+/*
+ * zfcp device driver
+ *
+ * Tracking of manually configured LUNs and helper functions to
+ * register the LUNs with the SCSI midlayer.
+ *
+ * Copyright IBM Corporation 2010
+ */
+
+#include "zfcp_def.h"
+#include "zfcp_ext.h"
+
+/**
+ * zfcp_unit_scsi_scan - Register LUN with SCSI midlayer
+ * @unit: The zfcp LUN/unit to register
+ *
+ * When the SCSI midlayer is not allowed to automatically scan and
+ * attach SCSI devices, zfcp has to register the single devices with
+ * the SCSI midlayer.
+ */
+void zfcp_unit_scsi_scan(struct zfcp_unit *unit)
+{
+        struct fc_rport *rport = unit->port->rport;
+        unsigned int lun;
+
+        lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
+
+        if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
+                scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, lun, 1);
+}
+
+static void zfcp_unit_scsi_scan_work(struct work_struct *work)
+{
+        struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
+                                              scsi_work);
+
+        zfcp_unit_scsi_scan(unit);
+        put_device(&unit->dev);
+}
+
+/**
+ * zfcp_unit_queue_scsi_scan - Register configured units on port
+ * @port: The zfcp_port where to register units
+ *
+ * After opening a port, all units configured on this port have to be
+ * registered with the SCSI midlayer. This function should be called
+ * after calling fc_remote_port_add, so that the fc_rport is already
+ * ONLINE and the call to scsi_scan_target runs the same way as the
+ * call in the FC transport class.
+ */
+void zfcp_unit_queue_scsi_scan(struct zfcp_port *port)
+{
+        struct zfcp_unit *unit;
+
+        read_lock_irq(&port->unit_list_lock);
+        list_for_each_entry(unit, &port->unit_list, list) {
+                get_device(&unit->dev);
+                if (scsi_queue_work(port->adapter->scsi_host,
+                                    &unit->scsi_work) <= 0)
+                        put_device(&unit->dev);
+        }
+        read_unlock_irq(&port->unit_list_lock);
+}
+
+static struct zfcp_unit *_zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+
+        list_for_each_entry(unit, &port->unit_list, list)
+                if (unit->fcp_lun == fcp_lun) {
+                        get_device(&unit->dev);
+                        return unit;
+                }
+
+        return NULL;
+}
+
+/**
+ * zfcp_unit_find - Find and return zfcp_unit with specified FCP LUN
+ * @port: zfcp_port where to look for the unit
+ * @fcp_lun: 64 Bit FCP LUN used to identify the zfcp_unit
+ *
+ * If zfcp_unit is found, a reference is acquired that has to be
+ * released later.
+ *
+ * Returns: Pointer to the zfcp_unit, or NULL if there is no zfcp_unit
+ *          with the specified FCP LUN.
+ */
+struct zfcp_unit *zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+
+        read_lock_irq(&port->unit_list_lock);
+        unit = _zfcp_unit_find(port, fcp_lun);
+        read_unlock_irq(&port->unit_list_lock);
+        return unit;
+}
+
+/**
+ * zfcp_unit_release - Drop reference to zfcp_port and free memory of zfcp_unit.
+ * @dev: pointer to device in zfcp_unit
+ */
+static void zfcp_unit_release(struct device *dev)
+{
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
+
+        put_device(&unit->port->dev);
+        kfree(unit);
+}
+
+/**
+ * zfcp_unit_enqueue - enqueue unit to unit list of a port.
+ * @port: pointer to port where unit is added
+ * @fcp_lun: FCP LUN of unit to be enqueued
+ * Returns: 0 success
+ *
+ * Sets up some unit internal structures and creates sysfs entry.
+ */
+int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+
+        unit = zfcp_unit_find(port, fcp_lun);
+        if (unit) {
+                put_device(&unit->dev);
+                return -EEXIST;
+        }
+
+        unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
+        if (!unit)
+                return -ENOMEM;
+
+        unit->port = port;
+        unit->fcp_lun = fcp_lun;
+        unit->dev.parent = &port->dev;
+        unit->dev.release = zfcp_unit_release;
+        unit->latencies.write.channel.min = 0xFFFFFFFF;
+        unit->latencies.write.fabric.min = 0xFFFFFFFF;
+        unit->latencies.read.channel.min = 0xFFFFFFFF;
+        unit->latencies.read.fabric.min = 0xFFFFFFFF;
+        unit->latencies.cmd.channel.min = 0xFFFFFFFF;
+        unit->latencies.cmd.fabric.min = 0xFFFFFFFF;
+        INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work);
+        spin_lock_init(&unit->latencies.lock);
+
+        if (dev_set_name(&unit->dev, "0x%016llx",
+                         (unsigned long long) fcp_lun)) {
+                kfree(unit);
+                return -ENOMEM;
+        }
+
+        if (device_register(&unit->dev)) {
+                put_device(&unit->dev);
+                return -ENOMEM;
+        }
+
+        if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs)) {
+                device_unregister(&unit->dev);
+                return -EINVAL;
+        }
+
+        get_device(&port->dev);
+
+        write_lock_irq(&port->unit_list_lock);
+        list_add_tail(&unit->list, &port->unit_list);
+        write_unlock_irq(&port->unit_list_lock);
+
+        atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status);
+        zfcp_erp_unit_reopen(unit, 0, "syuas_1", NULL);
+        zfcp_erp_wait(unit->port->adapter);
+        zfcp_unit_scsi_scan(unit);
+
+        return 0;
+}
+
+/**
+ * zfcp_unit_sdev - Return SCSI device for zfcp_unit
+ * @unit: The zfcp_unit where to get the SCSI device for
+ *
+ * Returns: scsi_device pointer on success, NULL if there is no SCSI
+ *          device for this zfcp_unit
+ *
+ * On success, the caller also holds a reference to the SCSI device
+ * that must be released with scsi_device_put.
+ */
+struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit)
+{
+        struct Scsi_Host *shost;
+        struct zfcp_port *port;
+        unsigned int lun;
+
+        lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
+        port = unit->port;
+        shost = port->adapter->scsi_host;
+        return scsi_device_lookup(shost, 0, port->starget_id, lun);
+}
+
+/**
+ * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device
+ * @unit: The unit to lookup the SCSI device for
+ *
+ * Returns the zfcp LUN status field of the SCSI device if the SCSI device
+ * for the zfcp_unit exists, 0 otherwise.
+ */
+unsigned int zfcp_unit_sdev_status(struct zfcp_unit *unit)
+{
+        unsigned int status = 0;
+        struct scsi_device *sdev;
+        struct zfcp_scsi_dev *zfcp_sdev;
+
+        sdev = zfcp_unit_sdev(unit);
+        if (sdev) {
+                zfcp_sdev = sdev_to_zfcp(sdev);
+                status = atomic_read(&zfcp_sdev->status);
+                scsi_device_put(sdev);
+        }
+
+        return status;
+}
+
+/**
+ * zfcp_unit_remove - Remove entry from list of configured units
+ * @port: The port where to remove the unit from the configuration
+ * @fcp_lun: The 64 bit LUN of the unit to remove
+ *
+ * Returns: -EINVAL if a unit with the specified LUN does not exist,
+ *          0 on success.
+ */
+int zfcp_unit_remove(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
+
+        write_lock_irq(&port->unit_list_lock);
+        unit = _zfcp_unit_find(port, fcp_lun);
+        if (unit)
+                list_del(&unit->list);
+        write_unlock_irq(&port->unit_list_lock);
+
+        if (!unit)
+                return -EINVAL;
+
+        sdev = zfcp_unit_sdev(unit);
+        if (sdev) {
+                scsi_remove_device(sdev);
+                scsi_device_put(sdev);
+        }
+
+        put_device(&unit->dev);
+
+        zfcp_erp_unit_shutdown(unit, 0, "unrem_1", NULL);
+        zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
+
+        return 0;
+}