git.oblomov.eu Git - linux-2.6/blob - drivers/s390/scsi/zfcp_ccw.c

   1 /*
   2  * zfcp device driver
   3  *
   4  * Registration and callback for the s390 common I/O layer.
   5  *
   6  * Copyright IBM Corporation 2002, 2009
   7  */
   8
   9 #define KMSG_COMPONENT "zfcp"
  10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11
  12 #include "zfcp_ext.h"
  13
  14 #define ZFCP_MODEL_PRIV 0x4
  15
  16 static struct ccw_device_id zfcp_ccw_device_id[] = {
  17         { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
  18         { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) },
  19         {},
  20 };
  21 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
  22
  23 /**
  24  * zfcp_ccw_priv_sch - check if subchannel is privileged
  25  * @adapter: Adapter/Subchannel to check
  26  */
  27 int zfcp_ccw_priv_sch(struct zfcp_adapter *adapter)
  28 {
  29         return adapter->ccw_device->id.dev_model == ZFCP_MODEL_PRIV;
  30 }
  31
  32 /**
  33  * zfcp_ccw_probe - probe function of zfcp driver
  34  * @ccw_device: pointer to belonging ccw device
  35  *
  36  * This function gets called by the common i/o layer and sets up the initial
  37  * data structures for each fcp adapter, which was detected by the system.
  38  * Also the sysfs files for this adapter will be created by this function.
  39  * In addition the nameserver port will be added to the ports of the adapter
  40  * and its sysfs representation will be created too.
  41  */
  42 static int zfcp_ccw_probe(struct ccw_device *ccw_device)
  43 {
  44         int retval = 0;
  45
  46         down(&zfcp_data.config_sema);
  47         if (zfcp_adapter_enqueue(ccw_device)) {
  48                 dev_err(&ccw_device->dev,
  49                         "Setting up data structures for the "
  50                         "FCP adapter failed\n");
  51                 retval = -EINVAL;
  52         }
  53         up(&zfcp_data.config_sema);
  54         return retval;
  55 }
  56
  57 /**
  58  * zfcp_ccw_remove - remove function of zfcp driver
  59  * @ccw_device: pointer to belonging ccw device
  60  *
  61  * This function gets called by the common i/o layer and removes an adapter
  62  * from the system. Task of this function is to get rid of all units and
  63  * ports that belong to this adapter. And in addition all resources of this
  64  * adapter will be freed too.
  65  */
  66 static void zfcp_ccw_remove(struct ccw_device *ccw_device)
  67 {
  68         struct zfcp_adapter *adapter;
  69         struct zfcp_port *port, *p;
  70         struct zfcp_unit *unit, *u;
  71         LIST_HEAD(unit_remove_lh);
  72         LIST_HEAD(port_remove_lh);
  73
  74         ccw_device_set_offline(ccw_device);
  75         down(&zfcp_data.config_sema);
  76         adapter = dev_get_drvdata(&ccw_device->dev);
  77
  78         write_lock_irq(&zfcp_data.config_lock);
  79         list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
  80                 list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
  81                         list_move(&unit->list, &unit_remove_lh);
  82                         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
  83                                         &unit->status);
  84                 }
  85                 list_move(&port->list, &port_remove_lh);
  86                 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
  87         }
  88         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
  89         write_unlock_irq(&zfcp_data.config_lock);
  90
  91         list_for_each_entry_safe(port, p, &port_remove_lh, list) {
  92                 list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
  93                         if (unit->device)
  94                                 scsi_remove_device(unit->device);
  95                         zfcp_unit_dequeue(unit);
  96                 }
  97                 zfcp_port_dequeue(port);
  98         }
  99         wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
 100         zfcp_adapter_dequeue(adapter);
 101
 102         up(&zfcp_data.config_sema);
 103 }
 104
 105 /**
 106  * zfcp_ccw_set_online - set_online function of zfcp driver
 107  * @ccw_device: pointer to belonging ccw device
 108  *
 109  * This function gets called by the common i/o layer and sets an adapter
 110  * into state online. Setting an fcp device online means that it will be
 111  * registered with the SCSI stack, that the QDIO queues will be set up
 112  * and that the adapter will be opened (asynchronously).
 113  */
 114 static int zfcp_ccw_set_online(struct ccw_device *ccw_device)
 115 {
 116         struct zfcp_adapter *adapter;
 117         int retval;
 118
 119         down(&zfcp_data.config_sema);
 120         adapter = dev_get_drvdata(&ccw_device->dev);
 121
 122         retval = zfcp_erp_thread_setup(adapter);
 123         if (retval)
 124                 goto out;
 125
 126         /* initialize request counter */
 127         BUG_ON(!zfcp_reqlist_isempty(adapter));
 128         adapter->req_no = 0;
 129
 130         zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL,
 131                                        ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
 132         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
 133                                 "ccsonl2", NULL);
 134         zfcp_erp_wait(adapter);
 135         up(&zfcp_data.config_sema);
 136         flush_work(&adapter->scan_work);
 137         return 0;
 138
 139  out:
 140         up(&zfcp_data.config_sema);
 141         return retval;
 142 }
 143
 144 /**
 145  * zfcp_ccw_set_offline - set_offline function of zfcp driver
 146  * @ccw_device: pointer to belonging ccw device
 147  *
 148  * This function gets called by the common i/o layer and sets an adapter
 149  * into state offline.
 150  */
 151 static int zfcp_ccw_set_offline(struct ccw_device *ccw_device)
 152 {
 153         struct zfcp_adapter *adapter;
 154
 155         down(&zfcp_data.config_sema);
 156         adapter = dev_get_drvdata(&ccw_device->dev);
 157         zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL);
 158         zfcp_erp_wait(adapter);
 159         zfcp_erp_thread_kill(adapter);
 160         up(&zfcp_data.config_sema);
 161         return 0;
 162 }
 163
 164 /**
 165  * zfcp_ccw_notify - ccw notify function
 166  * @ccw_device: pointer to belonging ccw device
 167  * @event: indicates if adapter was detached or attached
 168  *
 169  * This function gets called by the common i/o layer if an adapter has gone
 170  * or reappeared.
 171  */
 172 static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
 173 {
 174         struct zfcp_adapter *adapter = dev_get_drvdata(&ccw_device->dev);
 175
 176         switch (event) {
 177         case CIO_GONE:
 178                 dev_warn(&adapter->ccw_device->dev,
 179                          "The FCP device has been detached\n");
 180                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL);
 181                 break;
 182         case CIO_NO_PATH:
 183                 dev_warn(&adapter->ccw_device->dev,
 184                          "The CHPID for the FCP device is offline\n");
 185                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL);
 186                 break;
 187         case CIO_OPER:
 188                 dev_info(&adapter->ccw_device->dev,
 189                          "The FCP device is operational again\n");
 190                 zfcp_erp_modify_adapter_status(adapter, "ccnoti3", NULL,
 191                                                ZFCP_STATUS_COMMON_RUNNING,
 192                                                ZFCP_SET);
 193                 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
 194                                         "ccnoti4", NULL);
 195                 break;
 196         case CIO_BOXED:
 197                 dev_warn(&adapter->ccw_device->dev, "The FCP device "
 198                          "did not respond within the specified time\n");
 199                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL);
 200                 break;
 201         }
 202         return 1;
 203 }
 204
 205 /**
 206  * zfcp_ccw_shutdown - handle shutdown from cio
 207  * @cdev: device for adapter to shutdown.
 208  */
 209 static void zfcp_ccw_shutdown(struct ccw_device *cdev)
 210 {
 211         struct zfcp_adapter *adapter;
 212
 213         down(&zfcp_data.config_sema);
 214         adapter = dev_get_drvdata(&cdev->dev);
 215         zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL);
 216         zfcp_erp_wait(adapter);
 217         up(&zfcp_data.config_sema);
 218 }
 219
 220 static struct ccw_driver zfcp_ccw_driver = {
 221         .owner       = THIS_MODULE,
 222         .name        = "zfcp",
 223         .ids         = zfcp_ccw_device_id,
 224         .probe       = zfcp_ccw_probe,
 225         .remove      = zfcp_ccw_remove,
 226         .set_online  = zfcp_ccw_set_online,
 227         .set_offline = zfcp_ccw_set_offline,
 228         .notify      = zfcp_ccw_notify,
 229         .shutdown    = zfcp_ccw_shutdown,
 230 };
 231
 232 /**
 233  * zfcp_ccw_register - ccw register function
 234  *
 235  * Registers the driver at the common i/o layer. This function will be called
 236  * at module load time/system start.
 237  */
 238 int __init zfcp_ccw_register(void)
 239 {
 240         return ccw_driver_register(&zfcp_ccw_driver);
 241 }
 242
 243 /**
 244  * zfcp_get_adapter_by_busid - find zfcp_adapter struct
 245  * @busid: bus id string of zfcp adapter to find
 246  */
 247 struct zfcp_adapter *zfcp_get_adapter_by_busid(char *busid)
 248 {
 249         struct ccw_device *ccw_device;
 250         struct zfcp_adapter *adapter = NULL;
 251
 252         ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
 253         if (ccw_device) {
 254                 adapter = dev_get_drvdata(&ccw_device->dev);
 255                 put_device(&ccw_device->dev);
 256         }
 257         return adapter;
 258 }