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 | * |
Christof Schmitt | 615f59e | 2010-02-17 11:18:56 +0100 | [diff] [blame] | 6 | * Copyright IBM Corporation 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include "zfcp_ext.h" |
Christof Schmitt | b6bd2fb | 2010-02-17 11:18:50 +0100 | [diff] [blame] | 13 | #include "zfcp_reqlist.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
Christof Schmitt | 6fcf41d | 2009-05-15 13:18:21 +0200 | [diff] [blame] | 15 | #define ZFCP_MODEL_PRIV 0x4 |
| 16 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 17 | static DEFINE_SPINLOCK(zfcp_ccw_adapter_ref_lock); |
| 18 | |
| 19 | struct zfcp_adapter *zfcp_ccw_adapter_by_cdev(struct ccw_device *cdev) |
| 20 | { |
| 21 | struct zfcp_adapter *adapter; |
| 22 | unsigned long flags; |
| 23 | |
| 24 | spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags); |
| 25 | adapter = dev_get_drvdata(&cdev->dev); |
| 26 | if (adapter) |
| 27 | kref_get(&adapter->ref); |
| 28 | spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags); |
| 29 | return adapter; |
| 30 | } |
| 31 | |
| 32 | void zfcp_ccw_adapter_put(struct zfcp_adapter *adapter) |
| 33 | { |
| 34 | unsigned long flags; |
| 35 | |
| 36 | spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags); |
| 37 | kref_put(&adapter->ref, zfcp_adapter_release); |
| 38 | spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags); |
| 39 | } |
| 40 | |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 41 | static int zfcp_ccw_activate(struct ccw_device *cdev) |
| 42 | |
| 43 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 44 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 45 | |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 46 | if (!adapter) |
| 47 | return 0; |
| 48 | |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 49 | zfcp_erp_modify_adapter_status(adapter, "ccresu1", NULL, |
| 50 | ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET); |
| 51 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
| 52 | "ccresu2", NULL); |
| 53 | zfcp_erp_wait(adapter); |
| 54 | flush_work(&adapter->scan_work); |
| 55 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 56 | zfcp_ccw_adapter_put(adapter); |
| 57 | |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 58 | return 0; |
| 59 | } |
| 60 | |
Christof Schmitt | 6fcf41d | 2009-05-15 13:18:21 +0200 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | /** |
| 78 | * zfcp_ccw_probe - probe function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 79 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | * |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 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. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 86 | static int zfcp_ccw_probe(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | { |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 88 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | /** |
| 92 | * zfcp_ccw_remove - remove function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 93 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 100 | static void zfcp_ccw_remove(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | { |
| 102 | struct zfcp_adapter *adapter; |
| 103 | struct zfcp_port *port, *p; |
| 104 | struct zfcp_unit *unit, *u; |
Christof Schmitt | 0406289 | 2008-10-01 12:42:20 +0200 | [diff] [blame] | 105 | LIST_HEAD(unit_remove_lh); |
| 106 | LIST_HEAD(port_remove_lh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 108 | ccw_device_set_offline(cdev); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 109 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 110 | adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 111 | if (!adapter) |
| 112 | return; |
| 113 | |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 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); |
Swen Schillig | 6b183334 | 2009-11-24 16:54:05 +0100 | [diff] [blame] | 117 | list_for_each_entry_safe(unit, u, &port->unit_list, list) |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 118 | list_move(&unit->list, &unit_remove_lh); |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 119 | write_unlock(&port->unit_list_lock); |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 120 | list_move(&port->list, &port_remove_lh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | } |
Swen Schillig | ecf0c77 | 2009-11-24 16:53:58 +0100 | [diff] [blame] | 122 | write_unlock_irq(&adapter->port_list_lock); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 123 | zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | |
Swen Schillig | f3450c7 | 2009-11-24 16:53:59 +0100 | [diff] [blame] | 125 | list_for_each_entry_safe(unit, u, &unit_remove_lh, list) |
Christof Schmitt | 615f59e | 2010-02-17 11:18:56 +0100 | [diff] [blame] | 126 | zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs); |
Swen Schillig | f3450c7 | 2009-11-24 16:53:59 +0100 | [diff] [blame] | 127 | |
| 128 | list_for_each_entry_safe(port, p, &port_remove_lh, list) |
Christof Schmitt | 615f59e | 2010-02-17 11:18:56 +0100 | [diff] [blame] | 129 | zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); |
Swen Schillig | f3450c7 | 2009-11-24 16:53:59 +0100 | [diff] [blame] | 130 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 131 | zfcp_adapter_unregister(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | } |
| 133 | |
| 134 | /** |
| 135 | * zfcp_ccw_set_online - set_online function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 136 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | * |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 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. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 147 | static int zfcp_ccw_set_online(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 149 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 151 | if (!adapter) { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 152 | adapter = zfcp_adapter_enqueue(cdev); |
| 153 | |
| 154 | if (IS_ERR(adapter)) { |
| 155 | dev_err(&cdev->dev, |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 156 | "Setting up data structures for the " |
| 157 | "FCP adapter failed\n"); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 158 | return PTR_ERR(adapter); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 159 | } |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 160 | kref_get(&adapter->ref); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 161 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | |
Volker Sameske | fea9d6c | 2006-08-02 11:05:16 +0200 | [diff] [blame] | 163 | /* initialize request counter */ |
Christof Schmitt | b6bd2fb | 2010-02-17 11:18:50 +0100 | [diff] [blame] | 164 | BUG_ON(!zfcp_reqlist_isempty(adapter->req_list)); |
Volker Sameske | fea9d6c | 2006-08-02 11:05:16 +0200 | [diff] [blame] | 165 | adapter->req_no = 0; |
| 166 | |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 167 | zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL, |
Martin Peschke | 698ec016 | 2008-03-27 14:22:02 +0100 | [diff] [blame] | 168 | ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET); |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 169 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
| 170 | "ccsonl2", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | zfcp_erp_wait(adapter); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 172 | |
| 173 | flush_work(&adapter->scan_work); |
| 174 | |
| 175 | zfcp_ccw_adapter_put(adapter); |
| 176 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | } |
| 178 | |
| 179 | /** |
| 180 | * zfcp_ccw_set_offline - set_offline function of zfcp driver |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 181 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | * |
| 183 | * 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] | 184 | * into state offline. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 186 | static int zfcp_ccw_set_offline(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 188 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 190 | if (!adapter) |
| 191 | return 0; |
| 192 | |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 193 | zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | zfcp_erp_wait(adapter); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 195 | |
| 196 | zfcp_ccw_adapter_put(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | return 0; |
| 198 | } |
| 199 | |
| 200 | /** |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 201 | * zfcp_ccw_notify - ccw notify function |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 202 | * @cdev: pointer to belonging ccw device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | * @event: indicates if adapter was detached or attached |
| 204 | * |
| 205 | * This function gets called by the common i/o layer if an adapter has gone |
| 206 | * or reappeared. |
| 207 | */ |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 208 | static int zfcp_ccw_notify(struct ccw_device *cdev, int event) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 210 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
| 211 | |
| 212 | if (!adapter) |
| 213 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | switch (event) { |
| 216 | case CIO_GONE: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 217 | dev_warn(&cdev->dev, "The FCP device has been detached\n"); |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 218 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | break; |
| 220 | case CIO_NO_PATH: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 221 | dev_warn(&cdev->dev, |
Christof Schmitt | ff3b24f | 2008-10-01 12:42:15 +0200 | [diff] [blame] | 222 | "The CHPID for the FCP device is offline\n"); |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 223 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | break; |
| 225 | case CIO_OPER: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 226 | dev_info(&cdev->dev, "The FCP device is operational again\n"); |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 227 | zfcp_erp_modify_adapter_status(adapter, "ccnoti3", NULL, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | ZFCP_STATUS_COMMON_RUNNING, |
| 229 | ZFCP_SET); |
Martin Peschke | 1f6f712 | 2008-04-18 12:51:55 +0200 | [diff] [blame] | 230 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 231 | "ccnoti4", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | break; |
Sebastian Ott | 47593bf | 2009-03-31 19:16:05 +0200 | [diff] [blame] | 233 | case CIO_BOXED: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 234 | dev_warn(&cdev->dev, "The FCP device did not respond within " |
| 235 | "the specified time\n"); |
Sebastian Ott | 47593bf | 2009-03-31 19:16:05 +0200 | [diff] [blame] | 236 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL); |
| 237 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | } |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 239 | |
| 240 | zfcp_ccw_adapter_put(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | return 1; |
| 242 | } |
| 243 | |
| 244 | /** |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 245 | * zfcp_ccw_shutdown - handle shutdown from cio |
| 246 | * @cdev: device for adapter to shutdown. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | */ |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 248 | static void zfcp_ccw_shutdown(struct ccw_device *cdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | { |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 250 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | |
Christof Schmitt | 1f99bd4 | 2009-09-24 10:23:23 +0200 | [diff] [blame] | 252 | if (!adapter) |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 253 | return; |
Christof Schmitt | 1f99bd4 | 2009-09-24 10:23:23 +0200 | [diff] [blame] | 254 | |
Swen Schillig | 5ffd51a | 2009-03-02 13:09:04 +0100 | [diff] [blame] | 255 | zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | zfcp_erp_wait(adapter); |
Christof Schmitt | 143bb6b | 2009-08-18 15:43:27 +0200 | [diff] [blame] | 257 | zfcp_erp_thread_kill(adapter); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 258 | |
| 259 | zfcp_ccw_adapter_put(adapter); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Christof Schmitt | c5afd81 | 2009-09-24 10:23:22 +0200 | [diff] [blame] | 262 | struct ccw_driver zfcp_ccw_driver = { |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 263 | .owner = THIS_MODULE, |
| 264 | .name = "zfcp", |
| 265 | .ids = zfcp_ccw_device_id, |
| 266 | .probe = zfcp_ccw_probe, |
| 267 | .remove = zfcp_ccw_remove, |
| 268 | .set_online = zfcp_ccw_set_online, |
| 269 | .set_offline = zfcp_ccw_set_offline, |
| 270 | .notify = zfcp_ccw_notify, |
| 271 | .shutdown = zfcp_ccw_shutdown, |
Swen Schillig | b42aece | 2009-11-24 16:54:01 +0100 | [diff] [blame] | 272 | .freeze = zfcp_ccw_set_offline, |
Martin Petermann | daa70fa | 2009-06-16 10:30:34 +0200 | [diff] [blame] | 273 | .thaw = zfcp_ccw_activate, |
| 274 | .restore = zfcp_ccw_activate, |
Christof Schmitt | fa04c28 | 2008-06-10 18:20:56 +0200 | [diff] [blame] | 275 | }; |