2 * drivers/s390/cio/cio.c
3 * S/390 common I/O routines -- low level i/o calls
5 * Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
7 * Author(s): Ingo Adlung (adlung@de.ibm.com)
8 * Cornelia Huck (cornelia.huck@de.ibm.com)
9 * Arnd Bergmann (arndb@de.ibm.com)
10 * Martin Schwidefsky (schwidefsky@de.ibm.com)
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/device.h>
17 #include <linux/kernel_stat.h>
18 #include <linux/interrupt.h>
20 #include <asm/delay.h>
22 #include <asm/setup.h>
28 #include "blacklist.h"
29 #include "cio_debug.h"
31 debug_info_t *cio_debug_msg_id;
32 debug_info_t *cio_debug_trace_id;
33 debug_info_t *cio_debug_crw_id;
38 cio_setup (char *parm)
40 if (!strcmp (parm, "yes"))
42 else if (!strcmp (parm, "no"))
45 printk (KERN_ERR "cio_setup : invalid cio_msg parameter '%s'",
50 __setup ("cio_msg=", cio_setup);
53 * Function: cio_debug_init
54 * Initializes three debug logs (under /proc/s390dbf) for common I/O:
55 * - cio_msg logs the messages which are printk'ed when CONFIG_DEBUG_IO is on
56 * - cio_trace logs the calling of different functions
57 * - cio_crw logs the messages which are printk'ed when CONFIG_DEBUG_CRW is on
58 * debug levels depend on CONFIG_DEBUG_IO resp. CONFIG_DEBUG_CRW
63 cio_debug_msg_id = debug_register ("cio_msg", 16, 4, 16*sizeof (long));
64 if (!cio_debug_msg_id)
66 debug_register_view (cio_debug_msg_id, &debug_sprintf_view);
67 debug_set_level (cio_debug_msg_id, 2);
68 cio_debug_trace_id = debug_register ("cio_trace", 16, 4, 16);
69 if (!cio_debug_trace_id)
71 debug_register_view (cio_debug_trace_id, &debug_hex_ascii_view);
72 debug_set_level (cio_debug_trace_id, 2);
73 cio_debug_crw_id = debug_register ("cio_crw", 4, 4, 16*sizeof (long));
74 if (!cio_debug_crw_id)
76 debug_register_view (cio_debug_crw_id, &debug_sprintf_view);
77 debug_set_level (cio_debug_crw_id, 2);
78 pr_debug("debugging initialized\n");
83 debug_unregister (cio_debug_msg_id);
84 if (cio_debug_trace_id)
85 debug_unregister (cio_debug_trace_id);
87 debug_unregister (cio_debug_crw_id);
88 pr_debug("could not initialize debugging\n");
92 arch_initcall (cio_debug_init);
95 cio_set_options (struct subchannel *sch, int flags)
97 sch->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
98 sch->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
99 sch->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
103 /* FIXME: who wants to use this? */
105 cio_get_options (struct subchannel *sch)
110 if (sch->options.suspend)
111 flags |= DOIO_ALLOW_SUSPEND;
112 if (sch->options.prefetch)
113 flags |= DOIO_DENY_PREFETCH;
114 if (sch->options.inter)
115 flags |= DOIO_SUPPRESS_INTER;
120 * Use tpi to get a pending interrupt, call the interrupt handler and
121 * return a pointer to the subchannel structure.
126 struct tpi_info *tpi_info;
127 struct subchannel *sch;
130 tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
133 irb = (struct irb *) __LC_IRB;
134 /* Store interrupt response block to lowcore. */
135 if (tsch (tpi_info->schid, irb) != 0)
136 /* Not status pending or not operational. */
138 sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
143 spin_lock(&sch->lock);
144 memcpy (&sch->schib.scsw, &irb->scsw, sizeof (struct scsw));
145 if (sch->driver && sch->driver->irq)
146 sch->driver->irq(&sch->dev);
147 spin_unlock(&sch->lock);
154 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
163 stsch (sch->schid, &sch->schib);
165 CIO_MSG_EVENT(0, "cio_start: 'not oper' status for "
166 "subchannel 0.%x.%04x!\n", sch->schid.ssid,
168 sprintf(dbf_text, "no%s", sch->dev.bus_id);
169 CIO_TRACE_EVENT(0, dbf_text);
170 CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
172 return (sch->lpm ? -EACCES : -ENODEV);
176 cio_start_key (struct subchannel *sch, /* subchannel structure */
177 struct ccw1 * cpa, /* logical channel prog addr */
178 __u8 lpm, /* logical path mask */
179 __u8 key) /* storage key */
184 CIO_TRACE_EVENT (4, "stIO");
185 CIO_TRACE_EVENT (4, sch->dev.bus_id);
187 /* sch is always under 2G. */
188 sch->orb.intparm = (__u32)(unsigned long)sch;
191 sch->orb.pfch = sch->options.prefetch == 0;
192 sch->orb.spnd = sch->options.suspend;
193 sch->orb.ssic = sch->options.suspend && sch->options.inter;
194 sch->orb.lpm = (lpm != 0) ? (lpm & sch->opm) : sch->lpm;
197 * for 64 bit we always support 64 bit IDAWs with 4k page size only
202 sch->orb.key = key >> 4;
203 /* issue "Start Subchannel" */
204 sch->orb.cpa = (__u32) __pa (cpa);
205 ccode = ssch (sch->schid, &sch->orb);
207 /* process condition code */
208 sprintf (dbf_txt, "ccode:%d", ccode);
209 CIO_TRACE_EVENT (4, dbf_txt);
214 * initialize device status information
216 sch->schib.scsw.actl |= SCSW_ACTL_START_PEND;
218 case 1: /* status pending */
221 default: /* device/path not operational */
222 return cio_start_handle_notoper(sch, lpm);
227 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
229 return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
233 * resume suspended I/O operation
236 cio_resume (struct subchannel *sch)
241 CIO_TRACE_EVENT (4, "resIO");
242 CIO_TRACE_EVENT (4, sch->dev.bus_id);
244 ccode = rsch (sch->schid);
246 sprintf (dbf_txt, "ccode:%d", ccode);
247 CIO_TRACE_EVENT (4, dbf_txt);
251 sch->schib.scsw.actl |= SCSW_ACTL_RESUME_PEND;
259 * useless to wait for request completion
260 * as device is no longer operational !
270 cio_halt(struct subchannel *sch)
278 CIO_TRACE_EVENT (2, "haltIO");
279 CIO_TRACE_EVENT (2, sch->dev.bus_id);
282 * Issue "Halt subchannel" and process condition code
284 ccode = hsch (sch->schid);
286 sprintf (dbf_txt, "ccode:%d", ccode);
287 CIO_TRACE_EVENT (2, dbf_txt);
291 sch->schib.scsw.actl |= SCSW_ACTL_HALT_PEND;
293 case 1: /* status pending */
296 default: /* device not operational */
302 * Clear I/O operation
305 cio_clear(struct subchannel *sch)
313 CIO_TRACE_EVENT (2, "clearIO");
314 CIO_TRACE_EVENT (2, sch->dev.bus_id);
317 * Issue "Clear subchannel" and process condition code
319 ccode = csch (sch->schid);
321 sprintf (dbf_txt, "ccode:%d", ccode);
322 CIO_TRACE_EVENT (2, dbf_txt);
326 sch->schib.scsw.actl |= SCSW_ACTL_CLEAR_PEND;
328 default: /* device not operational */
334 * Function: cio_cancel
335 * Issues a "Cancel Subchannel" on the specified subchannel
336 * Note: We don't need any fancy intparms and flags here
337 * since xsch is executed synchronously.
338 * Only for common I/O internal use as for now.
341 cio_cancel (struct subchannel *sch)
349 CIO_TRACE_EVENT (2, "cancelIO");
350 CIO_TRACE_EVENT (2, sch->dev.bus_id);
352 ccode = xsch (sch->schid);
354 sprintf (dbf_txt, "ccode:%d", ccode);
355 CIO_TRACE_EVENT (2, dbf_txt);
358 case 0: /* success */
359 /* Update information in scsw. */
360 stsch (sch->schid, &sch->schib);
362 case 1: /* status pending */
364 case 2: /* not applicable */
366 default: /* not oper */
372 * Function: cio_modify
373 * Issues a "Modify Subchannel" on the specified subchannel
376 cio_modify (struct subchannel *sch)
378 int ccode, retry, ret;
381 for (retry = 0; retry < 5; retry++) {
382 ccode = msch_err (sch->schid, &sch->schib);
383 if (ccode < 0) /* -EIO if msch gets a program check. */
386 case 0: /* successfull */
388 case 1: /* status pending */
391 udelay (100); /* allow for recovery */
394 case 3: /* not operational */
405 cio_enable_subchannel (struct subchannel *sch, unsigned int isc)
412 CIO_TRACE_EVENT (2, "ensch");
413 CIO_TRACE_EVENT (2, sch->dev.bus_id);
415 ccode = stsch (sch->schid, &sch->schib);
419 for (retry = 5, ret = 0; retry > 0; retry--) {
420 sch->schib.pmcw.ena = 1;
421 sch->schib.pmcw.isc = isc;
422 sch->schib.pmcw.intparm = (__u32)(unsigned long)sch;
423 ret = cio_modify(sch);
428 * Got a program check in cio_modify. Try without
429 * the concurrent sense bit the next time.
431 sch->schib.pmcw.csense = 0;
433 stsch (sch->schid, &sch->schib);
434 if (sch->schib.pmcw.ena)
439 if (tsch(sch->schid, &irb) != 0)
443 sprintf (dbf_txt, "ret:%d", ret);
444 CIO_TRACE_EVENT (2, dbf_txt);
449 * Disable subchannel.
452 cio_disable_subchannel (struct subchannel *sch)
459 CIO_TRACE_EVENT (2, "dissch");
460 CIO_TRACE_EVENT (2, sch->dev.bus_id);
462 ccode = stsch (sch->schid, &sch->schib);
463 if (ccode == 3) /* Not operational. */
466 if (sch->schib.scsw.actl != 0)
468 * the disable function must not be called while there are
469 * requests pending for completion !
473 for (retry = 5, ret = 0; retry > 0; retry--) {
474 sch->schib.pmcw.ena = 0;
475 ret = cio_modify(sch);
480 * The subchannel is busy or status pending.
481 * We'll disable when the next interrupt was delivered
482 * via the state machine.
486 stsch (sch->schid, &sch->schib);
487 if (!sch->schib.pmcw.ena)
491 sprintf (dbf_txt, "ret:%d", ret);
492 CIO_TRACE_EVENT (2, dbf_txt);
497 * cio_validate_subchannel()
499 * Find out subchannel type and initialize struct subchannel.
501 * SUBCHANNEL_TYPE_IO for a normal io subchannel
502 * SUBCHANNEL_TYPE_CHSC for a chsc subchannel
503 * SUBCHANNEL_TYPE_MESSAGE for a messaging subchannel
504 * SUBCHANNEL_TYPE_ADM for a adm(?) subchannel
505 * -ENXIO for non-defined subchannels
506 * -ENODEV for subchannels with invalid device number or blacklisted devices
509 cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
514 sprintf (dbf_txt, "valsch%x", schid.sch_no);
515 CIO_TRACE_EVENT (4, dbf_txt);
517 /* Nuke all fields. */
518 memset(sch, 0, sizeof(struct subchannel));
520 spin_lock_init(&sch->lock);
521 mutex_init(&sch->reg_mutex);
523 /* Set a name for the subchannel */
524 snprintf (sch->dev.bus_id, BUS_ID_SIZE, "0.%x.%04x", schid.ssid,
528 * The first subchannel that is not-operational (ccode==3)
529 * indicates that there aren't any more devices available.
530 * If stsch gets an exception, it means the current subchannel set
533 ccode = stsch_err (schid, &sch->schib);
535 return (ccode == 3) ? -ENXIO : ccode;
538 /* Copy subchannel type from path management control word. */
539 sch->st = sch->schib.pmcw.st;
542 * ... just being curious we check for non I/O subchannels
545 CIO_DEBUG(KERN_INFO, 0,
546 "Subchannel 0.%x.%04x reports "
547 "non-I/O subchannel type %04X\n",
548 sch->schid.ssid, sch->schid.sch_no, sch->st);
549 /* We stop here for non-io subchannels. */
553 /* Initialization for io subchannels. */
554 if (!sch->schib.pmcw.dnv)
555 /* io subchannel but device number is invalid. */
558 /* Devno is valid. */
559 if (is_blacklisted (sch->schid.ssid, sch->schib.pmcw.dev)) {
561 * This device must not be known to Linux. So we simply
562 * say that there is no device and return ENODEV.
564 CIO_MSG_EVENT(0, "Blacklisted device detected "
565 "at devno %04X, subchannel set %x\n",
566 sch->schib.pmcw.dev, sch->schid.ssid);
570 if (!cio_is_console(sch->schid))
571 chsc_validate_chpids(sch);
572 sch->lpm = sch->schib.pmcw.pim &
573 sch->schib.pmcw.pam &
574 sch->schib.pmcw.pom &
577 CIO_DEBUG(KERN_INFO, 0,
578 "Detected device %04x on subchannel 0.%x.%04X"
579 " - PIM = %02X, PAM = %02X, POM = %02X\n",
580 sch->schib.pmcw.dev, sch->schid.ssid,
581 sch->schid.sch_no, sch->schib.pmcw.pim,
582 sch->schib.pmcw.pam, sch->schib.pmcw.pom);
585 * We now have to initially ...
586 * ... set "interruption subclass"
587 * ... enable "concurrent sense"
588 * ... enable "multipath mode" if more than one
589 * CHPID is available. This is done regardless
590 * whether multiple paths are available for us.
592 sch->schib.pmcw.isc = 3; /* could be smth. else */
593 sch->schib.pmcw.csense = 1; /* concurrent sense */
594 sch->schib.pmcw.ena = 0;
595 if ((sch->lpm & (sch->lpm - 1)) != 0)
596 sch->schib.pmcw.mp = 1; /* multipath mode */
601 * do_IRQ() handles all normal I/O device IRQ's (the special
602 * SMP cross-CPU interrupts have their own specific
607 do_IRQ (struct pt_regs *regs)
609 struct tpi_info *tpi_info;
610 struct subchannel *sch;
614 asm volatile ("mc 0,0");
615 if (S390_lowcore.int_clock >= S390_lowcore.jiffy_timer)
617 * Make sure that the i/o interrupt did not "overtake"
618 * the last HZ timer interrupt.
622 * Get interrupt information from lowcore
624 tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
625 irb = (struct irb *) __LC_IRB;
627 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
629 * Non I/O-subchannel thin interrupts are processed differently
631 if (tpi_info->adapter_IO == 1 &&
632 tpi_info->int_type == IO_INTERRUPT_TYPE) {
636 sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
638 spin_lock(&sch->lock);
639 /* Store interrupt response block to lowcore. */
640 if (tsch (tpi_info->schid, irb) == 0 && sch) {
641 /* Keep subchannel information word up to date. */
642 memcpy (&sch->schib.scsw, &irb->scsw,
644 /* Call interrupt handler if there is one. */
645 if (sch->driver && sch->driver->irq)
646 sch->driver->irq(&sch->dev);
649 spin_unlock(&sch->lock);
651 * Are more interrupts pending?
652 * If so, the tpi instruction will update the lowcore
653 * to hold the info for the next interrupt.
654 * We don't do this for VM because a tpi drops the cpu
655 * out of the sie which costs more cycles than it saves.
657 } while (!MACHINE_IS_VM && tpi (NULL) != 0);
661 #ifdef CONFIG_CCW_CONSOLE
662 static struct subchannel console_subchannel;
663 static int console_subchannel_in_use;
666 * busy wait for the next interrupt on the console
671 unsigned long cr6 __attribute__ ((aligned (8)));
672 unsigned long save_cr6 __attribute__ ((aligned (8)));
675 * before entering the spinlock we may already have
676 * processed the interrupt on a different CPU...
678 if (!console_subchannel_in_use)
681 /* disable all but isc 7 (console device) */
682 __ctl_store (save_cr6, 6, 6);
684 __ctl_load (cr6, 6, 6);
687 spin_unlock(&console_subchannel.lock);
690 spin_lock(&console_subchannel.lock);
691 } while (console_subchannel.schib.scsw.actl != 0);
693 * restore previous isc value
695 __ctl_load (save_cr6, 6, 6);
699 cio_test_for_console(struct subchannel_id schid, void *data)
701 if (stsch_err(schid, &console_subchannel.schib) != 0)
703 if (console_subchannel.schib.pmcw.dnv &&
704 console_subchannel.schib.pmcw.dev ==
706 console_irq = schid.sch_no;
707 return 1; /* found */
714 cio_get_console_sch_no(void)
716 struct subchannel_id schid;
718 init_subchannel_id(&schid);
719 if (console_irq != -1) {
720 /* VM provided us with the irq number of the console. */
721 schid.sch_no = console_irq;
722 if (stsch(schid, &console_subchannel.schib) != 0 ||
723 !console_subchannel.schib.pmcw.dnv)
725 console_devno = console_subchannel.schib.pmcw.dev;
726 } else if (console_devno != -1) {
727 /* At least the console device number is known. */
728 for_each_subchannel(cio_test_for_console, NULL);
729 if (console_irq == -1)
732 /* unlike in 2.4, we cannot autoprobe here, since
733 * the channel subsystem is not fully initialized.
734 * With some luck, the HWC console can take over */
735 printk(KERN_WARNING "No ccw console found!\n");
742 cio_probe_console(void)
745 struct subchannel_id schid;
747 if (xchg(&console_subchannel_in_use, 1) != 0)
748 return ERR_PTR(-EBUSY);
749 sch_no = cio_get_console_sch_no();
751 console_subchannel_in_use = 0;
752 return ERR_PTR(-ENODEV);
754 memset(&console_subchannel, 0, sizeof(struct subchannel));
755 init_subchannel_id(&schid);
756 schid.sch_no = sch_no;
757 ret = cio_validate_subchannel(&console_subchannel, schid);
759 console_subchannel_in_use = 0;
760 return ERR_PTR(-ENODEV);
764 * enable console I/O-interrupt subclass 7
767 console_subchannel.schib.pmcw.isc = 7;
768 console_subchannel.schib.pmcw.intparm =
769 (__u32)(unsigned long)&console_subchannel;
770 ret = cio_modify(&console_subchannel);
772 console_subchannel_in_use = 0;
775 return &console_subchannel;
779 cio_release_console(void)
781 console_subchannel.schib.pmcw.intparm = 0;
782 cio_modify(&console_subchannel);
783 ctl_clear_bit(6, 24);
784 console_subchannel_in_use = 0;
787 /* Bah... hack to catch console special sausages. */
789 cio_is_console(struct subchannel_id schid)
791 if (!console_subchannel_in_use)
793 return schid_equal(&schid, &console_subchannel.schid);
797 cio_get_console_subchannel(void)
799 if (!console_subchannel_in_use)
801 return &console_subchannel;
806 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
811 for (retry=0;retry<3;retry++) {
813 cc = msch(schid, schib);
815 return (cc==3?-ENODEV:-EBUSY);
817 if (!schib->pmcw.ena)
820 return -EBUSY; /* uhm... */
824 __clear_subchannel_easy(struct subchannel_id schid)
830 for (retry=0;retry<20;retry++) {
834 tsch(ti.schid, (struct irb *)__LC_IRB);
835 if (schid_equal(&ti.schid, &schid))
843 struct sch_match_id {
844 struct subchannel_id schid;
845 struct ccw_dev_id devid;
849 static int __shutdown_subchannel_easy_and_match(struct subchannel_id schid,
853 struct sch_match_id *match_id = data;
855 if (stsch_err(schid, &schib))
857 if (match_id && schib.pmcw.dnv &&
858 (schib.pmcw.dev == match_id->devid.devno) &&
859 (schid.ssid == match_id->devid.ssid)) {
860 match_id->schid = schid;
865 switch(__disable_subchannel_easy(schid, &schib)) {
869 default: /* -EBUSY */
870 if (__clear_subchannel_easy(schid))
871 break; /* give up... */
872 stsch(schid, &schib);
873 __disable_subchannel_easy(schid, &schib);
878 static int clear_all_subchannels_and_match(struct ccw_dev_id *devid,
879 struct subchannel_id *schid)
881 struct sch_match_id match_id;
883 match_id.devid = *devid;
884 match_id.rc = -ENODEV;
886 for_each_subchannel(__shutdown_subchannel_easy_and_match, &match_id);
887 if (match_id.rc == 0)
888 *schid = match_id.schid;
893 void clear_all_subchannels(void)
896 for_each_subchannel(__shutdown_subchannel_easy_and_match, NULL);
899 extern void do_reipl_asm(__u32 schid);
901 /* Make sure all subchannels are quiet before we re-ipl an lpar. */
902 void reipl_ccw_dev(struct ccw_dev_id *devid)
904 struct subchannel_id schid;
906 if (clear_all_subchannels_and_match(devid, &schid))
907 panic("IPL Device not found\n");
908 cio_reset_channel_paths();
909 do_reipl_asm(*((__u32*)&schid));
912 extern struct schib ipl_schib;
915 * ipl_save_parameters gets called very early. It is not allowed to access
916 * anything in the bss section at all. The bss section is not cleared yet,
917 * but may contain some ipl parameters written by the firmware.
918 * These parameters (if present) are copied to 0x2000.
919 * To avoid corruption of the ipl parameters, all variables used by this
920 * function must reside on the stack or in the data section.
922 void ipl_save_parameters(void)
924 struct subchannel_id schid;
925 unsigned int *ipl_ptr;
928 schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
931 if (stsch(schid, &ipl_schib))
933 if (!ipl_schib.pmcw.dnv)
935 ipl_devno = ipl_schib.pmcw.dev;
936 ipl_flags |= IPL_DEVNO_VALID;
937 if (!ipl_schib.pmcw.qf)
939 ipl_flags |= IPL_PARMBLOCK_VALID;
940 ipl_ptr = (unsigned int *)__LC_IPL_PARMBLOCK_PTR;
941 src = (void *)(unsigned long)*ipl_ptr;
942 dst = (void *)IPL_PARMBLOCK_ORIGIN;
943 memmove(dst, src, PAGE_SIZE);
944 *ipl_ptr = IPL_PARMBLOCK_ORIGIN;