2 * drivers/s390/cio/chsc.c
3 * S/390 common I/O routines -- channel subsystem call
6 * Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
8 * Author(s): Ingo Adlung (adlung@de.ibm.com)
9 * Cornelia Huck (cohuck@de.ibm.com)
10 * Arnd Bergmann (arndb@de.ibm.com)
13 #include <linux/module.h>
14 #include <linux/config.h>
15 #include <linux/slab.h>
16 #include <linux/init.h>
17 #include <linux/device.h>
23 #include "cio_debug.h"
27 #define CHPID_LONGS (256 / (8 * sizeof(long))) /* 256 chpids */
28 static struct channel_path *chps[NR_CHPIDS];
30 static void *sei_page;
32 static int new_channel_path(int chpid);
35 set_chp_logically_online(int chp, int onoff)
37 chps[chp]->state = onoff;
41 get_chp_status(int chp)
43 return (chps[chp] ? chps[chp]->state : -ENODEV);
47 chsc_validate_chpids(struct subchannel *sch)
51 for (chp = 0; chp <= 7; chp++) {
53 if (!get_chp_status(sch->schib.pmcw.chpid[chp]))
54 /* disable using this path */
60 chpid_is_actually_online(int chp)
64 state = get_chp_status(chp);
66 new_channel_path(chp);
69 /* FIXME: should notify other subchannels here */
72 /* FIXME: this is _always_ called for every subchannel. shouldn't we
73 * process more than one at a time? */
75 chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
80 struct chsc_header request;
82 u16 f_sch; /* first subchannel */
84 u16 l_sch; /* last subchannel */
86 struct chsc_header response;
90 u8 st : 3; /* subchannel type */
92 u8 unit_addr; /* unit address */
93 u16 devno; /* device number */
96 u16 sch; /* subchannel */
97 u8 chpid[8]; /* chpids 0-7 */
98 u16 fla[8]; /* full link addresses 0-7 */
103 ssd_area->request = (struct chsc_header) {
108 ssd_area->f_sch = sch->irq;
109 ssd_area->l_sch = sch->irq;
111 ccode = chsc(ssd_area);
113 pr_debug("chsc returned with ccode = %d\n", ccode);
114 return (ccode == 3) ? -ENODEV : -EBUSY;
117 switch (ssd_area->response.code) {
118 case 0x0001: /* everything ok */
121 CIO_CRW_EVENT(2, "Invalid command!\n");
124 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
127 CIO_CRW_EVENT(2, "Model does not provide ssd\n");
130 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
131 ssd_area->response.code);
136 * ssd_area->st stores the type of the detected
137 * subchannel, with the following definitions:
139 * 0: I/O subchannel: All fields have meaning
140 * 1: CHSC subchannel: Only sch_val, st and sch
142 * 2: Message subchannel: All fields except unit_addr
144 * 3: ADM subchannel: Only sch_val, st and sch
147 * Other types are currently undefined.
149 if (ssd_area->st > 3) { /* uhm, that looks strange... */
150 CIO_CRW_EVENT(0, "Strange subchannel type %d"
151 " for sch %04x\n", ssd_area->st, sch->irq);
153 * There may have been a new subchannel type defined in the
154 * time since this code was written; since we don't know which
155 * fields have meaning and what to do with it we just jump out
159 const char *type[4] = {"I/O", "chsc", "message", "ADM"};
160 CIO_CRW_EVENT(6, "ssd: sch %04x is %s subchannel\n",
161 sch->irq, type[ssd_area->st]);
163 sch->ssd_info.valid = 1;
164 sch->ssd_info.type = ssd_area->st;
167 if (ssd_area->st == 0 || ssd_area->st == 2) {
168 for (j = 0; j < 8; j++) {
169 if (!((0x80 >> j) & ssd_area->path_mask &
170 ssd_area->fla_valid_mask))
172 sch->ssd_info.chpid[j] = ssd_area->chpid[j];
173 sch->ssd_info.fla[j] = ssd_area->fla[j];
180 css_get_ssd_info(struct subchannel *sch)
185 page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
188 spin_lock_irq(&sch->lock);
189 ret = chsc_get_sch_desc_irq(sch, page);
191 static int cio_chsc_err_msg;
193 if (!cio_chsc_err_msg) {
195 "chsc_get_sch_descriptions:"
196 " Error %d while doing chsc; "
197 "processing some machine checks may "
199 cio_chsc_err_msg = 1;
202 spin_unlock_irq(&sch->lock);
203 free_page((unsigned long)page);
206 /* Allocate channel path structures, if needed. */
207 for (j = 0; j < 8; j++) {
208 chpid = sch->ssd_info.chpid[j];
209 if (chpid && (get_chp_status(chpid) < 0))
210 new_channel_path(chpid);
217 s390_subchannel_remove_chpid(struct device *dev, void *data)
221 struct subchannel *sch;
225 sch = to_subchannel(dev);
227 for (j = 0; j < 8; j++)
228 if (sch->schib.pmcw.chpid[j] == *chpid)
234 spin_lock(&sch->lock);
236 stsch(sch->irq, &schib);
239 memcpy(&sch->schib, &schib, sizeof(struct schib));
240 /* Check for single path devices. */
241 if (sch->schib.pmcw.pim == 0x80)
243 if (sch->vpm == mask)
246 if ((sch->schib.scsw.actl & (SCSW_ACTL_CLEAR_PEND |
247 SCSW_ACTL_HALT_PEND |
248 SCSW_ACTL_START_PEND |
249 SCSW_ACTL_RESUME_PEND)) &&
250 (sch->schib.pmcw.lpum == mask)) {
251 int cc = cio_cancel(sch);
261 if (sch->driver && sch->driver->termination)
262 sch->driver->termination(&sch->dev);
265 } else if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) &&
266 (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) &&
267 (sch->schib.pmcw.lpum == mask)) {
274 if (sch->driver && sch->driver->termination)
275 sch->driver->termination(&sch->dev);
279 /* trigger path verification. */
280 if (sch->driver && sch->driver->verify)
281 sch->driver->verify(&sch->dev);
283 spin_unlock(&sch->lock);
286 spin_unlock(&sch->lock);
288 /* We can't block here. */
289 device_call_nopath_notify(sch);
294 s390_set_chpid_offline( __u8 chpid)
298 sprintf(dbf_txt, "chpr%x", chpid);
299 CIO_TRACE_EVENT(2, dbf_txt);
301 if (get_chp_status(chpid) <= 0)
304 bus_for_each_dev(&css_bus_type, NULL, &chpid,
305 s390_subchannel_remove_chpid);
309 s390_process_res_acc_sch(u8 chpid, __u16 fla, u32 fla_mask,
310 struct subchannel *sch)
317 for (chp = 0; chp <= 7; chp++)
319 * check if chpid is in information updated by ssd
321 if (sch->ssd_info.valid &&
322 sch->ssd_info.chpid[chp] == chpid &&
323 (sch->ssd_info.fla[chp] & fla_mask) == fla) {
332 * Do a stsch to update our subchannel structure with the
333 * new path information and eventually check for logically
336 ccode = stsch(sch->irq, &sch->schib);
344 s390_process_res_acc (u8 chpid, __u16 fla, u32 fla_mask)
346 struct subchannel *sch;
350 sprintf(dbf_txt, "accpr%x", chpid);
351 CIO_TRACE_EVENT( 2, dbf_txt);
353 sprintf(dbf_txt, "fla%x", fla);
354 CIO_TRACE_EVENT( 2, dbf_txt);
358 * I/O resources may have become accessible.
359 * Scan through all subchannels that may be concerned and
360 * do a validation on those.
361 * The more information we have (info), the less scanning
362 * will we have to do.
365 if (!get_chp_status(chpid))
366 return 0; /* no need to do the rest */
369 for (irq = 0; irq < __MAX_SUBCHANNELS; irq++) {
370 int chp_mask, old_lpm;
372 sch = get_subchannel_by_schid(irq);
377 * We don't know the device yet, but since a path
378 * may be available now to the device we'll have
379 * to do recognition again.
380 * Since we don't have any idea about which chpid
381 * that beast may be on we'll have to do a stsch
382 * on all devices, grr...
384 if (stsch(irq, &schib)) {
394 /* Put it on the slow path. */
395 ret = css_enqueue_subchannel_slow(irq);
397 css_clear_subchannel_slow_list();
404 spin_lock_irq(&sch->lock);
406 chp_mask = s390_process_res_acc_sch(chpid, fla, fla_mask, sch);
410 spin_unlock_irq(&sch->lock);
418 sch->lpm = ((sch->schib.pmcw.pim &
419 sch->schib.pmcw.pam &
421 | chp_mask) & sch->opm;
422 spin_unlock_irq(&sch->lock);
423 if (!old_lpm && sch->lpm)
424 device_trigger_reprobe(sch);
425 else if (sch->driver && sch->driver->verify)
426 sch->driver->verify(&sch->dev);
428 put_device(&sch->dev);
436 __get_chpid_from_lir(void *data)
442 /* incident-node descriptor */
444 /* attached-node descriptor */
446 /* incident-specific information */
450 lir = (struct lir*) data;
452 /* NULL link incident record */
454 if (!(lir->indesc[0]&0xc0000000))
455 /* node descriptor not valid */
457 if (!(lir->indesc[0]&0x10000000))
458 /* don't handle device-type nodes - FIXME */
460 /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
462 return (u16) (lir->indesc[0]&0x000000ff);
466 chsc_process_crw(void)
470 struct chsc_header request;
474 struct chsc_header response;
477 u8 vf; /* validity flags */
478 u8 rs; /* reporting source */
479 u8 cc; /* content code */
480 u16 fla; /* full link address */
481 u16 rsid; /* reporting source id */
484 u32 ccdf[96]; /* content-code dependent field */
485 /* ccdf has to be big enough for a link-incident record */
491 * build the chsc request block for store event information
493 * This function is only called by the machine check handler thread,
494 * so we don't need locking for the sei_page.
498 CIO_TRACE_EVENT( 2, "prcss");
502 memset(sei_area, 0, sizeof(*sei_area));
504 sei_area->request = (struct chsc_header) {
509 ccode = chsc(sei_area);
513 switch (sei_area->response.code) {
514 /* for debug purposes, check for problems */
516 CIO_CRW_EVENT(4, "chsc_process_crw: event information "
517 "successfully stored\n");
518 break; /* everything ok */
521 "chsc_process_crw: invalid command!\n");
524 CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
528 CIO_CRW_EVENT(2, "chsc_process_crw: no event "
529 "information stored\n");
532 CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
533 sei_area->response.code);
537 /* Check if we might have lost some information. */
538 if (sei_area->flags & 0x40)
539 CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
540 "has been lost due to overflow!\n");
542 if (sei_area->rs != 4) {
543 CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
544 "(%04X) isn't a chpid!\n",
549 /* which kind of information was stored? */
550 switch (sei_area->cc) {
551 case 1: /* link incident*/
552 CIO_CRW_EVENT(4, "chsc_process_crw: "
553 "channel subsystem reports link incident,"
554 " reporting source is chpid %x\n",
556 chpid = __get_chpid_from_lir(sei_area->ccdf);
558 CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
561 s390_set_chpid_offline(chpid);
564 case 2: /* i/o resource accessibiliy */
565 CIO_CRW_EVENT(4, "chsc_process_crw: "
566 "channel subsystem reports some I/O "
567 "devices may have become accessible\n");
568 pr_debug("Data received after sei: \n");
569 pr_debug("Validity flags: %x\n", sei_area->vf);
571 /* allocate a new channel path structure, if needed */
572 status = get_chp_status(sei_area->rsid);
574 new_channel_path(sei_area->rsid);
577 if ((sei_area->vf & 0x80) == 0) {
578 pr_debug("chpid: %x\n", sei_area->rsid);
579 ret = s390_process_res_acc(sei_area->rsid,
581 } else if ((sei_area->vf & 0xc0) == 0x80) {
582 pr_debug("chpid: %x link addr: %x\n",
583 sei_area->rsid, sei_area->fla);
584 ret = s390_process_res_acc(sei_area->rsid,
587 } else if ((sei_area->vf & 0xc0) == 0xc0) {
588 pr_debug("chpid: %x full link addr: %x\n",
589 sei_area->rsid, sei_area->fla);
590 ret = s390_process_res_acc(sei_area->rsid,
598 default: /* other stuff */
599 CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
603 } while (sei_area->flags & 0x80);
610 struct subchannel *sch;
614 if (!get_chp_status(chpid))
615 return 0; /* no need to do the rest */
617 sprintf(dbf_txt, "cadd%x", chpid);
618 CIO_TRACE_EVENT(2, dbf_txt);
621 for (irq = 0; irq < __MAX_SUBCHANNELS; irq++) {
624 sch = get_subchannel_by_schid(irq);
628 if (stsch(irq, &schib)) {
638 /* Put it on the slow path. */
639 ret = css_enqueue_subchannel_slow(irq);
641 css_clear_subchannel_slow_list();
648 spin_lock(&sch->lock);
650 if (sch->schib.pmcw.chpid[i] == chpid) {
651 if (stsch(sch->irq, &sch->schib) != 0) {
653 spin_unlock(&sch->lock);
659 spin_unlock(&sch->lock);
662 sch->lpm = ((sch->schib.pmcw.pim &
663 sch->schib.pmcw.pam &
665 | 0x80 >> i) & sch->opm;
667 if (sch->driver && sch->driver->verify)
668 sch->driver->verify(&sch->dev);
670 spin_unlock(&sch->lock);
671 put_device(&sch->dev);
677 * Handling of crw machine checks with channel path source.
680 chp_process_crw(int chpid, int on)
683 /* Path has gone. We use the link incident routine.*/
684 s390_set_chpid_offline(chpid);
685 return 0; /* De-register is async anyway. */
688 * Path has come. Allocate a new channel path structure,
691 if (get_chp_status(chpid) < 0)
692 new_channel_path(chpid);
693 /* Avoid the extra overhead in process_rec_acc. */
694 return chp_add(chpid);
698 __check_for_io_and_kill(struct subchannel *sch, int index)
702 cc = stsch(sch->irq, &sch->schib);
705 if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == (0x80 >> index)) {
706 device_set_waiting(sch);
713 __s390_subchannel_vary_chpid(struct subchannel *sch, __u8 chpid, int on)
717 if (!sch->ssd_info.valid)
721 for (chp = 0; chp < 8; chp++) {
722 if (sch->ssd_info.chpid[chp] != chpid)
726 sch->opm |= (0x80 >> chp);
727 sch->lpm |= (0x80 >> chp);
729 device_trigger_reprobe(sch);
730 else if (sch->driver && sch->driver->verify)
731 sch->driver->verify(&sch->dev);
733 sch->opm &= ~(0x80 >> chp);
734 sch->lpm &= ~(0x80 >> chp);
736 * Give running I/O a grace period in which it
737 * can successfully terminate, even using the
738 * just varied off path. Then kill it.
740 if (!__check_for_io_and_kill(sch, chp) && !sch->lpm)
741 /* Get over with it now. */
742 device_call_nopath_notify(sch);
743 else if (sch->driver && sch->driver->verify)
744 sch->driver->verify(&sch->dev);
751 s390_subchannel_vary_chpid_off(struct device *dev, void *data)
753 struct subchannel *sch;
756 sch = to_subchannel(dev);
759 __s390_subchannel_vary_chpid(sch, *chpid, 0);
764 s390_subchannel_vary_chpid_on(struct device *dev, void *data)
766 struct subchannel *sch;
769 sch = to_subchannel(dev);
772 __s390_subchannel_vary_chpid(sch, *chpid, 1);
776 extern void css_trigger_slow_path(void);
777 typedef void (*workfunc)(void *);
778 static DECLARE_WORK(varyonoff_work, (workfunc)css_trigger_slow_path,
782 * Function: s390_vary_chpid
783 * Varies the specified chpid online or offline
786 s390_vary_chpid( __u8 chpid, int on)
789 int status, irq, ret;
790 struct subchannel *sch;
792 sprintf(dbf_text, on?"varyon%x":"varyoff%x", chpid);
793 CIO_TRACE_EVENT( 2, dbf_text);
795 status = get_chp_status(chpid);
797 printk(KERN_ERR "Can't vary unknown chpid %02X\n", chpid);
801 if (!on && !status) {
802 printk(KERN_ERR "chpid %x is already offline\n", chpid);
806 set_chp_logically_online(chpid, on);
809 * Redo PathVerification on the devices the chpid connects to
812 bus_for_each_dev(&css_bus_type, NULL, &chpid, on ?
813 s390_subchannel_vary_chpid_on :
814 s390_subchannel_vary_chpid_off);
817 /* Scan for new devices on varied on path. */
818 for (irq = 0; irq < __MAX_SUBCHANNELS; irq++) {
823 sch = get_subchannel_by_schid(irq);
825 put_device(&sch->dev);
828 if (stsch(irq, &schib))
831 /* Put it on the slow path. */
832 ret = css_enqueue_subchannel_slow(irq);
834 css_clear_subchannel_slow_list();
838 if (need_rescan || css_slow_subchannels_exist())
839 schedule_work(&varyonoff_work);
844 * Files for the channel path entries.
847 chp_status_show(struct device *dev, char *buf)
849 struct channel_path *chp = container_of(dev, struct channel_path, dev);
853 return (get_chp_status(chp->id) ? sprintf(buf, "online\n") :
854 sprintf(buf, "offline\n"));
858 chp_status_write(struct device *dev, const char *buf, size_t count)
860 struct channel_path *cp = container_of(dev, struct channel_path, dev);
865 num_args = sscanf(buf, "%5s", cmd);
869 if (!strnicmp(cmd, "on", 2))
870 error = s390_vary_chpid(cp->id, 1);
871 else if (!strnicmp(cmd, "off", 3))
872 error = s390_vary_chpid(cp->id, 0);
876 return error < 0 ? error : count;
880 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
884 chp_release(struct device *dev)
886 struct channel_path *cp;
888 cp = container_of(dev, struct channel_path, dev);
893 * Entries for chpids on the system bus.
894 * This replaces /proc/chpids.
897 new_channel_path(int chpid)
899 struct channel_path *chp;
902 chp = kmalloc(sizeof(struct channel_path), GFP_KERNEL);
905 memset(chp, 0, sizeof(struct channel_path));
909 /* fill in status, etc. */
912 chp->dev = (struct device) {
913 .parent = &css_bus_device,
914 .release = chp_release,
916 snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid);
918 /* make it known to the system */
919 ret = device_register(&chp->dev);
921 printk(KERN_WARNING "%s: could not register %02x\n",
925 ret = device_create_file(&chp->dev, &dev_attr_status);
927 device_unregister(&chp->dev);
933 chsc_alloc_sei_area(void)
935 sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
937 printk(KERN_WARNING"Can't allocate page for processing of " \
938 "chsc machine checks!\n");
939 return (sei_page ? 0 : -ENOMEM);
942 subsys_initcall(chsc_alloc_sei_area);