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; | |
211 | req->callback = spid_callback; | |
212 | spid_do(cdev); | |
213 | } | |
214 | ||
9679baaf PO |
215 | static int pgid_cmp(struct pgid *p1, struct pgid *p2) |
216 | { | |
217 | return memcmp((char *) p1 + 1, (char *) p2 + 1, | |
218 | sizeof(struct pgid) - 1); | |
1da177e4 LT |
219 | } |
220 | ||
7e560814 | 221 | /* |
9679baaf | 222 | * Determine pathgroup state from PGID data. |
7e560814 | 223 | */ |
9679baaf PO |
224 | static void pgid_analyze(struct ccw_device *cdev, struct pgid **p, |
225 | int *mismatch, int *reserved, int *reset) | |
7e560814 | 226 | { |
9679baaf PO |
227 | struct pgid *pgid = &cdev->private->pgid[0]; |
228 | struct pgid *first = NULL; | |
229 | int lpm; | |
230 | int i; | |
231 | ||
232 | *mismatch = 0; | |
233 | *reserved = 0; | |
234 | *reset = 0; | |
235 | for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) { | |
236 | if ((cdev->private->pgid_valid_mask & lpm) == 0) | |
237 | continue; | |
238 | if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE) | |
239 | *reserved = 1; | |
240 | if (pgid->inf.ps.state1 == SNID_STATE1_RESET) { | |
241 | /* A PGID was reset. */ | |
242 | *reset = 1; | |
243 | continue; | |
d23861ff | 244 | } |
9679baaf PO |
245 | if (!first) { |
246 | first = pgid; | |
247 | continue; | |
248 | } | |
249 | if (pgid_cmp(pgid, first) != 0) | |
250 | *mismatch = 1; | |
7e560814 | 251 | } |
9679baaf PO |
252 | if (!first) |
253 | first = &channel_subsystems[0]->global_pgid; | |
254 | *p = first; | |
7e560814 CH |
255 | } |
256 | ||
d302e1a5 | 257 | static u8 pgid_to_donepm(struct ccw_device *cdev) |
52ef0608 PO |
258 | { |
259 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
260 | struct pgid *pgid; | |
261 | int i; | |
262 | int lpm; | |
d302e1a5 | 263 | u8 donepm = 0; |
52ef0608 | 264 | |
d302e1a5 | 265 | /* Set bits for paths which are already in the target state. */ |
52ef0608 PO |
266 | for (i = 0; i < 8; i++) { |
267 | lpm = 0x80 >> i; | |
268 | if ((cdev->private->pgid_valid_mask & lpm) == 0) | |
269 | continue; | |
270 | pgid = &cdev->private->pgid[i]; | |
271 | if (sch->opm & lpm) { | |
272 | if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED) | |
273 | continue; | |
274 | } else { | |
275 | if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED) | |
276 | continue; | |
277 | } | |
278 | if (cdev->private->flags.mpath) { | |
279 | if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH) | |
280 | continue; | |
281 | } else { | |
282 | if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH) | |
283 | continue; | |
284 | } | |
d302e1a5 | 285 | donepm |= lpm; |
52ef0608 PO |
286 | } |
287 | ||
d302e1a5 | 288 | return donepm; |
52ef0608 PO |
289 | } |
290 | ||
9679baaf | 291 | static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid) |
1da177e4 | 292 | { |
9679baaf PO |
293 | int i; |
294 | ||
295 | for (i = 0; i < 8; i++) | |
296 | memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid)); | |
297 | } | |
298 | ||
299 | /* | |
300 | * Process SENSE PGID data and report result. | |
301 | */ | |
302 | static void snid_done(struct ccw_device *cdev, int rc) | |
303 | { | |
304 | struct ccw_dev_id *id = &cdev->private->dev_id; | |
52ef0608 | 305 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
9679baaf PO |
306 | struct pgid *pgid; |
307 | int mismatch = 0; | |
308 | int reserved = 0; | |
309 | int reset = 0; | |
d302e1a5 | 310 | u8 donepm; |
9679baaf PO |
311 | |
312 | if (rc) | |
313 | goto out; | |
314 | pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset); | |
9679baaf PO |
315 | if (reserved) |
316 | rc = -EUSERS; | |
52ef0608 PO |
317 | else if (mismatch) |
318 | rc = -EOPNOTSUPP; | |
319 | else { | |
d302e1a5 PO |
320 | donepm = pgid_to_donepm(cdev); |
321 | sch->vpm = donepm & sch->opm; | |
322 | cdev->private->pgid_todo_mask &= ~donepm; | |
52ef0608 PO |
323 | pgid_fill(cdev, pgid); |
324 | } | |
9679baaf | 325 | out: |
52ef0608 | 326 | CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x " |
d302e1a5 PO |
327 | "todo=%02x mism=%d rsvd=%d reset=%d\n", id->ssid, |
328 | id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm, | |
329 | cdev->private->pgid_todo_mask, mismatch, reserved, reset); | |
52ef0608 PO |
330 | switch (rc) { |
331 | case 0: | |
332 | /* Anything left to do? */ | |
d302e1a5 | 333 | if (cdev->private->pgid_todo_mask == 0) { |
52ef0608 PO |
334 | verify_done(cdev, sch->vpm == 0 ? -EACCES : 0); |
335 | return; | |
336 | } | |
337 | /* Perform path-grouping. */ | |
338 | spid_start(cdev); | |
339 | break; | |
340 | case -EOPNOTSUPP: | |
341 | /* Path-grouping not supported. */ | |
342 | cdev->private->flags.pgroup = 0; | |
343 | cdev->private->flags.mpath = 0; | |
344 | verify_start(cdev); | |
345 | break; | |
346 | default: | |
347 | verify_done(cdev, rc); | |
348 | } | |
1da177e4 | 349 | } |
9679baaf | 350 | |
1da177e4 | 351 | /* |
9679baaf | 352 | * Create channel program to perform a SENSE PGID on a single path. |
1da177e4 | 353 | */ |
9679baaf | 354 | static void snid_build_cp(struct ccw_device *cdev) |
1da177e4 | 355 | { |
9679baaf PO |
356 | struct ccw_request *req = &cdev->private->req; |
357 | struct ccw1 *cp = cdev->private->iccws; | |
358 | int i = 8 - ffs(req->lpm); | |
359 | ||
360 | /* Channel program setup. */ | |
361 | cp->cmd_code = CCW_CMD_SENSE_PGID; | |
362 | cp->cda = (u32) (addr_t) &cdev->private->pgid[i]; | |
363 | cp->count = sizeof(struct pgid); | |
364 | cp->flags = CCW_FLAG_SLI; | |
365 | req->cp = cp; | |
366 | } | |
1da177e4 | 367 | |
9679baaf PO |
368 | /* |
369 | * Perform SENSE PGID on a single path. | |
370 | */ | |
371 | static void snid_do(struct ccw_device *cdev) | |
372 | { | |
373 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
374 | struct ccw_request *req = &cdev->private->req; | |
375 | ||
376 | /* Adjust lpm if paths are not set in pam. */ | |
377 | req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam); | |
378 | if (!req->lpm) | |
379 | goto out_nopath; | |
380 | snid_build_cp(cdev); | |
381 | ccw_request_start(cdev); | |
382 | return; | |
383 | ||
384 | out_nopath: | |
385 | snid_done(cdev, cdev->private->pgid_valid_mask ? 0 : -EACCES); | |
386 | } | |
7b7db1b5 | 387 | |
9679baaf PO |
388 | /* |
389 | * Process SENSE PGID request result for single path. | |
390 | */ | |
391 | static void snid_callback(struct ccw_device *cdev, void *data, int rc) | |
392 | { | |
393 | struct ccw_request *req = &cdev->private->req; | |
394 | ||
395 | if (rc == 0) | |
396 | cdev->private->pgid_valid_mask |= req->lpm; | |
397 | else if (rc != -EACCES) | |
398 | goto err; | |
399 | req->lpm >>= 1; | |
400 | snid_do(cdev); | |
401 | return; | |
402 | ||
403 | err: | |
404 | snid_done(cdev, rc); | |
405 | } | |
28bdc6f6 | 406 | |
9679baaf PO |
407 | /* |
408 | * Perform path verification. | |
409 | */ | |
410 | static void verify_start(struct ccw_device *cdev) | |
1da177e4 | 411 | { |
6810a2bc | 412 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
9679baaf | 413 | struct ccw_request *req = &cdev->private->req; |
52ef0608 | 414 | struct ccw_dev_id *devid = &cdev->private->dev_id; |
6810a2bc | 415 | |
28bdc6f6 | 416 | sch->vpm = 0; |
d302e1a5 | 417 | sch->lpm = sch->schib.pmcw.pam; |
9679baaf PO |
418 | /* Initialize request data. */ |
419 | memset(req, 0, sizeof(*req)); | |
420 | req->timeout = PGID_TIMEOUT; | |
421 | req->maxretries = PGID_RETRIES; | |
422 | req->lpm = 0x80; | |
454e1fa1 | 423 | if (cdev->private->flags.pgroup) { |
52ef0608 PO |
424 | CIO_TRACE_EVENT(4, "snid"); |
425 | CIO_HEX_EVENT(4, devid, sizeof(*devid)); | |
426 | req->callback = snid_callback; | |
427 | snid_do(cdev); | |
9679baaf | 428 | } else { |
52ef0608 PO |
429 | CIO_TRACE_EVENT(4, "nop"); |
430 | CIO_HEX_EVENT(4, devid, sizeof(*devid)); | |
9679baaf PO |
431 | req->filter = nop_filter; |
432 | req->callback = nop_callback; | |
433 | nop_do(cdev); | |
6810a2bc | 434 | } |
1da177e4 LT |
435 | } |
436 | ||
9679baaf PO |
437 | /** |
438 | * ccw_device_verify_start - perform path verification | |
439 | * @cdev: ccw device | |
440 | * | |
441 | * Perform an I/O on each available channel path to @cdev to determine which | |
442 | * paths are operational. The resulting path mask is stored in sch->vpm. | |
443 | * If device options specify pathgrouping, establish a pathgroup for the | |
444 | * operational paths. When finished, call ccw_device_verify_done with a | |
445 | * return code specifying the result. | |
446 | */ | |
447 | void ccw_device_verify_start(struct ccw_device *cdev) | |
1da177e4 | 448 | { |
d302e1a5 PO |
449 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
450 | ||
9679baaf PO |
451 | CIO_TRACE_EVENT(4, "vrfy"); |
452 | CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); | |
52ef0608 PO |
453 | /* Initialize PGID data. */ |
454 | memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid)); | |
455 | cdev->private->pgid_valid_mask = 0; | |
d302e1a5 | 456 | cdev->private->pgid_todo_mask = sch->schib.pmcw.pam; |
52ef0608 PO |
457 | /* |
458 | * Initialize pathgroup and multipath state with target values. | |
459 | * They may change in the course of path verification. | |
460 | */ | |
461 | cdev->private->flags.pgroup = cdev->private->options.pgroup; | |
462 | cdev->private->flags.mpath = cdev->private->options.mpath; | |
9679baaf PO |
463 | cdev->private->flags.doverify = 0; |
464 | verify_start(cdev); | |
1da177e4 LT |
465 | } |
466 | ||
467 | /* | |
9679baaf | 468 | * Process disband SET PGID request result. |
1da177e4 | 469 | */ |
9679baaf | 470 | static void disband_callback(struct ccw_device *cdev, void *data, int rc) |
1da177e4 | 471 | { |
9679baaf PO |
472 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
473 | struct ccw_dev_id *id = &cdev->private->dev_id; | |
474 | ||
475 | if (rc) | |
476 | goto out; | |
477 | /* Ensure consistent multipathing state at device and channel. */ | |
454e1fa1 | 478 | cdev->private->flags.mpath = 0; |
9679baaf PO |
479 | if (sch->config.mp) { |
480 | sch->config.mp = 0; | |
481 | rc = cio_commit_config(sch); | |
1da177e4 | 482 | } |
9679baaf PO |
483 | out: |
484 | CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno, | |
485 | rc); | |
486 | ccw_device_disband_done(cdev, rc); | |
1da177e4 LT |
487 | } |
488 | ||
9679baaf PO |
489 | /** |
490 | * ccw_device_disband_start - disband pathgroup | |
491 | * @cdev: ccw device | |
492 | * | |
493 | * Execute a SET PGID channel program on @cdev to disband a previously | |
494 | * established pathgroup. When finished, call ccw_device_disband_done with | |
495 | * a return code specifying the result. | |
496 | */ | |
497 | void ccw_device_disband_start(struct ccw_device *cdev) | |
1da177e4 | 498 | { |
9679baaf PO |
499 | struct subchannel *sch = to_subchannel(cdev->dev.parent); |
500 | struct ccw_request *req = &cdev->private->req; | |
501 | u8 fn; | |
502 | ||
503 | CIO_TRACE_EVENT(4, "disb"); | |
504 | CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); | |
505 | /* Request setup. */ | |
506 | memset(req, 0, sizeof(*req)); | |
507 | req->timeout = PGID_TIMEOUT; | |
508 | req->maxretries = PGID_RETRIES; | |
509 | req->lpm = sch->schib.pmcw.pam & sch->opm; | |
510 | req->callback = disband_callback; | |
511 | fn = SPID_FUNC_DISBAND; | |
454e1fa1 | 512 | if (cdev->private->flags.mpath) |
9679baaf PO |
513 | fn |= SPID_FUNC_MULTI_PATH; |
514 | spid_build_cp(cdev, fn); | |
515 | ccw_request_start(cdev); | |
1da177e4 | 516 | } |
d7d12ef2 PO |
517 | |
518 | static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2) | |
519 | { | |
520 | struct ccw_request *req = &cdev->private->req; | |
521 | struct ccw1 *cp = cdev->private->iccws; | |
522 | ||
523 | cp[0].cmd_code = CCW_CMD_STLCK; | |
524 | cp[0].cda = (u32) (addr_t) buf1; | |
525 | cp[0].count = 32; | |
526 | cp[0].flags = CCW_FLAG_CC; | |
527 | cp[1].cmd_code = CCW_CMD_RELEASE; | |
528 | cp[1].cda = (u32) (addr_t) buf2; | |
529 | cp[1].count = 32; | |
530 | cp[1].flags = 0; | |
531 | req->cp = cp; | |
532 | } | |
533 | ||
534 | static void stlck_callback(struct ccw_device *cdev, void *data, int rc) | |
535 | { | |
536 | ccw_device_stlck_done(cdev, data, rc); | |
537 | } | |
538 | ||
539 | /** | |
540 | * ccw_device_stlck_start - perform unconditional release | |
541 | * @cdev: ccw device | |
542 | * @data: data pointer to be passed to ccw_device_stlck_done | |
543 | * @buf1: data pointer used in channel program | |
544 | * @buf2: data pointer used in channel program | |
545 | * | |
546 | * Execute a channel program on @cdev to release an existing PGID reservation. | |
547 | * When finished, call ccw_device_stlck_done with a return code specifying the | |
548 | * result. | |
549 | */ | |
550 | void ccw_device_stlck_start(struct ccw_device *cdev, void *data, void *buf1, | |
551 | void *buf2) | |
552 | { | |
553 | struct subchannel *sch = to_subchannel(cdev->dev.parent); | |
554 | struct ccw_request *req = &cdev->private->req; | |
555 | ||
556 | CIO_TRACE_EVENT(4, "stlck"); | |
557 | CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); | |
558 | /* Request setup. */ | |
559 | memset(req, 0, sizeof(*req)); | |
560 | req->timeout = PGID_TIMEOUT; | |
561 | req->maxretries = PGID_RETRIES; | |
562 | req->lpm = sch->schib.pmcw.pam & sch->opm; | |
563 | req->data = data; | |
564 | req->callback = stlck_callback; | |
565 | stlck_build_cp(cdev, buf1, buf2); | |
566 | ccw_request_start(cdev); | |
567 | } | |
568 |