Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
fa04c281 | 2 | * zfcp device driver |
1da177e4 | 3 | * |
fa04c281 | 4 | * Registration and callback for the s390 common I/O layer. |
1da177e4 | 5 | * |
a53c8fab | 6 | * Copyright IBM Corp. 2002, 2010 |
1da177e4 LT |
7 | */ |
8 | ||
ecf39d42 CS |
9 | #define KMSG_COMPONENT "zfcp" |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
11 | ||
3a4c5d59 | 12 | #include <linux/module.h> |
1da177e4 | 13 | #include "zfcp_ext.h" |
b6bd2fb9 | 14 | #include "zfcp_reqlist.h" |
1da177e4 | 15 | |
6fcf41d1 CS |
16 | #define ZFCP_MODEL_PRIV 0x4 |
17 | ||
de3dc572 SS |
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 | ||
cb452149 SM |
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) | |
daa70fa9 | 49 | { |
de3dc572 | 50 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
daa70fa9 | 51 | |
143bb6bf CS |
52 | if (!adapter) |
53 | return 0; | |
54 | ||
cb452149 | 55 | zfcp_erp_clear_adapter_status(adapter, clear); |
edaed859 | 56 | zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING); |
daa70fa9 | 57 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
cb452149 | 58 | tag); |
18f87a67 MP |
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()); | |
daa70fa9 | 73 | zfcp_erp_wait(adapter); |
18f87a67 | 74 | flush_delayed_work(&adapter->scan_work); |
daa70fa9 | 75 | |
de3dc572 SS |
76 | zfcp_ccw_adapter_put(adapter); |
77 | ||
daa70fa9 MP |
78 | return 0; |
79 | } | |
80 | ||
6fcf41d1 CS |
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 | ||
1da177e4 LT |
88 | /** |
89 | * zfcp_ccw_probe - probe function of zfcp driver | |
de3dc572 | 90 | * @cdev: pointer to belonging ccw device |
1da177e4 | 91 | * |
143bb6bf CS |
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. | |
1da177e4 | 96 | */ |
de3dc572 | 97 | static int zfcp_ccw_probe(struct ccw_device *cdev) |
1da177e4 | 98 | { |
143bb6bf | 99 | return 0; |
1da177e4 LT |
100 | } |
101 | ||
102 | /** | |
103 | * zfcp_ccw_remove - remove function of zfcp driver | |
de3dc572 | 104 | * @cdev: pointer to belonging ccw device |
1da177e4 LT |
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 | */ | |
de3dc572 | 111 | static void zfcp_ccw_remove(struct ccw_device *cdev) |
1da177e4 LT |
112 | { |
113 | struct zfcp_adapter *adapter; | |
114 | struct zfcp_port *port, *p; | |
115 | struct zfcp_unit *unit, *u; | |
0406289e CS |
116 | LIST_HEAD(unit_remove_lh); |
117 | LIST_HEAD(port_remove_lh); | |
1da177e4 | 118 | |
de3dc572 | 119 | ccw_device_set_offline(cdev); |
f45a5421 | 120 | |
de3dc572 | 121 | adapter = zfcp_ccw_adapter_by_cdev(cdev); |
ecf0c772 SS |
122 | if (!adapter) |
123 | return; | |
124 | ||
ecf0c772 SS |
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); | |
6b183334 | 128 | list_for_each_entry_safe(unit, u, &port->unit_list, list) |
ecf0c772 | 129 | list_move(&unit->list, &unit_remove_lh); |
ecf0c772 | 130 | write_unlock(&port->unit_list_lock); |
ecf0c772 | 131 | list_move(&port->list, &port_remove_lh); |
1da177e4 | 132 | } |
ecf0c772 | 133 | write_unlock_irq(&adapter->port_list_lock); |
de3dc572 | 134 | zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ |
1da177e4 | 135 | |
f3450c7b | 136 | list_for_each_entry_safe(unit, u, &unit_remove_lh, list) |
86bdf218 | 137 | device_unregister(&unit->dev); |
f3450c7b SS |
138 | |
139 | list_for_each_entry_safe(port, p, &port_remove_lh, list) | |
83d4e1c3 | 140 | device_unregister(&port->dev); |
f3450c7b | 141 | |
de3dc572 | 142 | zfcp_adapter_unregister(adapter); |
1da177e4 LT |
143 | } |
144 | ||
145 | /** | |
146 | * zfcp_ccw_set_online - set_online function of zfcp driver | |
de3dc572 | 147 | * @cdev: pointer to belonging ccw device |
1da177e4 | 148 | * |
143bb6bf CS |
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. | |
1da177e4 | 157 | */ |
de3dc572 | 158 | static int zfcp_ccw_set_online(struct ccw_device *cdev) |
1da177e4 | 159 | { |
de3dc572 | 160 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
1da177e4 | 161 | |
143bb6bf | 162 | if (!adapter) { |
de3dc572 SS |
163 | adapter = zfcp_adapter_enqueue(cdev); |
164 | ||
165 | if (IS_ERR(adapter)) { | |
166 | dev_err(&cdev->dev, | |
143bb6bf CS |
167 | "Setting up data structures for the " |
168 | "FCP adapter failed\n"); | |
de3dc572 | 169 | return PTR_ERR(adapter); |
143bb6bf | 170 | } |
de3dc572 | 171 | kref_get(&adapter->ref); |
143bb6bf | 172 | } |
1da177e4 | 173 | |
fea9d6c7 | 174 | /* initialize request counter */ |
b6bd2fb9 | 175 | BUG_ON(!zfcp_reqlist_isempty(adapter->req_list)); |
fea9d6c7 VS |
176 | adapter->req_no = 0; |
177 | ||
cb452149 | 178 | zfcp_ccw_activate(cdev, 0, "ccsonl1"); |
18f87a67 MP |
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 | */ | |
43f60cbd | 190 | zfcp_fc_inverse_conditional_port_scan(adapter); |
18f87a67 | 191 | flush_delayed_work(&adapter->scan_work); |
de3dc572 SS |
192 | zfcp_ccw_adapter_put(adapter); |
193 | return 0; | |
1da177e4 LT |
194 | } |
195 | ||
196 | /** | |
cb452149 | 197 | * zfcp_ccw_offline_sync - shut down adapter and wait for it to finish |
de3dc572 | 198 | * @cdev: pointer to belonging ccw device |
cb452149 SM |
199 | * @set: Status flags to set. |
200 | * @tag: s390dbf trace record tag | |
1da177e4 LT |
201 | * |
202 | * This function gets called by the common i/o layer and sets an adapter | |
9f28745a | 203 | * into state offline. |
1da177e4 | 204 | */ |
cb452149 | 205 | static int zfcp_ccw_offline_sync(struct ccw_device *cdev, int set, char *tag) |
1da177e4 | 206 | { |
de3dc572 SS |
207 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
208 | ||
209 | if (!adapter) | |
210 | return 0; | |
1da177e4 | 211 | |
cb452149 SM |
212 | zfcp_erp_set_adapter_status(adapter, set); |
213 | zfcp_erp_adapter_shutdown(adapter, 0, tag); | |
1da177e4 | 214 | zfcp_erp_wait(adapter); |
de3dc572 SS |
215 | |
216 | zfcp_ccw_adapter_put(adapter); | |
1da177e4 LT |
217 | return 0; |
218 | } | |
219 | ||
cb452149 SM |
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 | ||
1da177e4 | 232 | /** |
fa04c281 | 233 | * zfcp_ccw_notify - ccw notify function |
de3dc572 | 234 | * @cdev: pointer to belonging ccw device |
1da177e4 LT |
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 | */ | |
de3dc572 | 240 | static int zfcp_ccw_notify(struct ccw_device *cdev, int event) |
1da177e4 | 241 | { |
de3dc572 SS |
242 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
243 | ||
244 | if (!adapter) | |
245 | return 1; | |
1da177e4 | 246 | |
1da177e4 LT |
247 | switch (event) { |
248 | case CIO_GONE: | |
cb452149 SM |
249 | if (atomic_read(&adapter->status) & |
250 | ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ | |
251 | zfcp_dbf_hba_basic("ccnigo1", adapter); | |
252 | break; | |
253 | } | |
de3dc572 | 254 | dev_warn(&cdev->dev, "The FCP device has been detached\n"); |
ea4a3a6a | 255 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1"); |
1da177e4 LT |
256 | break; |
257 | case CIO_NO_PATH: | |
de3dc572 | 258 | dev_warn(&cdev->dev, |
ff3b24fa | 259 | "The CHPID for the FCP device is offline\n"); |
ea4a3a6a | 260 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2"); |
1da177e4 LT |
261 | break; |
262 | case CIO_OPER: | |
cb452149 SM |
263 | if (atomic_read(&adapter->status) & |
264 | ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */ | |
265 | zfcp_dbf_hba_basic("ccniop1", adapter); | |
266 | break; | |
267 | } | |
de3dc572 | 268 | dev_info(&cdev->dev, "The FCP device is operational again\n"); |
edaed859 SS |
269 | zfcp_erp_set_adapter_status(adapter, |
270 | ZFCP_STATUS_COMMON_RUNNING); | |
1f6f7129 | 271 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
ea4a3a6a | 272 | "ccnoti4"); |
1da177e4 | 273 | break; |
47593bfa | 274 | case CIO_BOXED: |
de3dc572 SS |
275 | dev_warn(&cdev->dev, "The FCP device did not respond within " |
276 | "the specified time\n"); | |
ea4a3a6a | 277 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5"); |
47593bfa | 278 | break; |
1da177e4 | 279 | } |
de3dc572 SS |
280 | |
281 | zfcp_ccw_adapter_put(adapter); | |
1da177e4 LT |
282 | return 1; |
283 | } | |
284 | ||
285 | /** | |
fa04c281 CS |
286 | * zfcp_ccw_shutdown - handle shutdown from cio |
287 | * @cdev: device for adapter to shutdown. | |
1da177e4 | 288 | */ |
fa04c281 | 289 | static void zfcp_ccw_shutdown(struct ccw_device *cdev) |
1da177e4 | 290 | { |
de3dc572 | 291 | struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); |
1da177e4 | 292 | |
1f99bd4c | 293 | if (!adapter) |
de3dc572 | 294 | return; |
1f99bd4c | 295 | |
ea4a3a6a | 296 | zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1"); |
1da177e4 | 297 | zfcp_erp_wait(adapter); |
143bb6bf | 298 | zfcp_erp_thread_kill(adapter); |
de3dc572 SS |
299 | |
300 | zfcp_ccw_adapter_put(adapter); | |
1da177e4 LT |
301 | } |
302 | ||
cb452149 SM |
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 | ||
c5afd81e | 325 | struct ccw_driver zfcp_ccw_driver = { |
3bda058b SO |
326 | .driver = { |
327 | .owner = THIS_MODULE, | |
328 | .name = "zfcp", | |
329 | }, | |
fa04c281 CS |
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, | |
cb452149 SM |
337 | .freeze = zfcp_ccw_suspend, |
338 | .thaw = zfcp_ccw_thaw, | |
339 | .restore = zfcp_ccw_resume, | |
fa04c281 | 340 | }; |