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_safe(port, p, &adapter->port_list, list) { 128 write_lock(&port->unit_list_lock); 129 list_for_each_entry_safe(unit, u, &port->unit_list, list) 130 list_move(&unit->list, &unit_remove_lh); 131 write_unlock(&port->unit_list_lock); 132 list_move(&port->list, &port_remove_lh); 133 } 134 write_unlock_irq(&adapter->port_list_lock); 135 zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ 136 137 list_for_each_entry_safe(unit, u, &unit_remove_lh, list) 138 device_unregister(&unit->dev); 139 140 list_for_each_entry_safe(port, p, &port_remove_lh, list) 141 device_unregister(&port->dev); 142 143 zfcp_adapter_unregister(adapter); 144 } 145 146 /** 147 * zfcp_ccw_set_online - set_online function of zfcp driver 148 * @cdev: pointer to belonging ccw device 149 * 150 * This function gets called by the common i/o layer and sets an 151 * adapter into state online. The first call will allocate all 152 * adapter resources that will be retained until the device is removed 153 * via zfcp_ccw_remove. 154 * 155 * Setting an fcp device online means that it will be registered with 156 * the SCSI stack, that the QDIO queues will be set up and that the 157 * adapter will be opened. 158 */ 159 static int zfcp_ccw_set_online(struct ccw_device *cdev) 160 { 161 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 162 163 if (!adapter) { 164 adapter = zfcp_adapter_enqueue(cdev); 165 166 if (IS_ERR(adapter)) { 167 dev_err(&cdev->dev, 168 "Setting up data structures for the " 169 "FCP adapter failed\n"); 170 return PTR_ERR(adapter); 171 } 172 kref_get(&adapter->ref); 173 } 174 175 /* initialize request counter */ 176 BUG_ON(!zfcp_reqlist_isempty(adapter->req_list)); 177 adapter->req_no = 0; 178 179 zfcp_ccw_activate(cdev, 0, "ccsonl1"); 180 181 /* 182 * We want to scan ports here, always, with some random delay and 183 * without rate limit - basically what zfcp_ccw_activate() has 184 * achieved for us. Not quite! That port scan depended on 185 * !no_auto_port_rescan. So let's cover the no_auto_port_rescan 186 * case here to make sure a port scan is done unconditionally. 187 * Since zfcp_ccw_activate() has waited the desired random time, 188 * we can immediately schedule and flush a port scan for the 189 * remaining cases. 190 */ 191 zfcp_fc_inverse_conditional_port_scan(adapter); 192 flush_delayed_work(&adapter->scan_work); 193 zfcp_ccw_adapter_put(adapter); 194 return 0; 195 } 196 197 /** 198 * zfcp_ccw_offline_sync - shut down adapter and wait for it to finish 199 * @cdev: pointer to belonging ccw device 200 * @set: Status flags to set. 201 * @tag: s390dbf trace record tag 202 * 203 * This function gets called by the common i/o layer and sets an adapter 204 * into state offline. 205 */ 206 static int zfcp_ccw_offline_sync(struct ccw_device *cdev, int set, char *tag) 207 { 208 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 209 210 if (!adapter) 211 return 0; 212 213 zfcp_erp_set_adapter_status(adapter, set); 214 zfcp_erp_adapter_shutdown(adapter, 0, tag); 215 zfcp_erp_wait(adapter); 216 217 zfcp_ccw_adapter_put(adapter); 218 return 0; 219 } 220 221 /** 222 * zfcp_ccw_set_offline - set_offline function of zfcp driver 223 * @cdev: pointer to belonging ccw device 224 * 225 * This function gets called by the common i/o layer and sets an adapter 226 * into state offline. 227 */ 228 static int zfcp_ccw_set_offline(struct ccw_device *cdev) 229 { 230 return zfcp_ccw_offline_sync(cdev, 0, "ccsoff1"); 231 } 232 233 /** 234 * zfcp_ccw_notify - ccw notify function 235 * @cdev: pointer to belonging ccw device 236 * @event: indicates if adapter was detached or attached 237 * 238 * This function gets called by the common i/o layer if an adapter has gone 239 * or reappeared. 240 */ 241 static int zfcp_ccw_notify(struct ccw_device *cdev, int event) 242 { 243 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 244 245 if (!adapter) 246 return 1; 247 248 switch (event) { 249 case CIO_GONE: 250 if (atomic_read(&adapter->status) & 251 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ 252 zfcp_dbf_hba_basic("ccnigo1", adapter); 253 break; 254 } 255 dev_warn(&cdev->dev, "The FCP device has been detached\n"); 256 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1"); 257 break; 258 case CIO_NO_PATH: 259 dev_warn(&cdev->dev, 260 "The CHPID for the FCP device is offline\n"); 261 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2"); 262 break; 263 case CIO_OPER: 264 if (atomic_read(&adapter->status) & 265 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ 266 zfcp_dbf_hba_basic("ccniop1", adapter); 267 break; 268 } 269 dev_info(&cdev->dev, "The FCP device is operational again\n"); 270 zfcp_erp_set_adapter_status(adapter, 271 ZFCP_STATUS_COMMON_RUNNING); 272 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 273 "ccnoti4"); 274 break; 275 case CIO_BOXED: 276 dev_warn(&cdev->dev, "The FCP device did not respond within " 277 "the specified time\n"); 278 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5"); 279 break; 280 } 281 282 zfcp_ccw_adapter_put(adapter); 283 return 1; 284 } 285 286 /** 287 * zfcp_ccw_shutdown - handle shutdown from cio 288 * @cdev: device for adapter to shutdown. 289 */ 290 static void zfcp_ccw_shutdown(struct ccw_device *cdev) 291 { 292 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 293 294 if (!adapter) 295 return; 296 297 zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1"); 298 zfcp_erp_wait(adapter); 299 zfcp_erp_thread_kill(adapter); 300 301 zfcp_ccw_adapter_put(adapter); 302 } 303 304 static int zfcp_ccw_suspend(struct ccw_device *cdev) 305 { 306 zfcp_ccw_offline_sync(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccsusp1"); 307 return 0; 308 } 309 310 static int zfcp_ccw_thaw(struct ccw_device *cdev) 311 { 312 /* trace records for thaw and final shutdown during suspend 313 can only be found in system dump until the end of suspend 314 but not after resume because it's based on the memory image 315 right after the very first suspend (freeze) callback */ 316 zfcp_ccw_activate(cdev, 0, "ccthaw1"); 317 return 0; 318 } 319 320 static int zfcp_ccw_resume(struct ccw_device *cdev) 321 { 322 zfcp_ccw_activate(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccresu1"); 323 return 0; 324 } 325 326 struct ccw_driver zfcp_ccw_driver = { 327 .driver = { 328 .owner = THIS_MODULE, 329 .name = "zfcp", 330 }, 331 .ids = zfcp_ccw_device_id, 332 .probe = zfcp_ccw_probe, 333 .remove = zfcp_ccw_remove, 334 .set_online = zfcp_ccw_set_online, 335 .set_offline = zfcp_ccw_set_offline, 336 .notify = zfcp_ccw_notify, 337 .shutdown = zfcp_ccw_shutdown, 338 .freeze = zfcp_ccw_suspend, 339 .thaw = zfcp_ccw_thaw, 340 .restore = zfcp_ccw_resume, 341 }; 342