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_offline_sync - shut down adapter and wait for it to finish 198 * @cdev: pointer to belonging ccw device 199 * @set: Status flags to set. 200 * @tag: s390dbf trace record tag 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_offline_sync(struct ccw_device *cdev, int set, char *tag) 206 { 207 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 208 209 if (!adapter) 210 return 0; 211 212 zfcp_erp_set_adapter_status(adapter, set); 213 zfcp_erp_adapter_shutdown(adapter, 0, tag); 214 zfcp_erp_wait(adapter); 215 216 zfcp_ccw_adapter_put(adapter); 217 return 0; 218 } 219 220 /** 221 * zfcp_ccw_set_offline - set_offline function of zfcp driver 222 * @cdev: pointer to belonging ccw device 223 * 224 * This function gets called by the common i/o layer and sets an adapter 225 * into state offline. 226 */ 227 static int zfcp_ccw_set_offline(struct ccw_device *cdev) 228 { 229 return zfcp_ccw_offline_sync(cdev, 0, "ccsoff1"); 230 } 231 232 /** 233 * zfcp_ccw_notify - ccw notify function 234 * @cdev: pointer to belonging ccw device 235 * @event: indicates if adapter was detached or attached 236 * 237 * This function gets called by the common i/o layer if an adapter has gone 238 * or reappeared. 239 */ 240 static int zfcp_ccw_notify(struct ccw_device *cdev, int event) 241 { 242 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 243 244 if (!adapter) 245 return 1; 246 247 switch (event) { 248 case CIO_GONE: 249 if (atomic_read(&adapter->status) & 250 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ 251 zfcp_dbf_hba_basic("ccnigo1", adapter); 252 break; 253 } 254 dev_warn(&cdev->dev, "The FCP device has been detached\n"); 255 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1"); 256 break; 257 case CIO_NO_PATH: 258 dev_warn(&cdev->dev, 259 "The CHPID for the FCP device is offline\n"); 260 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2"); 261 break; 262 case CIO_OPER: 263 if (atomic_read(&adapter->status) & 264 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ 265 zfcp_dbf_hba_basic("ccniop1", adapter); 266 break; 267 } 268 dev_info(&cdev->dev, "The FCP device is operational again\n"); 269 zfcp_erp_set_adapter_status(adapter, 270 ZFCP_STATUS_COMMON_RUNNING); 271 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 272 "ccnoti4"); 273 break; 274 case CIO_BOXED: 275 dev_warn(&cdev->dev, "The FCP device did not respond within " 276 "the specified time\n"); 277 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5"); 278 break; 279 } 280 281 zfcp_ccw_adapter_put(adapter); 282 return 1; 283 } 284 285 /** 286 * zfcp_ccw_shutdown - handle shutdown from cio 287 * @cdev: device for adapter to shutdown. 288 */ 289 static void zfcp_ccw_shutdown(struct ccw_device *cdev) 290 { 291 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); 292 293 if (!adapter) 294 return; 295 296 zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1"); 297 zfcp_erp_wait(adapter); 298 zfcp_erp_thread_kill(adapter); 299 300 zfcp_ccw_adapter_put(adapter); 301 } 302 303 static int zfcp_ccw_suspend(struct ccw_device *cdev) 304 { 305 zfcp_ccw_offline_sync(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccsusp1"); 306 return 0; 307 } 308 309 static int zfcp_ccw_thaw(struct ccw_device *cdev) 310 { 311 /* trace records for thaw and final shutdown during suspend 312 can only be found in system dump until the end of suspend 313 but not after resume because it's based on the memory image 314 right after the very first suspend (freeze) callback */ 315 zfcp_ccw_activate(cdev, 0, "ccthaw1"); 316 return 0; 317 } 318 319 static int zfcp_ccw_resume(struct ccw_device *cdev) 320 { 321 zfcp_ccw_activate(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccresu1"); 322 return 0; 323 } 324 325 struct ccw_driver zfcp_ccw_driver = { 326 .driver = { 327 .owner = THIS_MODULE, 328 .name = "zfcp", 329 }, 330 .ids = zfcp_ccw_device_id, 331 .probe = zfcp_ccw_probe, 332 .remove = zfcp_ccw_remove, 333 .set_online = zfcp_ccw_set_online, 334 .set_offline = zfcp_ccw_set_offline, 335 .notify = zfcp_ccw_notify, 336 .shutdown = zfcp_ccw_shutdown, 337 .freeze = zfcp_ccw_suspend, 338 .thaw = zfcp_ccw_thaw, 339 .restore = zfcp_ccw_resume, 340 }; 341