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->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.pam & sch->opm;
574 CIO_DEBUG(KERN_INFO, 0,
575 "Detected device %04x on subchannel 0.%x.%04X"
576 " - PIM = %02X, PAM = %02X, POM = %02X\n",
577 sch->schib.pmcw.dev, sch->schid.ssid,
578 sch->schid.sch_no, sch->schib.pmcw.pim,
579 sch->schib.pmcw.pam, sch->schib.pmcw.pom);
582 * We now have to initially ...
583 * ... set "interruption subclass"
584 * ... enable "concurrent sense"
585 * ... enable "multipath mode" if more than one
586 * CHPID is available. This is done regardless
587 * whether multiple paths are available for us.
589 sch->schib.pmcw.isc = 3; /* could be smth. else */
590 sch->schib.pmcw.csense = 1; /* concurrent sense */
591 sch->schib.pmcw.ena = 0;
592 if ((sch->lpm & (sch->lpm - 1)) != 0)
593 sch->schib.pmcw.mp = 1; /* multipath mode */
598 * do_IRQ() handles all normal I/O device IRQ's (the special
599 * SMP cross-CPU interrupts have their own specific
604 do_IRQ (struct pt_regs *regs)
606 struct tpi_info *tpi_info;
607 struct subchannel *sch;
611 asm volatile ("mc 0,0");
612 if (S390_lowcore.int_clock >= S390_lowcore.jiffy_timer)
614 * Make sure that the i/o interrupt did not "overtake"
615 * the last HZ timer interrupt.
619 * Get interrupt information from lowcore
621 tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
622 irb = (struct irb *) __LC_IRB;
624 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
626 * Non I/O-subchannel thin interrupts are processed differently
628 if (tpi_info->adapter_IO == 1 &&
629 tpi_info->int_type == IO_INTERRUPT_TYPE) {
633 sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
635 spin_lock(&sch->lock);
636 /* Store interrupt response block to lowcore. */
637 if (tsch (tpi_info->schid, irb) == 0 && sch) {
638 /* Keep subchannel information word up to date. */
639 memcpy (&sch->schib.scsw, &irb->scsw,
641 /* Call interrupt handler if there is one. */
642 if (sch->driver && sch->driver->irq)
643 sch->driver->irq(&sch->dev);
646 spin_unlock(&sch->lock);
648 * Are more interrupts pending?
649 * If so, the tpi instruction will update the lowcore
650 * to hold the info for the next interrupt.
651 * We don't do this for VM because a tpi drops the cpu
652 * out of the sie which costs more cycles than it saves.
654 } while (!MACHINE_IS_VM && tpi (NULL) != 0);
658 #ifdef CONFIG_CCW_CONSOLE
659 static struct subchannel console_subchannel;
660 static int console_subchannel_in_use;
663 * busy wait for the next interrupt on the console
668 unsigned long cr6 __attribute__ ((aligned (8)));
669 unsigned long save_cr6 __attribute__ ((aligned (8)));
672 * before entering the spinlock we may already have
673 * processed the interrupt on a different CPU...
675 if (!console_subchannel_in_use)
678 /* disable all but isc 7 (console device) */
679 __ctl_store (save_cr6, 6, 6);
681 __ctl_load (cr6, 6, 6);
684 spin_unlock(&console_subchannel.lock);
687 spin_lock(&console_subchannel.lock);
688 } while (console_subchannel.schib.scsw.actl != 0);
690 * restore previous isc value
692 __ctl_load (save_cr6, 6, 6);
696 cio_test_for_console(struct subchannel_id schid, void *data)
698 if (stsch_err(schid, &console_subchannel.schib) != 0)
700 if (console_subchannel.schib.pmcw.dnv &&
701 console_subchannel.schib.pmcw.dev ==
703 console_irq = schid.sch_no;
704 return 1; /* found */
711 cio_get_console_sch_no(void)
713 struct subchannel_id schid;
715 init_subchannel_id(&schid);
716 if (console_irq != -1) {
717 /* VM provided us with the irq number of the console. */
718 schid.sch_no = console_irq;
719 if (stsch(schid, &console_subchannel.schib) != 0 ||
720 !console_subchannel.schib.pmcw.dnv)
722 console_devno = console_subchannel.schib.pmcw.dev;
723 } else if (console_devno != -1) {
724 /* At least the console device number is known. */
725 for_each_subchannel(cio_test_for_console, NULL);
726 if (console_irq == -1)
729 /* unlike in 2.4, we cannot autoprobe here, since
730 * the channel subsystem is not fully initialized.
731 * With some luck, the HWC console can take over */
732 printk(KERN_WARNING "No ccw console found!\n");
739 cio_probe_console(void)
742 struct subchannel_id schid;
744 if (xchg(&console_subchannel_in_use, 1) != 0)
745 return ERR_PTR(-EBUSY);
746 sch_no = cio_get_console_sch_no();
748 console_subchannel_in_use = 0;
749 return ERR_PTR(-ENODEV);
751 memset(&console_subchannel, 0, sizeof(struct subchannel));
752 init_subchannel_id(&schid);
753 schid.sch_no = sch_no;
754 ret = cio_validate_subchannel(&console_subchannel, schid);
756 console_subchannel_in_use = 0;
757 return ERR_PTR(-ENODEV);
761 * enable console I/O-interrupt subclass 7
764 console_subchannel.schib.pmcw.isc = 7;
765 console_subchannel.schib.pmcw.intparm =
766 (__u32)(unsigned long)&console_subchannel;
767 ret = cio_modify(&console_subchannel);
769 console_subchannel_in_use = 0;
772 return &console_subchannel;
776 cio_release_console(void)
778 console_subchannel.schib.pmcw.intparm = 0;
779 cio_modify(&console_subchannel);
780 ctl_clear_bit(6, 24);
781 console_subchannel_in_use = 0;
784 /* Bah... hack to catch console special sausages. */
786 cio_is_console(struct subchannel_id schid)
788 if (!console_subchannel_in_use)
790 return schid_equal(&schid, &console_subchannel.schid);
794 cio_get_console_subchannel(void)
796 if (!console_subchannel_in_use)
798 return &console_subchannel;
803 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
808 for (retry=0;retry<3;retry++) {
810 cc = msch(schid, schib);
812 return (cc==3?-ENODEV:-EBUSY);
814 if (!schib->pmcw.ena)
817 return -EBUSY; /* uhm... */
821 __clear_subchannel_easy(struct subchannel_id schid)
827 for (retry=0;retry<20;retry++) {
831 tsch(ti.schid, (struct irb *)__LC_IRB);
832 if (schid_equal(&ti.schid, &schid))
840 struct sch_match_id {
841 struct subchannel_id schid;
842 struct ccw_dev_id devid;
846 static int __shutdown_subchannel_easy_and_match(struct subchannel_id schid,
850 struct sch_match_id *match_id = data;
852 if (stsch_err(schid, &schib))
854 if (match_id && schib.pmcw.dnv &&
855 (schib.pmcw.dev == match_id->devid.devno) &&
856 (schid.ssid == match_id->devid.ssid)) {
857 match_id->schid = schid;
862 switch(__disable_subchannel_easy(schid, &schib)) {
866 default: /* -EBUSY */
867 if (__clear_subchannel_easy(schid))
868 break; /* give up... */
869 stsch(schid, &schib);
870 __disable_subchannel_easy(schid, &schib);
875 static int clear_all_subchannels_and_match(struct ccw_dev_id *devid,
876 struct subchannel_id *schid)
878 struct sch_match_id match_id;
880 match_id.devid = *devid;
881 match_id.rc = -ENODEV;
883 for_each_subchannel(__shutdown_subchannel_easy_and_match, &match_id);
884 if (match_id.rc == 0)
885 *schid = match_id.schid;
890 void clear_all_subchannels(void)
893 for_each_subchannel(__shutdown_subchannel_easy_and_match, NULL);
896 extern void do_reipl_asm(__u32 schid);
898 /* Make sure all subchannels are quiet before we re-ipl an lpar. */
899 void reipl_ccw_dev(struct ccw_dev_id *devid)
901 struct subchannel_id schid;
903 if (clear_all_subchannels_and_match(devid, &schid))
904 panic("IPL Device not found\n");
905 cio_reset_channel_paths();
906 do_reipl_asm(*((__u32*)&schid));
909 extern struct schib ipl_schib;
912 * ipl_save_parameters gets called very early. It is not allowed to access
913 * anything in the bss section at all. The bss section is not cleared yet,
914 * but may contain some ipl parameters written by the firmware.
915 * These parameters (if present) are copied to 0x2000.
916 * To avoid corruption of the ipl parameters, all variables used by this
917 * function must reside on the stack or in the data section.
919 void ipl_save_parameters(void)
921 struct subchannel_id schid;
922 unsigned int *ipl_ptr;
925 schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
928 if (stsch(schid, &ipl_schib))
930 if (!ipl_schib.pmcw.dnv)
932 ipl_devno = ipl_schib.pmcw.dev;
933 ipl_flags |= IPL_DEVNO_VALID;
934 if (!ipl_schib.pmcw.qf)
936 ipl_flags |= IPL_PARMBLOCK_VALID;
937 ipl_ptr = (unsigned int *)__LC_IPL_PARMBLOCK_PTR;
938 src = (void *)(unsigned long)*ipl_ptr;
939 dst = (void *)IPL_PARMBLOCK_ORIGIN;
940 memmove(dst, src, PAGE_SIZE);
941 *ipl_ptr = IPL_PARMBLOCK_ORIGIN;