Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[linux-2.6] / drivers / s390 / cio / cio.c
1 /*
2  *  drivers/s390/cio/cio.c
3  *   S/390 common I/O routines -- low level i/o calls
4  *
5  *    Copyright (C) IBM Corp. 1999,2006
6  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
7  *               Cornelia Huck (cornelia.huck@de.ibm.com)
8  *               Arnd Bergmann (arndb@de.ibm.com)
9  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/device.h>
16 #include <linux/kernel_stat.h>
17 #include <linux/interrupt.h>
18 #include <asm/cio.h>
19 #include <asm/delay.h>
20 #include <asm/irq.h>
21 #include <asm/irq_regs.h>
22 #include <asm/setup.h>
23 #include <asm/reset.h>
24 #include <asm/ipl.h>
25 #include <asm/chpid.h>
26 #include "airq.h"
27 #include "cio.h"
28 #include "css.h"
29 #include "chsc.h"
30 #include "ioasm.h"
31 #include "blacklist.h"
32 #include "cio_debug.h"
33 #include "chp.h"
34 #include "../s390mach.h"
35
36 debug_info_t *cio_debug_msg_id;
37 debug_info_t *cio_debug_trace_id;
38 debug_info_t *cio_debug_crw_id;
39
40 int cio_show_msg;
41
42 static int __init
43 cio_setup (char *parm)
44 {
45         if (!strcmp (parm, "yes"))
46                 cio_show_msg = 1;
47         else if (!strcmp (parm, "no"))
48                 cio_show_msg = 0;
49         else
50                 printk (KERN_ERR "cio_setup : invalid cio_msg parameter '%s'",
51                         parm);
52         return 1;
53 }
54
55 __setup ("cio_msg=", cio_setup);
56
57 /*
58  * Function: cio_debug_init
59  * Initializes three debug logs (under /proc/s390dbf) for common I/O:
60  * - cio_msg logs the messages which are printk'ed when CONFIG_DEBUG_IO is on
61  * - cio_trace logs the calling of different functions
62  * - cio_crw logs the messages which are printk'ed when CONFIG_DEBUG_CRW is on
63  * debug levels depend on CONFIG_DEBUG_IO resp. CONFIG_DEBUG_CRW
64  */
65 static int __init
66 cio_debug_init (void)
67 {
68         cio_debug_msg_id = debug_register ("cio_msg", 16, 4, 16*sizeof (long));
69         if (!cio_debug_msg_id)
70                 goto out_unregister;
71         debug_register_view (cio_debug_msg_id, &debug_sprintf_view);
72         debug_set_level (cio_debug_msg_id, 2);
73         cio_debug_trace_id = debug_register ("cio_trace", 16, 4, 16);
74         if (!cio_debug_trace_id)
75                 goto out_unregister;
76         debug_register_view (cio_debug_trace_id, &debug_hex_ascii_view);
77         debug_set_level (cio_debug_trace_id, 2);
78         cio_debug_crw_id = debug_register ("cio_crw", 4, 4, 16*sizeof (long));
79         if (!cio_debug_crw_id)
80                 goto out_unregister;
81         debug_register_view (cio_debug_crw_id, &debug_sprintf_view);
82         debug_set_level (cio_debug_crw_id, 2);
83         pr_debug("debugging initialized\n");
84         return 0;
85
86 out_unregister:
87         if (cio_debug_msg_id)
88                 debug_unregister (cio_debug_msg_id);
89         if (cio_debug_trace_id)
90                 debug_unregister (cio_debug_trace_id);
91         if (cio_debug_crw_id)
92                 debug_unregister (cio_debug_crw_id);
93         pr_debug("could not initialize debugging\n");
94         return -1;
95 }
96
97 arch_initcall (cio_debug_init);
98
99 int
100 cio_set_options (struct subchannel *sch, int flags)
101 {
102        sch->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
103        sch->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
104        sch->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
105        return 0;
106 }
107
108 /* FIXME: who wants to use this? */
109 int
110 cio_get_options (struct subchannel *sch)
111 {
112        int flags;
113
114        flags = 0;
115        if (sch->options.suspend)
116                 flags |= DOIO_ALLOW_SUSPEND;
117        if (sch->options.prefetch)
118                 flags |= DOIO_DENY_PREFETCH;
119        if (sch->options.inter)
120                 flags |= DOIO_SUPPRESS_INTER;
121        return flags;
122 }
123
124 /*
125  * Use tpi to get a pending interrupt, call the interrupt handler and
126  * return a pointer to the subchannel structure.
127  */
128 static int
129 cio_tpi(void)
130 {
131         struct tpi_info *tpi_info;
132         struct subchannel *sch;
133         struct irb *irb;
134
135         tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
136         if (tpi (NULL) != 1)
137                 return 0;
138         irb = (struct irb *) __LC_IRB;
139         /* Store interrupt response block to lowcore. */
140         if (tsch (tpi_info->schid, irb) != 0)
141                 /* Not status pending or not operational. */
142                 return 1;
143         sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
144         if (!sch)
145                 return 1;
146         local_bh_disable();
147         irq_enter ();
148         spin_lock(sch->lock);
149         memcpy (&sch->schib.scsw, &irb->scsw, sizeof (struct scsw));
150         if (sch->driver && sch->driver->irq)
151                 sch->driver->irq(&sch->dev);
152         spin_unlock(sch->lock);
153         irq_exit ();
154         _local_bh_enable();
155         return 1;
156 }
157
158 static int
159 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
160 {
161         char dbf_text[15];
162
163         if (lpm != 0)
164                 sch->lpm &= ~lpm;
165         else
166                 sch->lpm = 0;
167
168         stsch (sch->schid, &sch->schib);
169
170         CIO_MSG_EVENT(0, "cio_start: 'not oper' status for "
171                       "subchannel 0.%x.%04x!\n", sch->schid.ssid,
172                       sch->schid.sch_no);
173         sprintf(dbf_text, "no%s", sch->dev.bus_id);
174         CIO_TRACE_EVENT(0, dbf_text);
175         CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
176
177         return (sch->lpm ? -EACCES : -ENODEV);
178 }
179
180 int
181 cio_start_key (struct subchannel *sch,  /* subchannel structure */
182                struct ccw1 * cpa,       /* logical channel prog addr */
183                __u8 lpm,                /* logical path mask */
184                __u8 key)                /* storage key */
185 {
186         char dbf_txt[15];
187         int ccode;
188
189         CIO_TRACE_EVENT (4, "stIO");
190         CIO_TRACE_EVENT (4, sch->dev.bus_id);
191
192         /* sch is always under 2G. */
193         sch->orb.intparm = (__u32)(unsigned long)sch;
194         sch->orb.fmt = 1;
195
196         sch->orb.pfch = sch->options.prefetch == 0;
197         sch->orb.spnd = sch->options.suspend;
198         sch->orb.ssic = sch->options.suspend && sch->options.inter;
199         sch->orb.lpm = (lpm != 0) ? lpm : sch->lpm;
200 #ifdef CONFIG_64BIT
201         /*
202          * for 64 bit we always support 64 bit IDAWs with 4k page size only
203          */
204         sch->orb.c64 = 1;
205         sch->orb.i2k = 0;
206 #endif
207         sch->orb.key = key >> 4;
208         /* issue "Start Subchannel" */
209         sch->orb.cpa = (__u32) __pa (cpa);
210         ccode = ssch (sch->schid, &sch->orb);
211
212         /* process condition code */
213         sprintf (dbf_txt, "ccode:%d", ccode);
214         CIO_TRACE_EVENT (4, dbf_txt);
215
216         switch (ccode) {
217         case 0:
218                 /*
219                  * initialize device status information
220                  */
221                 sch->schib.scsw.actl |= SCSW_ACTL_START_PEND;
222                 return 0;
223         case 1:         /* status pending */
224         case 2:         /* busy */
225                 return -EBUSY;
226         default:                /* device/path not operational */
227                 return cio_start_handle_notoper(sch, lpm);
228         }
229 }
230
231 int
232 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
233 {
234         return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
235 }
236
237 /*
238  * resume suspended I/O operation
239  */
240 int
241 cio_resume (struct subchannel *sch)
242 {
243         char dbf_txt[15];
244         int ccode;
245
246         CIO_TRACE_EVENT (4, "resIO");
247         CIO_TRACE_EVENT (4, sch->dev.bus_id);
248
249         ccode = rsch (sch->schid);
250
251         sprintf (dbf_txt, "ccode:%d", ccode);
252         CIO_TRACE_EVENT (4, dbf_txt);
253
254         switch (ccode) {
255         case 0:
256                 sch->schib.scsw.actl |= SCSW_ACTL_RESUME_PEND;
257                 return 0;
258         case 1:
259                 return -EBUSY;
260         case 2:
261                 return -EINVAL;
262         default:
263                 /*
264                  * useless to wait for request completion
265                  *  as device is no longer operational !
266                  */
267                 return -ENODEV;
268         }
269 }
270
271 /*
272  * halt I/O operation
273  */
274 int
275 cio_halt(struct subchannel *sch)
276 {
277         char dbf_txt[15];
278         int ccode;
279
280         if (!sch)
281                 return -ENODEV;
282
283         CIO_TRACE_EVENT (2, "haltIO");
284         CIO_TRACE_EVENT (2, sch->dev.bus_id);
285
286         /*
287          * Issue "Halt subchannel" and process condition code
288          */
289         ccode = hsch (sch->schid);
290
291         sprintf (dbf_txt, "ccode:%d", ccode);
292         CIO_TRACE_EVENT (2, dbf_txt);
293
294         switch (ccode) {
295         case 0:
296                 sch->schib.scsw.actl |= SCSW_ACTL_HALT_PEND;
297                 return 0;
298         case 1:         /* status pending */
299         case 2:         /* busy */
300                 return -EBUSY;
301         default:                /* device not operational */
302                 return -ENODEV;
303         }
304 }
305
306 /*
307  * Clear I/O operation
308  */
309 int
310 cio_clear(struct subchannel *sch)
311 {
312         char dbf_txt[15];
313         int ccode;
314
315         if (!sch)
316                 return -ENODEV;
317
318         CIO_TRACE_EVENT (2, "clearIO");
319         CIO_TRACE_EVENT (2, sch->dev.bus_id);
320
321         /*
322          * Issue "Clear subchannel" and process condition code
323          */
324         ccode = csch (sch->schid);
325
326         sprintf (dbf_txt, "ccode:%d", ccode);
327         CIO_TRACE_EVENT (2, dbf_txt);
328
329         switch (ccode) {
330         case 0:
331                 sch->schib.scsw.actl |= SCSW_ACTL_CLEAR_PEND;
332                 return 0;
333         default:                /* device not operational */
334                 return -ENODEV;
335         }
336 }
337
338 /*
339  * Function: cio_cancel
340  * Issues a "Cancel Subchannel" on the specified subchannel
341  * Note: We don't need any fancy intparms and flags here
342  *       since xsch is executed synchronously.
343  * Only for common I/O internal use as for now.
344  */
345 int
346 cio_cancel (struct subchannel *sch)
347 {
348         char dbf_txt[15];
349         int ccode;
350
351         if (!sch)
352                 return -ENODEV;
353
354         CIO_TRACE_EVENT (2, "cancelIO");
355         CIO_TRACE_EVENT (2, sch->dev.bus_id);
356
357         ccode = xsch (sch->schid);
358
359         sprintf (dbf_txt, "ccode:%d", ccode);
360         CIO_TRACE_EVENT (2, dbf_txt);
361
362         switch (ccode) {
363         case 0:         /* success */
364                 /* Update information in scsw. */
365                 stsch (sch->schid, &sch->schib);
366                 return 0;
367         case 1:         /* status pending */
368                 return -EBUSY;
369         case 2:         /* not applicable */
370                 return -EINVAL;
371         default:        /* not oper */
372                 return -ENODEV;
373         }
374 }
375
376 /*
377  * Function: cio_modify
378  * Issues a "Modify Subchannel" on the specified subchannel
379  */
380 int
381 cio_modify (struct subchannel *sch)
382 {
383         int ccode, retry, ret;
384
385         ret = 0;
386         for (retry = 0; retry < 5; retry++) {
387                 ccode = msch_err (sch->schid, &sch->schib);
388                 if (ccode < 0)  /* -EIO if msch gets a program check. */
389                         return ccode;
390                 switch (ccode) {
391                 case 0: /* successfull */
392                         return 0;
393                 case 1: /* status pending */
394                         return -EBUSY;
395                 case 2: /* busy */
396                         udelay (100);   /* allow for recovery */
397                         ret = -EBUSY;
398                         break;
399                 case 3: /* not operational */
400                         return -ENODEV;
401                 }
402         }
403         return ret;
404 }
405
406 /*
407  * Enable subchannel.
408  */
409 int
410 cio_enable_subchannel (struct subchannel *sch, unsigned int isc)
411 {
412         char dbf_txt[15];
413         int ccode;
414         int retry;
415         int ret;
416
417         CIO_TRACE_EVENT (2, "ensch");
418         CIO_TRACE_EVENT (2, sch->dev.bus_id);
419
420         if (sch_is_pseudo_sch(sch))
421                 return -EINVAL;
422         ccode = stsch (sch->schid, &sch->schib);
423         if (ccode)
424                 return -ENODEV;
425
426         for (retry = 5, ret = 0; retry > 0; retry--) {
427                 sch->schib.pmcw.ena = 1;
428                 sch->schib.pmcw.isc = isc;
429                 sch->schib.pmcw.intparm = (__u32)(unsigned long)sch;
430                 ret = cio_modify(sch);
431                 if (ret == -ENODEV)
432                         break;
433                 if (ret == -EIO)
434                         /*
435                          * Got a program check in cio_modify. Try without
436                          * the concurrent sense bit the next time.
437                          */
438                         sch->schib.pmcw.csense = 0;
439                 if (ret == 0) {
440                         stsch (sch->schid, &sch->schib);
441                         if (sch->schib.pmcw.ena)
442                                 break;
443                 }
444                 if (ret == -EBUSY) {
445                         struct irb irb;
446                         if (tsch(sch->schid, &irb) != 0)
447                                 break;
448                 }
449         }
450         sprintf (dbf_txt, "ret:%d", ret);
451         CIO_TRACE_EVENT (2, dbf_txt);
452         return ret;
453 }
454
455 /*
456  * Disable subchannel.
457  */
458 int
459 cio_disable_subchannel (struct subchannel *sch)
460 {
461         char dbf_txt[15];
462         int ccode;
463         int retry;
464         int ret;
465
466         CIO_TRACE_EVENT (2, "dissch");
467         CIO_TRACE_EVENT (2, sch->dev.bus_id);
468
469         if (sch_is_pseudo_sch(sch))
470                 return 0;
471         ccode = stsch (sch->schid, &sch->schib);
472         if (ccode == 3)         /* Not operational. */
473                 return -ENODEV;
474
475         if (sch->schib.scsw.actl != 0)
476                 /*
477                  * the disable function must not be called while there are
478                  *  requests pending for completion !
479                  */
480                 return -EBUSY;
481
482         for (retry = 5, ret = 0; retry > 0; retry--) {
483                 sch->schib.pmcw.ena = 0;
484                 ret = cio_modify(sch);
485                 if (ret == -ENODEV)
486                         break;
487                 if (ret == -EBUSY)
488                         /*
489                          * The subchannel is busy or status pending.
490                          * We'll disable when the next interrupt was delivered
491                          * via the state machine.
492                          */
493                         break;
494                 if (ret == 0) {
495                         stsch (sch->schid, &sch->schib);
496                         if (!sch->schib.pmcw.ena)
497                                 break;
498                 }
499         }
500         sprintf (dbf_txt, "ret:%d", ret);
501         CIO_TRACE_EVENT (2, dbf_txt);
502         return ret;
503 }
504
505 int cio_create_sch_lock(struct subchannel *sch)
506 {
507         sch->lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL);
508         if (!sch->lock)
509                 return -ENOMEM;
510         spin_lock_init(sch->lock);
511         return 0;
512 }
513
514 /*
515  * cio_validate_subchannel()
516  *
517  * Find out subchannel type and initialize struct subchannel.
518  * Return codes:
519  *   SUBCHANNEL_TYPE_IO for a normal io subchannel
520  *   SUBCHANNEL_TYPE_CHSC for a chsc subchannel
521  *   SUBCHANNEL_TYPE_MESSAGE for a messaging subchannel
522  *   SUBCHANNEL_TYPE_ADM for a adm(?) subchannel
523  *   -ENXIO for non-defined subchannels
524  *   -ENODEV for subchannels with invalid device number or blacklisted devices
525  */
526 int
527 cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
528 {
529         char dbf_txt[15];
530         int ccode;
531         int err;
532
533         sprintf (dbf_txt, "valsch%x", schid.sch_no);
534         CIO_TRACE_EVENT (4, dbf_txt);
535
536         /* Nuke all fields. */
537         memset(sch, 0, sizeof(struct subchannel));
538
539         sch->schid = schid;
540         if (cio_is_console(schid)) {
541                 sch->lock = cio_get_console_lock();
542         } else {
543                 err = cio_create_sch_lock(sch);
544                 if (err)
545                         goto out;
546         }
547         mutex_init(&sch->reg_mutex);
548         /* Set a name for the subchannel */
549         snprintf (sch->dev.bus_id, BUS_ID_SIZE, "0.%x.%04x", schid.ssid,
550                   schid.sch_no);
551
552         /*
553          * The first subchannel that is not-operational (ccode==3)
554          *  indicates that there aren't any more devices available.
555          * If stsch gets an exception, it means the current subchannel set
556          *  is not valid.
557          */
558         ccode = stsch_err (schid, &sch->schib);
559         if (ccode) {
560                 err = (ccode == 3) ? -ENXIO : ccode;
561                 goto out;
562         }
563         /* Copy subchannel type from path management control word. */
564         sch->st = sch->schib.pmcw.st;
565
566         /*
567          * ... just being curious we check for non I/O subchannels
568          */
569         if (sch->st != 0) {
570                 CIO_DEBUG(KERN_INFO, 0,
571                           "Subchannel 0.%x.%04x reports "
572                           "non-I/O subchannel type %04X\n",
573                           sch->schid.ssid, sch->schid.sch_no, sch->st);
574                 /* We stop here for non-io subchannels. */
575                 err = sch->st;
576                 goto out;
577         }
578
579         /* Initialization for io subchannels. */
580         if (!sch->schib.pmcw.dnv) {
581                 /* io subchannel but device number is invalid. */
582                 err = -ENODEV;
583                 goto out;
584         }
585         /* Devno is valid. */
586         if (is_blacklisted (sch->schid.ssid, sch->schib.pmcw.dev)) {
587                 /*
588                  * This device must not be known to Linux. So we simply
589                  * say that there is no device and return ENODEV.
590                  */
591                 CIO_MSG_EVENT(4, "Blacklisted device detected "
592                               "at devno %04X, subchannel set %x\n",
593                               sch->schib.pmcw.dev, sch->schid.ssid);
594                 err = -ENODEV;
595                 goto out;
596         }
597         if (cio_is_console(sch->schid))
598                 sch->opm = 0xff;
599         else
600                 sch->opm = chp_get_sch_opm(sch);
601         sch->lpm = sch->schib.pmcw.pam & sch->opm;
602
603         CIO_DEBUG(KERN_INFO, 0,
604                   "Detected device %04x on subchannel 0.%x.%04X"
605                   " - PIM = %02X, PAM = %02X, POM = %02X\n",
606                   sch->schib.pmcw.dev, sch->schid.ssid,
607                   sch->schid.sch_no, sch->schib.pmcw.pim,
608                   sch->schib.pmcw.pam, sch->schib.pmcw.pom);
609
610         /*
611          * We now have to initially ...
612          *  ... set "interruption subclass"
613          *  ... enable "concurrent sense"
614          *  ... enable "multipath mode" if more than one
615          *        CHPID is available. This is done regardless
616          *        whether multiple paths are available for us.
617          */
618         sch->schib.pmcw.isc = 3;        /* could be smth. else */
619         sch->schib.pmcw.csense = 1;     /* concurrent sense */
620         sch->schib.pmcw.ena = 0;
621         if ((sch->lpm & (sch->lpm - 1)) != 0)
622                 sch->schib.pmcw.mp = 1; /* multipath mode */
623         return 0;
624 out:
625         if (!cio_is_console(schid))
626                 kfree(sch->lock);
627         sch->lock = NULL;
628         return err;
629 }
630
631 /*
632  * do_IRQ() handles all normal I/O device IRQ's (the special
633  *          SMP cross-CPU interrupts have their own specific
634  *          handlers).
635  *
636  */
637 void
638 do_IRQ (struct pt_regs *regs)
639 {
640         struct tpi_info *tpi_info;
641         struct subchannel *sch;
642         struct irb *irb;
643         struct pt_regs *old_regs;
644
645         old_regs = set_irq_regs(regs);
646         irq_enter();
647         asm volatile ("mc 0,0");
648         if (S390_lowcore.int_clock >= S390_lowcore.jiffy_timer)
649                 /**
650                  * Make sure that the i/o interrupt did not "overtake"
651                  * the last HZ timer interrupt.
652                  */
653                 account_ticks(S390_lowcore.int_clock);
654         /*
655          * Get interrupt information from lowcore
656          */
657         tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
658         irb = (struct irb *) __LC_IRB;
659         do {
660                 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
661                 /*
662                  * Non I/O-subchannel thin interrupts are processed differently
663                  */
664                 if (tpi_info->adapter_IO == 1 &&
665                     tpi_info->int_type == IO_INTERRUPT_TYPE) {
666                         do_adapter_IO();
667                         continue;
668                 }
669                 sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
670                 if (sch)
671                         spin_lock(sch->lock);
672                 /* Store interrupt response block to lowcore. */
673                 if (tsch (tpi_info->schid, irb) == 0 && sch) {
674                         /* Keep subchannel information word up to date. */
675                         memcpy (&sch->schib.scsw, &irb->scsw,
676                                 sizeof (irb->scsw));
677                         /* Call interrupt handler if there is one. */
678                         if (sch->driver && sch->driver->irq)
679                                 sch->driver->irq(&sch->dev);
680                 }
681                 if (sch)
682                         spin_unlock(sch->lock);
683                 /*
684                  * Are more interrupts pending?
685                  * If so, the tpi instruction will update the lowcore
686                  * to hold the info for the next interrupt.
687                  * We don't do this for VM because a tpi drops the cpu
688                  * out of the sie which costs more cycles than it saves.
689                  */
690         } while (!MACHINE_IS_VM && tpi (NULL) != 0);
691         irq_exit();
692         set_irq_regs(old_regs);
693 }
694
695 #ifdef CONFIG_CCW_CONSOLE
696 static struct subchannel console_subchannel;
697 static int console_subchannel_in_use;
698
699 /*
700  * busy wait for the next interrupt on the console
701  */
702 void
703 wait_cons_dev (void)
704 {
705         unsigned long cr6      __attribute__ ((aligned (8)));
706         unsigned long save_cr6 __attribute__ ((aligned (8)));
707
708         /* 
709          * before entering the spinlock we may already have
710          * processed the interrupt on a different CPU...
711          */
712         if (!console_subchannel_in_use)
713                 return;
714
715         /* disable all but isc 7 (console device) */
716         __ctl_store (save_cr6, 6, 6);
717         cr6 = 0x01000000;
718         __ctl_load (cr6, 6, 6);
719
720         do {
721                 spin_unlock(console_subchannel.lock);
722                 if (!cio_tpi())
723                         cpu_relax();
724                 spin_lock(console_subchannel.lock);
725         } while (console_subchannel.schib.scsw.actl != 0);
726         /*
727          * restore previous isc value
728          */
729         __ctl_load (save_cr6, 6, 6);
730 }
731
732 static int
733 cio_test_for_console(struct subchannel_id schid, void *data)
734 {
735         if (stsch_err(schid, &console_subchannel.schib) != 0)
736                 return -ENXIO;
737         if (console_subchannel.schib.pmcw.dnv &&
738             console_subchannel.schib.pmcw.dev ==
739             console_devno) {
740                 console_irq = schid.sch_no;
741                 return 1; /* found */
742         }
743         return 0;
744 }
745
746
747 static int
748 cio_get_console_sch_no(void)
749 {
750         struct subchannel_id schid;
751         
752         init_subchannel_id(&schid);
753         if (console_irq != -1) {
754                 /* VM provided us with the irq number of the console. */
755                 schid.sch_no = console_irq;
756                 if (stsch(schid, &console_subchannel.schib) != 0 ||
757                     !console_subchannel.schib.pmcw.dnv)
758                         return -1;
759                 console_devno = console_subchannel.schib.pmcw.dev;
760         } else if (console_devno != -1) {
761                 /* At least the console device number is known. */
762                 for_each_subchannel(cio_test_for_console, NULL);
763                 if (console_irq == -1)
764                         return -1;
765         } else {
766                 /* unlike in 2.4, we cannot autoprobe here, since
767                  * the channel subsystem is not fully initialized.
768                  * With some luck, the HWC console can take over */
769                 printk(KERN_WARNING "No ccw console found!\n");
770                 return -1;
771         }
772         return console_irq;
773 }
774
775 struct subchannel *
776 cio_probe_console(void)
777 {
778         int sch_no, ret;
779         struct subchannel_id schid;
780
781         if (xchg(&console_subchannel_in_use, 1) != 0)
782                 return ERR_PTR(-EBUSY);
783         sch_no = cio_get_console_sch_no();
784         if (sch_no == -1) {
785                 console_subchannel_in_use = 0;
786                 return ERR_PTR(-ENODEV);
787         }
788         memset(&console_subchannel, 0, sizeof(struct subchannel));
789         init_subchannel_id(&schid);
790         schid.sch_no = sch_no;
791         ret = cio_validate_subchannel(&console_subchannel, schid);
792         if (ret) {
793                 console_subchannel_in_use = 0;
794                 return ERR_PTR(-ENODEV);
795         }
796
797         /*
798          * enable console I/O-interrupt subclass 7
799          */
800         ctl_set_bit(6, 24);
801         console_subchannel.schib.pmcw.isc = 7;
802         console_subchannel.schib.pmcw.intparm =
803                 (__u32)(unsigned long)&console_subchannel;
804         ret = cio_modify(&console_subchannel);
805         if (ret) {
806                 console_subchannel_in_use = 0;
807                 return ERR_PTR(ret);
808         }
809         return &console_subchannel;
810 }
811
812 void
813 cio_release_console(void)
814 {
815         console_subchannel.schib.pmcw.intparm = 0;
816         cio_modify(&console_subchannel);
817         ctl_clear_bit(6, 24);
818         console_subchannel_in_use = 0;
819 }
820
821 /* Bah... hack to catch console special sausages. */
822 int
823 cio_is_console(struct subchannel_id schid)
824 {
825         if (!console_subchannel_in_use)
826                 return 0;
827         return schid_equal(&schid, &console_subchannel.schid);
828 }
829
830 struct subchannel *
831 cio_get_console_subchannel(void)
832 {
833         if (!console_subchannel_in_use)
834                 return NULL;
835         return &console_subchannel;
836 }
837
838 #endif
839 static int
840 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
841 {
842         int retry, cc;
843
844         cc = 0;
845         for (retry=0;retry<3;retry++) {
846                 schib->pmcw.ena = 0;
847                 cc = msch(schid, schib);
848                 if (cc)
849                         return (cc==3?-ENODEV:-EBUSY);
850                 stsch(schid, schib);
851                 if (!schib->pmcw.ena)
852                         return 0;
853         }
854         return -EBUSY; /* uhm... */
855 }
856
857 /* we can't use the normal udelay here, since it enables external interrupts */
858
859 static void udelay_reset(unsigned long usecs)
860 {
861         uint64_t start_cc, end_cc;
862
863         asm volatile ("STCK %0" : "=m" (start_cc));
864         do {
865                 cpu_relax();
866                 asm volatile ("STCK %0" : "=m" (end_cc));
867         } while (((end_cc - start_cc)/4096) < usecs);
868 }
869
870 static int
871 __clear_subchannel_easy(struct subchannel_id schid)
872 {
873         int retry;
874
875         if (csch(schid))
876                 return -ENODEV;
877         for (retry=0;retry<20;retry++) {
878                 struct tpi_info ti;
879
880                 if (tpi(&ti)) {
881                         tsch(ti.schid, (struct irb *)__LC_IRB);
882                         if (schid_equal(&ti.schid, &schid))
883                                 return 0;
884                 }
885                 udelay_reset(100);
886         }
887         return -EBUSY;
888 }
889
890 static int pgm_check_occured;
891
892 static void cio_reset_pgm_check_handler(void)
893 {
894         pgm_check_occured = 1;
895 }
896
897 static int stsch_reset(struct subchannel_id schid, volatile struct schib *addr)
898 {
899         int rc;
900
901         pgm_check_occured = 0;
902         s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
903         rc = stsch(schid, addr);
904         s390_base_pgm_handler_fn = NULL;
905
906         /* The program check handler could have changed pgm_check_occured. */
907         barrier();
908
909         if (pgm_check_occured)
910                 return -EIO;
911         else
912                 return rc;
913 }
914
915 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
916 {
917         struct schib schib;
918
919         if (stsch_reset(schid, &schib))
920                 return -ENXIO;
921         if (!schib.pmcw.ena)
922                 return 0;
923         switch(__disable_subchannel_easy(schid, &schib)) {
924         case 0:
925         case -ENODEV:
926                 break;
927         default: /* -EBUSY */
928                 if (__clear_subchannel_easy(schid))
929                         break; /* give up... */
930                 stsch(schid, &schib);
931                 __disable_subchannel_easy(schid, &schib);
932         }
933         return 0;
934 }
935
936 static atomic_t chpid_reset_count;
937
938 static void s390_reset_chpids_mcck_handler(void)
939 {
940         struct crw crw;
941         struct mci *mci;
942
943         /* Check for pending channel report word. */
944         mci = (struct mci *)&S390_lowcore.mcck_interruption_code;
945         if (!mci->cp)
946                 return;
947         /* Process channel report words. */
948         while (stcrw(&crw) == 0) {
949                 /* Check for responses to RCHP. */
950                 if (crw.slct && crw.rsc == CRW_RSC_CPATH)
951                         atomic_dec(&chpid_reset_count);
952         }
953 }
954
955 #define RCHP_TIMEOUT (30 * USEC_PER_SEC)
956 static void css_reset(void)
957 {
958         int i, ret;
959         unsigned long long timeout;
960         struct chp_id chpid;
961
962         /* Reset subchannels. */
963         for_each_subchannel(__shutdown_subchannel_easy,  NULL);
964         /* Reset channel paths. */
965         s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
966         /* Enable channel report machine checks. */
967         __ctl_set_bit(14, 28);
968         /* Temporarily reenable machine checks. */
969         local_mcck_enable();
970         chp_id_init(&chpid);
971         for (i = 0; i <= __MAX_CHPID; i++) {
972                 chpid.id = i;
973                 ret = rchp(chpid);
974                 if ((ret == 0) || (ret == 2))
975                         /*
976                          * rchp either succeeded, or another rchp is already
977                          * in progress. In either case, we'll get a crw.
978                          */
979                         atomic_inc(&chpid_reset_count);
980         }
981         /* Wait for machine check for all channel paths. */
982         timeout = get_clock() + (RCHP_TIMEOUT << 12);
983         while (atomic_read(&chpid_reset_count) != 0) {
984                 if (get_clock() > timeout)
985                         break;
986                 cpu_relax();
987         }
988         /* Disable machine checks again. */
989         local_mcck_disable();
990         /* Disable channel report machine checks. */
991         __ctl_clear_bit(14, 28);
992         s390_base_mcck_handler_fn = NULL;
993 }
994
995 static struct reset_call css_reset_call = {
996         .fn = css_reset,
997 };
998
999 static int __init init_css_reset_call(void)
1000 {
1001         atomic_set(&chpid_reset_count, 0);
1002         register_reset_call(&css_reset_call);
1003         return 0;
1004 }
1005
1006 arch_initcall(init_css_reset_call);
1007
1008 struct sch_match_id {
1009         struct subchannel_id schid;
1010         struct ccw_dev_id devid;
1011         int rc;
1012 };
1013
1014 static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
1015 {
1016         struct schib schib;
1017         struct sch_match_id *match_id = data;
1018
1019         if (stsch_reset(schid, &schib))
1020                 return -ENXIO;
1021         if (schib.pmcw.dnv &&
1022             (schib.pmcw.dev == match_id->devid.devno) &&
1023             (schid.ssid == match_id->devid.ssid)) {
1024                 match_id->schid = schid;
1025                 match_id->rc = 0;
1026                 return 1;
1027         }
1028         return 0;
1029 }
1030
1031 static int reipl_find_schid(struct ccw_dev_id *devid,
1032                             struct subchannel_id *schid)
1033 {
1034         struct sch_match_id match_id;
1035
1036         match_id.devid = *devid;
1037         match_id.rc = -ENODEV;
1038         for_each_subchannel(__reipl_subchannel_match, &match_id);
1039         if (match_id.rc == 0)
1040                 *schid = match_id.schid;
1041         return match_id.rc;
1042 }
1043
1044 extern void do_reipl_asm(__u32 schid);
1045
1046 /* Make sure all subchannels are quiet before we re-ipl an lpar. */
1047 void reipl_ccw_dev(struct ccw_dev_id *devid)
1048 {
1049         struct subchannel_id schid;
1050
1051         s390_reset_system();
1052         if (reipl_find_schid(devid, &schid) != 0)
1053                 panic("IPL Device not found\n");
1054         do_reipl_asm(*((__u32*)&schid));
1055 }
1056
1057 int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
1058 {
1059         struct subchannel_id schid;
1060         struct schib schib;
1061
1062         schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
1063         if (!schid.one)
1064                 return -ENODEV;
1065         if (stsch(schid, &schib))
1066                 return -ENODEV;
1067         if (!schib.pmcw.dnv)
1068                 return -ENODEV;
1069         iplinfo->devno = schib.pmcw.dev;
1070         iplinfo->is_qdio = schib.pmcw.qf;
1071         return 0;
1072 }