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 /** 43 * zfcp_ccw_activate - activate adapter and wait for it to finish 44 * @cdev: pointer to belonging ccw device 45 * @clear: Status flags to clear. 46 * @tag: s390dbf trace record tag 47 */ 48 static int zfcp_ccw_activate(struct ccw_device *cdev, int clear, char *tag) 49 { 50 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 51 52 if (!adapter) 53 return 0; 54 55 zfcp_erp_clear_adapter_status(adapter, clear); 56 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING); 57 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 58 tag); 59 zfcp_erp_wait(adapter); 60 flush_work(&adapter->scan_work); /* ok to call even if nothing queued */ 61 62 zfcp_ccw_adapter_put(adapter); 63 64 return 0; 65 } 66 67 static struct ccw_device_id zfcp_ccw_device_id[] = { 68 { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) }, 69 { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) }, 70 {}, 71 }; 72 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id); 73 74 /** 75 * zfcp_ccw_probe - probe function of zfcp driver 76 * @cdev: pointer to belonging ccw device 77 * 78 * This function gets called by the common i/o layer for each FCP 79 * device found on the current system. This is only a stub to make cio 80 * work: To only allocate adapter resources for devices actually used, 81 * the allocation is deferred to the first call to ccw_set_online. 82 */ 83 static int zfcp_ccw_probe(struct ccw_device *cdev) 84 { 85 return 0; 86 } 87 88 /** 89 * zfcp_ccw_remove - remove function of zfcp driver 90 * @cdev: pointer to belonging ccw device 91 * 92 * This function gets called by the common i/o layer and removes an adapter 93 * from the system. Task of this function is to get rid of all units and 94 * ports that belong to this adapter. And in addition all resources of this 95 * adapter will be freed too. 96 */ 97 static void zfcp_ccw_remove(struct ccw_device *cdev) 98 { 99 struct zfcp_adapter *adapter; 100 struct zfcp_port *port, *p; 101 struct zfcp_unit *unit, *u; 102 LIST_HEAD(unit_remove_lh); 103 LIST_HEAD(port_remove_lh); 104 105 ccw_device_set_offline(cdev); 106 107 adapter = zfcp_ccw_adapter_by_cdev(cdev); 108 if (!adapter) 109 return; 110 111 write_lock_irq(&adapter->port_list_lock); 112 list_for_each_entry_safe(port, p, &adapter->port_list, list) { 113 write_lock(&port->unit_list_lock); 114 list_for_each_entry_safe(unit, u, &port->unit_list, list) 115 list_move(&unit->list, &unit_remove_lh); 116 write_unlock(&port->unit_list_lock); 117 list_move(&port->list, &port_remove_lh); 118 } 119 write_unlock_irq(&adapter->port_list_lock); 120 zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ 121 122 list_for_each_entry_safe(unit, u, &unit_remove_lh, list) 123 device_unregister(&unit->dev); 124 125 list_for_each_entry_safe(port, p, &port_remove_lh, list) 126 device_unregister(&port->dev); 127 128 zfcp_adapter_unregister(adapter); 129 } 130 131 /** 132 * zfcp_ccw_set_online - set_online function of zfcp driver 133 * @cdev: pointer to belonging ccw device 134 * 135 * This function gets called by the common i/o layer and sets an 136 * adapter into state online. The first call will allocate all 137 * adapter resources that will be retained until the device is removed 138 * via zfcp_ccw_remove. 139 * 140 * Setting an fcp device online means that it will be registered with 141 * the SCSI stack, that the QDIO queues will be set up and that the 142 * adapter will be opened. 143 */ 144 static int zfcp_ccw_set_online(struct ccw_device *cdev) 145 { 146 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 147 148 if (!adapter) { 149 adapter = zfcp_adapter_enqueue(cdev); 150 151 if (IS_ERR(adapter)) { 152 dev_err(&cdev->dev, 153 "Setting up data structures for the " 154 "FCP adapter failed\n"); 155 return PTR_ERR(adapter); 156 } 157 kref_get(&adapter->ref); 158 } 159 160 /* initialize request counter */ 161 BUG_ON(!zfcp_reqlist_isempty(adapter->req_list)); 162 adapter->req_no = 0; 163 164 zfcp_ccw_activate(cdev, 0, "ccsonl1"); 165 /* scan for remote ports 166 either at the end of any successful adapter recovery 167 or only after the adapter recovery for setting a device online */ 168 zfcp_fc_inverse_conditional_port_scan(adapter); 169 flush_work(&adapter->scan_work); /* ok to call even if nothing queued */ 170 zfcp_ccw_adapter_put(adapter); 171 return 0; 172 } 173 174 /** 175 * zfcp_ccw_offline_sync - shut down adapter and wait for it to finish 176 * @cdev: pointer to belonging ccw device 177 * @set: Status flags to set. 178 * @tag: s390dbf trace record tag 179 * 180 * This function gets called by the common i/o layer and sets an adapter 181 * into state offline. 182 */ 183 static int zfcp_ccw_offline_sync(struct ccw_device *cdev, int set, char *tag) 184 { 185 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 186 187 if (!adapter) 188 return 0; 189 190 zfcp_erp_set_adapter_status(adapter, set); 191 zfcp_erp_adapter_shutdown(adapter, 0, tag); 192 zfcp_erp_wait(adapter); 193 194 zfcp_ccw_adapter_put(adapter); 195 return 0; 196 } 197 198 /** 199 * zfcp_ccw_set_offline - set_offline function of zfcp driver 200 * @cdev: pointer to belonging ccw device 201 * 202 * This function gets called by the common i/o layer and sets an adapter 203 * into state offline. 204 */ 205 static int zfcp_ccw_set_offline(struct ccw_device *cdev) 206 { 207 return zfcp_ccw_offline_sync(cdev, 0, "ccsoff1"); 208 } 209 210 /** 211 * zfcp_ccw_notify - ccw notify function 212 * @cdev: pointer to belonging ccw device 213 * @event: indicates if adapter was detached or attached 214 * 215 * This function gets called by the common i/o layer if an adapter has gone 216 * or reappeared. 217 */ 218 static int zfcp_ccw_notify(struct ccw_device *cdev, int event) 219 { 220 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 221 222 if (!adapter) 223 return 1; 224 225 switch (event) { 226 case CIO_GONE: 227 if (atomic_read(&adapter->status) & 228 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ 229 zfcp_dbf_hba_basic("ccnigo1", adapter); 230 break; 231 } 232 dev_warn(&cdev->dev, "The FCP device has been detached\n"); 233 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1"); 234 break; 235 case CIO_NO_PATH: 236 dev_warn(&cdev->dev, 237 "The CHPID for the FCP device is offline\n"); 238 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2"); 239 break; 240 case CIO_OPER: 241 if (atomic_read(&adapter->status) & 242 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ 243 zfcp_dbf_hba_basic("ccniop1", adapter); 244 break; 245 } 246 dev_info(&cdev->dev, "The FCP device is operational again\n"); 247 zfcp_erp_set_adapter_status(adapter, 248 ZFCP_STATUS_COMMON_RUNNING); 249 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 250 "ccnoti4"); 251 break; 252 case CIO_BOXED: 253 dev_warn(&cdev->dev, "The FCP device did not respond within " 254 "the specified time\n"); 255 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5"); 256 break; 257 } 258 259 zfcp_ccw_adapter_put(adapter); 260 return 1; 261 } 262 263 /** 264 * zfcp_ccw_shutdown - handle shutdown from cio 265 * @cdev: device for adapter to shutdown. 266 */ 267 static void zfcp_ccw_shutdown(struct ccw_device *cdev) 268 { 269 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 270 271 if (!adapter) 272 return; 273 274 zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1"); 275 zfcp_erp_wait(adapter); 276 zfcp_erp_thread_kill(adapter); 277 278 zfcp_ccw_adapter_put(adapter); 279 } 280 281 static int zfcp_ccw_suspend(struct ccw_device *cdev) 282 { 283 zfcp_ccw_offline_sync(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccsusp1"); 284 return 0; 285 } 286 287 static int zfcp_ccw_thaw(struct ccw_device *cdev) 288 { 289 /* trace records for thaw and final shutdown during suspend 290 can only be found in system dump until the end of suspend 291 but not after resume because it's based on the memory image 292 right after the very first suspend (freeze) callback */ 293 zfcp_ccw_activate(cdev, 0, "ccthaw1"); 294 return 0; 295 } 296 297 static int zfcp_ccw_resume(struct ccw_device *cdev) 298 { 299 zfcp_ccw_activate(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccresu1"); 300 return 0; 301 } 302 303 struct ccw_driver zfcp_ccw_driver = { 304 .driver = { 305 .owner = THIS_MODULE, 306 .name = "zfcp", 307 }, 308 .ids = zfcp_ccw_device_id, 309 .probe = zfcp_ccw_probe, 310 .remove = zfcp_ccw_remove, 311 .set_online = zfcp_ccw_set_online, 312 .set_offline = zfcp_ccw_set_offline, 313 .notify = zfcp_ccw_notify, 314 .shutdown = zfcp_ccw_shutdown, 315 .freeze = zfcp_ccw_suspend, 316 .thaw = zfcp_ccw_thaw, 317 .restore = zfcp_ccw_resume, 318 }; 319