drivers/s390/scsi/zfcp_ccw.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * zfcp device driver
   4  *
   5  * Registration and callback for the s390 common I/O layer.
   6  *
   7  * Copyright IBM Corp. 2002, 2010
   8  */
   9
  10 #define KMSG_COMPONENT "zfcp"
  11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  12
  13 #include <linux/module.h>
  14 #include "zfcp_ext.h"
  15 #include "zfcp_reqlist.h"
  16
  17 #define ZFCP_MODEL_PRIV 0x4
  18
  19 static DEFINE_SPINLOCK(zfcp_ccw_adapter_ref_lock);
  20
  21 struct zfcp_adapter *zfcp_ccw_adapter_by_cdev(struct ccw_device *cdev)
  22 {
  23         struct zfcp_adapter *adapter;
  24         unsigned long flags;
  25
  26         spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
  27         adapter = dev_get_drvdata(&cdev->dev);
  28         if (adapter)
  29                 kref_get(&adapter->ref);
  30         spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
  31         return adapter;
  32 }
  33
  34 void zfcp_ccw_adapter_put(struct zfcp_adapter *adapter)
  35 {
  36         unsigned long flags;
  37
  38         spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
  39         kref_put(&adapter->ref, zfcp_adapter_release);
  40         spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
  41 }
  42
  43 /**
  44  * zfcp_ccw_activate - activate adapter and wait for it to finish
  45  * @cdev: pointer to belonging ccw device
  46  * @clear: Status flags to clear.
  47  * @tag: s390dbf trace record tag
  48  */
  49 static int zfcp_ccw_activate(struct ccw_device *cdev, int clear, char *tag)
  50 {
  51         struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
  52
  53         if (!adapter)
  54                 return 0;
  55
  56         zfcp_erp_clear_adapter_status(adapter, clear);
  57         zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
  58         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
  59                                 tag);
  60
  61         /*
  62          * We want to scan ports here, with some random backoff and without
  63          * rate limit. Recovery has already scheduled a port scan for us,
  64          * but with both random delay and rate limit. Nevertheless we get
  65          * what we want here by flushing the scheduled work after sleeping
  66          * an equivalent random time.
  67          * Let the port scan random delay elapse first. If recovery finishes
  68          * up to that point in time, that would be perfect for both recovery
  69          * and port scan. If not, i.e. recovery takes ages, there was no
  70          * point in waiting a random delay on top of the time consumed by
  71          * recovery.
  72          */
  73         msleep(zfcp_fc_port_scan_backoff());
  74         zfcp_erp_wait(adapter);
  75         flush_delayed_work(&adapter->scan_work);
  76
  77         zfcp_ccw_adapter_put(adapter);
  78
  79         return 0;
  80 }
  81
  82 static struct ccw_device_id zfcp_ccw_device_id[] = {
  83         { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
  84         { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) },
  85         {},
  86 };
  87 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
  88
  89 /**
  90  * zfcp_ccw_probe - probe function of zfcp driver
  91  * @cdev: pointer to belonging ccw device
  92  *
  93  * This function gets called by the common i/o layer for each FCP
  94  * device found on the current system. This is only a stub to make cio
  95  * work: To only allocate adapter resources for devices actually used,
  96  * the allocation is deferred to the first call to ccw_set_online.
  97  */
  98 static int zfcp_ccw_probe(struct ccw_device *cdev)
  99 {
 100         return 0;
 101 }
 102
 103 /**
 104  * zfcp_ccw_remove - remove function of zfcp driver
 105  * @cdev: pointer to belonging ccw device
 106  *
 107  * This function gets called by the common i/o layer and removes an adapter
 108  * from the system. Task of this function is to get rid of all units and
 109  * ports that belong to this adapter. And in addition all resources of this
 110  * adapter will be freed too.
 111  */
 112 static void zfcp_ccw_remove(struct ccw_device *cdev)
 113 {
 114         struct zfcp_adapter *adapter;
 115         struct zfcp_port *port, *p;
 116         struct zfcp_unit *unit, *u;
 117         LIST_HEAD(unit_remove_lh);
 118         LIST_HEAD(port_remove_lh);
 119
 120         ccw_device_set_offline(cdev);
 121
 122         adapter = zfcp_ccw_adapter_by_cdev(cdev);
 123         if (!adapter)
 124                 return;
 125
 126         write_lock_irq(&adapter->port_list_lock);
 127         list_for_each_entry(port, &adapter->port_list, list) {
 128                 write_lock(&port->unit_list_lock);
 129                 list_splice_init(&port->unit_list, &unit_remove_lh);
 130                 write_unlock(&port->unit_list_lock);
 131         }
 132         list_splice_init(&adapter->port_list, &port_remove_lh);
 133         write_unlock_irq(&adapter->port_list_lock);
 134         zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */
 135
 136         list_for_each_entry_safe(unit, u, &unit_remove_lh, list)
 137                 device_unregister(&unit->dev);
 138
 139         list_for_each_entry_safe(port, p, &port_remove_lh, list)
 140                 device_unregister(&port->dev);
 141
 142         zfcp_adapter_unregister(adapter);
 143 }
 144
 145 /**
 146  * zfcp_ccw_set_online - set_online function of zfcp driver
 147  * @cdev: pointer to belonging ccw device
 148  *
 149  * This function gets called by the common i/o layer and sets an
 150  * adapter into state online.  The first call will allocate all
 151  * adapter resources that will be retained until the device is removed
 152  * via zfcp_ccw_remove.
 153  *
 154  * Setting an fcp device online means that it will be registered with
 155  * the SCSI stack, that the QDIO queues will be set up and that the
 156  * adapter will be opened.
 157  */
 158 static int zfcp_ccw_set_online(struct ccw_device *cdev)
 159 {
 160         struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 161
 162         if (!adapter) {
 163                 adapter = zfcp_adapter_enqueue(cdev);
 164
 165                 if (IS_ERR(adapter)) {
 166                         dev_err(&cdev->dev,
 167                                 "Setting up data structures for the "
 168                                 "FCP adapter failed\n");
 169                         return PTR_ERR(adapter);
 170                 }
 171                 kref_get(&adapter->ref);
 172         }
 173
 174         /* initialize request counter */
 175         BUG_ON(!zfcp_reqlist_isempty(adapter->req_list));
 176         adapter->req_no = 0;
 177
 178         zfcp_ccw_activate(cdev, 0, "ccsonl1");
 179
 180         /*
 181          * We want to scan ports here, always, with some random delay and
 182          * without rate limit - basically what zfcp_ccw_activate() has
 183          * achieved for us. Not quite! That port scan depended on
 184          * !no_auto_port_rescan. So let's cover the no_auto_port_rescan
 185          * case here to make sure a port scan is done unconditionally.
 186          * Since zfcp_ccw_activate() has waited the desired random time,
 187          * we can immediately schedule and flush a port scan for the
 188          * remaining cases.
 189          */
 190         zfcp_fc_inverse_conditional_port_scan(adapter);
 191         flush_delayed_work(&adapter->scan_work);
 192         zfcp_ccw_adapter_put(adapter);
 193         return 0;
 194 }
 195
 196 /**
 197  * zfcp_ccw_set_offline - set_offline function of zfcp driver
 198  * @cdev: pointer to belonging ccw device
 199  *
 200  * This function gets called by the common i/o layer and sets an adapter
 201  * into state offline.
 202  */
 203 static int zfcp_ccw_set_offline(struct ccw_device *cdev)
 204 {
 205         struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 206
 207         if (!adapter)
 208                 return 0;
 209
 210         zfcp_erp_set_adapter_status(adapter, 0);
 211         zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1");
 212         zfcp_erp_wait(adapter);
 213
 214         zfcp_ccw_adapter_put(adapter);
 215         return 0;
 216 }
 217
 218 /**
 219  * zfcp_ccw_notify - ccw notify function
 220  * @cdev: pointer to belonging ccw device
 221  * @event: indicates if adapter was detached or attached
 222  *
 223  * This function gets called by the common i/o layer if an adapter has gone
 224  * or reappeared.
 225  */
 226 static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
 227 {
 228         struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 229
 230         if (!adapter)
 231                 return 1;
 232
 233         switch (event) {
 234         case CIO_GONE:
 235                 dev_warn(&cdev->dev, "The FCP device has been detached\n");
 236                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1");
 237                 break;
 238         case CIO_NO_PATH:
 239                 dev_warn(&cdev->dev,
 240                          "The CHPID for the FCP device is offline\n");
 241                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2");
 242                 break;
 243         case CIO_OPER:
 244                 dev_info(&cdev->dev, "The FCP device is operational again\n");
 245                 zfcp_erp_set_adapter_status(adapter,
 246                                             ZFCP_STATUS_COMMON_RUNNING);
 247                 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
 248                                         "ccnoti4");
 249                 break;
 250         case CIO_BOXED:
 251                 dev_warn(&cdev->dev, "The FCP device did not respond within "
 252                                      "the specified time\n");
 253                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5");
 254                 break;
 255         }
 256
 257         zfcp_ccw_adapter_put(adapter);
 258         return 1;
 259 }
 260
 261 /**
 262  * zfcp_ccw_shutdown - handle shutdown from cio
 263  * @cdev: device for adapter to shutdown.
 264  */
 265 static void zfcp_ccw_shutdown(struct ccw_device *cdev)
 266 {
 267         struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 268
 269         if (!adapter)
 270                 return;
 271
 272         zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1");
 273         zfcp_erp_wait(adapter);
 274         zfcp_erp_thread_kill(adapter);
 275
 276         zfcp_ccw_adapter_put(adapter);
 277 }
 278
 279 struct ccw_driver zfcp_ccw_driver = {
 280         .driver = {
 281                 .owner  = THIS_MODULE,
 282                 .name   = "zfcp",
 283         },
 284         .ids         = zfcp_ccw_device_id,
 285         .probe       = zfcp_ccw_probe,
 286         .remove      = zfcp_ccw_remove,
 287         .set_online  = zfcp_ccw_set_online,
 288         .set_offline = zfcp_ccw_set_offline,
 289         .notify      = zfcp_ccw_notify,
 290         .shutdown    = zfcp_ccw_shutdown,
 291 };