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