1
2
3
4
5
6
7
8
9
10
11#include <linux/kernel.h>
12#include <linux/string.h>
13#include <linux/bitops.h>
14#include <linux/types.h>
15#include <linux/errno.h>
16#include <linux/slab.h>
17#include <asm/ccwdev.h>
18#include <asm/cio.h>
19
20#include "cio.h"
21#include "cio_debug.h"
22#include "device.h"
23#include "io_sch.h"
24
25#define PGID_RETRIES 256
26#define PGID_TIMEOUT (10 * HZ)
27
28static void verify_start(struct ccw_device *cdev);
29
30
31
32
33static void verify_done(struct ccw_device *cdev, int rc)
34{
35 struct subchannel *sch = to_subchannel(cdev->dev.parent);
36 struct ccw_dev_id *id = &cdev->private->dev_id;
37 int mpath = cdev->private->flags.mpath;
38 int pgroup = cdev->private->flags.pgroup;
39
40 if (rc)
41 goto out;
42
43 if (sch->config.mp != mpath) {
44 sch->config.mp = mpath;
45 rc = cio_commit_config(sch);
46 }
47out:
48 CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
49 "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
50 sch->vpm);
51 ccw_device_verify_done(cdev, rc);
52}
53
54
55
56
57static void nop_build_cp(struct ccw_device *cdev)
58{
59 struct ccw_request *req = &cdev->private->req;
60 struct ccw1 *cp = cdev->private->iccws;
61
62 cp->cmd_code = CCW_CMD_NOOP;
63 cp->cda = 0;
64 cp->count = 0;
65 cp->flags = CCW_FLAG_SLI;
66 req->cp = cp;
67}
68
69
70
71
72static void nop_do(struct ccw_device *cdev)
73{
74 struct subchannel *sch = to_subchannel(cdev->dev.parent);
75 struct ccw_request *req = &cdev->private->req;
76
77 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm &
78 ~cdev->private->path_noirq_mask);
79 if (!req->lpm)
80 goto out_nopath;
81 nop_build_cp(cdev);
82 ccw_request_start(cdev);
83 return;
84
85out_nopath:
86 verify_done(cdev, sch->vpm ? 0 : -EACCES);
87}
88
89
90
91
92static enum io_status nop_filter(struct ccw_device *cdev, void *data,
93 struct irb *irb, enum io_status status)
94{
95
96 if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
97 return IO_DONE;
98 return status;
99}
100
101
102
103
104static void nop_callback(struct ccw_device *cdev, void *data, int rc)
105{
106 struct subchannel *sch = to_subchannel(cdev->dev.parent);
107 struct ccw_request *req = &cdev->private->req;
108
109 switch (rc) {
110 case 0:
111 sch->vpm |= req->lpm;
112 break;
113 case -ETIME:
114 cdev->private->path_noirq_mask |= req->lpm;
115 break;
116 case -EACCES:
117 cdev->private->path_notoper_mask |= req->lpm;
118 break;
119 default:
120 goto err;
121 }
122
123 req->lpm >>= 1;
124 nop_do(cdev);
125 return;
126
127err:
128 verify_done(cdev, rc);
129}
130
131
132
133
134static void spid_build_cp(struct ccw_device *cdev, u8 fn)
135{
136 struct ccw_request *req = &cdev->private->req;
137 struct ccw1 *cp = cdev->private->iccws;
138 int i = pathmask_to_pos(req->lpm);
139 struct pgid *pgid = &cdev->private->pgid[i];
140
141 pgid->inf.fc = fn;
142 cp->cmd_code = CCW_CMD_SET_PGID;
143 cp->cda = (u32) (addr_t) pgid;
144 cp->count = sizeof(*pgid);
145 cp->flags = CCW_FLAG_SLI;
146 req->cp = cp;
147}
148
149static void pgid_wipeout_callback(struct ccw_device *cdev, void *data, int rc)
150{
151 if (rc) {
152
153 verify_done(cdev, rc);
154 return;
155 }
156
157
158
159
160 cdev->private->flags.pgid_unknown = 0;
161 verify_start(cdev);
162}
163
164
165
166
167static void pgid_wipeout_start(struct ccw_device *cdev)
168{
169 struct subchannel *sch = to_subchannel(cdev->dev.parent);
170 struct ccw_dev_id *id = &cdev->private->dev_id;
171 struct ccw_request *req = &cdev->private->req;
172 u8 fn;
173
174 CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n",
175 id->ssid, id->devno, cdev->private->pgid_valid_mask,
176 cdev->private->path_noirq_mask);
177
178
179 memset(req, 0, sizeof(*req));
180 req->timeout = PGID_TIMEOUT;
181 req->maxretries = PGID_RETRIES;
182 req->lpm = sch->schib.pmcw.pam;
183 req->callback = pgid_wipeout_callback;
184 fn = SPID_FUNC_DISBAND;
185 if (cdev->private->flags.mpath)
186 fn |= SPID_FUNC_MULTI_PATH;
187 spid_build_cp(cdev, fn);
188 ccw_request_start(cdev);
189}
190
191
192
193
194static void spid_do(struct ccw_device *cdev)
195{
196 struct subchannel *sch = to_subchannel(cdev->dev.parent);
197 struct ccw_request *req = &cdev->private->req;
198 u8 fn;
199
200
201 req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
202 if (!req->lpm)
203 goto out_nopath;
204
205 if (req->lpm & sch->opm)
206 fn = SPID_FUNC_ESTABLISH;
207 else
208 fn = SPID_FUNC_RESIGN;
209 if (cdev->private->flags.mpath)
210 fn |= SPID_FUNC_MULTI_PATH;
211 spid_build_cp(cdev, fn);
212 ccw_request_start(cdev);
213 return;
214
215out_nopath:
216 if (cdev->private->flags.pgid_unknown) {
217
218 pgid_wipeout_start(cdev);
219 return;
220 }
221 verify_done(cdev, sch->vpm ? 0 : -EACCES);
222}
223
224
225
226
227static void spid_callback(struct ccw_device *cdev, void *data, int rc)
228{
229 struct subchannel *sch = to_subchannel(cdev->dev.parent);
230 struct ccw_request *req = &cdev->private->req;
231
232 switch (rc) {
233 case 0:
234 sch->vpm |= req->lpm & sch->opm;
235 break;
236 case -ETIME:
237 cdev->private->flags.pgid_unknown = 1;
238 cdev->private->path_noirq_mask |= req->lpm;
239 break;
240 case -EACCES:
241 cdev->private->path_notoper_mask |= req->lpm;
242 break;
243 case -EOPNOTSUPP:
244 if (cdev->private->flags.mpath) {
245
246 cdev->private->flags.mpath = 0;
247 goto out_restart;
248 }
249
250 cdev->private->flags.pgroup = 0;
251 goto out_restart;
252 default:
253 goto err;
254 }
255 req->lpm >>= 1;
256 spid_do(cdev);
257 return;
258
259out_restart:
260 verify_start(cdev);
261 return;
262err:
263 verify_done(cdev, rc);
264}
265
266static void spid_start(struct ccw_device *cdev)
267{
268 struct ccw_request *req = &cdev->private->req;
269
270
271 memset(req, 0, sizeof(*req));
272 req->timeout = PGID_TIMEOUT;
273 req->maxretries = PGID_RETRIES;
274 req->lpm = 0x80;
275 req->singlepath = 1;
276 req->callback = spid_callback;
277 spid_do(cdev);
278}
279
280static int pgid_is_reset(struct pgid *p)
281{
282 char *c;
283
284 for (c = (char *)p + 1; c < (char *)(p + 1); c++) {
285 if (*c != 0)
286 return 0;
287 }
288 return 1;
289}
290
291static int pgid_cmp(struct pgid *p1, struct pgid *p2)
292{
293 return memcmp((char *) p1 + 1, (char *) p2 + 1,
294 sizeof(struct pgid) - 1);
295}
296
297
298
299
300static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
301 int *mismatch, u8 *reserved, u8 *reset)
302{
303 struct pgid *pgid = &cdev->private->pgid[0];
304 struct pgid *first = NULL;
305 int lpm;
306 int i;
307
308 *mismatch = 0;
309 *reserved = 0;
310 *reset = 0;
311 for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
312 if ((cdev->private->pgid_valid_mask & lpm) == 0)
313 continue;
314 if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
315 *reserved |= lpm;
316 if (pgid_is_reset(pgid)) {
317 *reset |= lpm;
318 continue;
319 }
320 if (!first) {
321 first = pgid;
322 continue;
323 }
324 if (pgid_cmp(pgid, first) != 0)
325 *mismatch = 1;
326 }
327 if (!first)
328 first = &channel_subsystems[0]->global_pgid;
329 *p = first;
330}
331
332static u8 pgid_to_donepm(struct ccw_device *cdev)
333{
334 struct subchannel *sch = to_subchannel(cdev->dev.parent);
335 struct pgid *pgid;
336 int i;
337 int lpm;
338 u8 donepm = 0;
339
340
341 for (i = 0; i < 8; i++) {
342 lpm = 0x80 >> i;
343 if ((cdev->private->pgid_valid_mask & lpm) == 0)
344 continue;
345 pgid = &cdev->private->pgid[i];
346 if (sch->opm & lpm) {
347 if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
348 continue;
349 } else {
350 if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
351 continue;
352 }
353 if (cdev->private->flags.mpath) {
354 if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
355 continue;
356 } else {
357 if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
358 continue;
359 }
360 donepm |= lpm;
361 }
362
363 return donepm;
364}
365
366static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
367{
368 int i;
369
370 for (i = 0; i < 8; i++)
371 memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
372}
373
374
375
376
377static void snid_done(struct ccw_device *cdev, int rc)
378{
379 struct ccw_dev_id *id = &cdev->private->dev_id;
380 struct subchannel *sch = to_subchannel(cdev->dev.parent);
381 struct pgid *pgid;
382 int mismatch = 0;
383 u8 reserved = 0;
384 u8 reset = 0;
385 u8 donepm;
386
387 if (rc)
388 goto out;
389 pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
390 if (reserved == cdev->private->pgid_valid_mask)
391 rc = -EUSERS;
392 else if (mismatch)
393 rc = -EOPNOTSUPP;
394 else {
395 donepm = pgid_to_donepm(cdev);
396 sch->vpm = donepm & sch->opm;
397 cdev->private->pgid_reset_mask |= reset;
398 cdev->private->pgid_todo_mask &=
399 ~(donepm | cdev->private->path_noirq_mask);
400 pgid_fill(cdev, pgid);
401 }
402out:
403 CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
404 "todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid,
405 id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
406 cdev->private->pgid_todo_mask, mismatch, reserved, reset);
407 switch (rc) {
408 case 0:
409 if (cdev->private->flags.pgid_unknown) {
410 pgid_wipeout_start(cdev);
411 return;
412 }
413
414 if (cdev->private->pgid_todo_mask == 0) {
415 verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
416 return;
417 }
418
419 spid_start(cdev);
420 break;
421 case -EOPNOTSUPP:
422
423 cdev->private->flags.pgroup = 0;
424 cdev->private->flags.mpath = 0;
425 verify_start(cdev);
426 break;
427 default:
428 verify_done(cdev, rc);
429 }
430}
431
432
433
434
435static void snid_build_cp(struct ccw_device *cdev)
436{
437 struct ccw_request *req = &cdev->private->req;
438 struct ccw1 *cp = cdev->private->iccws;
439 int i = pathmask_to_pos(req->lpm);
440
441
442 cp->cmd_code = CCW_CMD_SENSE_PGID;
443 cp->cda = (u32) (addr_t) &cdev->private->pgid[i];
444 cp->count = sizeof(struct pgid);
445 cp->flags = CCW_FLAG_SLI;
446 req->cp = cp;
447}
448
449
450
451
452static void snid_do(struct ccw_device *cdev)
453{
454 struct subchannel *sch = to_subchannel(cdev->dev.parent);
455 struct ccw_request *req = &cdev->private->req;
456 int ret;
457
458 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam &
459 ~cdev->private->path_noirq_mask);
460 if (!req->lpm)
461 goto out_nopath;
462 snid_build_cp(cdev);
463 ccw_request_start(cdev);
464 return;
465
466out_nopath:
467 if (cdev->private->pgid_valid_mask)
468 ret = 0;
469 else if (cdev->private->path_noirq_mask)
470 ret = -ETIME;
471 else
472 ret = -EACCES;
473 snid_done(cdev, ret);
474}
475
476
477
478
479static void snid_callback(struct ccw_device *cdev, void *data, int rc)
480{
481 struct ccw_request *req = &cdev->private->req;
482
483 switch (rc) {
484 case 0:
485 cdev->private->pgid_valid_mask |= req->lpm;
486 break;
487 case -ETIME:
488 cdev->private->flags.pgid_unknown = 1;
489 cdev->private->path_noirq_mask |= req->lpm;
490 break;
491 case -EACCES:
492 cdev->private->path_notoper_mask |= req->lpm;
493 break;
494 default:
495 goto err;
496 }
497
498 req->lpm >>= 1;
499 snid_do(cdev);
500 return;
501
502err:
503 snid_done(cdev, rc);
504}
505
506
507
508
509static void verify_start(struct ccw_device *cdev)
510{
511 struct subchannel *sch = to_subchannel(cdev->dev.parent);
512 struct ccw_request *req = &cdev->private->req;
513 struct ccw_dev_id *devid = &cdev->private->dev_id;
514
515 sch->vpm = 0;
516 sch->lpm = sch->schib.pmcw.pam;
517
518
519 memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
520 cdev->private->pgid_valid_mask = 0;
521 cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
522 cdev->private->path_notoper_mask = 0;
523
524
525 memset(req, 0, sizeof(*req));
526 req->timeout = PGID_TIMEOUT;
527 req->maxretries = PGID_RETRIES;
528 req->lpm = 0x80;
529 req->singlepath = 1;
530 if (cdev->private->flags.pgroup) {
531 CIO_TRACE_EVENT(4, "snid");
532 CIO_HEX_EVENT(4, devid, sizeof(*devid));
533 req->callback = snid_callback;
534 snid_do(cdev);
535 } else {
536 CIO_TRACE_EVENT(4, "nop");
537 CIO_HEX_EVENT(4, devid, sizeof(*devid));
538 req->filter = nop_filter;
539 req->callback = nop_callback;
540 nop_do(cdev);
541 }
542}
543
544
545
546
547
548
549
550
551
552
553
554void ccw_device_verify_start(struct ccw_device *cdev)
555{
556 CIO_TRACE_EVENT(4, "vrfy");
557 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
558
559
560
561
562 cdev->private->flags.pgroup = cdev->private->options.pgroup;
563 cdev->private->flags.mpath = cdev->private->options.mpath;
564 cdev->private->flags.doverify = 0;
565 cdev->private->path_noirq_mask = 0;
566 verify_start(cdev);
567}
568
569
570
571
572static void disband_callback(struct ccw_device *cdev, void *data, int rc)
573{
574 struct subchannel *sch = to_subchannel(cdev->dev.parent);
575 struct ccw_dev_id *id = &cdev->private->dev_id;
576
577 if (rc)
578 goto out;
579
580 cdev->private->flags.mpath = 0;
581 if (sch->config.mp) {
582 sch->config.mp = 0;
583 rc = cio_commit_config(sch);
584 }
585out:
586 CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
587 rc);
588 ccw_device_disband_done(cdev, rc);
589}
590
591
592
593
594
595
596
597
598
599void ccw_device_disband_start(struct ccw_device *cdev)
600{
601 struct subchannel *sch = to_subchannel(cdev->dev.parent);
602 struct ccw_request *req = &cdev->private->req;
603 u8 fn;
604
605 CIO_TRACE_EVENT(4, "disb");
606 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
607
608 memset(req, 0, sizeof(*req));
609 req->timeout = PGID_TIMEOUT;
610 req->maxretries = PGID_RETRIES;
611 req->lpm = sch->schib.pmcw.pam & sch->opm;
612 req->singlepath = 1;
613 req->callback = disband_callback;
614 fn = SPID_FUNC_DISBAND;
615 if (cdev->private->flags.mpath)
616 fn |= SPID_FUNC_MULTI_PATH;
617 spid_build_cp(cdev, fn);
618 ccw_request_start(cdev);
619}
620
621struct stlck_data {
622 struct completion done;
623 int rc;
624};
625
626static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)
627{
628 struct ccw_request *req = &cdev->private->req;
629 struct ccw1 *cp = cdev->private->iccws;
630
631 cp[0].cmd_code = CCW_CMD_STLCK;
632 cp[0].cda = (u32) (addr_t) buf1;
633 cp[0].count = 32;
634 cp[0].flags = CCW_FLAG_CC;
635 cp[1].cmd_code = CCW_CMD_RELEASE;
636 cp[1].cda = (u32) (addr_t) buf2;
637 cp[1].count = 32;
638 cp[1].flags = 0;
639 req->cp = cp;
640}
641
642static void stlck_callback(struct ccw_device *cdev, void *data, int rc)
643{
644 struct stlck_data *sdata = data;
645
646 sdata->rc = rc;
647 complete(&sdata->done);
648}
649
650
651
652
653
654
655
656
657
658
659static void ccw_device_stlck_start(struct ccw_device *cdev, void *data,
660 void *buf1, void *buf2)
661{
662 struct subchannel *sch = to_subchannel(cdev->dev.parent);
663 struct ccw_request *req = &cdev->private->req;
664
665 CIO_TRACE_EVENT(4, "stlck");
666 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
667
668 memset(req, 0, sizeof(*req));
669 req->timeout = PGID_TIMEOUT;
670 req->maxretries = PGID_RETRIES;
671 req->lpm = sch->schib.pmcw.pam & sch->opm;
672 req->data = data;
673 req->callback = stlck_callback;
674 stlck_build_cp(cdev, buf1, buf2);
675 ccw_request_start(cdev);
676}
677
678
679
680
681int ccw_device_stlck(struct ccw_device *cdev)
682{
683 struct subchannel *sch = to_subchannel(cdev->dev.parent);
684 struct stlck_data data;
685 u8 *buffer;
686 int rc;
687
688
689 if (cdev->drv) {
690 if (!cdev->private->options.force)
691 return -EINVAL;
692 }
693 buffer = kzalloc(64, GFP_DMA | GFP_KERNEL);
694 if (!buffer)
695 return -ENOMEM;
696 init_completion(&data.done);
697 data.rc = -EIO;
698 spin_lock_irq(sch->lock);
699 rc = cio_enable_subchannel(sch, (u32) (addr_t) sch);
700 if (rc)
701 goto out_unlock;
702
703 cdev->private->state = DEV_STATE_STEAL_LOCK;
704 ccw_device_stlck_start(cdev, &data, &buffer[0], &buffer[32]);
705 spin_unlock_irq(sch->lock);
706
707 if (wait_for_completion_interruptible(&data.done)) {
708
709 spin_lock_irq(sch->lock);
710 ccw_request_cancel(cdev);
711 spin_unlock_irq(sch->lock);
712 wait_for_completion(&data.done);
713 }
714 rc = data.rc;
715
716 spin_lock_irq(sch->lock);
717 cio_disable_subchannel(sch);
718 cdev->private->state = DEV_STATE_BOXED;
719out_unlock:
720 spin_unlock_irq(sch->lock);
721 kfree(buffer);
722
723 return rc;
724}
725