2 * drivers/s390/cio/chsc.c
3 * S/390 common I/O routines -- channel subsystem call
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)
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/init.h>
15 #include <linux/device.h>
21 #include "cio_debug.h"
25 static void *sei_page;
27 static int new_channel_path(int chpid);
30 set_chp_logically_online(int chp, int onoff)
32 css[0]->chps[chp]->state = onoff;
36 get_chp_status(int chp)
38 return (css[0]->chps[chp] ? css[0]->chps[chp]->state : -ENODEV);
42 chsc_validate_chpids(struct subchannel *sch)
46 for (chp = 0; chp <= 7; chp++) {
48 if (!get_chp_status(sch->schib.pmcw.chpid[chp]))
49 /* disable using this path */
55 chpid_is_actually_online(int chp)
59 state = get_chp_status(chp);
62 queue_work(slow_path_wq, &slow_path_work);
67 /* FIXME: this is _always_ called for every subchannel. shouldn't we
68 * process more than one at a time? */
70 chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
75 struct chsc_header request;
79 u16 f_sch; /* first subchannel */
81 u16 l_sch; /* last subchannel */
83 struct chsc_header response;
87 u8 st : 3; /* subchannel type */
89 u8 unit_addr; /* unit address */
90 u16 devno; /* device number */
93 u16 sch; /* subchannel */
94 u8 chpid[8]; /* chpids 0-7 */
95 u16 fla[8]; /* full link addresses 0-7 */
100 ssd_area->request.length = 0x0010;
101 ssd_area->request.code = 0x0004;
103 ssd_area->ssid = sch->schid.ssid;
104 ssd_area->f_sch = sch->schid.sch_no;
105 ssd_area->l_sch = sch->schid.sch_no;
107 ccode = chsc(ssd_area);
109 pr_debug("chsc returned with ccode = %d\n", ccode);
110 return (ccode == 3) ? -ENODEV : -EBUSY;
113 switch (ssd_area->response.code) {
114 case 0x0001: /* everything ok */
117 CIO_CRW_EVENT(2, "Invalid command!\n");
120 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
123 CIO_CRW_EVENT(2, "Model does not provide ssd\n");
126 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
127 ssd_area->response.code);
132 * ssd_area->st stores the type of the detected
133 * subchannel, with the following definitions:
135 * 0: I/O subchannel: All fields have meaning
136 * 1: CHSC subchannel: Only sch_val, st and sch
138 * 2: Message subchannel: All fields except unit_addr
140 * 3: ADM subchannel: Only sch_val, st and sch
143 * Other types are currently undefined.
145 if (ssd_area->st > 3) { /* uhm, that looks strange... */
146 CIO_CRW_EVENT(0, "Strange subchannel type %d"
147 " for sch 0.%x.%04x\n", ssd_area->st,
148 sch->schid.ssid, sch->schid.sch_no);
150 * There may have been a new subchannel type defined in the
151 * time since this code was written; since we don't know which
152 * fields have meaning and what to do with it we just jump out
156 const char *type[4] = {"I/O", "chsc", "message", "ADM"};
157 CIO_CRW_EVENT(6, "ssd: sch 0.%x.%04x is %s subchannel\n",
158 sch->schid.ssid, sch->schid.sch_no,
161 sch->ssd_info.valid = 1;
162 sch->ssd_info.type = ssd_area->st;
165 if (ssd_area->st == 0 || ssd_area->st == 2) {
166 for (j = 0; j < 8; j++) {
167 if (!((0x80 >> j) & ssd_area->path_mask &
168 ssd_area->fla_valid_mask))
170 sch->ssd_info.chpid[j] = ssd_area->chpid[j];
171 sch->ssd_info.fla[j] = ssd_area->fla[j];
178 css_get_ssd_info(struct subchannel *sch)
183 page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
186 spin_lock_irq(&sch->lock);
187 ret = chsc_get_sch_desc_irq(sch, page);
189 static int cio_chsc_err_msg;
191 if (!cio_chsc_err_msg) {
193 "chsc_get_sch_descriptions:"
194 " Error %d while doing chsc; "
195 "processing some machine checks may "
197 cio_chsc_err_msg = 1;
200 spin_unlock_irq(&sch->lock);
201 free_page((unsigned long)page);
204 /* Allocate channel path structures, if needed. */
205 for (j = 0; j < 8; j++) {
207 chpid = sch->ssd_info.chpid[j];
208 if ((sch->schib.pmcw.pim & mask) &&
209 (get_chp_status(chpid) < 0))
210 new_channel_path(chpid);
217 s390_subchannel_remove_chpid(struct device *dev, void *data)
221 struct subchannel *sch;
222 struct channel_path *chpid;
225 sch = to_subchannel(dev);
227 for (j = 0; j < 8; j++) {
229 if ((sch->schib.pmcw.pim & mask) &&
230 (sch->schib.pmcw.chpid[j] == chpid->id))
236 spin_lock_irq(&sch->lock);
238 stsch(sch->schid, &schib);
241 memcpy(&sch->schib, &schib, sizeof(struct schib));
242 /* Check for single path devices. */
243 if (sch->schib.pmcw.pim == 0x80)
246 if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) &&
247 (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) &&
248 (sch->schib.pmcw.lpum == mask)) {
255 if (sch->driver && sch->driver->termination)
256 sch->driver->termination(&sch->dev);
260 /* trigger path verification. */
261 if (sch->driver && sch->driver->verify)
262 sch->driver->verify(&sch->dev);
263 else if (sch->lpm == mask)
266 spin_unlock_irq(&sch->lock);
269 spin_unlock_irq(&sch->lock);
271 if (css_enqueue_subchannel_slow(sch->schid)) {
272 css_clear_subchannel_slow_list();
279 s390_set_chpid_offline( __u8 chpid)
284 sprintf(dbf_txt, "chpr%x", chpid);
285 CIO_TRACE_EVENT(2, dbf_txt);
287 if (get_chp_status(chpid) <= 0)
289 dev = get_device(&css[0]->chps[chpid]->dev);
290 bus_for_each_dev(&css_bus_type, NULL, to_channelpath(dev),
291 s390_subchannel_remove_chpid);
293 if (need_rescan || css_slow_subchannels_exist())
294 queue_work(slow_path_wq, &slow_path_work);
298 struct res_acc_data {
299 struct channel_path *chp;
305 s390_process_res_acc_sch(struct res_acc_data *res_data, struct subchannel *sch)
312 for (chp = 0; chp <= 7; chp++)
314 * check if chpid is in information updated by ssd
316 if (sch->ssd_info.valid &&
317 sch->ssd_info.chpid[chp] == res_data->chp->id &&
318 (sch->ssd_info.fla[chp] & res_data->fla_mask)
328 * Do a stsch to update our subchannel structure with the
329 * new path information and eventually check for logically
332 ccode = stsch(sch->schid, &sch->schib);
340 s390_process_res_acc_new_sch(struct subchannel_id schid)
345 * We don't know the device yet, but since a path
346 * may be available now to the device we'll have
347 * to do recognition again.
348 * Since we don't have any idea about which chpid
349 * that beast may be on we'll have to do a stsch
350 * on all devices, grr...
352 if (stsch_err(schid, &schib))
354 return need_rescan ? -EAGAIN : -ENXIO;
356 /* Put it on the slow path. */
357 ret = css_enqueue_subchannel_slow(schid);
359 css_clear_subchannel_slow_list();
367 __s390_process_res_acc(struct subchannel_id schid, void *data)
369 int chp_mask, old_lpm;
370 struct res_acc_data *res_data;
371 struct subchannel *sch;
373 res_data = (struct res_acc_data *)data;
374 sch = get_subchannel_by_schid(schid);
376 /* Check if a subchannel is newly available. */
377 return s390_process_res_acc_new_sch(schid);
379 spin_lock_irq(&sch->lock);
381 chp_mask = s390_process_res_acc_sch(res_data, sch);
384 spin_unlock_irq(&sch->lock);
385 put_device(&sch->dev);
389 sch->lpm = ((sch->schib.pmcw.pim &
390 sch->schib.pmcw.pam &
392 | chp_mask) & sch->opm;
393 if (!old_lpm && sch->lpm)
394 device_trigger_reprobe(sch);
395 else if (sch->driver && sch->driver->verify)
396 sch->driver->verify(&sch->dev);
398 spin_unlock_irq(&sch->lock);
399 put_device(&sch->dev);
405 s390_process_res_acc (struct res_acc_data *res_data)
410 sprintf(dbf_txt, "accpr%x", res_data->chp->id);
411 CIO_TRACE_EVENT( 2, dbf_txt);
412 if (res_data->fla != 0) {
413 sprintf(dbf_txt, "fla%x", res_data->fla);
414 CIO_TRACE_EVENT( 2, dbf_txt);
418 * I/O resources may have become accessible.
419 * Scan through all subchannels that may be concerned and
420 * do a validation on those.
421 * The more information we have (info), the less scanning
422 * will we have to do.
424 rc = for_each_subchannel(__s390_process_res_acc, res_data);
425 if (css_slow_subchannels_exist())
427 else if (rc != -EAGAIN)
433 __get_chpid_from_lir(void *data)
439 /* incident-node descriptor */
441 /* attached-node descriptor */
443 /* incident-specific information */
447 lir = (struct lir*) data;
449 /* NULL link incident record */
451 if (!(lir->indesc[0]&0xc0000000))
452 /* node descriptor not valid */
454 if (!(lir->indesc[0]&0x10000000))
455 /* don't handle device-type nodes - FIXME */
457 /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
459 return (u16) (lir->indesc[0]&0x000000ff);
463 chsc_process_crw(void)
466 struct res_acc_data res_data;
468 struct chsc_header request;
472 struct chsc_header response;
475 u8 vf; /* validity flags */
476 u8 rs; /* reporting source */
477 u8 cc; /* content code */
478 u16 fla; /* full link address */
479 u16 rsid; /* reporting source id */
482 u32 ccdf[96]; /* content-code dependent field */
483 /* ccdf has to be big enough for a link-incident record */
489 * build the chsc request block for store event information
491 * This function is only called by the machine check handler thread,
492 * so we don't need locking for the sei_page.
496 CIO_TRACE_EVENT( 2, "prcss");
501 memset(sei_area, 0, sizeof(*sei_area));
502 memset(&res_data, 0, sizeof(struct res_acc_data));
503 sei_area->request.length = 0x0010;
504 sei_area->request.code = 0x000e;
506 ccode = chsc(sei_area);
510 switch (sei_area->response.code) {
511 /* for debug purposes, check for problems */
513 CIO_CRW_EVENT(4, "chsc_process_crw: event information "
514 "successfully stored\n");
515 break; /* everything ok */
518 "chsc_process_crw: invalid command!\n");
521 CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
525 CIO_CRW_EVENT(2, "chsc_process_crw: no event "
526 "information stored\n");
529 CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
530 sei_area->response.code);
534 /* Check if we might have lost some information. */
535 if (sei_area->flags & 0x40)
536 CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
537 "has been lost due to overflow!\n");
539 if (sei_area->rs != 4) {
540 CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
541 "(%04X) isn't a chpid!\n",
546 /* which kind of information was stored? */
547 switch (sei_area->cc) {
548 case 1: /* link incident*/
549 CIO_CRW_EVENT(4, "chsc_process_crw: "
550 "channel subsystem reports link incident,"
551 " reporting source is chpid %x\n",
553 chpid = __get_chpid_from_lir(sei_area->ccdf);
555 CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
558 s390_set_chpid_offline(chpid);
561 case 2: /* i/o resource accessibiliy */
562 CIO_CRW_EVENT(4, "chsc_process_crw: "
563 "channel subsystem reports some I/O "
564 "devices may have become accessible\n");
565 pr_debug("Data received after sei: \n");
566 pr_debug("Validity flags: %x\n", sei_area->vf);
568 /* allocate a new channel path structure, if needed */
569 status = get_chp_status(sei_area->rsid);
571 new_channel_path(sei_area->rsid);
574 dev = get_device(&css[0]->chps[sei_area->rsid]->dev);
575 res_data.chp = to_channelpath(dev);
576 pr_debug("chpid: %x", sei_area->rsid);
577 if ((sei_area->vf & 0xc0) != 0) {
578 res_data.fla = sei_area->fla;
579 if ((sei_area->vf & 0xc0) == 0xc0) {
580 pr_debug(" full link addr: %x",
582 res_data.fla_mask = 0xffff;
584 pr_debug(" link addr: %x",
586 res_data.fla_mask = 0xff00;
589 ret = s390_process_res_acc(&res_data);
594 default: /* other stuff */
595 CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
599 } while (sei_area->flags & 0x80);
604 __chp_add_new_sch(struct subchannel_id schid)
609 if (stsch(schid, &schib))
611 return need_rescan ? -EAGAIN : -ENXIO;
613 /* Put it on the slow path. */
614 ret = css_enqueue_subchannel_slow(schid);
616 css_clear_subchannel_slow_list();
625 __chp_add(struct subchannel_id schid, void *data)
628 struct channel_path *chp;
629 struct subchannel *sch;
631 chp = (struct channel_path *)data;
632 sch = get_subchannel_by_schid(schid);
634 /* Check if the subchannel is now available. */
635 return __chp_add_new_sch(schid);
636 spin_lock_irq(&sch->lock);
637 for (i=0; i<8; i++) {
639 if ((sch->schib.pmcw.pim & mask) &&
640 (sch->schib.pmcw.chpid[i] == chp->id)) {
641 if (stsch(sch->schid, &sch->schib) != 0) {
643 spin_unlock_irq(&sch->lock);
650 spin_unlock_irq(&sch->lock);
653 sch->lpm = ((sch->schib.pmcw.pim &
654 sch->schib.pmcw.pam &
658 if (sch->driver && sch->driver->verify)
659 sch->driver->verify(&sch->dev);
661 spin_unlock_irq(&sch->lock);
662 put_device(&sch->dev);
673 if (!get_chp_status(chpid))
674 return 0; /* no need to do the rest */
676 sprintf(dbf_txt, "cadd%x", chpid);
677 CIO_TRACE_EVENT(2, dbf_txt);
679 dev = get_device(&css[0]->chps[chpid]->dev);
680 rc = for_each_subchannel(__chp_add, to_channelpath(dev));
681 if (css_slow_subchannels_exist())
690 * Handling of crw machine checks with channel path source.
693 chp_process_crw(int chpid, int on)
696 /* Path has gone. We use the link incident routine.*/
697 s390_set_chpid_offline(chpid);
698 return 0; /* De-register is async anyway. */
701 * Path has come. Allocate a new channel path structure,
704 if (get_chp_status(chpid) < 0)
705 new_channel_path(chpid);
706 /* Avoid the extra overhead in process_rec_acc. */
707 return chp_add(chpid);
711 __check_for_io_and_kill(struct subchannel *sch, int index)
715 if (!device_is_online(sch))
716 /* cio could be doing I/O. */
718 cc = stsch(sch->schid, &sch->schib);
721 if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == (0x80 >> index)) {
722 device_set_waiting(sch);
729 __s390_subchannel_vary_chpid(struct subchannel *sch, __u8 chpid, int on)
734 if (!sch->ssd_info.valid)
737 spin_lock_irqsave(&sch->lock, flags);
739 for (chp = 0; chp < 8; chp++) {
740 if (sch->ssd_info.chpid[chp] != chpid)
744 sch->opm |= (0x80 >> chp);
745 sch->lpm |= (0x80 >> chp);
747 device_trigger_reprobe(sch);
748 else if (sch->driver && sch->driver->verify)
749 sch->driver->verify(&sch->dev);
751 sch->opm &= ~(0x80 >> chp);
752 sch->lpm &= ~(0x80 >> chp);
754 * Give running I/O a grace period in which it
755 * can successfully terminate, even using the
756 * just varied off path. Then kill it.
758 if (!__check_for_io_and_kill(sch, chp) && !sch->lpm) {
759 if (css_enqueue_subchannel_slow(sch->schid)) {
760 css_clear_subchannel_slow_list();
763 } else if (sch->driver && sch->driver->verify)
764 sch->driver->verify(&sch->dev);
768 spin_unlock_irqrestore(&sch->lock, flags);
772 s390_subchannel_vary_chpid_off(struct device *dev, void *data)
774 struct subchannel *sch;
777 sch = to_subchannel(dev);
780 __s390_subchannel_vary_chpid(sch, *chpid, 0);
785 s390_subchannel_vary_chpid_on(struct device *dev, void *data)
787 struct subchannel *sch;
790 sch = to_subchannel(dev);
793 __s390_subchannel_vary_chpid(sch, *chpid, 1);
798 __s390_vary_chpid_on(struct subchannel_id schid, void *data)
801 struct subchannel *sch;
803 sch = get_subchannel_by_schid(schid);
805 put_device(&sch->dev);
808 if (stsch_err(schid, &schib))
811 /* Put it on the slow path. */
812 if (css_enqueue_subchannel_slow(schid)) {
813 css_clear_subchannel_slow_list();
821 * Function: s390_vary_chpid
822 * Varies the specified chpid online or offline
825 s390_vary_chpid( __u8 chpid, int on)
830 sprintf(dbf_text, on?"varyon%x":"varyoff%x", chpid);
831 CIO_TRACE_EVENT( 2, dbf_text);
833 status = get_chp_status(chpid);
835 printk(KERN_ERR "Can't vary unknown chpid %02X\n", chpid);
839 if (!on && !status) {
840 printk(KERN_ERR "chpid %x is already offline\n", chpid);
844 set_chp_logically_online(chpid, on);
847 * Redo PathVerification on the devices the chpid connects to
850 bus_for_each_dev(&css_bus_type, NULL, &chpid, on ?
851 s390_subchannel_vary_chpid_on :
852 s390_subchannel_vary_chpid_off);
854 /* Scan for new devices on varied on path. */
855 for_each_subchannel(__s390_vary_chpid_on, NULL);
856 if (need_rescan || css_slow_subchannels_exist())
857 queue_work(slow_path_wq, &slow_path_work);
862 * Channel measurement related functions
865 chp_measurement_chars_read(struct kobject *kobj, char *buf, loff_t off,
868 struct channel_path *chp;
871 chp = to_channelpath(container_of(kobj, struct device, kobj));
875 size = sizeof(struct cmg_chars);
879 if (off + count > size)
881 memcpy(buf, chp->cmg_chars + off, count);
885 static struct bin_attribute chp_measurement_chars_attr = {
887 .name = "measurement_chars",
889 .owner = THIS_MODULE,
891 .size = sizeof(struct cmg_chars),
892 .read = chp_measurement_chars_read,
896 chp_measurement_copy_block(struct cmg_entry *buf,
897 struct channel_subsystem *css, int chpid)
900 struct cmg_entry *entry, reference_buf;
904 area = css->cub_addr1;
907 area = css->cub_addr2;
910 entry = area + (idx * sizeof(struct cmg_entry));
912 memcpy(buf, entry, sizeof(*entry));
913 memcpy(&reference_buf, entry, sizeof(*entry));
914 } while (reference_buf.values[0] != buf->values[0]);
918 chp_measurement_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
920 struct channel_path *chp;
921 struct channel_subsystem *css;
924 chp = to_channelpath(container_of(kobj, struct device, kobj));
925 css = to_css(chp->dev.parent);
927 size = sizeof(struct cmg_entry);
929 /* Only allow single reads. */
930 if (off || count < size)
932 chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->id);
937 static struct bin_attribute chp_measurement_attr = {
939 .name = "measurement",
941 .owner = THIS_MODULE,
943 .size = sizeof(struct cmg_entry),
944 .read = chp_measurement_read,
948 chsc_remove_chp_cmg_attr(struct channel_path *chp)
950 sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_chars_attr);
951 sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_attr);
955 chsc_add_chp_cmg_attr(struct channel_path *chp)
959 ret = sysfs_create_bin_file(&chp->dev.kobj,
960 &chp_measurement_chars_attr);
963 ret = sysfs_create_bin_file(&chp->dev.kobj, &chp_measurement_attr);
965 sysfs_remove_bin_file(&chp->dev.kobj,
966 &chp_measurement_chars_attr);
971 chsc_remove_cmg_attr(struct channel_subsystem *css)
975 for (i = 0; i <= __MAX_CHPID; i++) {
978 chsc_remove_chp_cmg_attr(css->chps[i]);
983 chsc_add_cmg_attr(struct channel_subsystem *css)
988 for (i = 0; i <= __MAX_CHPID; i++) {
991 ret = chsc_add_chp_cmg_attr(css->chps[i]);
997 for (--i; i >= 0; i--) {
1000 chsc_remove_chp_cmg_attr(css->chps[i]);
1007 __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
1010 struct chsc_header request;
1011 u32 operation_code : 2;
1020 struct chsc_header response;
1029 secm_area->request.length = 0x0050;
1030 secm_area->request.code = 0x0016;
1032 secm_area->key = PAGE_DEFAULT_KEY;
1033 secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
1034 secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
1036 secm_area->operation_code = enable ? 0 : 1;
1038 ccode = chsc(secm_area);
1040 return (ccode == 3) ? -ENODEV : -EBUSY;
1042 switch (secm_area->response.code) {
1043 case 0x0001: /* Success. */
1046 case 0x0003: /* Invalid block. */
1047 case 0x0007: /* Invalid format. */
1048 case 0x0008: /* Other invalid block. */
1049 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1052 case 0x0004: /* Command not provided in model. */
1053 CIO_CRW_EVENT(2, "Model does not provide secm\n");
1056 case 0x0102: /* cub adresses incorrect */
1057 CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n");
1060 case 0x0103: /* key error */
1061 CIO_CRW_EVENT(2, "Access key error in secm\n");
1064 case 0x0105: /* error while starting */
1065 CIO_CRW_EVENT(2, "Error while starting channel measurement\n");
1069 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1070 secm_area->response.code);
1077 chsc_secm(struct channel_subsystem *css, int enable)
1082 secm_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1086 mutex_lock(&css->mutex);
1087 if (enable && !css->cm_enabled) {
1088 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1089 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1090 if (!css->cub_addr1 || !css->cub_addr2) {
1091 free_page((unsigned long)css->cub_addr1);
1092 free_page((unsigned long)css->cub_addr2);
1093 free_page((unsigned long)secm_area);
1094 mutex_unlock(&css->mutex);
1098 ret = __chsc_do_secm(css, enable, secm_area);
1100 css->cm_enabled = enable;
1101 if (css->cm_enabled) {
1102 ret = chsc_add_cmg_attr(css);
1104 memset(secm_area, 0, PAGE_SIZE);
1105 __chsc_do_secm(css, 0, secm_area);
1106 css->cm_enabled = 0;
1109 chsc_remove_cmg_attr(css);
1111 if (enable && !css->cm_enabled) {
1112 free_page((unsigned long)css->cub_addr1);
1113 free_page((unsigned long)css->cub_addr2);
1115 mutex_unlock(&css->mutex);
1116 free_page((unsigned long)secm_area);
1121 * Files for the channel path entries.
1124 chp_status_show(struct device *dev, struct device_attribute *attr, char *buf)
1126 struct channel_path *chp = container_of(dev, struct channel_path, dev);
1130 return (get_chp_status(chp->id) ? sprintf(buf, "online\n") :
1131 sprintf(buf, "offline\n"));
1135 chp_status_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1137 struct channel_path *cp = container_of(dev, struct channel_path, dev);
1142 num_args = sscanf(buf, "%5s", cmd);
1146 if (!strnicmp(cmd, "on", 2))
1147 error = s390_vary_chpid(cp->id, 1);
1148 else if (!strnicmp(cmd, "off", 3))
1149 error = s390_vary_chpid(cp->id, 0);
1153 return error < 0 ? error : count;
1157 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
1160 chp_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1162 struct channel_path *chp = container_of(dev, struct channel_path, dev);
1166 return sprintf(buf, "%x\n", chp->desc.desc);
1169 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
1172 chp_cmg_show(struct device *dev, struct device_attribute *attr, char *buf)
1174 struct channel_path *chp = to_channelpath(dev);
1178 if (chp->cmg == -1) /* channel measurements not available */
1179 return sprintf(buf, "unknown\n");
1180 return sprintf(buf, "%x\n", chp->cmg);
1183 static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL);
1186 chp_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
1188 struct channel_path *chp = to_channelpath(dev);
1192 if (chp->shared == -1) /* channel measurements not available */
1193 return sprintf(buf, "unknown\n");
1194 return sprintf(buf, "%x\n", chp->shared);
1197 static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
1199 static struct attribute * chp_attrs[] = {
1200 &dev_attr_status.attr,
1201 &dev_attr_type.attr,
1203 &dev_attr_shared.attr,
1207 static struct attribute_group chp_attr_group = {
1212 chp_release(struct device *dev)
1214 struct channel_path *cp;
1216 cp = container_of(dev, struct channel_path, dev);
1221 chsc_determine_channel_path_description(int chpid,
1222 struct channel_path_desc *desc)
1227 struct chsc_header request;
1229 u32 first_chpid : 8;
1233 struct chsc_header response;
1235 struct channel_path_desc desc;
1238 scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1242 scpd_area->request.length = 0x0010;
1243 scpd_area->request.code = 0x0002;
1245 scpd_area->first_chpid = chpid;
1246 scpd_area->last_chpid = chpid;
1248 ccode = chsc(scpd_area);
1250 ret = (ccode == 3) ? -ENODEV : -EBUSY;
1254 switch (scpd_area->response.code) {
1255 case 0x0001: /* Success. */
1256 memcpy(desc, &scpd_area->desc,
1257 sizeof(struct channel_path_desc));
1260 case 0x0003: /* Invalid block. */
1261 case 0x0007: /* Invalid format. */
1262 case 0x0008: /* Other invalid block. */
1263 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1266 case 0x0004: /* Command not provided in model. */
1267 CIO_CRW_EVENT(2, "Model does not provide scpd\n");
1271 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1272 scpd_area->response.code);
1276 free_page((unsigned long)scpd_area);
1281 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
1282 struct cmg_chars *chars)
1287 chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
1289 if (chp->cmg_chars) {
1291 struct cmg_chars *cmg_chars;
1293 cmg_chars = chp->cmg_chars;
1294 for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
1295 mask = 0x80 >> (i + 3);
1297 cmg_chars->values[i] = chars->values[i];
1299 cmg_chars->values[i] = 0;
1304 /* No cmg-dependent data. */
1310 chsc_get_channel_measurement_chars(struct channel_path *chp)
1315 struct chsc_header request;
1317 u32 first_chpid : 8;
1321 struct chsc_header response;
1332 u32 data[NR_MEASUREMENT_CHARS];
1335 scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1339 scmc_area->request.length = 0x0010;
1340 scmc_area->request.code = 0x0022;
1342 scmc_area->first_chpid = chp->id;
1343 scmc_area->last_chpid = chp->id;
1345 ccode = chsc(scmc_area);
1347 ret = (ccode == 3) ? -ENODEV : -EBUSY;
1351 switch (scmc_area->response.code) {
1352 case 0x0001: /* Success. */
1353 if (!scmc_area->not_valid) {
1354 chp->cmg = scmc_area->cmg;
1355 chp->shared = scmc_area->shared;
1356 chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
1357 (struct cmg_chars *)
1365 case 0x0003: /* Invalid block. */
1366 case 0x0007: /* Invalid format. */
1367 case 0x0008: /* Invalid bit combination. */
1368 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1371 case 0x0004: /* Command not provided. */
1372 CIO_CRW_EVENT(2, "Model does not provide scmc\n");
1376 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1377 scmc_area->response.code);
1381 free_page((unsigned long)scmc_area);
1386 * Entries for chpids on the system bus.
1387 * This replaces /proc/chpids.
1390 new_channel_path(int chpid)
1392 struct channel_path *chp;
1395 chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL);
1399 /* fill in status, etc. */
1402 chp->dev.parent = &css[0]->device;
1403 chp->dev.release = chp_release;
1404 snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid);
1406 /* Obtain channel path description and fill it in. */
1407 ret = chsc_determine_channel_path_description(chpid, &chp->desc);
1410 /* Get channel-measurement characteristics. */
1411 if (css_characteristics_avail && css_chsc_characteristics.scmc
1412 && css_chsc_characteristics.secm) {
1413 ret = chsc_get_channel_measurement_chars(chp);
1417 static int msg_done;
1420 printk(KERN_WARNING "cio: Channel measurements not "
1421 "available, continuing.\n");
1427 /* make it known to the system */
1428 ret = device_register(&chp->dev);
1430 printk(KERN_WARNING "%s: could not register %02x\n",
1434 ret = sysfs_create_group(&chp->dev.kobj, &chp_attr_group);
1436 device_unregister(&chp->dev);
1439 mutex_lock(&css[0]->mutex);
1440 if (css[0]->cm_enabled) {
1441 ret = chsc_add_chp_cmg_attr(chp);
1443 sysfs_remove_group(&chp->dev.kobj, &chp_attr_group);
1444 device_unregister(&chp->dev);
1445 mutex_unlock(&css[0]->mutex);
1449 css[0]->chps[chpid] = chp;
1450 mutex_unlock(&css[0]->mutex);
1458 chsc_get_chp_desc(struct subchannel *sch, int chp_no)
1460 struct channel_path *chp;
1461 struct channel_path_desc *desc;
1463 chp = css[0]->chps[sch->schib.pmcw.chpid[chp_no]];
1466 desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
1469 memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
1473 static int reset_channel_path(struct channel_path *chp)
1488 static void reset_channel_paths_css(struct channel_subsystem *css)
1492 for (i = 0; i <= __MAX_CHPID; i++) {
1494 reset_channel_path(css->chps[i]);
1498 void cio_reset_channel_paths(void)
1502 for (i = 0; i <= __MAX_CSSID; i++) {
1503 if (css[i] && css[i]->valid)
1504 reset_channel_paths_css(css[i]);
1509 chsc_alloc_sei_area(void)
1511 sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1513 printk(KERN_WARNING"Can't allocate page for processing of " \
1514 "chsc machine checks!\n");
1515 return (sei_page ? 0 : -ENOMEM);
1519 chsc_enable_facility(int operation_code)
1523 struct chsc_header request;
1530 u32 operation_data_area[252];
1531 struct chsc_header response;
1537 sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
1540 sda_area->request.length = 0x0400;
1541 sda_area->request.code = 0x0031;
1542 sda_area->operation_code = operation_code;
1544 ret = chsc(sda_area);
1546 ret = (ret == 3) ? -ENODEV : -EBUSY;
1549 switch (sda_area->response.code) {
1550 case 0x0001: /* everything ok */
1553 case 0x0003: /* invalid request block */
1557 case 0x0004: /* command not provided */
1558 case 0x0101: /* facility not provided */
1561 default: /* something went wrong */
1565 free_page((unsigned long)sda_area);
1569 subsys_initcall(chsc_alloc_sei_area);
1571 struct css_general_char css_general_characteristics;
1572 struct css_chsc_char css_chsc_characteristics;
1575 chsc_determine_css_characteristics(void)
1579 struct chsc_header request;
1583 struct chsc_header response;
1585 u32 general_char[510];
1589 scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1591 printk(KERN_WARNING"cio: Was not able to determine available" \
1592 "CHSCs due to no memory.\n");
1596 scsc_area->request.length = 0x0010;
1597 scsc_area->request.code = 0x0010;
1599 result = chsc(scsc_area);
1601 printk(KERN_WARNING"cio: Was not able to determine " \
1602 "available CHSCs, cc=%i.\n", result);
1607 if (scsc_area->response.code != 1) {
1608 printk(KERN_WARNING"cio: Was not able to determine " \
1609 "available CHSCs.\n");
1613 memcpy(&css_general_characteristics, scsc_area->general_char,
1614 sizeof(css_general_characteristics));
1615 memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1616 sizeof(css_chsc_characteristics));
1618 free_page ((unsigned long) scsc_area);
1622 EXPORT_SYMBOL_GPL(css_general_characteristics);
1623 EXPORT_SYMBOL_GPL(css_chsc_characteristics);