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
++) {
206 chpid
= sch
->ssd_info
.chpid
[j
];
207 if (chpid
&& (get_chp_status(chpid
) < 0))
208 new_channel_path(chpid
);
215 s390_subchannel_remove_chpid(struct device
*dev
, void *data
)
219 struct subchannel
*sch
;
220 struct channel_path
*chpid
;
223 sch
= to_subchannel(dev
);
225 for (j
= 0; j
< 8; j
++)
226 if (sch
->schib
.pmcw
.chpid
[j
] == chpid
->id
)
232 spin_lock_irq(&sch
->lock
);
234 stsch(sch
->schid
, &schib
);
237 memcpy(&sch
->schib
, &schib
, sizeof(struct schib
));
238 /* Check for single path devices. */
239 if (sch
->schib
.pmcw
.pim
== 0x80)
242 if ((sch
->schib
.scsw
.actl
& SCSW_ACTL_DEVACT
) &&
243 (sch
->schib
.scsw
.actl
& SCSW_ACTL_SCHACT
) &&
244 (sch
->schib
.pmcw
.lpum
== mask
)) {
251 if (sch
->driver
&& sch
->driver
->termination
)
252 sch
->driver
->termination(&sch
->dev
);
256 /* trigger path verification. */
257 if (sch
->driver
&& sch
->driver
->verify
)
258 sch
->driver
->verify(&sch
->dev
);
259 else if (sch
->vpm
== mask
)
262 spin_unlock_irq(&sch
->lock
);
265 spin_unlock_irq(&sch
->lock
);
267 if (css_enqueue_subchannel_slow(sch
->schid
)) {
268 css_clear_subchannel_slow_list();
275 s390_set_chpid_offline( __u8 chpid
)
280 sprintf(dbf_txt
, "chpr%x", chpid
);
281 CIO_TRACE_EVENT(2, dbf_txt
);
283 if (get_chp_status(chpid
) <= 0)
285 dev
= get_device(&css
[0]->chps
[chpid
]->dev
);
286 bus_for_each_dev(&css_bus_type
, NULL
, to_channelpath(dev
),
287 s390_subchannel_remove_chpid
);
289 if (need_rescan
|| css_slow_subchannels_exist())
290 queue_work(slow_path_wq
, &slow_path_work
);
294 struct res_acc_data
{
295 struct channel_path
*chp
;
301 s390_process_res_acc_sch(struct res_acc_data
*res_data
, struct subchannel
*sch
)
308 for (chp
= 0; chp
<= 7; chp
++)
310 * check if chpid is in information updated by ssd
312 if (sch
->ssd_info
.valid
&&
313 sch
->ssd_info
.chpid
[chp
] == res_data
->chp
->id
&&
314 (sch
->ssd_info
.fla
[chp
] & res_data
->fla_mask
)
324 * Do a stsch to update our subchannel structure with the
325 * new path information and eventually check for logically
328 ccode
= stsch(sch
->schid
, &sch
->schib
);
336 s390_process_res_acc_new_sch(struct subchannel_id schid
)
341 * We don't know the device yet, but since a path
342 * may be available now to the device we'll have
343 * to do recognition again.
344 * Since we don't have any idea about which chpid
345 * that beast may be on we'll have to do a stsch
346 * on all devices, grr...
348 if (stsch_err(schid
, &schib
))
350 return need_rescan
? -EAGAIN
: -ENXIO
;
352 /* Put it on the slow path. */
353 ret
= css_enqueue_subchannel_slow(schid
);
355 css_clear_subchannel_slow_list();
363 __s390_process_res_acc(struct subchannel_id schid
, void *data
)
365 int chp_mask
, old_lpm
;
366 struct res_acc_data
*res_data
;
367 struct subchannel
*sch
;
369 res_data
= (struct res_acc_data
*)data
;
370 sch
= get_subchannel_by_schid(schid
);
372 /* Check if a subchannel is newly available. */
373 return s390_process_res_acc_new_sch(schid
);
375 spin_lock_irq(&sch
->lock
);
377 chp_mask
= s390_process_res_acc_sch(res_data
, sch
);
380 spin_unlock_irq(&sch
->lock
);
381 put_device(&sch
->dev
);
385 sch
->lpm
= ((sch
->schib
.pmcw
.pim
&
386 sch
->schib
.pmcw
.pam
&
388 | chp_mask
) & sch
->opm
;
389 if (!old_lpm
&& sch
->lpm
)
390 device_trigger_reprobe(sch
);
391 else if (sch
->driver
&& sch
->driver
->verify
)
392 sch
->driver
->verify(&sch
->dev
);
394 spin_unlock_irq(&sch
->lock
);
395 put_device(&sch
->dev
);
401 s390_process_res_acc (struct res_acc_data
*res_data
)
406 sprintf(dbf_txt
, "accpr%x", res_data
->chp
->id
);
407 CIO_TRACE_EVENT( 2, dbf_txt
);
408 if (res_data
->fla
!= 0) {
409 sprintf(dbf_txt
, "fla%x", res_data
->fla
);
410 CIO_TRACE_EVENT( 2, dbf_txt
);
414 * I/O resources may have become accessible.
415 * Scan through all subchannels that may be concerned and
416 * do a validation on those.
417 * The more information we have (info), the less scanning
418 * will we have to do.
420 rc
= for_each_subchannel(__s390_process_res_acc
, res_data
);
421 if (css_slow_subchannels_exist())
423 else if (rc
!= -EAGAIN
)
429 __get_chpid_from_lir(void *data
)
435 /* incident-node descriptor */
437 /* attached-node descriptor */
439 /* incident-specific information */
443 lir
= (struct lir
*) data
;
445 /* NULL link incident record */
447 if (!(lir
->indesc
[0]&0xc0000000))
448 /* node descriptor not valid */
450 if (!(lir
->indesc
[0]&0x10000000))
451 /* don't handle device-type nodes - FIXME */
453 /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
455 return (u16
) (lir
->indesc
[0]&0x000000ff);
459 chsc_process_crw(void)
462 struct res_acc_data res_data
;
464 struct chsc_header request
;
468 struct chsc_header response
;
471 u8 vf
; /* validity flags */
472 u8 rs
; /* reporting source */
473 u8 cc
; /* content code */
474 u16 fla
; /* full link address */
475 u16 rsid
; /* reporting source id */
478 u32 ccdf
[96]; /* content-code dependent field */
479 /* ccdf has to be big enough for a link-incident record */
485 * build the chsc request block for store event information
487 * This function is only called by the machine check handler thread,
488 * so we don't need locking for the sei_page.
492 CIO_TRACE_EVENT( 2, "prcss");
497 memset(sei_area
, 0, sizeof(*sei_area
));
498 memset(&res_data
, 0, sizeof(struct res_acc_data
));
499 sei_area
->request
.length
= 0x0010;
500 sei_area
->request
.code
= 0x000e;
502 ccode
= chsc(sei_area
);
506 switch (sei_area
->response
.code
) {
507 /* for debug purposes, check for problems */
509 CIO_CRW_EVENT(4, "chsc_process_crw: event information "
510 "successfully stored\n");
511 break; /* everything ok */
514 "chsc_process_crw: invalid command!\n");
517 CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
521 CIO_CRW_EVENT(2, "chsc_process_crw: no event "
522 "information stored\n");
525 CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
526 sei_area
->response
.code
);
530 /* Check if we might have lost some information. */
531 if (sei_area
->flags
& 0x40)
532 CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
533 "has been lost due to overflow!\n");
535 if (sei_area
->rs
!= 4) {
536 CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
537 "(%04X) isn't a chpid!\n",
542 /* which kind of information was stored? */
543 switch (sei_area
->cc
) {
544 case 1: /* link incident*/
545 CIO_CRW_EVENT(4, "chsc_process_crw: "
546 "channel subsystem reports link incident,"
547 " reporting source is chpid %x\n",
549 chpid
= __get_chpid_from_lir(sei_area
->ccdf
);
551 CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
554 s390_set_chpid_offline(chpid
);
557 case 2: /* i/o resource accessibiliy */
558 CIO_CRW_EVENT(4, "chsc_process_crw: "
559 "channel subsystem reports some I/O "
560 "devices may have become accessible\n");
561 pr_debug("Data received after sei: \n");
562 pr_debug("Validity flags: %x\n", sei_area
->vf
);
564 /* allocate a new channel path structure, if needed */
565 status
= get_chp_status(sei_area
->rsid
);
567 new_channel_path(sei_area
->rsid
);
570 dev
= get_device(&css
[0]->chps
[sei_area
->rsid
]->dev
);
571 res_data
.chp
= to_channelpath(dev
);
572 pr_debug("chpid: %x", sei_area
->rsid
);
573 if ((sei_area
->vf
& 0xc0) != 0) {
574 res_data
.fla
= sei_area
->fla
;
575 if ((sei_area
->vf
& 0xc0) == 0xc0) {
576 pr_debug(" full link addr: %x",
578 res_data
.fla_mask
= 0xffff;
580 pr_debug(" link addr: %x",
582 res_data
.fla_mask
= 0xff00;
585 ret
= s390_process_res_acc(&res_data
);
590 default: /* other stuff */
591 CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
595 } while (sei_area
->flags
& 0x80);
600 __chp_add_new_sch(struct subchannel_id schid
)
605 if (stsch(schid
, &schib
))
607 return need_rescan
? -EAGAIN
: -ENXIO
;
609 /* Put it on the slow path. */
610 ret
= css_enqueue_subchannel_slow(schid
);
612 css_clear_subchannel_slow_list();
621 __chp_add(struct subchannel_id schid
, void *data
)
624 struct channel_path
*chp
;
625 struct subchannel
*sch
;
627 chp
= (struct channel_path
*)data
;
628 sch
= get_subchannel_by_schid(schid
);
630 /* Check if the subchannel is now available. */
631 return __chp_add_new_sch(schid
);
632 spin_lock_irq(&sch
->lock
);
634 if (sch
->schib
.pmcw
.chpid
[i
] == chp
->id
) {
635 if (stsch(sch
->schid
, &sch
->schib
) != 0) {
637 spin_unlock_irq(&sch
->lock
);
643 spin_unlock_irq(&sch
->lock
);
646 sch
->lpm
= ((sch
->schib
.pmcw
.pim
&
647 sch
->schib
.pmcw
.pam
&
649 | 0x80 >> i
) & sch
->opm
;
651 if (sch
->driver
&& sch
->driver
->verify
)
652 sch
->driver
->verify(&sch
->dev
);
654 spin_unlock_irq(&sch
->lock
);
655 put_device(&sch
->dev
);
666 if (!get_chp_status(chpid
))
667 return 0; /* no need to do the rest */
669 sprintf(dbf_txt
, "cadd%x", chpid
);
670 CIO_TRACE_EVENT(2, dbf_txt
);
672 dev
= get_device(&css
[0]->chps
[chpid
]->dev
);
673 rc
= for_each_subchannel(__chp_add
, to_channelpath(dev
));
674 if (css_slow_subchannels_exist())
683 * Handling of crw machine checks with channel path source.
686 chp_process_crw(int chpid
, int on
)
689 /* Path has gone. We use the link incident routine.*/
690 s390_set_chpid_offline(chpid
);
691 return 0; /* De-register is async anyway. */
694 * Path has come. Allocate a new channel path structure,
697 if (get_chp_status(chpid
) < 0)
698 new_channel_path(chpid
);
699 /* Avoid the extra overhead in process_rec_acc. */
700 return chp_add(chpid
);
704 __check_for_io_and_kill(struct subchannel
*sch
, int index
)
708 if (!device_is_online(sch
))
709 /* cio could be doing I/O. */
711 cc
= stsch(sch
->schid
, &sch
->schib
);
714 if (sch
->schib
.scsw
.actl
&& sch
->schib
.pmcw
.lpum
== (0x80 >> index
)) {
715 device_set_waiting(sch
);
722 __s390_subchannel_vary_chpid(struct subchannel
*sch
, __u8 chpid
, int on
)
727 if (!sch
->ssd_info
.valid
)
730 spin_lock_irqsave(&sch
->lock
, flags
);
732 for (chp
= 0; chp
< 8; chp
++) {
733 if (sch
->ssd_info
.chpid
[chp
] != chpid
)
737 sch
->opm
|= (0x80 >> chp
);
738 sch
->lpm
|= (0x80 >> chp
);
740 device_trigger_reprobe(sch
);
741 else if (sch
->driver
&& sch
->driver
->verify
)
742 sch
->driver
->verify(&sch
->dev
);
744 sch
->opm
&= ~(0x80 >> chp
);
745 sch
->lpm
&= ~(0x80 >> chp
);
747 * Give running I/O a grace period in which it
748 * can successfully terminate, even using the
749 * just varied off path. Then kill it.
751 if (!__check_for_io_and_kill(sch
, chp
) && !sch
->lpm
) {
752 if (css_enqueue_subchannel_slow(sch
->schid
)) {
753 css_clear_subchannel_slow_list();
756 } else if (sch
->driver
&& sch
->driver
->verify
)
757 sch
->driver
->verify(&sch
->dev
);
761 spin_unlock_irqrestore(&sch
->lock
, flags
);
765 s390_subchannel_vary_chpid_off(struct device
*dev
, void *data
)
767 struct subchannel
*sch
;
770 sch
= to_subchannel(dev
);
773 __s390_subchannel_vary_chpid(sch
, *chpid
, 0);
778 s390_subchannel_vary_chpid_on(struct device
*dev
, void *data
)
780 struct subchannel
*sch
;
783 sch
= to_subchannel(dev
);
786 __s390_subchannel_vary_chpid(sch
, *chpid
, 1);
791 __s390_vary_chpid_on(struct subchannel_id schid
, void *data
)
794 struct subchannel
*sch
;
796 sch
= get_subchannel_by_schid(schid
);
798 put_device(&sch
->dev
);
801 if (stsch_err(schid
, &schib
))
804 /* Put it on the slow path. */
805 if (css_enqueue_subchannel_slow(schid
)) {
806 css_clear_subchannel_slow_list();
814 * Function: s390_vary_chpid
815 * Varies the specified chpid online or offline
818 s390_vary_chpid( __u8 chpid
, int on
)
823 sprintf(dbf_text
, on
?"varyon%x":"varyoff%x", chpid
);
824 CIO_TRACE_EVENT( 2, dbf_text
);
826 status
= get_chp_status(chpid
);
828 printk(KERN_ERR
"Can't vary unknown chpid %02X\n", chpid
);
832 if (!on
&& !status
) {
833 printk(KERN_ERR
"chpid %x is already offline\n", chpid
);
837 set_chp_logically_online(chpid
, on
);
840 * Redo PathVerification on the devices the chpid connects to
843 bus_for_each_dev(&css_bus_type
, NULL
, &chpid
, on
?
844 s390_subchannel_vary_chpid_on
:
845 s390_subchannel_vary_chpid_off
);
847 /* Scan for new devices on varied on path. */
848 for_each_subchannel(__s390_vary_chpid_on
, NULL
);
849 if (need_rescan
|| css_slow_subchannels_exist())
850 queue_work(slow_path_wq
, &slow_path_work
);
855 * Channel measurement related functions
858 chp_measurement_chars_read(struct kobject
*kobj
, char *buf
, loff_t off
,
861 struct channel_path
*chp
;
864 chp
= to_channelpath(container_of(kobj
, struct device
, kobj
));
868 size
= sizeof(struct cmg_chars
);
872 if (off
+ count
> size
)
874 memcpy(buf
, chp
->cmg_chars
+ off
, count
);
878 static struct bin_attribute chp_measurement_chars_attr
= {
880 .name
= "measurement_chars",
882 .owner
= THIS_MODULE
,
884 .size
= sizeof(struct cmg_chars
),
885 .read
= chp_measurement_chars_read
,
889 chp_measurement_copy_block(struct cmg_entry
*buf
,
890 struct channel_subsystem
*css
, int chpid
)
893 struct cmg_entry
*entry
, reference_buf
;
897 area
= css
->cub_addr1
;
900 area
= css
->cub_addr2
;
903 entry
= area
+ (idx
* sizeof(struct cmg_entry
));
905 memcpy(buf
, entry
, sizeof(*entry
));
906 memcpy(&reference_buf
, entry
, sizeof(*entry
));
907 } while (reference_buf
.values
[0] != buf
->values
[0]);
911 chp_measurement_read(struct kobject
*kobj
, char *buf
, loff_t off
, size_t count
)
913 struct channel_path
*chp
;
914 struct channel_subsystem
*css
;
917 chp
= to_channelpath(container_of(kobj
, struct device
, kobj
));
918 css
= to_css(chp
->dev
.parent
);
920 size
= sizeof(struct cmg_entry
);
922 /* Only allow single reads. */
923 if (off
|| count
< size
)
925 chp_measurement_copy_block((struct cmg_entry
*)buf
, css
, chp
->id
);
930 static struct bin_attribute chp_measurement_attr
= {
932 .name
= "measurement",
934 .owner
= THIS_MODULE
,
936 .size
= sizeof(struct cmg_entry
),
937 .read
= chp_measurement_read
,
941 chsc_remove_chp_cmg_attr(struct channel_path
*chp
)
943 sysfs_remove_bin_file(&chp
->dev
.kobj
, &chp_measurement_chars_attr
);
944 sysfs_remove_bin_file(&chp
->dev
.kobj
, &chp_measurement_attr
);
948 chsc_add_chp_cmg_attr(struct channel_path
*chp
)
952 ret
= sysfs_create_bin_file(&chp
->dev
.kobj
,
953 &chp_measurement_chars_attr
);
956 ret
= sysfs_create_bin_file(&chp
->dev
.kobj
, &chp_measurement_attr
);
958 sysfs_remove_bin_file(&chp
->dev
.kobj
,
959 &chp_measurement_chars_attr
);
964 chsc_remove_cmg_attr(struct channel_subsystem
*css
)
968 for (i
= 0; i
<= __MAX_CHPID
; i
++) {
971 chsc_remove_chp_cmg_attr(css
->chps
[i
]);
976 chsc_add_cmg_attr(struct channel_subsystem
*css
)
981 for (i
= 0; i
<= __MAX_CHPID
; i
++) {
984 ret
= chsc_add_chp_cmg_attr(css
->chps
[i
]);
990 for (--i
; i
>= 0; i
--) {
993 chsc_remove_chp_cmg_attr(css
->chps
[i
]);
1000 __chsc_do_secm(struct channel_subsystem
*css
, int enable
, void *page
)
1003 struct chsc_header request
;
1004 u32 operation_code
: 2;
1013 struct chsc_header response
;
1022 secm_area
->request
.length
= 0x0050;
1023 secm_area
->request
.code
= 0x0016;
1025 secm_area
->key
= PAGE_DEFAULT_KEY
;
1026 secm_area
->cub_addr1
= (u64
)(unsigned long)css
->cub_addr1
;
1027 secm_area
->cub_addr2
= (u64
)(unsigned long)css
->cub_addr2
;
1029 secm_area
->operation_code
= enable
? 0 : 1;
1031 ccode
= chsc(secm_area
);
1033 return (ccode
== 3) ? -ENODEV
: -EBUSY
;
1035 switch (secm_area
->response
.code
) {
1036 case 0x0001: /* Success. */
1039 case 0x0003: /* Invalid block. */
1040 case 0x0007: /* Invalid format. */
1041 case 0x0008: /* Other invalid block. */
1042 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1045 case 0x0004: /* Command not provided in model. */
1046 CIO_CRW_EVENT(2, "Model does not provide secm\n");
1049 case 0x0102: /* cub adresses incorrect */
1050 CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n");
1053 case 0x0103: /* key error */
1054 CIO_CRW_EVENT(2, "Access key error in secm\n");
1057 case 0x0105: /* error while starting */
1058 CIO_CRW_EVENT(2, "Error while starting channel measurement\n");
1062 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1063 secm_area
->response
.code
);
1070 chsc_secm(struct channel_subsystem
*css
, int enable
)
1075 secm_area
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1079 mutex_lock(&css
->mutex
);
1080 if (enable
&& !css
->cm_enabled
) {
1081 css
->cub_addr1
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1082 css
->cub_addr2
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1083 if (!css
->cub_addr1
|| !css
->cub_addr2
) {
1084 free_page((unsigned long)css
->cub_addr1
);
1085 free_page((unsigned long)css
->cub_addr2
);
1086 free_page((unsigned long)secm_area
);
1087 mutex_unlock(&css
->mutex
);
1091 ret
= __chsc_do_secm(css
, enable
, secm_area
);
1093 css
->cm_enabled
= enable
;
1094 if (css
->cm_enabled
) {
1095 ret
= chsc_add_cmg_attr(css
);
1097 memset(secm_area
, 0, PAGE_SIZE
);
1098 __chsc_do_secm(css
, 0, secm_area
);
1099 css
->cm_enabled
= 0;
1102 chsc_remove_cmg_attr(css
);
1104 if (enable
&& !css
->cm_enabled
) {
1105 free_page((unsigned long)css
->cub_addr1
);
1106 free_page((unsigned long)css
->cub_addr2
);
1108 mutex_unlock(&css
->mutex
);
1109 free_page((unsigned long)secm_area
);
1114 * Files for the channel path entries.
1117 chp_status_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1119 struct channel_path
*chp
= container_of(dev
, struct channel_path
, dev
);
1123 return (get_chp_status(chp
->id
) ? sprintf(buf
, "online\n") :
1124 sprintf(buf
, "offline\n"));
1128 chp_status_write(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1130 struct channel_path
*cp
= container_of(dev
, struct channel_path
, dev
);
1135 num_args
= sscanf(buf
, "%5s", cmd
);
1139 if (!strnicmp(cmd
, "on", 2))
1140 error
= s390_vary_chpid(cp
->id
, 1);
1141 else if (!strnicmp(cmd
, "off", 3))
1142 error
= s390_vary_chpid(cp
->id
, 0);
1146 return error
< 0 ? error
: count
;
1150 static DEVICE_ATTR(status
, 0644, chp_status_show
, chp_status_write
);
1153 chp_type_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1155 struct channel_path
*chp
= container_of(dev
, struct channel_path
, dev
);
1159 return sprintf(buf
, "%x\n", chp
->desc
.desc
);
1162 static DEVICE_ATTR(type
, 0444, chp_type_show
, NULL
);
1165 chp_cmg_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1167 struct channel_path
*chp
= to_channelpath(dev
);
1171 if (chp
->cmg
== -1) /* channel measurements not available */
1172 return sprintf(buf
, "unknown\n");
1173 return sprintf(buf
, "%x\n", chp
->cmg
);
1176 static DEVICE_ATTR(cmg
, 0444, chp_cmg_show
, NULL
);
1179 chp_shared_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1181 struct channel_path
*chp
= to_channelpath(dev
);
1185 if (chp
->shared
== -1) /* channel measurements not available */
1186 return sprintf(buf
, "unknown\n");
1187 return sprintf(buf
, "%x\n", chp
->shared
);
1190 static DEVICE_ATTR(shared
, 0444, chp_shared_show
, NULL
);
1192 static struct attribute
* chp_attrs
[] = {
1193 &dev_attr_status
.attr
,
1194 &dev_attr_type
.attr
,
1196 &dev_attr_shared
.attr
,
1200 static struct attribute_group chp_attr_group
= {
1205 chp_release(struct device
*dev
)
1207 struct channel_path
*cp
;
1209 cp
= container_of(dev
, struct channel_path
, dev
);
1214 chsc_determine_channel_path_description(int chpid
,
1215 struct channel_path_desc
*desc
)
1220 struct chsc_header request
;
1222 u32 first_chpid
: 8;
1226 struct chsc_header response
;
1228 struct channel_path_desc desc
;
1231 scpd_area
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1235 scpd_area
->request
.length
= 0x0010;
1236 scpd_area
->request
.code
= 0x0002;
1238 scpd_area
->first_chpid
= chpid
;
1239 scpd_area
->last_chpid
= chpid
;
1241 ccode
= chsc(scpd_area
);
1243 ret
= (ccode
== 3) ? -ENODEV
: -EBUSY
;
1247 switch (scpd_area
->response
.code
) {
1248 case 0x0001: /* Success. */
1249 memcpy(desc
, &scpd_area
->desc
,
1250 sizeof(struct channel_path_desc
));
1253 case 0x0003: /* Invalid block. */
1254 case 0x0007: /* Invalid format. */
1255 case 0x0008: /* Other invalid block. */
1256 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1259 case 0x0004: /* Command not provided in model. */
1260 CIO_CRW_EVENT(2, "Model does not provide scpd\n");
1264 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1265 scpd_area
->response
.code
);
1269 free_page((unsigned long)scpd_area
);
1274 chsc_initialize_cmg_chars(struct channel_path
*chp
, u8 cmcv
,
1275 struct cmg_chars
*chars
)
1280 chp
->cmg_chars
= kmalloc(sizeof(struct cmg_chars
),
1282 if (chp
->cmg_chars
) {
1284 struct cmg_chars
*cmg_chars
;
1286 cmg_chars
= chp
->cmg_chars
;
1287 for (i
= 0; i
< NR_MEASUREMENT_CHARS
; i
++) {
1288 mask
= 0x80 >> (i
+ 3);
1290 cmg_chars
->values
[i
] = chars
->values
[i
];
1292 cmg_chars
->values
[i
] = 0;
1297 /* No cmg-dependent data. */
1303 chsc_get_channel_measurement_chars(struct channel_path
*chp
)
1308 struct chsc_header request
;
1310 u32 first_chpid
: 8;
1314 struct chsc_header response
;
1325 u32 data
[NR_MEASUREMENT_CHARS
];
1328 scmc_area
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1332 scmc_area
->request
.length
= 0x0010;
1333 scmc_area
->request
.code
= 0x0022;
1335 scmc_area
->first_chpid
= chp
->id
;
1336 scmc_area
->last_chpid
= chp
->id
;
1338 ccode
= chsc(scmc_area
);
1340 ret
= (ccode
== 3) ? -ENODEV
: -EBUSY
;
1344 switch (scmc_area
->response
.code
) {
1345 case 0x0001: /* Success. */
1346 if (!scmc_area
->not_valid
) {
1347 chp
->cmg
= scmc_area
->cmg
;
1348 chp
->shared
= scmc_area
->shared
;
1349 chsc_initialize_cmg_chars(chp
, scmc_area
->cmcv
,
1350 (struct cmg_chars
*)
1358 case 0x0003: /* Invalid block. */
1359 case 0x0007: /* Invalid format. */
1360 case 0x0008: /* Invalid bit combination. */
1361 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1364 case 0x0004: /* Command not provided. */
1365 CIO_CRW_EVENT(2, "Model does not provide scmc\n");
1369 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1370 scmc_area
->response
.code
);
1374 free_page((unsigned long)scmc_area
);
1379 * Entries for chpids on the system bus.
1380 * This replaces /proc/chpids.
1383 new_channel_path(int chpid
)
1385 struct channel_path
*chp
;
1388 chp
= kzalloc(sizeof(struct channel_path
), GFP_KERNEL
);
1392 /* fill in status, etc. */
1395 chp
->dev
.parent
= &css
[0]->device
;
1396 chp
->dev
.release
= chp_release
;
1397 snprintf(chp
->dev
.bus_id
, BUS_ID_SIZE
, "chp0.%x", chpid
);
1399 /* Obtain channel path description and fill it in. */
1400 ret
= chsc_determine_channel_path_description(chpid
, &chp
->desc
);
1403 /* Get channel-measurement characteristics. */
1404 if (css_characteristics_avail
&& css_chsc_characteristics
.scmc
1405 && css_chsc_characteristics
.secm
) {
1406 ret
= chsc_get_channel_measurement_chars(chp
);
1410 static int msg_done
;
1413 printk(KERN_WARNING
"cio: Channel measurements not "
1414 "available, continuing.\n");
1420 /* make it known to the system */
1421 ret
= device_register(&chp
->dev
);
1423 printk(KERN_WARNING
"%s: could not register %02x\n",
1427 ret
= sysfs_create_group(&chp
->dev
.kobj
, &chp_attr_group
);
1429 device_unregister(&chp
->dev
);
1432 mutex_lock(&css
[0]->mutex
);
1433 if (css
[0]->cm_enabled
) {
1434 ret
= chsc_add_chp_cmg_attr(chp
);
1436 sysfs_remove_group(&chp
->dev
.kobj
, &chp_attr_group
);
1437 device_unregister(&chp
->dev
);
1438 mutex_unlock(&css
[0]->mutex
);
1442 css
[0]->chps
[chpid
] = chp
;
1443 mutex_unlock(&css
[0]->mutex
);
1451 chsc_get_chp_desc(struct subchannel
*sch
, int chp_no
)
1453 struct channel_path
*chp
;
1454 struct channel_path_desc
*desc
;
1456 chp
= css
[0]->chps
[sch
->schib
.pmcw
.chpid
[chp_no
]];
1459 desc
= kmalloc(sizeof(struct channel_path_desc
), GFP_KERNEL
);
1462 memcpy(desc
, &chp
->desc
, sizeof(struct channel_path_desc
));
1466 static int reset_channel_path(struct channel_path
*chp
)
1481 static void reset_channel_paths_css(struct channel_subsystem
*css
)
1485 for (i
= 0; i
<= __MAX_CHPID
; i
++) {
1487 reset_channel_path(css
->chps
[i
]);
1491 void cio_reset_channel_paths(void)
1495 for (i
= 0; i
<= __MAX_CSSID
; i
++) {
1496 if (css
[i
] && css
[i
]->valid
)
1497 reset_channel_paths_css(css
[i
]);
1502 chsc_alloc_sei_area(void)
1504 sei_page
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1506 printk(KERN_WARNING
"Can't allocate page for processing of " \
1507 "chsc machine checks!\n");
1508 return (sei_page
? 0 : -ENOMEM
);
1512 chsc_enable_facility(int operation_code
)
1516 struct chsc_header request
;
1523 u32 operation_data_area
[252];
1524 struct chsc_header response
;
1530 sda_area
= (void *)get_zeroed_page(GFP_KERNEL
|GFP_DMA
);
1533 sda_area
->request
.length
= 0x0400;
1534 sda_area
->request
.code
= 0x0031;
1535 sda_area
->operation_code
= operation_code
;
1537 ret
= chsc(sda_area
);
1539 ret
= (ret
== 3) ? -ENODEV
: -EBUSY
;
1542 switch (sda_area
->response
.code
) {
1543 case 0x0001: /* everything ok */
1546 case 0x0003: /* invalid request block */
1550 case 0x0004: /* command not provided */
1551 case 0x0101: /* facility not provided */
1554 default: /* something went wrong */
1558 free_page((unsigned long)sda_area
);
1562 subsys_initcall(chsc_alloc_sei_area
);
1564 struct css_general_char css_general_characteristics
;
1565 struct css_chsc_char css_chsc_characteristics
;
1568 chsc_determine_css_characteristics(void)
1572 struct chsc_header request
;
1576 struct chsc_header response
;
1578 u32 general_char
[510];
1582 scsc_area
= (void *)get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
1584 printk(KERN_WARNING
"cio: Was not able to determine available" \
1585 "CHSCs due to no memory.\n");
1589 scsc_area
->request
.length
= 0x0010;
1590 scsc_area
->request
.code
= 0x0010;
1592 result
= chsc(scsc_area
);
1594 printk(KERN_WARNING
"cio: Was not able to determine " \
1595 "available CHSCs, cc=%i.\n", result
);
1600 if (scsc_area
->response
.code
!= 1) {
1601 printk(KERN_WARNING
"cio: Was not able to determine " \
1602 "available CHSCs.\n");
1606 memcpy(&css_general_characteristics
, scsc_area
->general_char
,
1607 sizeof(css_general_characteristics
));
1608 memcpy(&css_chsc_characteristics
, scsc_area
->chsc_char
,
1609 sizeof(css_chsc_characteristics
));
1611 free_page ((unsigned long) scsc_area
);
1615 EXPORT_SYMBOL_GPL(css_general_characteristics
);
1616 EXPORT_SYMBOL_GPL(css_chsc_characteristics
);