Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
9679baaf | 2 | * CCW device PGID and path verification I/O handling. |
1da177e4 | 3 | * |
a53c8fab | 4 | * Copyright IBM Corp. 2002, 2009 |
9679baaf PO |
5 | * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> |
6 | * Martin Schwidefsky <schwidefsky@de.ibm.com> | |
7 | * Peter Oberparleiter <peter.oberparleiter@de.ibm.com> | |
1da177e4 LT |
8 | */ |
9 | ||
9679baaf PO |
10 | #include <linux/kernel.h> |
11 | #include <linux/string.h> | |
12 | #include <linux/types.h> | |
13 | #include <linux/errno.h> | |
14 | #include <linux/bitops.h> | |
1da177e4 LT |
15 | #include <asm/ccwdev.h> |
16 | #include <asm/cio.h> | |
1da177e4 LT |
17 | |
18 | #include "cio.h" | |
19 | #include "cio_debug.h" | |
1da177e4 | 20 | #include "device.h" |
cd6b4f27 | 21 | #include "io_sch.h" |
1da177e4 | 22 | |
de1b0438 | 23 | #define PGID_RETRIES 256 |
9679baaf PO |
24 | #define PGID_TIMEOUT (10 * HZ) |
25 | ||
88e7616e SO |
26 | static void verify_start(struct ccw_device *cdev); |
27 | ||
7b7db1b5 | 28 | /* |
9679baaf | 29 | * Process path verification data and report result. |
7b7db1b5 | 30 | */ |
9679baaf | 31 | static void verify_done(struct ccw_device *cdev, int rc) |
7b7db1b5 | 32 | { |
9679baaf PO |
33 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
34 | struct ccw_dev_id *id = &cdev->private->dev_id; | |
454e1fa1 PO |
35 | int mpath = cdev->private->flags.mpath; |
36 | int pgroup = cdev->private->flags.pgroup; | |
9679baaf PO |
37 | |
38 | if (rc) | |
39 | goto out; | |
40 | /* Ensure consistent multipathing state at device and channel. */ | |
41 | if (sch->config.mp != mpath) { | |
42 | sch->config.mp = mpath; | |
43 | rc = cio_commit_config(sch); | |
44 | } | |
45 | out: | |
46 | CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d " | |
47 | "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath, | |
48 | sch->vpm); | |
49 | ccw_device_verify_done(cdev, rc); | |
7b7db1b5 SB |
50 | } |
51 | ||
1da177e4 | 52 | /* |
9679baaf | 53 | * Create channel program to perform a NOOP. |
1da177e4 | 54 | */ |
9679baaf | 55 | static void nop_build_cp(struct ccw_device *cdev) |
1da177e4 | 56 | { |
9679baaf PO |
57 | struct ccw_request *req = &cdev->private->req; |
58 | struct ccw1 *cp = cdev->private->iccws; | |
59 | ||
60 | cp->cmd_code = CCW_CMD_NOOP; | |
61 | cp->cda = 0; | |
62 | cp->count = 0; | |
63 | cp->flags = CCW_FLAG_SLI; | |
64 | req->cp = cp; | |
1da177e4 LT |
65 | } |
66 | ||
9679baaf PO |
67 | /* |
68 | * Perform NOOP on a single path. | |
69 | */ | |
70 | static void nop_do(struct ccw_device *cdev) | |
1da177e4 | 71 | { |
9679baaf PO |
72 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
73 | struct ccw_request *req = &cdev->private->req; | |
74 | ||
e6a0b7c9 SO |
75 | req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm & |
76 | ~cdev->private->path_noirq_mask); | |
9679baaf PO |
77 | if (!req->lpm) |
78 | goto out_nopath; | |
79 | nop_build_cp(cdev); | |
80 | ccw_request_start(cdev); | |
81 | return; | |
82 | ||
83 | out_nopath: | |
84 | verify_done(cdev, sch->vpm ? 0 : -EACCES); | |
1da177e4 LT |
85 | } |
86 | ||
87 | /* | |
9679baaf | 88 | * Adjust NOOP I/O status. |
1da177e4 | 89 | */ |
9679baaf PO |
90 | static enum io_status nop_filter(struct ccw_device *cdev, void *data, |
91 | struct irb *irb, enum io_status status) | |
1da177e4 | 92 | { |
9679baaf PO |
93 | /* Only subchannel status might indicate a path error. */ |
94 | if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0) | |
95 | return IO_DONE; | |
96 | return status; | |
1da177e4 LT |
97 | } |
98 | ||
99 | /* | |
9679baaf | 100 | * Process NOOP request result for a single path. |
1da177e4 | 101 | */ |
9679baaf | 102 | static void nop_callback(struct ccw_device *cdev, void *data, int rc) |
1da177e4 | 103 | { |
9679baaf PO |
104 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
105 | struct ccw_request *req = &cdev->private->req; | |
106 | ||
69f5576f SO |
107 | switch (rc) { |
108 | case 0: | |
9679baaf | 109 | sch->vpm |= req->lpm; |
69f5576f SO |
110 | break; |
111 | case -ETIME: | |
112 | cdev->private->path_noirq_mask |= req->lpm; | |
113 | break; | |
114 | case -EACCES: | |
115 | cdev->private->path_notoper_mask |= req->lpm; | |
116 | break; | |
117 | default: | |
9679baaf | 118 | goto err; |
69f5576f SO |
119 | } |
120 | /* Continue on the next path. */ | |
9679baaf PO |
121 | req->lpm >>= 1; |
122 | nop_do(cdev); | |
123 | return; | |
124 | ||
125 | err: | |
126 | verify_done(cdev, rc); | |
1da177e4 LT |
127 | } |
128 | ||
129 | /* | |
9679baaf | 130 | * Create channel program to perform SET PGID on a single path. |
1da177e4 | 131 | */ |
9679baaf | 132 | static void spid_build_cp(struct ccw_device *cdev, u8 fn) |
1da177e4 | 133 | { |
9679baaf PO |
134 | struct ccw_request *req = &cdev->private->req; |
135 | struct ccw1 *cp = cdev->private->iccws; | |
136 | int i = 8 - ffs(req->lpm); | |
137 | struct pgid *pgid = &cdev->private->pgid[i]; | |
138 | ||
139 | pgid->inf.fc = fn; | |
140 | cp->cmd_code = CCW_CMD_SET_PGID; | |
141 | cp->cda = (u32) (addr_t) pgid; | |
142 | cp->count = sizeof(*pgid); | |
143 | cp->flags = CCW_FLAG_SLI; | |
144 | req->cp = cp; | |
1da177e4 LT |
145 | } |
146 | ||
88e7616e SO |
147 | static void pgid_wipeout_callback(struct ccw_device *cdev, void *data, int rc) |
148 | { | |
149 | if (rc) { | |
150 | /* We don't know the path groups' state. Abort. */ | |
151 | verify_done(cdev, rc); | |
152 | return; | |
153 | } | |
154 | /* | |
155 | * Path groups have been reset. Restart path verification but | |
156 | * leave paths in path_noirq_mask out. | |
157 | */ | |
158 | cdev->private->flags.pgid_unknown = 0; | |
159 | verify_start(cdev); | |
160 | } | |
161 | ||
162 | /* | |
163 | * Reset pathgroups and restart path verification, leave unusable paths out. | |
164 | */ | |
165 | static void pgid_wipeout_start(struct ccw_device *cdev) | |
166 | { | |
167 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
168 | struct ccw_dev_id *id = &cdev->private->dev_id; | |
169 | struct ccw_request *req = &cdev->private->req; | |
170 | u8 fn; | |
171 | ||
172 | CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n", | |
173 | id->ssid, id->devno, cdev->private->pgid_valid_mask, | |
174 | cdev->private->path_noirq_mask); | |
175 | ||
176 | /* Initialize request data. */ | |
177 | memset(req, 0, sizeof(*req)); | |
178 | req->timeout = PGID_TIMEOUT; | |
179 | req->maxretries = PGID_RETRIES; | |
180 | req->lpm = sch->schib.pmcw.pam; | |
181 | req->callback = pgid_wipeout_callback; | |
182 | fn = SPID_FUNC_DISBAND; | |
183 | if (cdev->private->flags.mpath) | |
184 | fn |= SPID_FUNC_MULTI_PATH; | |
185 | spid_build_cp(cdev, fn); | |
186 | ccw_request_start(cdev); | |
187 | } | |
188 | ||
7e560814 | 189 | /* |
9679baaf | 190 | * Perform establish/resign SET PGID on a single path. |
7e560814 | 191 | */ |
9679baaf | 192 | static void spid_do(struct ccw_device *cdev) |
7e560814 | 193 | { |
9679baaf PO |
194 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
195 | struct ccw_request *req = &cdev->private->req; | |
196 | u8 fn; | |
197 | ||
52ef0608 | 198 | /* Use next available path that is not already in correct state. */ |
d302e1a5 | 199 | req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask); |
9679baaf PO |
200 | if (!req->lpm) |
201 | goto out_nopath; | |
202 | /* Channel program setup. */ | |
203 | if (req->lpm & sch->opm) | |
204 | fn = SPID_FUNC_ESTABLISH; | |
205 | else | |
206 | fn = SPID_FUNC_RESIGN; | |
454e1fa1 | 207 | if (cdev->private->flags.mpath) |
9679baaf PO |
208 | fn |= SPID_FUNC_MULTI_PATH; |
209 | spid_build_cp(cdev, fn); | |
210 | ccw_request_start(cdev); | |
211 | return; | |
212 | ||
213 | out_nopath: | |
88e7616e SO |
214 | if (cdev->private->flags.pgid_unknown) { |
215 | /* At least one SPID could be partially done. */ | |
216 | pgid_wipeout_start(cdev); | |
217 | return; | |
218 | } | |
9679baaf | 219 | verify_done(cdev, sch->vpm ? 0 : -EACCES); |
7e560814 CH |
220 | } |
221 | ||
1da177e4 | 222 | /* |
9679baaf | 223 | * Process SET PGID request result for a single path. |
1da177e4 | 224 | */ |
9679baaf | 225 | static void spid_callback(struct ccw_device *cdev, void *data, int rc) |
1da177e4 | 226 | { |
9679baaf PO |
227 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
228 | struct ccw_request *req = &cdev->private->req; | |
229 | ||
230 | switch (rc) { | |
231 | case 0: | |
232 | sch->vpm |= req->lpm & sch->opm; | |
233 | break; | |
69f5576f SO |
234 | case -ETIME: |
235 | cdev->private->flags.pgid_unknown = 1; | |
236 | cdev->private->path_noirq_mask |= req->lpm; | |
237 | break; | |
9679baaf | 238 | case -EACCES: |
69f5576f | 239 | cdev->private->path_notoper_mask |= req->lpm; |
9679baaf PO |
240 | break; |
241 | case -EOPNOTSUPP: | |
454e1fa1 | 242 | if (cdev->private->flags.mpath) { |
9679baaf | 243 | /* Try without multipathing. */ |
454e1fa1 | 244 | cdev->private->flags.mpath = 0; |
9679baaf | 245 | goto out_restart; |
d23861ff | 246 | } |
9679baaf | 247 | /* Try without pathgrouping. */ |
454e1fa1 | 248 | cdev->private->flags.pgroup = 0; |
9679baaf PO |
249 | goto out_restart; |
250 | default: | |
251 | goto err; | |
1da177e4 | 252 | } |
9679baaf PO |
253 | req->lpm >>= 1; |
254 | spid_do(cdev); | |
255 | return; | |
256 | ||
257 | out_restart: | |
258 | verify_start(cdev); | |
259 | return; | |
260 | err: | |
261 | verify_done(cdev, rc); | |
262 | } | |
263 | ||
52ef0608 PO |
264 | static void spid_start(struct ccw_device *cdev) |
265 | { | |
266 | struct ccw_request *req = &cdev->private->req; | |
267 | ||
268 | /* Initialize request data. */ | |
269 | memset(req, 0, sizeof(*req)); | |
270 | req->timeout = PGID_TIMEOUT; | |
271 | req->maxretries = PGID_RETRIES; | |
272 | req->lpm = 0x80; | |
982bdf81 | 273 | req->singlepath = 1; |
52ef0608 PO |
274 | req->callback = spid_callback; |
275 | spid_do(cdev); | |
276 | } | |
277 | ||
585b954e SO |
278 | static int pgid_is_reset(struct pgid *p) |
279 | { | |
280 | char *c; | |
281 | ||
282 | for (c = (char *)p + 1; c < (char *)(p + 1); c++) { | |
283 | if (*c != 0) | |
284 | return 0; | |
285 | } | |
286 | return 1; | |
287 | } | |
288 | ||
9679baaf PO |
289 | static int pgid_cmp(struct pgid *p1, struct pgid *p2) |
290 | { | |
291 | return memcmp((char *) p1 + 1, (char *) p2 + 1, | |
292 | sizeof(struct pgid) - 1); | |
1da177e4 LT |
293 | } |
294 | ||
7e560814 | 295 | /* |
9679baaf | 296 | * Determine pathgroup state from PGID data. |
7e560814 | 297 | */ |
9679baaf | 298 | static void pgid_analyze(struct ccw_device *cdev, struct pgid **p, |
d99e79ec | 299 | int *mismatch, u8 *reserved, u8 *reset) |
7e560814 | 300 | { |
9679baaf PO |
301 | struct pgid *pgid = &cdev->private->pgid[0]; |
302 | struct pgid *first = NULL; | |
303 | int lpm; | |
304 | int i; | |
305 | ||
306 | *mismatch = 0; | |
307 | *reserved = 0; | |
308 | *reset = 0; | |
309 | for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) { | |
310 | if ((cdev->private->pgid_valid_mask & lpm) == 0) | |
311 | continue; | |
312 | if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE) | |
d99e79ec | 313 | *reserved |= lpm; |
585b954e SO |
314 | if (pgid_is_reset(pgid)) { |
315 | *reset |= lpm; | |
9679baaf | 316 | continue; |
d23861ff | 317 | } |
9679baaf PO |
318 | if (!first) { |
319 | first = pgid; | |
320 | continue; | |
321 | } | |
322 | if (pgid_cmp(pgid, first) != 0) | |
323 | *mismatch = 1; | |
7e560814 | 324 | } |
9679baaf PO |
325 | if (!first) |
326 | first = &channel_subsystems[0]->global_pgid; | |
327 | *p = first; | |
7e560814 CH |
328 | } |
329 | ||
d302e1a5 | 330 | static u8 pgid_to_donepm(struct ccw_device *cdev) |
52ef0608 PO |
331 | { |
332 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
333 | struct pgid *pgid; | |
334 | int i; | |
335 | int lpm; | |
d302e1a5 | 336 | u8 donepm = 0; |
52ef0608 | 337 | |
d302e1a5 | 338 | /* Set bits for paths which are already in the target state. */ |
52ef0608 PO |
339 | for (i = 0; i < 8; i++) { |
340 | lpm = 0x80 >> i; | |
341 | if ((cdev->private->pgid_valid_mask & lpm) == 0) | |
342 | continue; | |
343 | pgid = &cdev->private->pgid[i]; | |
344 | if (sch->opm & lpm) { | |
345 | if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED) | |
346 | continue; | |
347 | } else { | |
348 | if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED) | |
349 | continue; | |
350 | } | |
351 | if (cdev->private->flags.mpath) { | |
352 | if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH) | |
353 | continue; | |
354 | } else { | |
355 | if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH) | |
356 | continue; | |
357 | } | |
d302e1a5 | 358 | donepm |= lpm; |
52ef0608 PO |
359 | } |
360 | ||
d302e1a5 | 361 | return donepm; |
52ef0608 PO |
362 | } |
363 | ||
9679baaf | 364 | static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid) |
1da177e4 | 365 | { |
9679baaf PO |
366 | int i; |
367 | ||
368 | for (i = 0; i < 8; i++) | |
369 | memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid)); | |
370 | } | |
371 | ||
372 | /* | |
373 | * Process SENSE PGID data and report result. | |
374 | */ | |
375 | static void snid_done(struct ccw_device *cdev, int rc) | |
376 | { | |
377 | struct ccw_dev_id *id = &cdev->private->dev_id; | |
52ef0608 | 378 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
9679baaf PO |
379 | struct pgid *pgid; |
380 | int mismatch = 0; | |
d99e79ec | 381 | u8 reserved = 0; |
585b954e | 382 | u8 reset = 0; |
d302e1a5 | 383 | u8 donepm; |
9679baaf PO |
384 | |
385 | if (rc) | |
386 | goto out; | |
387 | pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset); | |
d99e79ec | 388 | if (reserved == cdev->private->pgid_valid_mask) |
9679baaf | 389 | rc = -EUSERS; |
52ef0608 PO |
390 | else if (mismatch) |
391 | rc = -EOPNOTSUPP; | |
392 | else { | |
d302e1a5 PO |
393 | donepm = pgid_to_donepm(cdev); |
394 | sch->vpm = donepm & sch->opm; | |
585b954e | 395 | cdev->private->pgid_reset_mask |= reset; |
e6a0b7c9 SO |
396 | cdev->private->pgid_todo_mask &= |
397 | ~(donepm | cdev->private->path_noirq_mask); | |
52ef0608 PO |
398 | pgid_fill(cdev, pgid); |
399 | } | |
9679baaf | 400 | out: |
52ef0608 | 401 | CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x " |
d99e79ec | 402 | "todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid, |
d302e1a5 PO |
403 | id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm, |
404 | cdev->private->pgid_todo_mask, mismatch, reserved, reset); | |
52ef0608 PO |
405 | switch (rc) { |
406 | case 0: | |
88e7616e SO |
407 | if (cdev->private->flags.pgid_unknown) { |
408 | pgid_wipeout_start(cdev); | |
409 | return; | |
410 | } | |
52ef0608 | 411 | /* Anything left to do? */ |
d302e1a5 | 412 | if (cdev->private->pgid_todo_mask == 0) { |
52ef0608 PO |
413 | verify_done(cdev, sch->vpm == 0 ? -EACCES : 0); |
414 | return; | |
415 | } | |
416 | /* Perform path-grouping. */ | |
417 | spid_start(cdev); | |
418 | break; | |
419 | case -EOPNOTSUPP: | |
420 | /* Path-grouping not supported. */ | |
421 | cdev->private->flags.pgroup = 0; | |
422 | cdev->private->flags.mpath = 0; | |
423 | verify_start(cdev); | |
424 | break; | |
425 | default: | |
426 | verify_done(cdev, rc); | |
427 | } | |
1da177e4 | 428 | } |
9679baaf | 429 | |
1da177e4 | 430 | /* |
9679baaf | 431 | * Create channel program to perform a SENSE PGID on a single path. |
1da177e4 | 432 | */ |
9679baaf | 433 | static void snid_build_cp(struct ccw_device *cdev) |
1da177e4 | 434 | { |
9679baaf PO |
435 | struct ccw_request *req = &cdev->private->req; |
436 | struct ccw1 *cp = cdev->private->iccws; | |
437 | int i = 8 - ffs(req->lpm); | |
438 | ||
439 | /* Channel program setup. */ | |
440 | cp->cmd_code = CCW_CMD_SENSE_PGID; | |
441 | cp->cda = (u32) (addr_t) &cdev->private->pgid[i]; | |
442 | cp->count = sizeof(struct pgid); | |
443 | cp->flags = CCW_FLAG_SLI; | |
444 | req->cp = cp; | |
445 | } | |
1da177e4 | 446 | |
9679baaf PO |
447 | /* |
448 | * Perform SENSE PGID on a single path. | |
449 | */ | |
450 | static void snid_do(struct ccw_device *cdev) | |
451 | { | |
452 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
453 | struct ccw_request *req = &cdev->private->req; | |
88e7616e | 454 | int ret; |
9679baaf | 455 | |
e6a0b7c9 SO |
456 | req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & |
457 | ~cdev->private->path_noirq_mask); | |
9679baaf PO |
458 | if (!req->lpm) |
459 | goto out_nopath; | |
460 | snid_build_cp(cdev); | |
461 | ccw_request_start(cdev); | |
462 | return; | |
463 | ||
464 | out_nopath: | |
88e7616e SO |
465 | if (cdev->private->pgid_valid_mask) |
466 | ret = 0; | |
467 | else if (cdev->private->path_noirq_mask) | |
468 | ret = -ETIME; | |
469 | else | |
470 | ret = -EACCES; | |
471 | snid_done(cdev, ret); | |
9679baaf | 472 | } |
7b7db1b5 | 473 | |
9679baaf PO |
474 | /* |
475 | * Process SENSE PGID request result for single path. | |
476 | */ | |
477 | static void snid_callback(struct ccw_device *cdev, void *data, int rc) | |
478 | { | |
479 | struct ccw_request *req = &cdev->private->req; | |
480 | ||
69f5576f SO |
481 | switch (rc) { |
482 | case 0: | |
9679baaf | 483 | cdev->private->pgid_valid_mask |= req->lpm; |
69f5576f SO |
484 | break; |
485 | case -ETIME: | |
486 | cdev->private->flags.pgid_unknown = 1; | |
487 | cdev->private->path_noirq_mask |= req->lpm; | |
488 | break; | |
489 | case -EACCES: | |
490 | cdev->private->path_notoper_mask |= req->lpm; | |
491 | break; | |
492 | default: | |
9679baaf | 493 | goto err; |
69f5576f SO |
494 | } |
495 | /* Continue on the next path. */ | |
9679baaf PO |
496 | req->lpm >>= 1; |
497 | snid_do(cdev); | |
498 | return; | |
499 | ||
500 | err: | |
501 | snid_done(cdev, rc); | |
502 | } | |
28bdc6f6 | 503 | |
9679baaf PO |
504 | /* |
505 | * Perform path verification. | |
506 | */ | |
507 | static void verify_start(struct ccw_device *cdev) | |
1da177e4 | 508 | { |
6810a2bc | 509 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
9679baaf | 510 | struct ccw_request *req = &cdev->private->req; |
52ef0608 | 511 | struct ccw_dev_id *devid = &cdev->private->dev_id; |
6810a2bc | 512 | |
28bdc6f6 | 513 | sch->vpm = 0; |
d302e1a5 | 514 | sch->lpm = sch->schib.pmcw.pam; |
69f5576f SO |
515 | |
516 | /* Initialize PGID data. */ | |
517 | memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid)); | |
518 | cdev->private->pgid_valid_mask = 0; | |
519 | cdev->private->pgid_todo_mask = sch->schib.pmcw.pam; | |
520 | cdev->private->path_notoper_mask = 0; | |
521 | ||
9679baaf PO |
522 | /* Initialize request data. */ |
523 | memset(req, 0, sizeof(*req)); | |
524 | req->timeout = PGID_TIMEOUT; | |
525 | req->maxretries = PGID_RETRIES; | |
526 | req->lpm = 0x80; | |
982bdf81 | 527 | req->singlepath = 1; |
454e1fa1 | 528 | if (cdev->private->flags.pgroup) { |
52ef0608 PO |
529 | CIO_TRACE_EVENT(4, "snid"); |
530 | CIO_HEX_EVENT(4, devid, sizeof(*devid)); | |
531 | req->callback = snid_callback; | |
532 | snid_do(cdev); | |
9679baaf | 533 | } else { |
52ef0608 PO |
534 | CIO_TRACE_EVENT(4, "nop"); |
535 | CIO_HEX_EVENT(4, devid, sizeof(*devid)); | |
9679baaf PO |
536 | req->filter = nop_filter; |
537 | req->callback = nop_callback; | |
538 | nop_do(cdev); | |
6810a2bc | 539 | } |
1da177e4 LT |
540 | } |
541 | ||
9679baaf PO |
542 | /** |
543 | * ccw_device_verify_start - perform path verification | |
544 | * @cdev: ccw device | |
545 | * | |
546 | * Perform an I/O on each available channel path to @cdev to determine which | |
547 | * paths are operational. The resulting path mask is stored in sch->vpm. | |
548 | * If device options specify pathgrouping, establish a pathgroup for the | |
549 | * operational paths. When finished, call ccw_device_verify_done with a | |
550 | * return code specifying the result. | |
551 | */ | |
552 | void ccw_device_verify_start(struct ccw_device *cdev) | |
1da177e4 | 553 | { |
9679baaf PO |
554 | CIO_TRACE_EVENT(4, "vrfy"); |
555 | CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); | |
52ef0608 PO |
556 | /* |
557 | * Initialize pathgroup and multipath state with target values. | |
558 | * They may change in the course of path verification. | |
559 | */ | |
560 | cdev->private->flags.pgroup = cdev->private->options.pgroup; | |
561 | cdev->private->flags.mpath = cdev->private->options.mpath; | |
9679baaf | 562 | cdev->private->flags.doverify = 0; |
69f5576f | 563 | cdev->private->path_noirq_mask = 0; |
9679baaf | 564 | verify_start(cdev); |
1da177e4 LT |
565 | } |
566 | ||
567 | /* | |
9679baaf | 568 | * Process disband SET PGID request result. |
1da177e4 | 569 | */ |
9679baaf | 570 | static void disband_callback(struct ccw_device *cdev, void *data, int rc) |
1da177e4 | 571 | { |
9679baaf PO |
572 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
573 | struct ccw_dev_id *id = &cdev->private->dev_id; | |
574 | ||
575 | if (rc) | |
576 | goto out; | |
577 | /* Ensure consistent multipathing state at device and channel. */ | |
454e1fa1 | 578 | cdev->private->flags.mpath = 0; |
9679baaf PO |
579 | if (sch->config.mp) { |
580 | sch->config.mp = 0; | |
581 | rc = cio_commit_config(sch); | |
1da177e4 | 582 | } |
9679baaf PO |
583 | out: |
584 | CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno, | |
585 | rc); | |
586 | ccw_device_disband_done(cdev, rc); | |
1da177e4 LT |
587 | } |
588 | ||
9679baaf PO |
589 | /** |
590 | * ccw_device_disband_start - disband pathgroup | |
591 | * @cdev: ccw device | |
592 | * | |
593 | * Execute a SET PGID channel program on @cdev to disband a previously | |
594 | * established pathgroup. When finished, call ccw_device_disband_done with | |
595 | * a return code specifying the result. | |
596 | */ | |
597 | void ccw_device_disband_start(struct ccw_device *cdev) | |
1da177e4 | 598 | { |
9679baaf PO |
599 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
600 | struct ccw_request *req = &cdev->private->req; | |
601 | u8 fn; | |
602 | ||
603 | CIO_TRACE_EVENT(4, "disb"); | |
604 | CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); | |
605 | /* Request setup. */ | |
606 | memset(req, 0, sizeof(*req)); | |
607 | req->timeout = PGID_TIMEOUT; | |
608 | req->maxretries = PGID_RETRIES; | |
609 | req->lpm = sch->schib.pmcw.pam & sch->opm; | |
982bdf81 | 610 | req->singlepath = 1; |
9679baaf PO |
611 | req->callback = disband_callback; |
612 | fn = SPID_FUNC_DISBAND; | |
454e1fa1 | 613 | if (cdev->private->flags.mpath) |
9679baaf PO |
614 | fn |= SPID_FUNC_MULTI_PATH; |
615 | spid_build_cp(cdev, fn); | |
616 | ccw_request_start(cdev); | |
1da177e4 | 617 | } |
d7d12ef2 PO |
618 | |
619 | static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2) | |
620 | { | |
621 | struct ccw_request *req = &cdev->private->req; | |
622 | struct ccw1 *cp = cdev->private->iccws; | |
623 | ||
624 | cp[0].cmd_code = CCW_CMD_STLCK; | |
625 | cp[0].cda = (u32) (addr_t) buf1; | |
626 | cp[0].count = 32; | |
627 | cp[0].flags = CCW_FLAG_CC; | |
628 | cp[1].cmd_code = CCW_CMD_RELEASE; | |
629 | cp[1].cda = (u32) (addr_t) buf2; | |
630 | cp[1].count = 32; | |
631 | cp[1].flags = 0; | |
632 | req->cp = cp; | |
633 | } | |
634 | ||
635 | static void stlck_callback(struct ccw_device *cdev, void *data, int rc) | |
636 | { | |
637 | ccw_device_stlck_done(cdev, data, rc); | |
638 | } | |
639 | ||
640 | /** | |
641 | * ccw_device_stlck_start - perform unconditional release | |
642 | * @cdev: ccw device | |
643 | * @data: data pointer to be passed to ccw_device_stlck_done | |
644 | * @buf1: data pointer used in channel program | |
645 | * @buf2: data pointer used in channel program | |
646 | * | |
647 | * Execute a channel program on @cdev to release an existing PGID reservation. | |
648 | * When finished, call ccw_device_stlck_done with a return code specifying the | |
649 | * result. | |
650 | */ | |
651 | void ccw_device_stlck_start(struct ccw_device *cdev, void *data, void *buf1, | |
652 | void *buf2) | |
653 | { | |
654 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
655 | struct ccw_request *req = &cdev->private->req; | |
656 | ||
657 | CIO_TRACE_EVENT(4, "stlck"); | |
658 | CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); | |
659 | /* Request setup. */ | |
660 | memset(req, 0, sizeof(*req)); | |
661 | req->timeout = PGID_TIMEOUT; | |
662 | req->maxretries = PGID_RETRIES; | |
663 | req->lpm = sch->schib.pmcw.pam & sch->opm; | |
664 | req->data = data; | |
665 | req->callback = stlck_callback; | |
666 | stlck_build_cp(cdev, buf1, buf2); | |
667 | ccw_request_start(cdev); | |
668 | } | |
669 |