2 * Channel subsystem base support.
4 * Copyright 2012 IBM Corp.
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
7 * This work is licensed under the terms of the GNU GPL, version 2 or (at
8 * your option) any later version. See the COPYING file in the top-level
12 #include "qemu/osdep.h"
13 #include "qapi/error.h"
14 #include "qapi/visitor.h"
16 #include "qemu/bitops.h"
17 #include "qemu/error-report.h"
18 #include "exec/address-spaces.h"
20 #include "hw/s390x/ioinst.h"
21 #include "hw/s390x/css.h"
23 #include "hw/s390x/s390_flic.h"
24 #include "hw/s390x/s390-virtio-ccw.h"
26 typedef struct CrwContainer
{
28 QTAILQ_ENTRY(CrwContainer
) sibling
;
31 static const VMStateDescription vmstate_crw
= {
34 .minimum_version_id
= 1,
35 .fields
= (VMStateField
[]) {
36 VMSTATE_UINT16(flags
, CRW
),
37 VMSTATE_UINT16(rsid
, CRW
),
42 static const VMStateDescription vmstate_crw_container
= {
43 .name
= "s390_crw_container",
45 .minimum_version_id
= 1,
46 .fields
= (VMStateField
[]) {
47 VMSTATE_STRUCT(crw
, CrwContainer
, 0, vmstate_crw
, CRW
),
52 typedef struct ChpInfo
{
58 static const VMStateDescription vmstate_chp_info
= {
59 .name
= "s390_chp_info",
61 .minimum_version_id
= 1,
62 .fields
= (VMStateField
[]) {
63 VMSTATE_UINT8(in_use
, ChpInfo
),
64 VMSTATE_UINT8(type
, ChpInfo
),
65 VMSTATE_UINT8(is_virtual
, ChpInfo
),
70 typedef struct SubchSet
{
71 SubchDev
*sch
[MAX_SCHID
+ 1];
72 unsigned long schids_used
[BITS_TO_LONGS(MAX_SCHID
+ 1)];
73 unsigned long devnos_used
[BITS_TO_LONGS(MAX_SCHID
+ 1)];
76 static const VMStateDescription vmstate_scsw
= {
79 .minimum_version_id
= 1,
80 .fields
= (VMStateField
[]) {
81 VMSTATE_UINT16(flags
, SCSW
),
82 VMSTATE_UINT16(ctrl
, SCSW
),
83 VMSTATE_UINT32(cpa
, SCSW
),
84 VMSTATE_UINT8(dstat
, SCSW
),
85 VMSTATE_UINT8(cstat
, SCSW
),
86 VMSTATE_UINT16(count
, SCSW
),
91 static const VMStateDescription vmstate_pmcw
= {
94 .minimum_version_id
= 1,
95 .fields
= (VMStateField
[]) {
96 VMSTATE_UINT32(intparm
, PMCW
),
97 VMSTATE_UINT16(flags
, PMCW
),
98 VMSTATE_UINT16(devno
, PMCW
),
99 VMSTATE_UINT8(lpm
, PMCW
),
100 VMSTATE_UINT8(pnom
, PMCW
),
101 VMSTATE_UINT8(lpum
, PMCW
),
102 VMSTATE_UINT8(pim
, PMCW
),
103 VMSTATE_UINT16(mbi
, PMCW
),
104 VMSTATE_UINT8(pom
, PMCW
),
105 VMSTATE_UINT8(pam
, PMCW
),
106 VMSTATE_UINT8_ARRAY(chpid
, PMCW
, 8),
107 VMSTATE_UINT32(chars
, PMCW
),
108 VMSTATE_END_OF_LIST()
112 static const VMStateDescription vmstate_schib
= {
113 .name
= "s390_schib",
115 .minimum_version_id
= 1,
116 .fields
= (VMStateField
[]) {
117 VMSTATE_STRUCT(pmcw
, SCHIB
, 0, vmstate_pmcw
, PMCW
),
118 VMSTATE_STRUCT(scsw
, SCHIB
, 0, vmstate_scsw
, SCSW
),
119 VMSTATE_UINT64(mba
, SCHIB
),
120 VMSTATE_UINT8_ARRAY(mda
, SCHIB
, 4),
121 VMSTATE_END_OF_LIST()
126 static const VMStateDescription vmstate_ccw1
= {
129 .minimum_version_id
= 1,
130 .fields
= (VMStateField
[]) {
131 VMSTATE_UINT8(cmd_code
, CCW1
),
132 VMSTATE_UINT8(flags
, CCW1
),
133 VMSTATE_UINT16(count
, CCW1
),
134 VMSTATE_UINT32(cda
, CCW1
),
135 VMSTATE_END_OF_LIST()
139 static const VMStateDescription vmstate_ciw
= {
142 .minimum_version_id
= 1,
143 .fields
= (VMStateField
[]) {
144 VMSTATE_UINT8(type
, CIW
),
145 VMSTATE_UINT8(command
, CIW
),
146 VMSTATE_UINT16(count
, CIW
),
147 VMSTATE_END_OF_LIST()
151 static const VMStateDescription vmstate_sense_id
= {
152 .name
= "s390_sense_id",
154 .minimum_version_id
= 1,
155 .fields
= (VMStateField
[]) {
156 VMSTATE_UINT8(reserved
, SenseId
),
157 VMSTATE_UINT16(cu_type
, SenseId
),
158 VMSTATE_UINT8(cu_model
, SenseId
),
159 VMSTATE_UINT16(dev_type
, SenseId
),
160 VMSTATE_UINT8(dev_model
, SenseId
),
161 VMSTATE_UINT8(unused
, SenseId
),
162 VMSTATE_STRUCT_ARRAY(ciw
, SenseId
, MAX_CIWS
, 0, vmstate_ciw
, CIW
),
163 VMSTATE_END_OF_LIST()
167 static const VMStateDescription vmstate_orb
= {
170 .minimum_version_id
= 1,
171 .fields
= (VMStateField
[]) {
172 VMSTATE_UINT32(intparm
, ORB
),
173 VMSTATE_UINT16(ctrl0
, ORB
),
174 VMSTATE_UINT8(lpm
, ORB
),
175 VMSTATE_UINT8(ctrl1
, ORB
),
176 VMSTATE_UINT32(cpa
, ORB
),
177 VMSTATE_END_OF_LIST()
181 static bool vmstate_schdev_orb_needed(void *opaque
)
183 return css_migration_enabled();
186 static const VMStateDescription vmstate_schdev_orb
= {
187 .name
= "s390_subch_dev/orb",
189 .minimum_version_id
= 1,
190 .needed
= vmstate_schdev_orb_needed
,
191 .fields
= (VMStateField
[]) {
192 VMSTATE_STRUCT(orb
, SubchDev
, 1, vmstate_orb
, ORB
),
193 VMSTATE_END_OF_LIST()
197 static int subch_dev_post_load(void *opaque
, int version_id
);
198 static int subch_dev_pre_save(void *opaque
);
200 const char err_hint_devno
[] = "Devno mismatch, tried to load wrong section!"
201 " Likely reason: some sequences of plug and unplug can break"
202 " migration for machine versions prior to 2.7 (known design flaw).";
204 const VMStateDescription vmstate_subch_dev
= {
205 .name
= "s390_subch_dev",
207 .minimum_version_id
= 1,
208 .post_load
= subch_dev_post_load
,
209 .pre_save
= subch_dev_pre_save
,
210 .fields
= (VMStateField
[]) {
211 VMSTATE_UINT8_EQUAL(cssid
, SubchDev
, "Bug!"),
212 VMSTATE_UINT8_EQUAL(ssid
, SubchDev
, "Bug!"),
213 VMSTATE_UINT16(migrated_schid
, SubchDev
),
214 VMSTATE_UINT16_EQUAL(devno
, SubchDev
, err_hint_devno
),
215 VMSTATE_BOOL(thinint_active
, SubchDev
),
216 VMSTATE_STRUCT(curr_status
, SubchDev
, 0, vmstate_schib
, SCHIB
),
217 VMSTATE_UINT8_ARRAY(sense_data
, SubchDev
, 32),
218 VMSTATE_UINT64(channel_prog
, SubchDev
),
219 VMSTATE_STRUCT(last_cmd
, SubchDev
, 0, vmstate_ccw1
, CCW1
),
220 VMSTATE_BOOL(last_cmd_valid
, SubchDev
),
221 VMSTATE_STRUCT(id
, SubchDev
, 0, vmstate_sense_id
, SenseId
),
222 VMSTATE_BOOL(ccw_fmt_1
, SubchDev
),
223 VMSTATE_UINT8(ccw_no_data_cnt
, SubchDev
),
224 VMSTATE_END_OF_LIST()
226 .subsections
= (const VMStateDescription
* []) {
232 typedef struct IndAddrPtrTmp
{
238 static int post_load_ind_addr(void *opaque
, int version_id
)
240 IndAddrPtrTmp
*ptmp
= opaque
;
241 IndAddr
**ind_addr
= ptmp
->parent
;
243 if (ptmp
->len
!= 0) {
244 *ind_addr
= get_indicator(ptmp
->addr
, ptmp
->len
);
251 static int pre_save_ind_addr(void *opaque
)
253 IndAddrPtrTmp
*ptmp
= opaque
;
254 IndAddr
*ind_addr
= *(ptmp
->parent
);
256 if (ind_addr
!= NULL
) {
257 ptmp
->len
= ind_addr
->len
;
258 ptmp
->addr
= ind_addr
->addr
;
267 const VMStateDescription vmstate_ind_addr_tmp
= {
268 .name
= "s390_ind_addr_tmp",
269 .pre_save
= pre_save_ind_addr
,
270 .post_load
= post_load_ind_addr
,
272 .fields
= (VMStateField
[]) {
273 VMSTATE_INT32(len
, IndAddrPtrTmp
),
274 VMSTATE_UINT64(addr
, IndAddrPtrTmp
),
275 VMSTATE_END_OF_LIST()
279 const VMStateDescription vmstate_ind_addr
= {
280 .name
= "s390_ind_addr_tmp",
281 .fields
= (VMStateField
[]) {
282 VMSTATE_WITH_TMP(IndAddr
*, IndAddrPtrTmp
, vmstate_ind_addr_tmp
),
283 VMSTATE_END_OF_LIST()
287 typedef struct CssImage
{
288 SubchSet
*sch_set
[MAX_SSID
+ 1];
289 ChpInfo chpids
[MAX_CHPID
+ 1];
292 static const VMStateDescription vmstate_css_img
= {
293 .name
= "s390_css_img",
295 .minimum_version_id
= 1,
296 .fields
= (VMStateField
[]) {
297 /* Subchannel sets have no relevant state. */
298 VMSTATE_STRUCT_ARRAY(chpids
, CssImage
, MAX_CHPID
+ 1, 0,
299 vmstate_chp_info
, ChpInfo
),
300 VMSTATE_END_OF_LIST()
305 typedef struct IoAdapter
{
312 typedef struct ChannelSubSys
{
313 QTAILQ_HEAD(, CrwContainer
) pending_crws
;
320 uint64_t chnmon_area
;
321 CssImage
*css
[MAX_CSSID
+ 1];
322 uint8_t default_cssid
;
323 /* don't migrate, see css_register_io_adapters */
324 IoAdapter
*io_adapters
[CSS_IO_ADAPTER_TYPE_NUMS
][MAX_ISC
+ 1];
325 /* don't migrate, see get_indicator and IndAddrPtrTmp */
326 QTAILQ_HEAD(, IndAddr
) indicator_addresses
;
329 static const VMStateDescription vmstate_css
= {
332 .minimum_version_id
= 1,
333 .fields
= (VMStateField
[]) {
334 VMSTATE_QTAILQ_V(pending_crws
, ChannelSubSys
, 1, vmstate_crw_container
,
335 CrwContainer
, sibling
),
336 VMSTATE_BOOL(sei_pending
, ChannelSubSys
),
337 VMSTATE_BOOL(do_crw_mchk
, ChannelSubSys
),
338 VMSTATE_BOOL(crws_lost
, ChannelSubSys
),
339 /* These were kind of migrated by virtio */
340 VMSTATE_UINT8(max_cssid
, ChannelSubSys
),
341 VMSTATE_UINT8(max_ssid
, ChannelSubSys
),
342 VMSTATE_BOOL(chnmon_active
, ChannelSubSys
),
343 VMSTATE_UINT64(chnmon_area
, ChannelSubSys
),
344 VMSTATE_ARRAY_OF_POINTER_TO_STRUCT(css
, ChannelSubSys
, MAX_CSSID
+ 1,
345 0, vmstate_css_img
, CssImage
),
346 VMSTATE_UINT8(default_cssid
, ChannelSubSys
),
347 VMSTATE_END_OF_LIST()
351 static ChannelSubSys channel_subsys
= {
352 .pending_crws
= QTAILQ_HEAD_INITIALIZER(channel_subsys
.pending_crws
),
354 .sei_pending
= false,
357 .chnmon_active
= false,
358 .indicator_addresses
=
359 QTAILQ_HEAD_INITIALIZER(channel_subsys
.indicator_addresses
),
362 static int subch_dev_pre_save(void *opaque
)
364 SubchDev
*s
= opaque
;
366 /* Prepare remote_schid for save */
367 s
->migrated_schid
= s
->schid
;
372 static int subch_dev_post_load(void *opaque
, int version_id
)
375 SubchDev
*s
= opaque
;
377 /* Re-assign the subchannel to remote_schid if necessary */
378 if (s
->migrated_schid
!= s
->schid
) {
379 if (css_find_subch(true, s
->cssid
, s
->ssid
, s
->schid
) == s
) {
381 * Cleanup the slot before moving to s->migrated_schid provided
382 * it still belongs to us, i.e. it was not changed by previous
383 * invocation of this function.
385 css_subch_assign(s
->cssid
, s
->ssid
, s
->schid
, s
->devno
, NULL
);
387 /* It's OK to re-assign without a prior de-assign. */
388 s
->schid
= s
->migrated_schid
;
389 css_subch_assign(s
->cssid
, s
->ssid
, s
->schid
, s
->devno
, s
);
392 if (css_migration_enabled()) {
393 /* No compat voodoo to do ;) */
397 * Hack alert. If we don't migrate the channel subsystem status
398 * we still need to find out if the guest enabled mss/mcss-e.
399 * If the subchannel is enabled, it certainly was able to access it,
400 * so adjust the max_ssid/max_cssid values for relevant ssid/cssid
401 * values. This is not watertight, but better than nothing.
403 if (s
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
) {
405 channel_subsys
.max_ssid
= MAX_SSID
;
407 if (s
->cssid
!= channel_subsys
.default_cssid
) {
408 channel_subsys
.max_cssid
= MAX_CSSID
;
414 void css_register_vmstate(void)
416 vmstate_register(NULL
, 0, &vmstate_css
, &channel_subsys
);
419 IndAddr
*get_indicator(hwaddr ind_addr
, int len
)
423 QTAILQ_FOREACH(indicator
, &channel_subsys
.indicator_addresses
, sibling
) {
424 if (indicator
->addr
== ind_addr
) {
429 indicator
= g_new0(IndAddr
, 1);
430 indicator
->addr
= ind_addr
;
431 indicator
->len
= len
;
432 indicator
->refcnt
= 1;
433 QTAILQ_INSERT_TAIL(&channel_subsys
.indicator_addresses
,
438 static int s390_io_adapter_map(AdapterInfo
*adapter
, uint64_t map_addr
,
441 S390FLICState
*fs
= s390_get_flic();
442 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
444 return fsc
->io_adapter_map(fs
, adapter
->adapter_id
, map_addr
, do_map
);
447 void release_indicator(AdapterInfo
*adapter
, IndAddr
*indicator
)
449 assert(indicator
->refcnt
> 0);
451 if (indicator
->refcnt
> 0) {
454 QTAILQ_REMOVE(&channel_subsys
.indicator_addresses
, indicator
, sibling
);
455 if (indicator
->map
) {
456 s390_io_adapter_map(adapter
, indicator
->map
, false);
461 int map_indicator(AdapterInfo
*adapter
, IndAddr
*indicator
)
465 if (indicator
->map
) {
466 return 0; /* already mapped is not an error */
468 indicator
->map
= indicator
->addr
;
469 ret
= s390_io_adapter_map(adapter
, indicator
->map
, true);
470 if ((ret
!= 0) && (ret
!= -ENOSYS
)) {
480 int css_create_css_image(uint8_t cssid
, bool default_image
)
482 trace_css_new_image(cssid
, default_image
? "(default)" : "");
483 /* 255 is reserved */
487 if (channel_subsys
.css
[cssid
]) {
490 channel_subsys
.css
[cssid
] = g_new0(CssImage
, 1);
492 channel_subsys
.default_cssid
= cssid
;
497 uint32_t css_get_adapter_id(CssIoAdapterType type
, uint8_t isc
)
499 if (type
>= CSS_IO_ADAPTER_TYPE_NUMS
|| isc
> MAX_ISC
||
500 !channel_subsys
.io_adapters
[type
][isc
]) {
504 return channel_subsys
.io_adapters
[type
][isc
]->id
;
508 * css_register_io_adapters: Register I/O adapters per ISC during init
510 * @swap: an indication if byte swap is needed.
511 * @maskable: an indication if the adapter is subject to the mask operation.
512 * @flags: further characteristics of the adapter.
513 * e.g. suppressible, an indication if the adapter is subject to AIS.
514 * @errp: location to store error information.
516 void css_register_io_adapters(CssIoAdapterType type
, bool swap
, bool maskable
,
517 uint8_t flags
, Error
**errp
)
522 S390FLICState
*fs
= s390_get_flic();
523 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
526 * Disallow multiple registrations for the same device type.
527 * Report an error if registering for an already registered type.
529 if (channel_subsys
.io_adapters
[type
][0]) {
530 error_setg(errp
, "Adapters for type %d already registered", type
);
533 for (isc
= 0; isc
<= MAX_ISC
; isc
++) {
534 id
= (type
<< 3) | isc
;
535 ret
= fsc
->register_io_adapter(fs
, id
, isc
, swap
, maskable
, flags
);
537 adapter
= g_new0(IoAdapter
, 1);
540 adapter
->type
= type
;
541 adapter
->flags
= flags
;
542 channel_subsys
.io_adapters
[type
][isc
] = adapter
;
544 error_setg_errno(errp
, -ret
, "Unexpected error %d when "
545 "registering adapter %d", ret
, id
);
551 * No need to free registered adapters in kvm: kvm will clean up
552 * when the machine goes away.
555 for (isc
--; isc
>= 0; isc
--) {
556 g_free(channel_subsys
.io_adapters
[type
][isc
]);
557 channel_subsys
.io_adapters
[type
][isc
] = NULL
;
563 static void css_clear_io_interrupt(uint16_t subchannel_id
,
564 uint16_t subchannel_nr
)
567 static bool no_clear_irq
;
568 S390FLICState
*fs
= s390_get_flic();
569 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
572 if (unlikely(no_clear_irq
)) {
575 r
= fsc
->clear_io_irq(fs
, subchannel_id
, subchannel_nr
);
582 * Ignore unavailability, as the user can't do anything
587 error_setg_errno(&err
, -r
, "unexpected error condition");
588 error_propagate(&error_abort
, err
);
592 static inline uint16_t css_do_build_subchannel_id(uint8_t cssid
, uint8_t ssid
)
594 if (channel_subsys
.max_cssid
> 0) {
595 return (cssid
<< 8) | (1 << 3) | (ssid
<< 1) | 1;
597 return (ssid
<< 1) | 1;
600 uint16_t css_build_subchannel_id(SubchDev
*sch
)
602 return css_do_build_subchannel_id(sch
->cssid
, sch
->ssid
);
605 void css_inject_io_interrupt(SubchDev
*sch
)
607 uint8_t isc
= (sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ISC
) >> 11;
609 trace_css_io_interrupt(sch
->cssid
, sch
->ssid
, sch
->schid
,
610 sch
->curr_status
.pmcw
.intparm
, isc
, "");
611 s390_io_interrupt(css_build_subchannel_id(sch
),
613 sch
->curr_status
.pmcw
.intparm
,
617 void css_conditional_io_interrupt(SubchDev
*sch
)
620 * If the subchannel is not enabled, it is not made status pending
621 * (see PoP p. 16-17, "Status Control").
623 if (!(sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
)) {
628 * If the subchannel is not currently status pending, make it pending
631 if (!(sch
->curr_status
.scsw
.ctrl
& SCSW_STCTL_STATUS_PEND
)) {
632 uint8_t isc
= (sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ISC
) >> 11;
634 trace_css_io_interrupt(sch
->cssid
, sch
->ssid
, sch
->schid
,
635 sch
->curr_status
.pmcw
.intparm
, isc
,
637 sch
->curr_status
.scsw
.ctrl
&= ~SCSW_CTRL_MASK_STCTL
;
638 sch
->curr_status
.scsw
.ctrl
|=
639 SCSW_STCTL_ALERT
| SCSW_STCTL_STATUS_PEND
;
640 /* Inject an I/O interrupt. */
641 s390_io_interrupt(css_build_subchannel_id(sch
),
643 sch
->curr_status
.pmcw
.intparm
,
648 int css_do_sic(CPUS390XState
*env
, uint8_t isc
, uint16_t mode
)
650 S390FLICState
*fs
= s390_get_flic();
651 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
654 if (env
->psw
.mask
& PSW_MASK_PSTATE
) {
659 trace_css_do_sic(mode
, isc
);
661 case SIC_IRQ_MODE_ALL
:
662 case SIC_IRQ_MODE_SINGLE
:
669 r
= fsc
->modify_ais_mode(fs
, isc
, mode
) ? -PGM_OPERATION
: 0;
674 void css_adapter_interrupt(CssIoAdapterType type
, uint8_t isc
)
676 S390FLICState
*fs
= s390_get_flic();
677 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
678 uint32_t io_int_word
= (isc
<< 27) | IO_INT_WORD_AI
;
679 IoAdapter
*adapter
= channel_subsys
.io_adapters
[type
][isc
];
685 trace_css_adapter_interrupt(isc
);
686 if (fs
->ais_supported
) {
687 if (fsc
->inject_airq(fs
, type
, isc
, adapter
->flags
)) {
688 error_report("Failed to inject airq with AIS supported");
692 s390_io_interrupt(0, 0, 0, io_int_word
);
696 static void sch_handle_clear_func(SubchDev
*sch
)
698 PMCW
*p
= &sch
->curr_status
.pmcw
;
699 SCSW
*s
= &sch
->curr_status
.scsw
;
702 /* Path management: In our simple css, we always choose the only path. */
705 /* Reset values prior to 'issuing the clear signal'. */
708 s
->flags
&= ~SCSW_FLAGS_MASK_PNO
;
710 /* We always 'attempt to issue the clear signal', and we always succeed. */
711 sch
->channel_prog
= 0x0;
712 sch
->last_cmd_valid
= false;
713 s
->ctrl
&= ~SCSW_ACTL_CLEAR_PEND
;
714 s
->ctrl
|= SCSW_STCTL_STATUS_PEND
;
722 static void sch_handle_halt_func(SubchDev
*sch
)
725 PMCW
*p
= &sch
->curr_status
.pmcw
;
726 SCSW
*s
= &sch
->curr_status
.scsw
;
727 hwaddr curr_ccw
= sch
->channel_prog
;
730 /* Path management: In our simple css, we always choose the only path. */
733 /* We always 'attempt to issue the halt signal', and we always succeed. */
734 sch
->channel_prog
= 0x0;
735 sch
->last_cmd_valid
= false;
736 s
->ctrl
&= ~SCSW_ACTL_HALT_PEND
;
737 s
->ctrl
|= SCSW_STCTL_STATUS_PEND
;
739 if ((s
->ctrl
& (SCSW_ACTL_SUBCH_ACTIVE
| SCSW_ACTL_DEVICE_ACTIVE
)) ||
740 !((s
->ctrl
& SCSW_ACTL_START_PEND
) ||
741 (s
->ctrl
& SCSW_ACTL_SUSP
))) {
742 s
->dstat
= SCSW_DSTAT_DEVICE_END
;
744 if ((s
->ctrl
& (SCSW_ACTL_SUBCH_ACTIVE
| SCSW_ACTL_DEVICE_ACTIVE
)) ||
745 (s
->ctrl
& SCSW_ACTL_SUSP
)) {
746 s
->cpa
= curr_ccw
+ 8;
753 static void copy_sense_id_to_guest(SenseId
*dest
, SenseId
*src
)
757 dest
->reserved
= src
->reserved
;
758 dest
->cu_type
= cpu_to_be16(src
->cu_type
);
759 dest
->cu_model
= src
->cu_model
;
760 dest
->dev_type
= cpu_to_be16(src
->dev_type
);
761 dest
->dev_model
= src
->dev_model
;
762 dest
->unused
= src
->unused
;
763 for (i
= 0; i
< ARRAY_SIZE(dest
->ciw
); i
++) {
764 dest
->ciw
[i
].type
= src
->ciw
[i
].type
;
765 dest
->ciw
[i
].command
= src
->ciw
[i
].command
;
766 dest
->ciw
[i
].count
= cpu_to_be16(src
->ciw
[i
].count
);
770 static CCW1
copy_ccw_from_guest(hwaddr addr
, bool fmt1
)
777 cpu_physical_memory_read(addr
, &tmp1
, sizeof(tmp1
));
778 ret
.cmd_code
= tmp1
.cmd_code
;
779 ret
.flags
= tmp1
.flags
;
780 ret
.count
= be16_to_cpu(tmp1
.count
);
781 ret
.cda
= be32_to_cpu(tmp1
.cda
);
783 cpu_physical_memory_read(addr
, &tmp0
, sizeof(tmp0
));
784 if ((tmp0
.cmd_code
& 0x0f) == CCW_CMD_TIC
) {
785 ret
.cmd_code
= CCW_CMD_TIC
;
789 ret
.cmd_code
= tmp0
.cmd_code
;
790 ret
.flags
= tmp0
.flags
;
791 ret
.count
= be16_to_cpu(tmp0
.count
);
793 ret
.cda
= be16_to_cpu(tmp0
.cda1
) | (tmp0
.cda0
<< 16);
798 * If out of bounds marks the stream broken. If broken returns -EINVAL,
799 * otherwise the requested length (may be zero)
801 static inline int cds_check_len(CcwDataStream
*cds
, int len
)
803 if (cds
->at_byte
+ len
> cds
->count
) {
804 cds
->flags
|= CDS_F_STREAM_BROKEN
;
806 return cds
->flags
& CDS_F_STREAM_BROKEN
? -EINVAL
: len
;
809 static inline bool cds_ccw_addrs_ok(hwaddr addr
, int len
, bool ccw_fmt1
)
811 return (addr
+ len
) < (ccw_fmt1
? (1UL << 31) : (1UL << 24));
814 static int ccw_dstream_rw_noflags(CcwDataStream
*cds
, void *buff
, int len
,
819 ret
= cds_check_len(cds
, len
);
823 if (!cds_ccw_addrs_ok(cds
->cda
, len
, cds
->flags
& CDS_F_FMT
)) {
824 return -EINVAL
; /* channel program check */
826 if (op
== CDS_OP_A
) {
829 ret
= address_space_rw(&address_space_memory
, cds
->cda
,
830 MEMTXATTRS_UNSPECIFIED
, buff
, len
, op
);
831 if (ret
!= MEMTX_OK
) {
832 cds
->flags
|= CDS_F_STREAM_BROKEN
;
841 /* returns values between 1 and bsz, where bsz is a power of 2 */
842 static inline uint16_t ida_continuous_left(hwaddr cda
, uint64_t bsz
)
844 return bsz
- (cda
& (bsz
- 1));
847 static inline uint64_t ccw_ida_block_size(uint8_t flags
)
849 if ((flags
& CDS_F_C64
) && !(flags
& CDS_F_I2K
)) {
855 static inline int ida_read_next_idaw(CcwDataStream
*cds
)
857 union {uint64_t fmt2
; uint32_t fmt1
; } idaw
;
860 bool idaw_fmt2
= cds
->flags
& CDS_F_C64
;
861 bool ccw_fmt1
= cds
->flags
& CDS_F_FMT
;
864 idaw_addr
= cds
->cda_orig
+ sizeof(idaw
.fmt2
) * cds
->at_idaw
;
865 if (idaw_addr
& 0x07 || !cds_ccw_addrs_ok(idaw_addr
, 0, ccw_fmt1
)) {
866 return -EINVAL
; /* channel program check */
868 ret
= address_space_rw(&address_space_memory
, idaw_addr
,
869 MEMTXATTRS_UNSPECIFIED
, (void *) &idaw
.fmt2
,
870 sizeof(idaw
.fmt2
), false);
871 cds
->cda
= be64_to_cpu(idaw
.fmt2
);
873 idaw_addr
= cds
->cda_orig
+ sizeof(idaw
.fmt1
) * cds
->at_idaw
;
874 if (idaw_addr
& 0x03 || !cds_ccw_addrs_ok(idaw_addr
, 0, ccw_fmt1
)) {
875 return -EINVAL
; /* channel program check */
877 ret
= address_space_rw(&address_space_memory
, idaw_addr
,
878 MEMTXATTRS_UNSPECIFIED
, (void *) &idaw
.fmt1
,
879 sizeof(idaw
.fmt1
), false);
880 cds
->cda
= be64_to_cpu(idaw
.fmt1
);
881 if (cds
->cda
& 0x80000000) {
882 return -EINVAL
; /* channel program check */
886 if (ret
!= MEMTX_OK
) {
887 /* assume inaccessible address */
888 return -EINVAL
; /* channel program check */
893 static int ccw_dstream_rw_ida(CcwDataStream
*cds
, void *buff
, int len
,
896 uint64_t bsz
= ccw_ida_block_size(cds
->flags
);
898 uint16_t cont_left
, iter_len
;
900 ret
= cds_check_len(cds
, len
);
905 /* read first idaw */
906 ret
= ida_read_next_idaw(cds
);
910 cont_left
= ida_continuous_left(cds
->cda
, bsz
);
912 cont_left
= ida_continuous_left(cds
->cda
, bsz
);
913 if (cont_left
== bsz
) {
914 ret
= ida_read_next_idaw(cds
);
918 if (cds
->cda
& (bsz
- 1)) {
919 ret
= -EINVAL
; /* channel program check */
925 iter_len
= MIN(len
, cont_left
);
926 if (op
!= CDS_OP_A
) {
927 ret
= address_space_rw(&address_space_memory
, cds
->cda
,
928 MEMTXATTRS_UNSPECIFIED
, buff
, iter_len
, op
);
929 if (ret
!= MEMTX_OK
) {
930 /* assume inaccessible address */
931 ret
= -EINVAL
; /* channel program check */
935 cds
->at_byte
+= iter_len
;
936 cds
->cda
+= iter_len
;
941 ret
= ida_read_next_idaw(cds
);
949 cds
->flags
|= CDS_F_STREAM_BROKEN
;
953 void ccw_dstream_init(CcwDataStream
*cds
, CCW1
const *ccw
, ORB
const *orb
)
956 * We don't support MIDA (an optional facility) yet and we
957 * catch this earlier. Just for expressing the precondition.
959 g_assert(!(orb
->ctrl1
& ORB_CTRL1_MASK_MIDAW
));
960 cds
->flags
= (orb
->ctrl0
& ORB_CTRL0_MASK_I2K
? CDS_F_I2K
: 0) |
961 (orb
->ctrl0
& ORB_CTRL0_MASK_C64
? CDS_F_C64
: 0) |
962 (orb
->ctrl0
& ORB_CTRL0_MASK_FMT
? CDS_F_FMT
: 0) |
963 (ccw
->flags
& CCW_FLAG_IDA
? CDS_F_IDA
: 0);
965 cds
->count
= ccw
->count
;
966 cds
->cda_orig
= ccw
->cda
;
967 ccw_dstream_rewind(cds
);
968 if (!(cds
->flags
& CDS_F_IDA
)) {
969 cds
->op_handler
= ccw_dstream_rw_noflags
;
971 cds
->op_handler
= ccw_dstream_rw_ida
;
975 static int css_interpret_ccw(SubchDev
*sch
, hwaddr ccw_addr
,
976 bool suspend_allowed
)
984 return -EINVAL
; /* channel-program check */
986 /* Check doubleword aligned and 31 or 24 (fmt 0) bit addressable. */
987 if (ccw_addr
& (sch
->ccw_fmt_1
? 0x80000007 : 0xff000007)) {
991 /* Translate everything to format-1 ccws - the information is the same. */
992 ccw
= copy_ccw_from_guest(ccw_addr
, sch
->ccw_fmt_1
);
994 /* Check for invalid command codes. */
995 if ((ccw
.cmd_code
& 0x0f) == 0) {
998 if (((ccw
.cmd_code
& 0x0f) == CCW_CMD_TIC
) &&
999 ((ccw
.cmd_code
& 0xf0) != 0)) {
1002 if (!sch
->ccw_fmt_1
&& (ccw
.count
== 0) &&
1003 (ccw
.cmd_code
!= CCW_CMD_TIC
)) {
1007 /* We don't support MIDA. */
1008 if (ccw
.flags
& CCW_FLAG_MIDA
) {
1012 if (ccw
.flags
& CCW_FLAG_SUSPEND
) {
1013 return suspend_allowed
? -EINPROGRESS
: -EINVAL
;
1016 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
1019 if (sch
->ccw_no_data_cnt
== 255) {
1022 sch
->ccw_no_data_cnt
++;
1025 /* Look at the command. */
1026 ccw_dstream_init(&sch
->cds
, &ccw
, &(sch
->orb
));
1027 switch (ccw
.cmd_code
) {
1029 /* Nothing to do. */
1032 case CCW_CMD_BASIC_SENSE
:
1034 if (ccw
.count
!= sizeof(sch
->sense_data
)) {
1039 len
= MIN(ccw
.count
, sizeof(sch
->sense_data
));
1040 ccw_dstream_write_buf(&sch
->cds
, sch
->sense_data
, len
);
1041 sch
->curr_status
.scsw
.count
= ccw_dstream_residual_count(&sch
->cds
);
1042 memset(sch
->sense_data
, 0, sizeof(sch
->sense_data
));
1045 case CCW_CMD_SENSE_ID
:
1049 copy_sense_id_to_guest(&sense_id
, &sch
->id
);
1050 /* Sense ID information is device specific. */
1052 if (ccw
.count
!= sizeof(sense_id
)) {
1057 len
= MIN(ccw
.count
, sizeof(sense_id
));
1059 * Only indicate 0xff in the first sense byte if we actually
1060 * have enough place to store at least bytes 0-3.
1063 sense_id
.reserved
= 0xff;
1065 sense_id
.reserved
= 0;
1067 ccw_dstream_write_buf(&sch
->cds
, &sense_id
, len
);
1068 sch
->curr_status
.scsw
.count
= ccw_dstream_residual_count(&sch
->cds
);
1073 if (sch
->last_cmd_valid
&& (sch
->last_cmd
.cmd_code
== CCW_CMD_TIC
)) {
1077 if (ccw
.flags
|| ccw
.count
) {
1078 /* We have already sanitized these if converted from fmt 0. */
1082 sch
->channel_prog
= ccw
.cda
;
1087 /* Handle device specific commands. */
1088 ret
= sch
->ccw_cb(sch
, ccw
);
1094 sch
->last_cmd
= ccw
;
1095 sch
->last_cmd_valid
= true;
1097 if (ccw
.flags
& CCW_FLAG_CC
) {
1098 sch
->channel_prog
+= 8;
1106 static void sch_handle_start_func_virtual(SubchDev
*sch
)
1109 PMCW
*p
= &sch
->curr_status
.pmcw
;
1110 SCSW
*s
= &sch
->curr_status
.scsw
;
1113 bool suspend_allowed
;
1115 /* Path management: In our simple css, we always choose the only path. */
1118 if (!(s
->ctrl
& SCSW_ACTL_SUSP
)) {
1119 /* Start Function triggered via ssch, i.e. we have an ORB */
1120 ORB
*orb
= &sch
->orb
;
1123 /* Look at the orb and try to execute the channel program. */
1124 p
->intparm
= orb
->intparm
;
1125 if (!(orb
->lpm
& path
)) {
1126 /* Generate a deferred cc 3 condition. */
1127 s
->flags
|= SCSW_FLAGS_MASK_CC
;
1128 s
->ctrl
&= ~SCSW_CTRL_MASK_STCTL
;
1129 s
->ctrl
|= (SCSW_STCTL_ALERT
| SCSW_STCTL_STATUS_PEND
);
1132 sch
->ccw_fmt_1
= !!(orb
->ctrl0
& ORB_CTRL0_MASK_FMT
);
1133 s
->flags
|= (sch
->ccw_fmt_1
) ? SCSW_FLAGS_MASK_FMT
: 0;
1134 sch
->ccw_no_data_cnt
= 0;
1135 suspend_allowed
= !!(orb
->ctrl0
& ORB_CTRL0_MASK_SPND
);
1137 /* Start Function resumed via rsch */
1138 s
->ctrl
&= ~(SCSW_ACTL_SUSP
| SCSW_ACTL_RESUME_PEND
);
1139 /* The channel program had been suspended before. */
1140 suspend_allowed
= true;
1142 sch
->last_cmd_valid
= false;
1144 ret
= css_interpret_ccw(sch
, sch
->channel_prog
, suspend_allowed
);
1147 /* ccw chain, continue processing */
1151 s
->ctrl
&= ~SCSW_ACTL_START_PEND
;
1152 s
->ctrl
&= ~SCSW_CTRL_MASK_STCTL
;
1153 s
->ctrl
|= SCSW_STCTL_PRIMARY
| SCSW_STCTL_SECONDARY
|
1154 SCSW_STCTL_STATUS_PEND
;
1155 s
->dstat
= SCSW_DSTAT_CHANNEL_END
| SCSW_DSTAT_DEVICE_END
;
1156 s
->cpa
= sch
->channel_prog
+ 8;
1159 /* I/O errors, status depends on specific devices */
1162 /* unsupported command, generate unit check (command reject) */
1163 s
->ctrl
&= ~SCSW_ACTL_START_PEND
;
1164 s
->dstat
= SCSW_DSTAT_UNIT_CHECK
;
1165 /* Set sense bit 0 in ecw0. */
1166 sch
->sense_data
[0] = 0x80;
1167 s
->ctrl
&= ~SCSW_CTRL_MASK_STCTL
;
1168 s
->ctrl
|= SCSW_STCTL_PRIMARY
| SCSW_STCTL_SECONDARY
|
1169 SCSW_STCTL_ALERT
| SCSW_STCTL_STATUS_PEND
;
1170 s
->cpa
= sch
->channel_prog
+ 8;
1173 /* channel program has been suspended */
1174 s
->ctrl
&= ~SCSW_ACTL_START_PEND
;
1175 s
->ctrl
|= SCSW_ACTL_SUSP
;
1178 /* error, generate channel program check */
1179 s
->ctrl
&= ~SCSW_ACTL_START_PEND
;
1180 s
->cstat
= SCSW_CSTAT_PROG_CHECK
;
1181 s
->ctrl
&= ~SCSW_CTRL_MASK_STCTL
;
1182 s
->ctrl
|= SCSW_STCTL_PRIMARY
| SCSW_STCTL_SECONDARY
|
1183 SCSW_STCTL_ALERT
| SCSW_STCTL_STATUS_PEND
;
1184 s
->cpa
= sch
->channel_prog
+ 8;
1187 } while (ret
== -EAGAIN
);
1191 static IOInstEnding
sch_handle_start_func_passthrough(SubchDev
*sch
)
1194 PMCW
*p
= &sch
->curr_status
.pmcw
;
1195 SCSW
*s
= &sch
->curr_status
.scsw
;
1197 ORB
*orb
= &sch
->orb
;
1198 if (!(s
->ctrl
& SCSW_ACTL_SUSP
)) {
1199 assert(orb
!= NULL
);
1200 p
->intparm
= orb
->intparm
;
1204 * Only support prefetch enable mode.
1205 * Only support 64bit addressing idal.
1207 if (!(orb
->ctrl0
& ORB_CTRL0_MASK_C64
)) {
1208 warn_report("vfio-ccw requires PFCH and C64 flags set");
1209 sch_gen_unit_exception(sch
);
1210 css_inject_io_interrupt(sch
);
1211 return IOINST_CC_EXPECTED
;
1213 return s390_ccw_cmd_request(sch
);
1217 * On real machines, this would run asynchronously to the main vcpus.
1218 * We might want to make some parts of the ssch handling (interpreting
1219 * read/writes) asynchronous later on if we start supporting more than
1220 * our current very simple devices.
1222 IOInstEnding
do_subchannel_work_virtual(SubchDev
*sch
)
1225 SCSW
*s
= &sch
->curr_status
.scsw
;
1227 if (s
->ctrl
& SCSW_FCTL_CLEAR_FUNC
) {
1228 sch_handle_clear_func(sch
);
1229 } else if (s
->ctrl
& SCSW_FCTL_HALT_FUNC
) {
1230 sch_handle_halt_func(sch
);
1231 } else if (s
->ctrl
& SCSW_FCTL_START_FUNC
) {
1232 /* Triggered by both ssch and rsch. */
1233 sch_handle_start_func_virtual(sch
);
1235 css_inject_io_interrupt(sch
);
1236 /* inst must succeed if this func is called */
1237 return IOINST_CC_EXPECTED
;
1240 IOInstEnding
do_subchannel_work_passthrough(SubchDev
*sch
)
1242 SCSW
*s
= &sch
->curr_status
.scsw
;
1244 if (s
->ctrl
& SCSW_FCTL_CLEAR_FUNC
) {
1245 /* TODO: Clear handling */
1246 sch_handle_clear_func(sch
);
1247 } else if (s
->ctrl
& SCSW_FCTL_HALT_FUNC
) {
1248 /* TODO: Halt handling */
1249 sch_handle_halt_func(sch
);
1250 } else if (s
->ctrl
& SCSW_FCTL_START_FUNC
) {
1251 return sch_handle_start_func_passthrough(sch
);
1253 return IOINST_CC_EXPECTED
;
1256 static IOInstEnding
do_subchannel_work(SubchDev
*sch
)
1258 if (!sch
->do_subchannel_work
) {
1259 return IOINST_CC_STATUS_PRESENT
;
1261 g_assert(sch
->curr_status
.scsw
.ctrl
& SCSW_CTRL_MASK_FCTL
);
1262 return sch
->do_subchannel_work(sch
);
1265 static void copy_pmcw_to_guest(PMCW
*dest
, const PMCW
*src
)
1269 dest
->intparm
= cpu_to_be32(src
->intparm
);
1270 dest
->flags
= cpu_to_be16(src
->flags
);
1271 dest
->devno
= cpu_to_be16(src
->devno
);
1272 dest
->lpm
= src
->lpm
;
1273 dest
->pnom
= src
->pnom
;
1274 dest
->lpum
= src
->lpum
;
1275 dest
->pim
= src
->pim
;
1276 dest
->mbi
= cpu_to_be16(src
->mbi
);
1277 dest
->pom
= src
->pom
;
1278 dest
->pam
= src
->pam
;
1279 for (i
= 0; i
< ARRAY_SIZE(dest
->chpid
); i
++) {
1280 dest
->chpid
[i
] = src
->chpid
[i
];
1282 dest
->chars
= cpu_to_be32(src
->chars
);
1285 void copy_scsw_to_guest(SCSW
*dest
, const SCSW
*src
)
1287 dest
->flags
= cpu_to_be16(src
->flags
);
1288 dest
->ctrl
= cpu_to_be16(src
->ctrl
);
1289 dest
->cpa
= cpu_to_be32(src
->cpa
);
1290 dest
->dstat
= src
->dstat
;
1291 dest
->cstat
= src
->cstat
;
1292 dest
->count
= cpu_to_be16(src
->count
);
1295 static void copy_schib_to_guest(SCHIB
*dest
, const SCHIB
*src
)
1299 copy_pmcw_to_guest(&dest
->pmcw
, &src
->pmcw
);
1300 copy_scsw_to_guest(&dest
->scsw
, &src
->scsw
);
1301 dest
->mba
= cpu_to_be64(src
->mba
);
1302 for (i
= 0; i
< ARRAY_SIZE(dest
->mda
); i
++) {
1303 dest
->mda
[i
] = src
->mda
[i
];
1307 int css_do_stsch(SubchDev
*sch
, SCHIB
*schib
)
1309 /* Use current status. */
1310 copy_schib_to_guest(schib
, &sch
->curr_status
);
1314 static void copy_pmcw_from_guest(PMCW
*dest
, const PMCW
*src
)
1318 dest
->intparm
= be32_to_cpu(src
->intparm
);
1319 dest
->flags
= be16_to_cpu(src
->flags
);
1320 dest
->devno
= be16_to_cpu(src
->devno
);
1321 dest
->lpm
= src
->lpm
;
1322 dest
->pnom
= src
->pnom
;
1323 dest
->lpum
= src
->lpum
;
1324 dest
->pim
= src
->pim
;
1325 dest
->mbi
= be16_to_cpu(src
->mbi
);
1326 dest
->pom
= src
->pom
;
1327 dest
->pam
= src
->pam
;
1328 for (i
= 0; i
< ARRAY_SIZE(dest
->chpid
); i
++) {
1329 dest
->chpid
[i
] = src
->chpid
[i
];
1331 dest
->chars
= be32_to_cpu(src
->chars
);
1334 static void copy_scsw_from_guest(SCSW
*dest
, const SCSW
*src
)
1336 dest
->flags
= be16_to_cpu(src
->flags
);
1337 dest
->ctrl
= be16_to_cpu(src
->ctrl
);
1338 dest
->cpa
= be32_to_cpu(src
->cpa
);
1339 dest
->dstat
= src
->dstat
;
1340 dest
->cstat
= src
->cstat
;
1341 dest
->count
= be16_to_cpu(src
->count
);
1344 static void copy_schib_from_guest(SCHIB
*dest
, const SCHIB
*src
)
1348 copy_pmcw_from_guest(&dest
->pmcw
, &src
->pmcw
);
1349 copy_scsw_from_guest(&dest
->scsw
, &src
->scsw
);
1350 dest
->mba
= be64_to_cpu(src
->mba
);
1351 for (i
= 0; i
< ARRAY_SIZE(dest
->mda
); i
++) {
1352 dest
->mda
[i
] = src
->mda
[i
];
1356 IOInstEnding
css_do_msch(SubchDev
*sch
, const SCHIB
*orig_schib
)
1358 SCSW
*s
= &sch
->curr_status
.scsw
;
1359 PMCW
*p
= &sch
->curr_status
.pmcw
;
1363 if (!(sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_DNV
)) {
1364 return IOINST_CC_EXPECTED
;
1367 if (s
->ctrl
& SCSW_STCTL_STATUS_PEND
) {
1368 return IOINST_CC_STATUS_PRESENT
;
1372 (SCSW_FCTL_START_FUNC
|SCSW_FCTL_HALT_FUNC
|SCSW_FCTL_CLEAR_FUNC
)) {
1373 return IOINST_CC_BUSY
;
1376 copy_schib_from_guest(&schib
, orig_schib
);
1377 /* Only update the program-modifiable fields. */
1378 p
->intparm
= schib
.pmcw
.intparm
;
1379 oldflags
= p
->flags
;
1380 p
->flags
&= ~(PMCW_FLAGS_MASK_ISC
| PMCW_FLAGS_MASK_ENA
|
1381 PMCW_FLAGS_MASK_LM
| PMCW_FLAGS_MASK_MME
|
1382 PMCW_FLAGS_MASK_MP
);
1383 p
->flags
|= schib
.pmcw
.flags
&
1384 (PMCW_FLAGS_MASK_ISC
| PMCW_FLAGS_MASK_ENA
|
1385 PMCW_FLAGS_MASK_LM
| PMCW_FLAGS_MASK_MME
|
1386 PMCW_FLAGS_MASK_MP
);
1387 p
->lpm
= schib
.pmcw
.lpm
;
1388 p
->mbi
= schib
.pmcw
.mbi
;
1389 p
->pom
= schib
.pmcw
.pom
;
1390 p
->chars
&= ~(PMCW_CHARS_MASK_MBFC
| PMCW_CHARS_MASK_CSENSE
);
1391 p
->chars
|= schib
.pmcw
.chars
&
1392 (PMCW_CHARS_MASK_MBFC
| PMCW_CHARS_MASK_CSENSE
);
1393 sch
->curr_status
.mba
= schib
.mba
;
1395 /* Has the channel been disabled? */
1396 if (sch
->disable_cb
&& (oldflags
& PMCW_FLAGS_MASK_ENA
) != 0
1397 && (p
->flags
& PMCW_FLAGS_MASK_ENA
) == 0) {
1398 sch
->disable_cb(sch
);
1400 return IOINST_CC_EXPECTED
;
1403 IOInstEnding
css_do_xsch(SubchDev
*sch
)
1405 SCSW
*s
= &sch
->curr_status
.scsw
;
1406 PMCW
*p
= &sch
->curr_status
.pmcw
;
1408 if (~(p
->flags
) & (PMCW_FLAGS_MASK_DNV
| PMCW_FLAGS_MASK_ENA
)) {
1409 return IOINST_CC_NOT_OPERATIONAL
;
1412 if (s
->ctrl
& SCSW_CTRL_MASK_STCTL
) {
1413 return IOINST_CC_STATUS_PRESENT
;
1416 if (!(s
->ctrl
& SCSW_CTRL_MASK_FCTL
) ||
1417 ((s
->ctrl
& SCSW_CTRL_MASK_FCTL
) != SCSW_FCTL_START_FUNC
) ||
1419 (SCSW_ACTL_RESUME_PEND
| SCSW_ACTL_START_PEND
| SCSW_ACTL_SUSP
))) ||
1420 (s
->ctrl
& SCSW_ACTL_SUBCH_ACTIVE
)) {
1421 return IOINST_CC_BUSY
;
1424 /* Cancel the current operation. */
1425 s
->ctrl
&= ~(SCSW_FCTL_START_FUNC
|
1426 SCSW_ACTL_RESUME_PEND
|
1427 SCSW_ACTL_START_PEND
|
1429 sch
->channel_prog
= 0x0;
1430 sch
->last_cmd_valid
= false;
1433 return IOINST_CC_EXPECTED
;
1436 IOInstEnding
css_do_csch(SubchDev
*sch
)
1438 SCSW
*s
= &sch
->curr_status
.scsw
;
1439 PMCW
*p
= &sch
->curr_status
.pmcw
;
1441 if (~(p
->flags
) & (PMCW_FLAGS_MASK_DNV
| PMCW_FLAGS_MASK_ENA
)) {
1442 return IOINST_CC_NOT_OPERATIONAL
;
1445 /* Trigger the clear function. */
1446 s
->ctrl
&= ~(SCSW_CTRL_MASK_FCTL
| SCSW_CTRL_MASK_ACTL
);
1447 s
->ctrl
|= SCSW_FCTL_CLEAR_FUNC
| SCSW_ACTL_CLEAR_PEND
;
1449 return do_subchannel_work(sch
);
1452 IOInstEnding
css_do_hsch(SubchDev
*sch
)
1454 SCSW
*s
= &sch
->curr_status
.scsw
;
1455 PMCW
*p
= &sch
->curr_status
.pmcw
;
1457 if (~(p
->flags
) & (PMCW_FLAGS_MASK_DNV
| PMCW_FLAGS_MASK_ENA
)) {
1458 return IOINST_CC_NOT_OPERATIONAL
;
1461 if (((s
->ctrl
& SCSW_CTRL_MASK_STCTL
) == SCSW_STCTL_STATUS_PEND
) ||
1462 (s
->ctrl
& (SCSW_STCTL_PRIMARY
|
1463 SCSW_STCTL_SECONDARY
|
1464 SCSW_STCTL_ALERT
))) {
1465 return IOINST_CC_STATUS_PRESENT
;
1468 if (s
->ctrl
& (SCSW_FCTL_HALT_FUNC
| SCSW_FCTL_CLEAR_FUNC
)) {
1469 return IOINST_CC_BUSY
;
1472 /* Trigger the halt function. */
1473 s
->ctrl
|= SCSW_FCTL_HALT_FUNC
;
1474 s
->ctrl
&= ~SCSW_FCTL_START_FUNC
;
1475 if (((s
->ctrl
& SCSW_CTRL_MASK_ACTL
) ==
1476 (SCSW_ACTL_SUBCH_ACTIVE
| SCSW_ACTL_DEVICE_ACTIVE
)) &&
1477 ((s
->ctrl
& SCSW_CTRL_MASK_STCTL
) == SCSW_STCTL_INTERMEDIATE
)) {
1478 s
->ctrl
&= ~SCSW_STCTL_STATUS_PEND
;
1480 s
->ctrl
|= SCSW_ACTL_HALT_PEND
;
1482 return do_subchannel_work(sch
);
1485 static void css_update_chnmon(SubchDev
*sch
)
1487 if (!(sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_MME
)) {
1491 /* The counter is conveniently located at the beginning of the struct. */
1492 if (sch
->curr_status
.pmcw
.chars
& PMCW_CHARS_MASK_MBFC
) {
1493 /* Format 1, per-subchannel area. */
1496 count
= address_space_ldl(&address_space_memory
,
1497 sch
->curr_status
.mba
,
1498 MEMTXATTRS_UNSPECIFIED
,
1501 address_space_stl(&address_space_memory
, sch
->curr_status
.mba
, count
,
1502 MEMTXATTRS_UNSPECIFIED
, NULL
);
1504 /* Format 0, global area. */
1508 offset
= sch
->curr_status
.pmcw
.mbi
<< 5;
1509 count
= address_space_lduw(&address_space_memory
,
1510 channel_subsys
.chnmon_area
+ offset
,
1511 MEMTXATTRS_UNSPECIFIED
,
1514 address_space_stw(&address_space_memory
,
1515 channel_subsys
.chnmon_area
+ offset
, count
,
1516 MEMTXATTRS_UNSPECIFIED
, NULL
);
1520 IOInstEnding
css_do_ssch(SubchDev
*sch
, ORB
*orb
)
1522 SCSW
*s
= &sch
->curr_status
.scsw
;
1523 PMCW
*p
= &sch
->curr_status
.pmcw
;
1525 if (~(p
->flags
) & (PMCW_FLAGS_MASK_DNV
| PMCW_FLAGS_MASK_ENA
)) {
1526 return IOINST_CC_NOT_OPERATIONAL
;
1529 if (s
->ctrl
& SCSW_STCTL_STATUS_PEND
) {
1530 return IOINST_CC_STATUS_PRESENT
;
1533 if (s
->ctrl
& (SCSW_FCTL_START_FUNC
|
1534 SCSW_FCTL_HALT_FUNC
|
1535 SCSW_FCTL_CLEAR_FUNC
)) {
1536 return IOINST_CC_BUSY
;
1539 /* If monitoring is active, update counter. */
1540 if (channel_subsys
.chnmon_active
) {
1541 css_update_chnmon(sch
);
1544 sch
->channel_prog
= orb
->cpa
;
1545 /* Trigger the start function. */
1546 s
->ctrl
|= (SCSW_FCTL_START_FUNC
| SCSW_ACTL_START_PEND
);
1547 s
->flags
&= ~SCSW_FLAGS_MASK_PNO
;
1549 return do_subchannel_work(sch
);
1552 static void copy_irb_to_guest(IRB
*dest
, const IRB
*src
, PMCW
*pmcw
,
1556 uint16_t stctl
= src
->scsw
.ctrl
& SCSW_CTRL_MASK_STCTL
;
1557 uint16_t actl
= src
->scsw
.ctrl
& SCSW_CTRL_MASK_ACTL
;
1559 copy_scsw_to_guest(&dest
->scsw
, &src
->scsw
);
1561 for (i
= 0; i
< ARRAY_SIZE(dest
->esw
); i
++) {
1562 dest
->esw
[i
] = cpu_to_be32(src
->esw
[i
]);
1564 for (i
= 0; i
< ARRAY_SIZE(dest
->ecw
); i
++) {
1565 dest
->ecw
[i
] = cpu_to_be32(src
->ecw
[i
]);
1567 *irb_len
= sizeof(*dest
) - sizeof(dest
->emw
);
1569 /* extended measurements enabled? */
1570 if ((src
->scsw
.flags
& SCSW_FLAGS_MASK_ESWF
) ||
1571 !(pmcw
->flags
& PMCW_FLAGS_MASK_TF
) ||
1572 !(pmcw
->chars
& PMCW_CHARS_MASK_XMWME
)) {
1575 /* extended measurements pending? */
1576 if (!(stctl
& SCSW_STCTL_STATUS_PEND
)) {
1579 if ((stctl
& SCSW_STCTL_PRIMARY
) ||
1580 (stctl
== SCSW_STCTL_SECONDARY
) ||
1581 ((stctl
& SCSW_STCTL_INTERMEDIATE
) && (actl
& SCSW_ACTL_SUSP
))) {
1582 for (i
= 0; i
< ARRAY_SIZE(dest
->emw
); i
++) {
1583 dest
->emw
[i
] = cpu_to_be32(src
->emw
[i
]);
1586 *irb_len
= sizeof(*dest
);
1589 int css_do_tsch_get_irb(SubchDev
*sch
, IRB
*target_irb
, int *irb_len
)
1591 SCSW
*s
= &sch
->curr_status
.scsw
;
1592 PMCW
*p
= &sch
->curr_status
.pmcw
;
1596 if (~(p
->flags
) & (PMCW_FLAGS_MASK_DNV
| PMCW_FLAGS_MASK_ENA
)) {
1600 stctl
= s
->ctrl
& SCSW_CTRL_MASK_STCTL
;
1602 /* Prepare the irb for the guest. */
1603 memset(&irb
, 0, sizeof(IRB
));
1605 /* Copy scsw from current status. */
1606 memcpy(&irb
.scsw
, s
, sizeof(SCSW
));
1607 if (stctl
& SCSW_STCTL_STATUS_PEND
) {
1608 if (s
->cstat
& (SCSW_CSTAT_DATA_CHECK
|
1609 SCSW_CSTAT_CHN_CTRL_CHK
|
1610 SCSW_CSTAT_INTF_CTRL_CHK
)) {
1611 irb
.scsw
.flags
|= SCSW_FLAGS_MASK_ESWF
;
1612 irb
.esw
[0] = 0x04804000;
1614 irb
.esw
[0] = 0x00800000;
1616 /* If a unit check is pending, copy sense data. */
1617 if ((s
->dstat
& SCSW_DSTAT_UNIT_CHECK
) &&
1618 (p
->chars
& PMCW_CHARS_MASK_CSENSE
)) {
1621 irb
.scsw
.flags
|= SCSW_FLAGS_MASK_ESWF
| SCSW_FLAGS_MASK_ECTL
;
1622 /* Attention: sense_data is already BE! */
1623 memcpy(irb
.ecw
, sch
->sense_data
, sizeof(sch
->sense_data
));
1624 for (i
= 0; i
< ARRAY_SIZE(irb
.ecw
); i
++) {
1625 irb
.ecw
[i
] = be32_to_cpu(irb
.ecw
[i
]);
1627 irb
.esw
[1] = 0x01000000 | (sizeof(sch
->sense_data
) << 8);
1630 /* Store the irb to the guest. */
1631 copy_irb_to_guest(target_irb
, &irb
, p
, irb_len
);
1633 return ((stctl
& SCSW_STCTL_STATUS_PEND
) == 0);
1636 void css_do_tsch_update_subch(SubchDev
*sch
)
1638 SCSW
*s
= &sch
->curr_status
.scsw
;
1639 PMCW
*p
= &sch
->curr_status
.pmcw
;
1644 stctl
= s
->ctrl
& SCSW_CTRL_MASK_STCTL
;
1645 fctl
= s
->ctrl
& SCSW_CTRL_MASK_FCTL
;
1646 actl
= s
->ctrl
& SCSW_CTRL_MASK_ACTL
;
1648 /* Clear conditions on subchannel, if applicable. */
1649 if (stctl
& SCSW_STCTL_STATUS_PEND
) {
1650 s
->ctrl
&= ~SCSW_CTRL_MASK_STCTL
;
1651 if ((stctl
!= (SCSW_STCTL_INTERMEDIATE
| SCSW_STCTL_STATUS_PEND
)) ||
1652 ((fctl
& SCSW_FCTL_HALT_FUNC
) &&
1653 (actl
& SCSW_ACTL_SUSP
))) {
1654 s
->ctrl
&= ~SCSW_CTRL_MASK_FCTL
;
1656 if (stctl
!= (SCSW_STCTL_INTERMEDIATE
| SCSW_STCTL_STATUS_PEND
)) {
1657 s
->flags
&= ~SCSW_FLAGS_MASK_PNO
;
1658 s
->ctrl
&= ~(SCSW_ACTL_RESUME_PEND
|
1659 SCSW_ACTL_START_PEND
|
1660 SCSW_ACTL_HALT_PEND
|
1661 SCSW_ACTL_CLEAR_PEND
|
1664 if ((actl
& SCSW_ACTL_SUSP
) &&
1665 (fctl
& SCSW_FCTL_START_FUNC
)) {
1666 s
->flags
&= ~SCSW_FLAGS_MASK_PNO
;
1667 if (fctl
& SCSW_FCTL_HALT_FUNC
) {
1668 s
->ctrl
&= ~(SCSW_ACTL_RESUME_PEND
|
1669 SCSW_ACTL_START_PEND
|
1670 SCSW_ACTL_HALT_PEND
|
1671 SCSW_ACTL_CLEAR_PEND
|
1674 s
->ctrl
&= ~SCSW_ACTL_RESUME_PEND
;
1678 /* Clear pending sense data. */
1679 if (p
->chars
& PMCW_CHARS_MASK_CSENSE
) {
1680 memset(sch
->sense_data
, 0 , sizeof(sch
->sense_data
));
1685 static void copy_crw_to_guest(CRW
*dest
, const CRW
*src
)
1687 dest
->flags
= cpu_to_be16(src
->flags
);
1688 dest
->rsid
= cpu_to_be16(src
->rsid
);
1691 int css_do_stcrw(CRW
*crw
)
1693 CrwContainer
*crw_cont
;
1696 crw_cont
= QTAILQ_FIRST(&channel_subsys
.pending_crws
);
1698 QTAILQ_REMOVE(&channel_subsys
.pending_crws
, crw_cont
, sibling
);
1699 copy_crw_to_guest(crw
, &crw_cont
->crw
);
1703 /* List was empty, turn crw machine checks on again. */
1704 memset(crw
, 0, sizeof(*crw
));
1705 channel_subsys
.do_crw_mchk
= true;
1712 static void copy_crw_from_guest(CRW
*dest
, const CRW
*src
)
1714 dest
->flags
= be16_to_cpu(src
->flags
);
1715 dest
->rsid
= be16_to_cpu(src
->rsid
);
1718 void css_undo_stcrw(CRW
*crw
)
1720 CrwContainer
*crw_cont
;
1722 crw_cont
= g_try_new0(CrwContainer
, 1);
1724 channel_subsys
.crws_lost
= true;
1727 copy_crw_from_guest(&crw_cont
->crw
, crw
);
1729 QTAILQ_INSERT_HEAD(&channel_subsys
.pending_crws
, crw_cont
, sibling
);
1732 int css_collect_chp_desc(int m
, uint8_t cssid
, uint8_t f_chpid
, uint8_t l_chpid
,
1733 int rfmt
, void *buf
)
1737 uint32_t chpid_type_word
;
1741 css
= channel_subsys
.css
[channel_subsys
.default_cssid
];
1743 css
= channel_subsys
.css
[cssid
];
1749 for (i
= f_chpid
; i
<= l_chpid
; i
++) {
1750 if (css
->chpids
[i
].in_use
) {
1751 chpid_type_word
= 0x80000000 | (css
->chpids
[i
].type
<< 8) | i
;
1753 words
[0] = cpu_to_be32(chpid_type_word
);
1755 memcpy(buf
+ desc_size
, words
, 8);
1757 } else if (rfmt
== 1) {
1758 words
[0] = cpu_to_be32(chpid_type_word
);
1766 memcpy(buf
+ desc_size
, words
, 32);
1774 void css_do_schm(uint8_t mbk
, int update
, int dct
, uint64_t mbo
)
1776 /* dct is currently ignored (not really meaningful for our devices) */
1777 /* TODO: Don't ignore mbk. */
1778 if (update
&& !channel_subsys
.chnmon_active
) {
1779 /* Enable measuring. */
1780 channel_subsys
.chnmon_area
= mbo
;
1781 channel_subsys
.chnmon_active
= true;
1783 if (!update
&& channel_subsys
.chnmon_active
) {
1784 /* Disable measuring. */
1785 channel_subsys
.chnmon_area
= 0;
1786 channel_subsys
.chnmon_active
= false;
1790 IOInstEnding
css_do_rsch(SubchDev
*sch
)
1792 SCSW
*s
= &sch
->curr_status
.scsw
;
1793 PMCW
*p
= &sch
->curr_status
.pmcw
;
1795 if (~(p
->flags
) & (PMCW_FLAGS_MASK_DNV
| PMCW_FLAGS_MASK_ENA
)) {
1796 return IOINST_CC_NOT_OPERATIONAL
;
1799 if (s
->ctrl
& SCSW_STCTL_STATUS_PEND
) {
1800 return IOINST_CC_STATUS_PRESENT
;
1803 if (((s
->ctrl
& SCSW_CTRL_MASK_FCTL
) != SCSW_FCTL_START_FUNC
) ||
1804 (s
->ctrl
& SCSW_ACTL_RESUME_PEND
) ||
1805 (!(s
->ctrl
& SCSW_ACTL_SUSP
))) {
1806 return IOINST_CC_BUSY
;
1809 /* If monitoring is active, update counter. */
1810 if (channel_subsys
.chnmon_active
) {
1811 css_update_chnmon(sch
);
1814 s
->ctrl
|= SCSW_ACTL_RESUME_PEND
;
1815 return do_subchannel_work(sch
);
1818 int css_do_rchp(uint8_t cssid
, uint8_t chpid
)
1822 if (cssid
> channel_subsys
.max_cssid
) {
1825 if (channel_subsys
.max_cssid
== 0) {
1826 real_cssid
= channel_subsys
.default_cssid
;
1830 if (!channel_subsys
.css
[real_cssid
]) {
1834 if (!channel_subsys
.css
[real_cssid
]->chpids
[chpid
].in_use
) {
1838 if (!channel_subsys
.css
[real_cssid
]->chpids
[chpid
].is_virtual
) {
1840 "rchp unsupported for non-virtual chpid %x.%02x!\n",
1845 /* We don't really use a channel path, so we're done here. */
1846 css_queue_crw(CRW_RSC_CHP
, CRW_ERC_INIT
, 1,
1847 channel_subsys
.max_cssid
> 0 ? 1 : 0, chpid
);
1848 if (channel_subsys
.max_cssid
> 0) {
1849 css_queue_crw(CRW_RSC_CHP
, CRW_ERC_INIT
, 1, 0, real_cssid
<< 8);
1854 bool css_schid_final(int m
, uint8_t cssid
, uint8_t ssid
, uint16_t schid
)
1859 real_cssid
= (!m
&& (cssid
== 0)) ? channel_subsys
.default_cssid
: cssid
;
1860 if (ssid
> MAX_SSID
||
1861 !channel_subsys
.css
[real_cssid
] ||
1862 !channel_subsys
.css
[real_cssid
]->sch_set
[ssid
]) {
1865 set
= channel_subsys
.css
[real_cssid
]->sch_set
[ssid
];
1866 return schid
> find_last_bit(set
->schids_used
,
1867 (MAX_SCHID
+ 1) / sizeof(unsigned long));
1870 unsigned int css_find_free_chpid(uint8_t cssid
)
1872 CssImage
*css
= channel_subsys
.css
[cssid
];
1876 return MAX_CHPID
+ 1;
1879 for (chpid
= 0; chpid
<= MAX_CHPID
; chpid
++) {
1880 /* skip reserved chpid */
1881 if (chpid
== VIRTIO_CCW_CHPID
) {
1884 if (!css
->chpids
[chpid
].in_use
) {
1888 return MAX_CHPID
+ 1;
1891 static int css_add_chpid(uint8_t cssid
, uint8_t chpid
, uint8_t type
,
1896 trace_css_chpid_add(cssid
, chpid
, type
);
1897 css
= channel_subsys
.css
[cssid
];
1901 if (css
->chpids
[chpid
].in_use
) {
1904 css
->chpids
[chpid
].in_use
= 1;
1905 css
->chpids
[chpid
].type
= type
;
1906 css
->chpids
[chpid
].is_virtual
= is_virt
;
1908 css_generate_chp_crws(cssid
, chpid
);
1913 void css_sch_build_virtual_schib(SubchDev
*sch
, uint8_t chpid
, uint8_t type
)
1915 PMCW
*p
= &sch
->curr_status
.pmcw
;
1916 SCSW
*s
= &sch
->curr_status
.scsw
;
1918 CssImage
*css
= channel_subsys
.css
[sch
->cssid
];
1920 assert(css
!= NULL
);
1921 memset(p
, 0, sizeof(PMCW
));
1922 p
->flags
|= PMCW_FLAGS_MASK_DNV
;
1923 p
->devno
= sch
->devno
;
1928 p
->chpid
[0] = chpid
;
1929 if (!css
->chpids
[chpid
].in_use
) {
1930 css_add_chpid(sch
->cssid
, chpid
, type
, true);
1933 memset(s
, 0, sizeof(SCSW
));
1934 sch
->curr_status
.mba
= 0;
1935 for (i
= 0; i
< ARRAY_SIZE(sch
->curr_status
.mda
); i
++) {
1936 sch
->curr_status
.mda
[i
] = 0;
1940 SubchDev
*css_find_subch(uint8_t m
, uint8_t cssid
, uint8_t ssid
, uint16_t schid
)
1944 real_cssid
= (!m
&& (cssid
== 0)) ? channel_subsys
.default_cssid
: cssid
;
1946 if (!channel_subsys
.css
[real_cssid
]) {
1950 if (!channel_subsys
.css
[real_cssid
]->sch_set
[ssid
]) {
1954 return channel_subsys
.css
[real_cssid
]->sch_set
[ssid
]->sch
[schid
];
1958 * Return free device number in subchannel set.
1960 * Return index of the first free device number in the subchannel set
1961 * identified by @p cssid and @p ssid, beginning the search at @p
1962 * start and wrapping around at MAX_DEVNO. Return a value exceeding
1963 * MAX_SCHID if there are no free device numbers in the subchannel
1966 static uint32_t css_find_free_devno(uint8_t cssid
, uint8_t ssid
,
1971 for (round
= 0; round
<= MAX_DEVNO
; round
++) {
1972 uint16_t devno
= (start
+ round
) % MAX_DEVNO
;
1974 if (!css_devno_used(cssid
, ssid
, devno
)) {
1978 return MAX_DEVNO
+ 1;
1982 * Return first free subchannel (id) in subchannel set.
1984 * Return index of the first free subchannel in the subchannel set
1985 * identified by @p cssid and @p ssid, if there is any. Return a value
1986 * exceeding MAX_SCHID if there are no free subchannels in the
1989 static uint32_t css_find_free_subch(uint8_t cssid
, uint8_t ssid
)
1993 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
1994 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
1998 return MAX_SCHID
+ 1;
2002 * Return first free subchannel (id) in subchannel set for a device number
2004 * Verify the device number @p devno is not used yet in the subchannel
2005 * set identified by @p cssid and @p ssid. Set @p schid to the index
2006 * of the first free subchannel in the subchannel set, if there is
2007 * any. Return true if everything succeeded and false otherwise.
2009 static bool css_find_free_subch_for_devno(uint8_t cssid
, uint8_t ssid
,
2010 uint16_t devno
, uint16_t *schid
,
2013 uint32_t free_schid
;
2016 if (css_devno_used(cssid
, ssid
, devno
)) {
2017 error_setg(errp
, "Device %x.%x.%04x already exists",
2018 cssid
, ssid
, devno
);
2021 free_schid
= css_find_free_subch(cssid
, ssid
);
2022 if (free_schid
> MAX_SCHID
) {
2023 error_setg(errp
, "No free subchannel found for %x.%x.%04x",
2024 cssid
, ssid
, devno
);
2027 *schid
= free_schid
;
2032 * Return first free subchannel (id) and device number
2034 * Locate the first free subchannel and first free device number in
2035 * any of the subchannel sets of the channel subsystem identified by
2036 * @p cssid. Return false if no free subchannel / device number could
2037 * be found. Otherwise set @p ssid, @p devno and @p schid to identify
2038 * the available subchannel and device number and return true.
2040 * May modify @p ssid, @p devno and / or @p schid even if no free
2041 * subchannel / device number could be found.
2043 static bool css_find_free_subch_and_devno(uint8_t cssid
, uint8_t *ssid
,
2044 uint16_t *devno
, uint16_t *schid
,
2047 uint32_t free_schid
, free_devno
;
2049 assert(ssid
&& devno
&& schid
);
2050 for (*ssid
= 0; *ssid
<= MAX_SSID
; (*ssid
)++) {
2051 free_schid
= css_find_free_subch(cssid
, *ssid
);
2052 if (free_schid
> MAX_SCHID
) {
2055 free_devno
= css_find_free_devno(cssid
, *ssid
, free_schid
);
2056 if (free_devno
> MAX_DEVNO
) {
2059 *schid
= free_schid
;
2060 *devno
= free_devno
;
2063 error_setg(errp
, "Virtual channel subsystem is full!");
2067 bool css_subch_visible(SubchDev
*sch
)
2069 if (sch
->ssid
> channel_subsys
.max_ssid
) {
2073 if (sch
->cssid
!= channel_subsys
.default_cssid
) {
2074 return (channel_subsys
.max_cssid
> 0);
2080 bool css_present(uint8_t cssid
)
2082 return (channel_subsys
.css
[cssid
] != NULL
);
2085 bool css_devno_used(uint8_t cssid
, uint8_t ssid
, uint16_t devno
)
2087 if (!channel_subsys
.css
[cssid
]) {
2090 if (!channel_subsys
.css
[cssid
]->sch_set
[ssid
]) {
2094 return !!test_bit(devno
,
2095 channel_subsys
.css
[cssid
]->sch_set
[ssid
]->devnos_used
);
2098 void css_subch_assign(uint8_t cssid
, uint8_t ssid
, uint16_t schid
,
2099 uint16_t devno
, SubchDev
*sch
)
2104 trace_css_assign_subch(sch
? "assign" : "deassign", cssid
, ssid
, schid
,
2106 if (!channel_subsys
.css
[cssid
]) {
2108 "Suspicious call to %s (%x.%x.%04x) for non-existing css!\n",
2109 __func__
, cssid
, ssid
, schid
);
2112 css
= channel_subsys
.css
[cssid
];
2114 if (!css
->sch_set
[ssid
]) {
2115 css
->sch_set
[ssid
] = g_new0(SubchSet
, 1);
2117 s_set
= css
->sch_set
[ssid
];
2119 s_set
->sch
[schid
] = sch
;
2121 set_bit(schid
, s_set
->schids_used
);
2122 set_bit(devno
, s_set
->devnos_used
);
2124 clear_bit(schid
, s_set
->schids_used
);
2125 clear_bit(devno
, s_set
->devnos_used
);
2129 void css_queue_crw(uint8_t rsc
, uint8_t erc
, int solicited
,
2130 int chain
, uint16_t rsid
)
2132 CrwContainer
*crw_cont
;
2134 trace_css_crw(rsc
, erc
, rsid
, chain
? "(chained)" : "");
2135 /* TODO: Maybe use a static crw pool? */
2136 crw_cont
= g_try_new0(CrwContainer
, 1);
2138 channel_subsys
.crws_lost
= true;
2141 crw_cont
->crw
.flags
= (rsc
<< 8) | erc
;
2143 crw_cont
->crw
.flags
|= CRW_FLAGS_MASK_S
;
2146 crw_cont
->crw
.flags
|= CRW_FLAGS_MASK_C
;
2148 crw_cont
->crw
.rsid
= rsid
;
2149 if (channel_subsys
.crws_lost
) {
2150 crw_cont
->crw
.flags
|= CRW_FLAGS_MASK_R
;
2151 channel_subsys
.crws_lost
= false;
2154 QTAILQ_INSERT_TAIL(&channel_subsys
.pending_crws
, crw_cont
, sibling
);
2156 if (channel_subsys
.do_crw_mchk
) {
2157 channel_subsys
.do_crw_mchk
= false;
2158 /* Inject crw pending machine check. */
2163 void css_generate_sch_crws(uint8_t cssid
, uint8_t ssid
, uint16_t schid
,
2164 int hotplugged
, int add
)
2166 uint8_t guest_cssid
;
2169 if (add
&& !hotplugged
) {
2172 if (channel_subsys
.max_cssid
== 0) {
2173 /* Default cssid shows up as 0. */
2174 guest_cssid
= (cssid
== channel_subsys
.default_cssid
) ? 0 : cssid
;
2176 /* Show real cssid to the guest. */
2177 guest_cssid
= cssid
;
2180 * Only notify for higher subchannel sets/channel subsystems if the
2181 * guest has enabled it.
2183 if ((ssid
> channel_subsys
.max_ssid
) ||
2184 (guest_cssid
> channel_subsys
.max_cssid
) ||
2185 ((channel_subsys
.max_cssid
== 0) &&
2186 (cssid
!= channel_subsys
.default_cssid
))) {
2189 chain_crw
= (channel_subsys
.max_ssid
> 0) ||
2190 (channel_subsys
.max_cssid
> 0);
2191 css_queue_crw(CRW_RSC_SUBCH
, CRW_ERC_IPI
, 0, chain_crw
? 1 : 0, schid
);
2193 css_queue_crw(CRW_RSC_SUBCH
, CRW_ERC_IPI
, 0, 0,
2194 (guest_cssid
<< 8) | (ssid
<< 4));
2196 /* RW_ERC_IPI --> clear pending interrupts */
2197 css_clear_io_interrupt(css_do_build_subchannel_id(cssid
, ssid
), schid
);
2200 void css_generate_chp_crws(uint8_t cssid
, uint8_t chpid
)
2205 void css_generate_css_crws(uint8_t cssid
)
2207 if (!channel_subsys
.sei_pending
) {
2208 css_queue_crw(CRW_RSC_CSS
, CRW_ERC_EVENT
, 0, 0, cssid
);
2210 channel_subsys
.sei_pending
= true;
2213 void css_clear_sei_pending(void)
2215 channel_subsys
.sei_pending
= false;
2218 int css_enable_mcsse(void)
2220 trace_css_enable_facility("mcsse");
2221 channel_subsys
.max_cssid
= MAX_CSSID
;
2225 int css_enable_mss(void)
2227 trace_css_enable_facility("mss");
2228 channel_subsys
.max_ssid
= MAX_SSID
;
2232 void css_reset_sch(SubchDev
*sch
)
2234 PMCW
*p
= &sch
->curr_status
.pmcw
;
2236 if ((p
->flags
& PMCW_FLAGS_MASK_ENA
) != 0 && sch
->disable_cb
) {
2237 sch
->disable_cb(sch
);
2241 p
->flags
&= ~(PMCW_FLAGS_MASK_ISC
| PMCW_FLAGS_MASK_ENA
|
2242 PMCW_FLAGS_MASK_LM
| PMCW_FLAGS_MASK_MME
|
2243 PMCW_FLAGS_MASK_MP
| PMCW_FLAGS_MASK_TF
);
2244 p
->flags
|= PMCW_FLAGS_MASK_DNV
;
2245 p
->devno
= sch
->devno
;
2253 p
->chars
&= ~(PMCW_CHARS_MASK_MBFC
| PMCW_CHARS_MASK_XMWME
|
2254 PMCW_CHARS_MASK_CSENSE
);
2256 memset(&sch
->curr_status
.scsw
, 0, sizeof(sch
->curr_status
.scsw
));
2257 sch
->curr_status
.mba
= 0;
2259 sch
->channel_prog
= 0x0;
2260 sch
->last_cmd_valid
= false;
2261 sch
->thinint_active
= false;
2264 void css_reset(void)
2266 CrwContainer
*crw_cont
;
2268 /* Clean up monitoring. */
2269 channel_subsys
.chnmon_active
= false;
2270 channel_subsys
.chnmon_area
= 0;
2272 /* Clear pending CRWs. */
2273 while ((crw_cont
= QTAILQ_FIRST(&channel_subsys
.pending_crws
))) {
2274 QTAILQ_REMOVE(&channel_subsys
.pending_crws
, crw_cont
, sibling
);
2277 channel_subsys
.sei_pending
= false;
2278 channel_subsys
.do_crw_mchk
= true;
2279 channel_subsys
.crws_lost
= false;
2281 /* Reset maximum ids. */
2282 channel_subsys
.max_cssid
= 0;
2283 channel_subsys
.max_ssid
= 0;
2286 static void get_css_devid(Object
*obj
, Visitor
*v
, const char *name
,
2287 void *opaque
, Error
**errp
)
2289 DeviceState
*dev
= DEVICE(obj
);
2290 Property
*prop
= opaque
;
2291 CssDevId
*dev_id
= qdev_get_prop_ptr(dev
, prop
);
2292 char buffer
[] = "xx.x.xxxx";
2296 if (dev_id
->valid
) {
2298 r
= snprintf(buffer
, sizeof(buffer
), "%02x.%1x.%04x", dev_id
->cssid
,
2299 dev_id
->ssid
, dev_id
->devid
);
2300 assert(r
== sizeof(buffer
) - 1);
2302 /* drop leading zero */
2303 if (dev_id
->cssid
<= 0xf) {
2307 snprintf(buffer
, sizeof(buffer
), "<unset>");
2310 visit_type_str(v
, name
, &p
, errp
);
2314 * parse <cssid>.<ssid>.<devid> and assert valid range for cssid/ssid
2316 static void set_css_devid(Object
*obj
, Visitor
*v
, const char *name
,
2317 void *opaque
, Error
**errp
)
2319 DeviceState
*dev
= DEVICE(obj
);
2320 Property
*prop
= opaque
;
2321 CssDevId
*dev_id
= qdev_get_prop_ptr(dev
, prop
);
2322 Error
*local_err
= NULL
;
2325 unsigned int cssid
, ssid
, devid
;
2327 if (dev
->realized
) {
2328 qdev_prop_set_after_realize(dev
, name
, errp
);
2332 visit_type_str(v
, name
, &str
, &local_err
);
2334 error_propagate(errp
, local_err
);
2338 num
= sscanf(str
, "%2x.%1x%n.%4x%n", &cssid
, &ssid
, &n1
, &devid
, &n2
);
2339 if (num
!= 3 || (n2
- n1
) != 5 || strlen(str
) != n2
) {
2340 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
2343 if ((cssid
> MAX_CSSID
) || (ssid
> MAX_SSID
)) {
2344 error_setg(errp
, "Invalid cssid or ssid: cssid %x, ssid %x",
2349 dev_id
->cssid
= cssid
;
2350 dev_id
->ssid
= ssid
;
2351 dev_id
->devid
= devid
;
2352 dev_id
->valid
= true;
2358 const PropertyInfo css_devid_propinfo
= {
2360 .description
= "Identifier of an I/O device in the channel "
2361 "subsystem, example: fe.1.23ab",
2362 .get
= get_css_devid
,
2363 .set
= set_css_devid
,
2366 const PropertyInfo css_devid_ro_propinfo
= {
2368 .description
= "Read-only identifier of an I/O device in the channel "
2369 "subsystem, example: fe.1.23ab",
2370 .get
= get_css_devid
,
2373 SubchDev
*css_create_sch(CssDevId bus_id
, bool squash_mcss
, Error
**errp
)
2380 bus_id
.cssid
= channel_subsys
.default_cssid
;
2381 } else if (!channel_subsys
.css
[bus_id
.cssid
]) {
2382 css_create_css_image(bus_id
.cssid
, false);
2385 if (!css_find_free_subch_for_devno(bus_id
.cssid
, bus_id
.ssid
,
2386 bus_id
.devid
, &schid
, errp
)) {
2390 for (bus_id
.cssid
= channel_subsys
.default_cssid
;;) {
2391 if (!channel_subsys
.css
[bus_id
.cssid
]) {
2392 css_create_css_image(bus_id
.cssid
, false);
2395 if (css_find_free_subch_and_devno(bus_id
.cssid
, &bus_id
.ssid
,
2396 &bus_id
.devid
, &schid
,
2400 bus_id
.cssid
= (bus_id
.cssid
+ 1) % MAX_CSSID
;
2401 if (bus_id
.cssid
== channel_subsys
.default_cssid
) {
2402 error_setg(errp
, "Virtual channel subsystem is full!");
2408 sch
= g_new0(SubchDev
, 1);
2409 sch
->cssid
= bus_id
.cssid
;
2410 sch
->ssid
= bus_id
.ssid
;
2411 sch
->devno
= bus_id
.devid
;
2413 css_subch_assign(sch
->cssid
, sch
->ssid
, schid
, sch
->devno
, sch
);
2417 static int css_sch_get_chpids(SubchDev
*sch
, CssDevId
*dev_id
)
2423 PMCW
*p
= &sch
->curr_status
.pmcw
;
2425 fid_path
= g_strdup_printf("/sys/bus/css/devices/%x.%x.%04x/chpids",
2426 dev_id
->cssid
, dev_id
->ssid
, dev_id
->devid
);
2427 fd
= fopen(fid_path
, "r");
2429 error_report("%s: open %s failed", __func__
, fid_path
);
2434 if (fscanf(fd
, "%x %x %x %x %x %x %x %x",
2435 &chpid
[0], &chpid
[1], &chpid
[2], &chpid
[3],
2436 &chpid
[4], &chpid
[5], &chpid
[6], &chpid
[7]) != 8) {
2442 for (i
= 0; i
< ARRAY_SIZE(p
->chpid
); i
++) {
2443 p
->chpid
[i
] = chpid
[i
];
2452 static int css_sch_get_path_masks(SubchDev
*sch
, CssDevId
*dev_id
)
2456 uint32_t pim
, pam
, pom
;
2457 PMCW
*p
= &sch
->curr_status
.pmcw
;
2459 fid_path
= g_strdup_printf("/sys/bus/css/devices/%x.%x.%04x/pimpampom",
2460 dev_id
->cssid
, dev_id
->ssid
, dev_id
->devid
);
2461 fd
= fopen(fid_path
, "r");
2463 error_report("%s: open %s failed", __func__
, fid_path
);
2468 if (fscanf(fd
, "%x %x %x", &pim
, &pam
, &pom
) != 3) {
2483 static int css_sch_get_chpid_type(uint8_t chpid
, uint32_t *type
,
2489 fid_path
= g_strdup_printf("/sys/devices/css%x/chp0.%02x/type",
2490 dev_id
->cssid
, chpid
);
2491 fd
= fopen(fid_path
, "r");
2493 error_report("%s: open %s failed", __func__
, fid_path
);
2498 if (fscanf(fd
, "%x", type
) != 1) {
2511 * We currently retrieve the real device information from sysfs to build the
2512 * guest subchannel information block without considering the migration feature.
2513 * We need to revisit this problem when we want to add migration support.
2515 int css_sch_build_schib(SubchDev
*sch
, CssDevId
*dev_id
)
2517 CssImage
*css
= channel_subsys
.css
[sch
->cssid
];
2518 PMCW
*p
= &sch
->curr_status
.pmcw
;
2519 SCSW
*s
= &sch
->curr_status
.scsw
;
2523 assert(css
!= NULL
);
2524 memset(p
, 0, sizeof(PMCW
));
2525 p
->flags
|= PMCW_FLAGS_MASK_DNV
;
2526 /* We are dealing with I/O subchannels only. */
2527 p
->devno
= sch
->devno
;
2529 /* Grab path mask from sysfs. */
2530 ret
= css_sch_get_path_masks(sch
, dev_id
);
2535 /* Grab chpids from sysfs. */
2536 ret
= css_sch_get_chpids(sch
, dev_id
);
2541 /* Build chpid type. */
2542 for (i
= 0; i
< ARRAY_SIZE(p
->chpid
); i
++) {
2543 if (p
->chpid
[i
] && !css
->chpids
[p
->chpid
[i
]].in_use
) {
2544 ret
= css_sch_get_chpid_type(p
->chpid
[i
], &type
, dev_id
);
2548 css_add_chpid(sch
->cssid
, p
->chpid
[i
], type
, false);
2552 memset(s
, 0, sizeof(SCSW
));
2553 sch
->curr_status
.mba
= 0;
2554 for (i
= 0; i
< ARRAY_SIZE(sch
->curr_status
.mda
); i
++) {
2555 sch
->curr_status
.mda
[i
] = 0;