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