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 | * |
6d1a27f6 | 6 | * Copyright IBM Corporation 2002, 2009 |
1da177e4 LT |
7 | */ |
8 | ||
ecf39d42 CS |
9 | #define KMSG_COMPONENT "zfcp" |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
11 | ||
1da177e4 LT |
12 | #include "zfcp_ext.h" |
13 | ||
6fcf41d1 CS |
14 | #define ZFCP_MODEL_PRIV 0x4 |
15 | ||
daa70fa9 MP |
16 | static int zfcp_ccw_suspend(struct ccw_device *cdev) |
17 | ||
18 | { | |
19 | struct zfcp_adapter *adapter = dev_get_drvdata(&cdev->dev); | |
20 | ||
143bb6bf CS |
21 | if (!adapter) |
22 | return 0; | |
23 | ||
24680def | 24 | mutex_lock(&zfcp_data.config_mutex); |
daa70fa9 MP |
25 | |
26 | zfcp_erp_adapter_shutdown(adapter, 0, "ccsusp1", NULL); | |
27 | zfcp_erp_wait(adapter); | |
28 | ||
24680def | 29 | mutex_unlock(&zfcp_data.config_mutex); |
daa70fa9 MP |
30 | |
31 | return 0; | |
32 | } | |
33 | ||
34 | static int zfcp_ccw_activate(struct ccw_device *cdev) | |
35 | ||
36 | { | |
37 | struct zfcp_adapter *adapter = dev_get_drvdata(&cdev->dev); | |
38 | ||
143bb6bf CS |
39 | if (!adapter) |
40 | return 0; | |
41 | ||
daa70fa9 MP |
42 | zfcp_erp_modify_adapter_status(adapter, "ccresu1", NULL, |
43 | ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET); | |
44 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, | |
45 | "ccresu2", NULL); | |
46 | zfcp_erp_wait(adapter); | |
47 | flush_work(&adapter->scan_work); | |
48 | ||
49 | return 0; | |
50 | } | |
51 | ||
6fcf41d1 CS |
52 | static struct ccw_device_id zfcp_ccw_device_id[] = { |
53 | { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) }, | |
54 | { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) }, | |
55 | {}, | |
56 | }; | |
57 | MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id); | |
58 | ||
59 | /** | |
60 | * zfcp_ccw_priv_sch - check if subchannel is privileged | |
61 | * @adapter: Adapter/Subchannel to check | |
62 | */ | |
63 | int zfcp_ccw_priv_sch(struct zfcp_adapter *adapter) | |
64 | { | |
65 | return adapter->ccw_device->id.dev_model == ZFCP_MODEL_PRIV; | |
66 | } | |
67 | ||
1da177e4 LT |
68 | /** |
69 | * zfcp_ccw_probe - probe function of zfcp driver | |
70 | * @ccw_device: pointer to belonging ccw device | |
71 | * | |
143bb6bf CS |
72 | * This function gets called by the common i/o layer for each FCP |
73 | * device found on the current system. This is only a stub to make cio | |
74 | * work: To only allocate adapter resources for devices actually used, | |
75 | * the allocation is deferred to the first call to ccw_set_online. | |
1da177e4 | 76 | */ |
fa04c281 | 77 | static int zfcp_ccw_probe(struct ccw_device *ccw_device) |
1da177e4 | 78 | { |
143bb6bf | 79 | return 0; |
1da177e4 LT |
80 | } |
81 | ||
82 | /** | |
83 | * zfcp_ccw_remove - remove function of zfcp driver | |
84 | * @ccw_device: pointer to belonging ccw device | |
85 | * | |
86 | * This function gets called by the common i/o layer and removes an adapter | |
87 | * from the system. Task of this function is to get rid of all units and | |
88 | * ports that belong to this adapter. And in addition all resources of this | |
89 | * adapter will be freed too. | |
90 | */ | |
fa04c281 | 91 | static void zfcp_ccw_remove(struct ccw_device *ccw_device) |
1da177e4 LT |
92 | { |
93 | struct zfcp_adapter *adapter; | |
94 | struct zfcp_port *port, *p; | |
95 | struct zfcp_unit *unit, *u; | |
0406289e CS |
96 | LIST_HEAD(unit_remove_lh); |
97 | LIST_HEAD(port_remove_lh); | |
1da177e4 LT |
98 | |
99 | ccw_device_set_offline(ccw_device); | |
143bb6bf | 100 | |
24680def | 101 | mutex_lock(&zfcp_data.config_mutex); |
1da177e4 | 102 | adapter = dev_get_drvdata(&ccw_device->dev); |
143bb6bf CS |
103 | if (!adapter) |
104 | goto out; | |
f45a5421 CS |
105 | mutex_unlock(&zfcp_data.config_mutex); |
106 | ||
107 | cancel_work_sync(&adapter->scan_work); | |
1da177e4 | 108 | |
f45a5421 | 109 | mutex_lock(&zfcp_data.config_mutex); |
d74cf7c3 CS |
110 | |
111 | /* this also removes the scsi devices, so call it first */ | |
112 | zfcp_adapter_scsi_unregister(adapter); | |
113 | ||
1da177e4 LT |
114 | write_lock_irq(&zfcp_data.config_lock); |
115 | list_for_each_entry_safe(port, p, &adapter->port_list_head, list) { | |
116 | list_for_each_entry_safe(unit, u, &port->unit_list_head, list) { | |
0406289e | 117 | list_move(&unit->list, &unit_remove_lh); |
1da177e4 LT |
118 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, |
119 | &unit->status); | |
120 | } | |
0406289e | 121 | list_move(&port->list, &port_remove_lh); |
1da177e4 LT |
122 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); |
123 | } | |
124 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); | |
125 | write_unlock_irq(&zfcp_data.config_lock); | |
126 | ||
0406289e | 127 | list_for_each_entry_safe(port, p, &port_remove_lh, list) { |
d74cf7c3 | 128 | list_for_each_entry_safe(unit, u, &unit_remove_lh, list) |
1da177e4 | 129 | zfcp_unit_dequeue(unit); |
1da177e4 LT |
130 | zfcp_port_dequeue(port); |
131 | } | |
44cc76f2 | 132 | wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0); |
1da177e4 LT |
133 | zfcp_adapter_dequeue(adapter); |
134 | ||
143bb6bf | 135 | out: |
24680def | 136 | mutex_unlock(&zfcp_data.config_mutex); |
1da177e4 LT |
137 | } |
138 | ||
139 | /** | |
140 | * zfcp_ccw_set_online - set_online function of zfcp driver | |
141 | * @ccw_device: pointer to belonging ccw device | |
142 | * | |
143bb6bf CS |
143 | * This function gets called by the common i/o layer and sets an |
144 | * adapter into state online. The first call will allocate all | |
145 | * adapter resources that will be retained until the device is removed | |
146 | * via zfcp_ccw_remove. | |
147 | * | |
148 | * Setting an fcp device online means that it will be registered with | |
149 | * the SCSI stack, that the QDIO queues will be set up and that the | |
150 | * adapter will be opened. | |
1da177e4 | 151 | */ |
fa04c281 | 152 | static int zfcp_ccw_set_online(struct ccw_device *ccw_device) |
1da177e4 LT |
153 | { |
154 | struct zfcp_adapter *adapter; | |
143bb6bf | 155 | int ret = 0; |
1da177e4 | 156 | |
24680def | 157 | mutex_lock(&zfcp_data.config_mutex); |
1da177e4 LT |
158 | adapter = dev_get_drvdata(&ccw_device->dev); |
159 | ||
143bb6bf CS |
160 | if (!adapter) { |
161 | ret = zfcp_adapter_enqueue(ccw_device); | |
162 | if (ret) { | |
163 | dev_err(&ccw_device->dev, | |
164 | "Setting up data structures for the " | |
165 | "FCP adapter failed\n"); | |
166 | goto out; | |
167 | } | |
168 | adapter = dev_get_drvdata(&ccw_device->dev); | |
169 | } | |
1da177e4 | 170 | |
fea9d6c7 VS |
171 | /* initialize request counter */ |
172 | BUG_ON(!zfcp_reqlist_isempty(adapter)); | |
173 | adapter->req_no = 0; | |
174 | ||
5ffd51a5 | 175 | zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL, |
698ec016 | 176 | ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET); |
5ffd51a5 SS |
177 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
178 | "ccsonl2", NULL); | |
1da177e4 | 179 | zfcp_erp_wait(adapter); |
143bb6bf | 180 | out: |
24680def | 181 | mutex_unlock(&zfcp_data.config_mutex); |
143bb6bf CS |
182 | if (!ret) |
183 | flush_work(&adapter->scan_work); | |
184 | return ret; | |
1da177e4 LT |
185 | } |
186 | ||
187 | /** | |
188 | * zfcp_ccw_set_offline - set_offline function of zfcp driver | |
189 | * @ccw_device: pointer to belonging ccw device | |
190 | * | |
191 | * This function gets called by the common i/o layer and sets an adapter | |
9f28745a | 192 | * into state offline. |
1da177e4 | 193 | */ |
fa04c281 | 194 | static int zfcp_ccw_set_offline(struct ccw_device *ccw_device) |
1da177e4 LT |
195 | { |
196 | struct zfcp_adapter *adapter; | |
197 | ||
24680def | 198 | mutex_lock(&zfcp_data.config_mutex); |
1da177e4 | 199 | adapter = dev_get_drvdata(&ccw_device->dev); |
5ffd51a5 | 200 | zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL); |
1da177e4 | 201 | zfcp_erp_wait(adapter); |
24680def | 202 | mutex_unlock(&zfcp_data.config_mutex); |
1da177e4 LT |
203 | return 0; |
204 | } | |
205 | ||
206 | /** | |
fa04c281 | 207 | * zfcp_ccw_notify - ccw notify function |
1da177e4 LT |
208 | * @ccw_device: pointer to belonging ccw device |
209 | * @event: indicates if adapter was detached or attached | |
210 | * | |
211 | * This function gets called by the common i/o layer if an adapter has gone | |
212 | * or reappeared. | |
213 | */ | |
fa04c281 | 214 | static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event) |
1da177e4 | 215 | { |
f48bf7fb | 216 | struct zfcp_adapter *adapter = dev_get_drvdata(&ccw_device->dev); |
1da177e4 | 217 | |
1da177e4 LT |
218 | switch (event) { |
219 | case CIO_GONE: | |
ff3b24fa CS |
220 | dev_warn(&adapter->ccw_device->dev, |
221 | "The FCP device has been detached\n"); | |
5ffd51a5 | 222 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL); |
1da177e4 LT |
223 | break; |
224 | case CIO_NO_PATH: | |
ff3b24fa CS |
225 | dev_warn(&adapter->ccw_device->dev, |
226 | "The CHPID for the FCP device is offline\n"); | |
5ffd51a5 | 227 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL); |
1da177e4 LT |
228 | break; |
229 | case CIO_OPER: | |
ff3b24fa CS |
230 | dev_info(&adapter->ccw_device->dev, |
231 | "The FCP device is operational again\n"); | |
5ffd51a5 | 232 | zfcp_erp_modify_adapter_status(adapter, "ccnoti3", NULL, |
1da177e4 LT |
233 | ZFCP_STATUS_COMMON_RUNNING, |
234 | ZFCP_SET); | |
1f6f7129 | 235 | zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, |
5ffd51a5 | 236 | "ccnoti4", NULL); |
1da177e4 | 237 | break; |
47593bfa | 238 | case CIO_BOXED: |
955a2155 CS |
239 | dev_warn(&adapter->ccw_device->dev, "The FCP device " |
240 | "did not respond within the specified time\n"); | |
47593bfa SO |
241 | zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL); |
242 | break; | |
1da177e4 | 243 | } |
1da177e4 LT |
244 | return 1; |
245 | } | |
246 | ||
247 | /** | |
fa04c281 CS |
248 | * zfcp_ccw_shutdown - handle shutdown from cio |
249 | * @cdev: device for adapter to shutdown. | |
1da177e4 | 250 | */ |
fa04c281 | 251 | static void zfcp_ccw_shutdown(struct ccw_device *cdev) |
1da177e4 LT |
252 | { |
253 | struct zfcp_adapter *adapter; | |
254 | ||
24680def | 255 | mutex_lock(&zfcp_data.config_mutex); |
958974fb | 256 | adapter = dev_get_drvdata(&cdev->dev); |
1f99bd4c CS |
257 | if (!adapter) |
258 | goto out; | |
259 | ||
5ffd51a5 | 260 | zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL); |
1da177e4 | 261 | zfcp_erp_wait(adapter); |
143bb6bf | 262 | zfcp_erp_thread_kill(adapter); |
1f99bd4c | 263 | out: |
24680def | 264 | mutex_unlock(&zfcp_data.config_mutex); |
1da177e4 LT |
265 | } |
266 | ||
c5afd81e | 267 | struct ccw_driver zfcp_ccw_driver = { |
fa04c281 CS |
268 | .owner = THIS_MODULE, |
269 | .name = "zfcp", | |
270 | .ids = zfcp_ccw_device_id, | |
271 | .probe = zfcp_ccw_probe, | |
272 | .remove = zfcp_ccw_remove, | |
273 | .set_online = zfcp_ccw_set_online, | |
274 | .set_offline = zfcp_ccw_set_offline, | |
275 | .notify = zfcp_ccw_notify, | |
276 | .shutdown = zfcp_ccw_shutdown, | |
daa70fa9 MP |
277 | .freeze = zfcp_ccw_suspend, |
278 | .thaw = zfcp_ccw_activate, | |
279 | .restore = zfcp_ccw_activate, | |
fa04c281 CS |
280 | }; |
281 | ||
282 | /** | |
283 | * zfcp_ccw_register - ccw register function | |
284 | * | |
285 | * Registers the driver at the common i/o layer. This function will be called | |
286 | * at module load time/system start. | |
287 | */ | |
288 | int __init zfcp_ccw_register(void) | |
289 | { | |
290 | return ccw_driver_register(&zfcp_ccw_driver); | |
291 | } |