Merge git://git.infradead.org/~kmpark/onenand-mtd-2.6
[linux-2.6] / drivers / s390 / cio / device_pgid.c
1 /*
2  * drivers/s390/cio/device_pgid.c
3  *
4  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
5  *                       IBM Corporation
6  *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
7  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
8  *
9  * Path Group ID functions.
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14
15 #include <asm/ccwdev.h>
16 #include <asm/cio.h>
17 #include <asm/delay.h>
18 #include <asm/lowcore.h>
19
20 #include "cio.h"
21 #include "cio_debug.h"
22 #include "css.h"
23 #include "device.h"
24 #include "ioasm.h"
25 #include "io_sch.h"
26
27 /*
28  * Helper function called from interrupt context to decide whether an
29  * operation should be tried again.
30  */
31 static int __ccw_device_should_retry(struct scsw *scsw)
32 {
33         /* CC is only valid if start function bit is set. */
34         if ((scsw->fctl & SCSW_FCTL_START_FUNC) && scsw->cc == 1)
35                 return 1;
36         /* No more activity. For sense and set PGID we stubbornly try again. */
37         if (!scsw->actl)
38                 return 1;
39         return 0;
40 }
41
42 /*
43  * Start Sense Path Group ID helper function. Used in ccw_device_recog
44  * and ccw_device_sense_pgid.
45  */
46 static int
47 __ccw_device_sense_pgid_start(struct ccw_device *cdev)
48 {
49         struct subchannel *sch;
50         struct ccw1 *ccw;
51         int ret;
52         int i;
53
54         sch = to_subchannel(cdev->dev.parent);
55         /* Return if we already checked on all paths. */
56         if (cdev->private->imask == 0)
57                 return (sch->lpm == 0) ? -ENODEV : -EACCES;
58         i = 8 - ffs(cdev->private->imask);
59
60         /* Setup sense path group id channel program. */
61         ccw = cdev->private->iccws;
62         ccw->cmd_code = CCW_CMD_SENSE_PGID;
63         ccw->count = sizeof (struct pgid);
64         ccw->flags = CCW_FLAG_SLI;
65
66         /* Reset device status. */
67         memset(&cdev->private->irb, 0, sizeof(struct irb));
68         /* Try on every path. */
69         ret = -ENODEV;
70         while (cdev->private->imask != 0) {
71                 /* Try every path multiple times. */
72                 ccw->cda = (__u32) __pa (&cdev->private->pgid[i]);
73                 if (cdev->private->iretry > 0) {
74                         cdev->private->iretry--;
75                         /* Reset internal retry indication. */
76                         cdev->private->flags.intretry = 0;
77                         ret = cio_start (sch, cdev->private->iccws, 
78                                          cdev->private->imask);
79                         /* ret is 0, -EBUSY, -EACCES or -ENODEV */
80                         if (ret != -EACCES)
81                                 return ret;
82                         CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel "
83                                       "0.%x.%04x, lpm %02X, became 'not "
84                                       "operational'\n",
85                                       cdev->private->dev_id.devno,
86                                       sch->schid.ssid,
87                                       sch->schid.sch_no, cdev->private->imask);
88
89                 }
90                 cdev->private->imask >>= 1;
91                 cdev->private->iretry = 5;
92                 i++;
93         }
94
95         return ret;
96 }
97
98 void
99 ccw_device_sense_pgid_start(struct ccw_device *cdev)
100 {
101         int ret;
102
103         /* Set a timeout of 60s */
104         ccw_device_set_timeout(cdev, 60*HZ);
105
106         cdev->private->state = DEV_STATE_SENSE_PGID;
107         cdev->private->imask = 0x80;
108         cdev->private->iretry = 5;
109         memset (&cdev->private->pgid, 0, sizeof (cdev->private->pgid));
110         ret = __ccw_device_sense_pgid_start(cdev);
111         if (ret && ret != -EBUSY)
112                 ccw_device_sense_pgid_done(cdev, ret);
113 }
114
115 /*
116  * Called from interrupt context to check if a valid answer
117  * to Sense Path Group ID was received.
118  */
119 static int
120 __ccw_device_check_sense_pgid(struct ccw_device *cdev)
121 {
122         struct subchannel *sch;
123         struct irb *irb;
124         int i;
125
126         sch = to_subchannel(cdev->dev.parent);
127         irb = &cdev->private->irb;
128         if (irb->scsw.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
129                 /* Retry Sense PGID if requested. */
130                 if (cdev->private->flags.intretry) {
131                         cdev->private->flags.intretry = 0;
132                         return -EAGAIN;
133                 }
134                 return -ETIME;
135         }
136         if (irb->esw.esw0.erw.cons &&
137             (irb->ecw[0]&(SNS0_CMD_REJECT|SNS0_INTERVENTION_REQ))) {
138                 /*
139                  * If the device doesn't support the Sense Path Group ID
140                  *  command further retries wouldn't help ...
141                  */
142                 return -EOPNOTSUPP;
143         }
144         if (irb->esw.esw0.erw.cons) {
145                 CIO_MSG_EVENT(2, "SNID - device 0.%x.%04x, unit check, "
146                               "lpum %02X, cnt %02d, sns : "
147                               "%02X%02X%02X%02X %02X%02X%02X%02X ...\n",
148                               cdev->private->dev_id.ssid,
149                               cdev->private->dev_id.devno,
150                               irb->esw.esw0.sublog.lpum,
151                               irb->esw.esw0.erw.scnt,
152                               irb->ecw[0], irb->ecw[1],
153                               irb->ecw[2], irb->ecw[3],
154                               irb->ecw[4], irb->ecw[5],
155                               irb->ecw[6], irb->ecw[7]);
156                 return -EAGAIN;
157         }
158         if (irb->scsw.cc == 3) {
159                 u8 lpm;
160
161                 lpm = to_io_private(sch)->orb.lpm;
162                 CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel 0.%x.%04x,"
163                               " lpm %02X, became 'not operational'\n",
164                               cdev->private->dev_id.devno, sch->schid.ssid,
165                               sch->schid.sch_no, lpm);
166                 return -EACCES;
167         }
168         i = 8 - ffs(cdev->private->imask);
169         if (cdev->private->pgid[i].inf.ps.state2 == SNID_STATE2_RESVD_ELSE) {
170                 CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel 0.%x.%04x "
171                               "is reserved by someone else\n",
172                               cdev->private->dev_id.devno, sch->schid.ssid,
173                               sch->schid.sch_no);
174                 return -EUSERS;
175         }
176         return 0;
177 }
178
179 /*
180  * Got interrupt for Sense Path Group ID.
181  */
182 void
183 ccw_device_sense_pgid_irq(struct ccw_device *cdev, enum dev_event dev_event)
184 {
185         struct subchannel *sch;
186         struct irb *irb;
187         int ret;
188
189         irb = (struct irb *) __LC_IRB;
190
191         if (irb->scsw.stctl ==
192             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
193                 if (__ccw_device_should_retry(&irb->scsw)) {
194                         ret = __ccw_device_sense_pgid_start(cdev);
195                         if (ret && ret != -EBUSY)
196                                 ccw_device_sense_pgid_done(cdev, ret);
197                 }
198                 return;
199         }
200         if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
201                 return;
202         sch = to_subchannel(cdev->dev.parent);
203         ret = __ccw_device_check_sense_pgid(cdev);
204         memset(&cdev->private->irb, 0, sizeof(struct irb));
205         switch (ret) {
206         /* 0, -ETIME, -EOPNOTSUPP, -EAGAIN, -EACCES or -EUSERS */
207         case -EOPNOTSUPP:       /* Sense Path Group ID not supported */
208                 ccw_device_sense_pgid_done(cdev, -EOPNOTSUPP);
209                 break;
210         case -ETIME:            /* Sense path group id stopped by timeout. */
211                 ccw_device_sense_pgid_done(cdev, -ETIME);
212                 break;
213         case -EACCES:           /* channel is not operational. */
214                 sch->lpm &= ~cdev->private->imask;
215                 /* Fall through. */
216         case 0:                 /* Sense Path Group ID successful. */
217                 cdev->private->imask >>= 1;
218                 cdev->private->iretry = 5;
219                 /* Fall through. */
220         case -EAGAIN:           /* Try again. */
221                 ret = __ccw_device_sense_pgid_start(cdev);
222                 if (ret != 0 && ret != -EBUSY)
223                         ccw_device_sense_pgid_done(cdev, ret);
224                 break;
225         case -EUSERS:           /* device is reserved for someone else. */
226                 ccw_device_sense_pgid_done(cdev, -EUSERS);
227                 break;
228         }
229 }
230
231 /*
232  * Path Group ID helper function.
233  */
234 static int
235 __ccw_device_do_pgid(struct ccw_device *cdev, __u8 func)
236 {
237         struct subchannel *sch;
238         struct ccw1 *ccw;
239         int ret;
240
241         sch = to_subchannel(cdev->dev.parent);
242
243         /* Setup sense path group id channel program. */
244         cdev->private->pgid[0].inf.fc = func;
245         ccw = cdev->private->iccws;
246         if (!cdev->private->flags.pgid_single) {
247                 cdev->private->pgid[0].inf.fc |= SPID_FUNC_MULTI_PATH;
248                 ccw->cmd_code = CCW_CMD_SUSPEND_RECONN;
249                 ccw->cda = 0;
250                 ccw->count = 0;
251                 ccw->flags = CCW_FLAG_SLI | CCW_FLAG_CC;
252                 ccw++;
253         } else
254                 cdev->private->pgid[0].inf.fc |= SPID_FUNC_SINGLE_PATH;
255
256         ccw->cmd_code = CCW_CMD_SET_PGID;
257         ccw->cda = (__u32) __pa (&cdev->private->pgid[0]);
258         ccw->count = sizeof (struct pgid);
259         ccw->flags = CCW_FLAG_SLI;
260
261         /* Reset device status. */
262         memset(&cdev->private->irb, 0, sizeof(struct irb));
263
264         /* Try multiple times. */
265         ret = -EACCES;
266         if (cdev->private->iretry > 0) {
267                 cdev->private->iretry--;
268                 /* Reset internal retry indication. */
269                 cdev->private->flags.intretry = 0;
270                 ret = cio_start (sch, cdev->private->iccws,
271                                  cdev->private->imask);
272                 /* We expect an interrupt in case of success or busy
273                  * indication. */
274                 if ((ret == 0) || (ret == -EBUSY))
275                         return ret;
276         }
277         /* PGID command failed on this path. */
278         CIO_MSG_EVENT(2, "SPID - Device %04x on Subchannel "
279                       "0.%x.%04x, lpm %02X, became 'not operational'\n",
280                       cdev->private->dev_id.devno, sch->schid.ssid,
281                       sch->schid.sch_no, cdev->private->imask);
282         return ret;
283 }
284
285 /*
286  * Helper function to send a nop ccw down a path.
287  */
288 static int __ccw_device_do_nop(struct ccw_device *cdev)
289 {
290         struct subchannel *sch;
291         struct ccw1 *ccw;
292         int ret;
293
294         sch = to_subchannel(cdev->dev.parent);
295
296         /* Setup nop channel program. */
297         ccw = cdev->private->iccws;
298         ccw->cmd_code = CCW_CMD_NOOP;
299         ccw->cda = 0;
300         ccw->count = 0;
301         ccw->flags = CCW_FLAG_SLI;
302
303         /* Reset device status. */
304         memset(&cdev->private->irb, 0, sizeof(struct irb));
305
306         /* Try multiple times. */
307         ret = -EACCES;
308         if (cdev->private->iretry > 0) {
309                 cdev->private->iretry--;
310                 /* Reset internal retry indication. */
311                 cdev->private->flags.intretry = 0;
312                 ret = cio_start (sch, cdev->private->iccws,
313                                  cdev->private->imask);
314                 /* We expect an interrupt in case of success or busy
315                  * indication. */
316                 if ((ret == 0) || (ret == -EBUSY))
317                         return ret;
318         }
319         /* nop command failed on this path. */
320         CIO_MSG_EVENT(2, "NOP - Device %04x on Subchannel "
321                       "0.%x.%04x, lpm %02X, became 'not operational'\n",
322                       cdev->private->dev_id.devno, sch->schid.ssid,
323                       sch->schid.sch_no, cdev->private->imask);
324         return ret;
325 }
326
327
328 /*
329  * Called from interrupt context to check if a valid answer
330  * to Set Path Group ID was received.
331  */
332 static int
333 __ccw_device_check_pgid(struct ccw_device *cdev)
334 {
335         struct subchannel *sch;
336         struct irb *irb;
337
338         sch = to_subchannel(cdev->dev.parent);
339         irb = &cdev->private->irb;
340         if (irb->scsw.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
341                 /* Retry Set PGID if requested. */
342                 if (cdev->private->flags.intretry) {
343                         cdev->private->flags.intretry = 0;
344                         return -EAGAIN;
345                 }
346                 return -ETIME;
347         }
348         if (irb->esw.esw0.erw.cons) {
349                 if (irb->ecw[0] & SNS0_CMD_REJECT)
350                         return -EOPNOTSUPP;
351                 /* Hmm, whatever happened, try again. */
352                 CIO_MSG_EVENT(2, "SPID - device 0.%x.%04x, unit check, "
353                               "cnt %02d, "
354                               "sns : %02X%02X%02X%02X %02X%02X%02X%02X ...\n",
355                               cdev->private->dev_id.ssid,
356                               cdev->private->dev_id.devno,
357                               irb->esw.esw0.erw.scnt,
358                               irb->ecw[0], irb->ecw[1],
359                               irb->ecw[2], irb->ecw[3],
360                               irb->ecw[4], irb->ecw[5],
361                               irb->ecw[6], irb->ecw[7]);
362                 return -EAGAIN;
363         }
364         if (irb->scsw.cc == 3) {
365                 CIO_MSG_EVENT(2, "SPID - Device %04x on Subchannel 0.%x.%04x,"
366                               " lpm %02X, became 'not operational'\n",
367                               cdev->private->dev_id.devno, sch->schid.ssid,
368                               sch->schid.sch_no, cdev->private->imask);
369                 return -EACCES;
370         }
371         return 0;
372 }
373
374 /*
375  * Called from interrupt context to check the path status after a nop has
376  * been send.
377  */
378 static int __ccw_device_check_nop(struct ccw_device *cdev)
379 {
380         struct subchannel *sch;
381         struct irb *irb;
382
383         sch = to_subchannel(cdev->dev.parent);
384         irb = &cdev->private->irb;
385         if (irb->scsw.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
386                 /* Retry NOP if requested. */
387                 if (cdev->private->flags.intretry) {
388                         cdev->private->flags.intretry = 0;
389                         return -EAGAIN;
390                 }
391                 return -ETIME;
392         }
393         if (irb->scsw.cc == 3) {
394                 CIO_MSG_EVENT(2, "NOP - Device %04x on Subchannel 0.%x.%04x,"
395                               " lpm %02X, became 'not operational'\n",
396                               cdev->private->dev_id.devno, sch->schid.ssid,
397                               sch->schid.sch_no, cdev->private->imask);
398                 return -EACCES;
399         }
400         return 0;
401 }
402
403 static void
404 __ccw_device_verify_start(struct ccw_device *cdev)
405 {
406         struct subchannel *sch;
407         __u8 func;
408         int ret;
409
410         sch = to_subchannel(cdev->dev.parent);
411         /* Repeat for all paths. */
412         for (; cdev->private->imask; cdev->private->imask >>= 1,
413                                      cdev->private->iretry = 5) {
414                 if ((cdev->private->imask & sch->schib.pmcw.pam) == 0)
415                         /* Path not available, try next. */
416                         continue;
417                 if (cdev->private->options.pgroup) {
418                         if (sch->opm & cdev->private->imask)
419                                 func = SPID_FUNC_ESTABLISH;
420                         else
421                                 func = SPID_FUNC_RESIGN;
422                         ret = __ccw_device_do_pgid(cdev, func);
423                 } else
424                         ret = __ccw_device_do_nop(cdev);
425                 /* We expect an interrupt in case of success or busy
426                  * indication. */
427                 if (ret == 0 || ret == -EBUSY)
428                         return;
429                 /* Permanent path failure, try next. */
430         }
431         /* Done with all paths. */
432         ccw_device_verify_done(cdev, (sch->vpm != 0) ? 0 : -ENODEV);
433 }
434                 
435 /*
436  * Got interrupt for Set Path Group ID.
437  */
438 void
439 ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
440 {
441         struct subchannel *sch;
442         struct irb *irb;
443         int ret;
444
445         irb = (struct irb *) __LC_IRB;
446
447         if (irb->scsw.stctl ==
448             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
449                 if (__ccw_device_should_retry(&irb->scsw))
450                         __ccw_device_verify_start(cdev);
451                 return;
452         }
453         if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
454                 return;
455         sch = to_subchannel(cdev->dev.parent);
456         if (cdev->private->options.pgroup)
457                 ret = __ccw_device_check_pgid(cdev);
458         else
459                 ret = __ccw_device_check_nop(cdev);
460         memset(&cdev->private->irb, 0, sizeof(struct irb));
461
462         switch (ret) {
463         /* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
464         case 0:
465                 /* Path verification ccw finished successfully, update lpm. */
466                 sch->vpm |= sch->opm & cdev->private->imask;
467                 /* Go on with next path. */
468                 cdev->private->imask >>= 1;
469                 cdev->private->iretry = 5;
470                 __ccw_device_verify_start(cdev);
471                 break;
472         case -EOPNOTSUPP:
473                 /*
474                  * One of those strange devices which claim to be able
475                  * to do multipathing but not for Set Path Group ID.
476                  */
477                 if (cdev->private->flags.pgid_single)
478                         cdev->private->options.pgroup = 0;
479                 else
480                         cdev->private->flags.pgid_single = 1;
481                 /* Retry */
482                 sch->vpm = 0;
483                 cdev->private->imask = 0x80;
484                 cdev->private->iretry = 5;
485                 /* fall through. */
486         case -EAGAIN:           /* Try again. */
487                 __ccw_device_verify_start(cdev);
488                 break;
489         case -ETIME:            /* Set path group id stopped by timeout. */
490                 ccw_device_verify_done(cdev, -ETIME);
491                 break;
492         case -EACCES:           /* channel is not operational. */
493                 cdev->private->imask >>= 1;
494                 cdev->private->iretry = 5;
495                 __ccw_device_verify_start(cdev);
496                 break;
497         }
498 }
499
500 void
501 ccw_device_verify_start(struct ccw_device *cdev)
502 {
503         struct subchannel *sch = to_subchannel(cdev->dev.parent);
504
505         cdev->private->flags.pgid_single = 0;
506         cdev->private->imask = 0x80;
507         cdev->private->iretry = 5;
508
509         /* Start with empty vpm. */
510         sch->vpm = 0;
511
512         /* Get current pam. */
513         if (stsch(sch->schid, &sch->schib)) {
514                 ccw_device_verify_done(cdev, -ENODEV);
515                 return;
516         }
517         /* After 60s path verification is considered to have failed. */
518         ccw_device_set_timeout(cdev, 60*HZ);
519         __ccw_device_verify_start(cdev);
520 }
521
522 static void
523 __ccw_device_disband_start(struct ccw_device *cdev)
524 {
525         struct subchannel *sch;
526         int ret;
527
528         sch = to_subchannel(cdev->dev.parent);
529         while (cdev->private->imask != 0) {
530                 if (sch->lpm & cdev->private->imask) {
531                         ret = __ccw_device_do_pgid(cdev, SPID_FUNC_DISBAND);
532                         if (ret == 0)
533                                 return;
534                 }
535                 cdev->private->iretry = 5;
536                 cdev->private->imask >>= 1;
537         }
538         ccw_device_disband_done(cdev, (sch->lpm != 0) ? 0 : -ENODEV);
539 }
540
541 /*
542  * Got interrupt for Unset Path Group ID.
543  */
544 void
545 ccw_device_disband_irq(struct ccw_device *cdev, enum dev_event dev_event)
546 {
547         struct subchannel *sch;
548         struct irb *irb;
549         int ret;
550
551         irb = (struct irb *) __LC_IRB;
552
553         if (irb->scsw.stctl ==
554             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
555                 if (__ccw_device_should_retry(&irb->scsw))
556                         __ccw_device_disband_start(cdev);
557                 return;
558         }
559         if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
560                 return;
561         sch = to_subchannel(cdev->dev.parent);
562         ret = __ccw_device_check_pgid(cdev);
563         memset(&cdev->private->irb, 0, sizeof(struct irb));
564         switch (ret) {
565         /* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
566         case 0:                 /* disband successful. */
567                 ccw_device_disband_done(cdev, ret);
568                 break;
569         case -EOPNOTSUPP:
570                 /*
571                  * One of those strange devices which claim to be able
572                  * to do multipathing but not for Unset Path Group ID.
573                  */
574                 cdev->private->flags.pgid_single = 1;
575                 /* fall through. */
576         case -EAGAIN:           /* Try again. */
577                 __ccw_device_disband_start(cdev);
578                 break;
579         case -ETIME:            /* Set path group id stopped by timeout. */
580                 ccw_device_disband_done(cdev, -ETIME);
581                 break;
582         case -EACCES:           /* channel is not operational. */
583                 cdev->private->imask >>= 1;
584                 cdev->private->iretry = 5;
585                 __ccw_device_disband_start(cdev);
586                 break;
587         }
588 }
589
590 void
591 ccw_device_disband_start(struct ccw_device *cdev)
592 {
593         /* After 60s disbanding is considered to have failed. */
594         ccw_device_set_timeout(cdev, 60*HZ);
595
596         cdev->private->flags.pgid_single = 0;
597         cdev->private->iretry = 5;
598         cdev->private->imask = 0x80;
599         __ccw_device_disband_start(cdev);
600 }