Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 2 | * zfcp device driver |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 4 | * Registration and callback for the s390 common I/O layer. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * |
Heiko Carstens | a53c8fa | 2012-07-20 11:15:04 +0200 | [diff] [blame] | 6 | * Copyright IBM Corp. 2002, 2010 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
Christof Schmitt | ecf39d4 | 2008-12-25 13:39:53 +0100 | [diff] [blame] | 9 | #define KMSG_COMPONENT "zfcp" |
| 10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
| 11 | |
Heiko Carstens | 3a4c5d5 | 2011-07-30 09:25:15 +0200 | [diff] [blame] | 12 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include "zfcp_ext.h" |
Christof Schmitt | b6bd2fb | 2010-02-17 11:18:50 +0100 | [diff] [blame] | 14 | #include "zfcp_reqlist.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
Christof Schmitt | 6fcf41d | 2009-05-15 13:18:21 +0200 | [diff] [blame] | 16 | #define ZFCP_MODEL_PRIV 0x4 |
| 17 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 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 | |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 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) |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 49 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 50 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 51 | |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 52 | if (!adapter) |
| 53 | return 0; |
| 54 | |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 55 | zfcp_erp_clear_adapter_status(adapter, clear); |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 56 | zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING); |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 57 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 58 | tag); |
Martin Peschke | 18f87a6 | 2014-11-13 14:59:48 +0100 | [diff] [blame] | 59 | |
| 60 | /* |
| 61 | * We want to scan ports here, with some random backoff and without |
| 62 | * rate limit. Recovery has already scheduled a port scan for us, |
| 63 | * but with both random delay and rate limit. Nevertheless we get |
| 64 | * what we want here by flushing the scheduled work after sleeping |
| 65 | * an equivalent random time. |
| 66 | * Let the port scan random delay elapse first. If recovery finishes |
| 67 | * up to that point in time, that would be perfect for both recovery |
| 68 | * and port scan. If not, i.e. recovery takes ages, there was no |
| 69 | * point in waiting a random delay on top of the time consumed by |
| 70 | * recovery. |
| 71 | */ |
| 72 | msleep(zfcp_fc_port_scan_backoff()); |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 73 | zfcp_erp_wait(adapter); |
Martin Peschke | 18f87a6 | 2014-11-13 14:59:48 +0100 | [diff] [blame] | 74 | flush_delayed_work(&adapter->scan_work); |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 75 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 76 | zfcp_ccw_adapter_put(adapter); |
| 77 | |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 78 | return 0; |
| 79 | } |
| 80 | |
Christof Schmitt | 6fcf41d | 2009-05-15 13:18:21 +0200 | [diff] [blame] | 81 | static struct ccw_device_id zfcp_ccw_device_id[] = { |
| 82 | { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) }, |
| 83 | { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) }, |
| 84 | {}, |
| 85 | }; |
| 86 | MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id); |
| 87 | |
| 88 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | * zfcp_ccw_probe - probe function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 90 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | * |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 92 | * This function gets called by the common i/o layer for each FCP |
| 93 | * device found on the current system. This is only a stub to make cio |
| 94 | * work: To only allocate adapter resources for devices actually used, |
| 95 | * the allocation is deferred to the first call to ccw_set_online. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 97 | static int zfcp_ccw_probe(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | { |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 99 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | /** |
| 103 | * zfcp_ccw_remove - remove function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 104 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | * |
| 106 | * This function gets called by the common i/o layer and removes an adapter |
| 107 | * from the system. Task of this function is to get rid of all units and |
| 108 | * ports that belong to this adapter. And in addition all resources of this |
| 109 | * adapter will be freed too. |
| 110 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 111 | static void zfcp_ccw_remove(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | { |
| 113 | struct zfcp_adapter *adapter; |
| 114 | struct zfcp_port *port, *p; |
| 115 | struct zfcp_unit *unit, *u; |
Christof Schmitt | 0406289 | 2008-10-01 12:42:20 +0200 | [diff] [blame] | 116 | LIST_HEAD(unit_remove_lh); |
| 117 | LIST_HEAD(port_remove_lh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 119 | ccw_device_set_offline(cdev); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 120 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 121 | adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 122 | if (!adapter) |
| 123 | return; |
| 124 | |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 125 | write_lock_irq(&adapter->port_list_lock); |
| 126 | list_for_each_entry_safe(port, p, &adapter->port_list, list) { |
| 127 | write_lock(&port->unit_list_lock); |
Swen Schillig | 6b183334 | 2009-11-24 16:54:05 +0100 | [diff] [blame] | 128 | list_for_each_entry_safe(unit, u, &port->unit_list, list) |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 129 | list_move(&unit->list, &unit_remove_lh); |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 130 | write_unlock(&port->unit_list_lock); |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 131 | list_move(&port->list, &port_remove_lh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | } |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 133 | write_unlock_irq(&adapter->port_list_lock); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 134 | zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | |
Swen Schillig | f3450c7 | 2009-11-24 16:53:59 +0100 | [diff] [blame] | 136 | list_for_each_entry_safe(unit, u, &unit_remove_lh, list) |
Sebastian Ott | 86bdf21 | 2013-04-26 16:13:49 +0200 | [diff] [blame] | 137 | device_unregister(&unit->dev); |
Swen Schillig | f3450c7 | 2009-11-24 16:53:59 +0100 | [diff] [blame] | 138 | |
| 139 | list_for_each_entry_safe(port, p, &port_remove_lh, list) |
Sebastian Ott | 83d4e1c | 2013-04-26 16:13:48 +0200 | [diff] [blame] | 140 | device_unregister(&port->dev); |
Swen Schillig | f3450c7 | 2009-11-24 16:53:59 +0100 | [diff] [blame] | 141 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 142 | zfcp_adapter_unregister(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | /** |
| 146 | * zfcp_ccw_set_online - set_online function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 147 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | * |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 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. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 158 | static int zfcp_ccw_set_online(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 160 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 162 | if (!adapter) { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 163 | adapter = zfcp_adapter_enqueue(cdev); |
| 164 | |
| 165 | if (IS_ERR(adapter)) { |
| 166 | dev_err(&cdev->dev, |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 167 | "Setting up data structures for the " |
| 168 | "FCP adapter failed\n"); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 169 | return PTR_ERR(adapter); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 170 | } |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 171 | kref_get(&adapter->ref); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 172 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | |
Volker Sameske | fea9d6c | 2006-08-02 11:05:16 +0200 | [diff] [blame] | 174 | /* initialize request counter */ |
Christof Schmitt | b6bd2fb | 2010-02-17 11:18:50 +0100 | [diff] [blame] | 175 | BUG_ON(!zfcp_reqlist_isempty(adapter->req_list)); |
Volker Sameske | fea9d6c | 2006-08-02 11:05:16 +0200 | [diff] [blame] | 176 | adapter->req_no = 0; |
| 177 | |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 178 | zfcp_ccw_activate(cdev, 0, "ccsonl1"); |
Martin Peschke | 18f87a6 | 2014-11-13 14:59:48 +0100 | [diff] [blame] | 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 | */ |
Steffen Maier | 43f60cb | 2012-09-04 15:23:35 +0200 | [diff] [blame] | 190 | zfcp_fc_inverse_conditional_port_scan(adapter); |
Martin Peschke | 18f87a6 | 2014-11-13 14:59:48 +0100 | [diff] [blame] | 191 | flush_delayed_work(&adapter->scan_work); |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 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 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 216 | zfcp_ccw_adapter_put(adapter); |
| 217 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | /** |
| 221 | * zfcp_ccw_set_offline - set_offline function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 222 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | * |
| 224 | * This function gets called by the common i/o layer and sets an adapter |
Michael Loehr | 9f28745 | 2007-05-09 11:01:24 +0200 | [diff] [blame] | 225 | * into state offline. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 227 | static int zfcp_ccw_set_offline(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | { |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 229 | return zfcp_ccw_offline_sync(cdev, 0, "ccsoff1"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | /** |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 233 | * zfcp_ccw_notify - ccw notify function |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 234 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 240 | static int zfcp_ccw_notify(struct ccw_device *cdev, int event) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 242 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
| 243 | |
| 244 | if (!adapter) |
| 245 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | switch (event) { |
| 248 | case CIO_GONE: |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 249 | if (atomic_read(&adapter->status) & |
| 250 | ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ |
| 251 | zfcp_dbf_hba_basic("ccnigo1", adapter); |
| 252 | break; |
| 253 | } |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 254 | dev_warn(&cdev->dev, "The FCP device has been detached\n"); |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 255 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | break; |
| 257 | case CIO_NO_PATH: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 258 | dev_warn(&cdev->dev, |
Christof Schmitt | ff3b24f | 2008-10-01 12:42:15 +0200 | [diff] [blame] | 259 | "The CHPID for the FCP device is offline\n"); |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 260 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | break; |
| 262 | case CIO_OPER: |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 263 | if (atomic_read(&adapter->status) & |
| 264 | ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ |
| 265 | zfcp_dbf_hba_basic("ccniop1", adapter); |
| 266 | break; |
| 267 | } |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 268 | dev_info(&cdev->dev, "The FCP device is operational again\n"); |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 269 | zfcp_erp_set_adapter_status(adapter, |
| 270 | ZFCP_STATUS_COMMON_RUNNING); |
Martin Peschke | 1f6f712 | 2008-04-18 12:51:55 +0200 | [diff] [blame] | 271 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 272 | "ccnoti4"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | break; |
Sebastian Ott | 47593bf | 2009-03-31 19:16:05 +0200 | [diff] [blame] | 274 | case CIO_BOXED: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 275 | dev_warn(&cdev->dev, "The FCP device did not respond within " |
| 276 | "the specified time\n"); |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 277 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5"); |
Sebastian Ott | 47593bf | 2009-03-31 19:16:05 +0200 | [diff] [blame] | 278 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | } |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 280 | |
| 281 | zfcp_ccw_adapter_put(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | return 1; |
| 283 | } |
| 284 | |
| 285 | /** |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 286 | * zfcp_ccw_shutdown - handle shutdown from cio |
| 287 | * @cdev: device for adapter to shutdown. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | */ |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 289 | static void zfcp_ccw_shutdown(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 291 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | |
Christof Schmitt | 1f99bd4 | 2009-09-24 10:23:23 +0200 | [diff] [blame] | 293 | if (!adapter) |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 294 | return; |
Christof Schmitt | 1f99bd4 | 2009-09-24 10:23:23 +0200 | [diff] [blame] | 295 | |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 296 | zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | zfcp_erp_wait(adapter); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 298 | zfcp_erp_thread_kill(adapter); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 299 | |
| 300 | zfcp_ccw_adapter_put(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | } |
| 302 | |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 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 | |
Christof Schmitt | c5afd81 | 2009-09-24 10:23:22 +0200 | [diff] [blame] | 325 | struct ccw_driver zfcp_ccw_driver = { |
Sebastian Ott | 3bda058 | 2011-03-23 10:16:02 +0100 | [diff] [blame] | 326 | .driver = { |
| 327 | .owner = THIS_MODULE, |
| 328 | .name = "zfcp", |
| 329 | }, |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 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, |
Steffen Maier | cb452149 | 2012-09-04 15:23:32 +0200 | [diff] [blame] | 337 | .freeze = zfcp_ccw_suspend, |
| 338 | .thaw = zfcp_ccw_thaw, |
| 339 | .restore = zfcp_ccw_resume, |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 340 | }; |