4 * Copyright IBM, Corp. 2012
7 * Christian Borntraeger <borntraeger@de.ibm.com>
8 * Heinz Graalfs <graalfs@linux.vnet.ibm.com>
10 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
11 * option) any later version. See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
16 #include "qapi/error.h"
18 #include "sysemu/kvm.h"
19 #include "exec/memory.h"
20 #include "sysemu/sysemu.h"
21 #include "exec/address-spaces.h"
22 #include "hw/boards.h"
23 #include "hw/s390x/sclp.h"
24 #include "hw/s390x/event-facility.h"
25 #include "hw/s390x/s390-pci-bus.h"
26 #include "hw/s390x/ipl.h"
28 static inline SCLPDevice
*get_sclp_device(void)
30 static SCLPDevice
*sclp
;
33 sclp
= SCLP(object_resolve_path_type("", TYPE_SCLP
, NULL
));
38 static void prepare_cpu_entries(SCLPDevice
*sclp
, CPUEntry
*entry
, int count
)
40 uint8_t features
[SCCB_CPU_FEATURE_LEN
] = { 0 };
43 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CPU
, features
);
44 for (i
= 0; i
< count
; i
++) {
47 memcpy(entry
[i
].features
, features
, sizeof(entry
[i
].features
));
51 /* Provide information about the configuration, CPUs and storage */
52 static void read_SCP_info(SCLPDevice
*sclp
, SCCB
*sccb
)
54 ReadInfo
*read_info
= (ReadInfo
*) sccb
;
55 MachineState
*machine
= MACHINE(qdev_get_machine());
56 sclpMemoryHotplugDev
*mhd
= get_sclp_memory_hotplug_dev();
60 int slots
= MIN(machine
->ram_slots
, s390_get_memslot_count(kvm_state
));
61 IplParameterBlock
*ipib
= s390_ipl_get_iplb();
68 read_info
->entries_cpu
= cpu_to_be16(cpu_count
);
69 read_info
->offset_cpu
= cpu_to_be16(offsetof(ReadInfo
, entries
));
70 read_info
->highest_cpu
= cpu_to_be16(max_cpus
);
72 read_info
->ibc_val
= cpu_to_be32(s390_get_ibc_val());
74 /* Configuration Characteristic (Extension) */
75 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR
,
76 read_info
->conf_char
);
77 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT
,
78 read_info
->conf_char_ext
);
80 prepare_cpu_entries(sclp
, read_info
->entries
, cpu_count
);
82 read_info
->facilities
= cpu_to_be64(SCLP_HAS_CPU_INFO
|
83 SCLP_HAS_PCI_RECONFIG
);
85 /* Memory Hotplug is only supported for the ccw machine type */
87 mhd
->standby_subregion_size
= MEM_SECTION_SIZE
;
88 /* Deduct the memory slot already used for core */
90 while ((mhd
->standby_subregion_size
* (slots
- 1)
91 < mhd
->standby_mem_size
)) {
92 mhd
->standby_subregion_size
= mhd
->standby_subregion_size
<< 1;
96 * Initialize mapping of guest standby memory sections indicating which
97 * are and are not online. Assume all standby memory begins offline.
99 if (mhd
->standby_state_map
== 0) {
100 if (mhd
->standby_mem_size
% mhd
->standby_subregion_size
) {
101 mhd
->standby_state_map
= g_malloc0((mhd
->standby_mem_size
/
102 mhd
->standby_subregion_size
+ 1) *
103 (mhd
->standby_subregion_size
/
106 mhd
->standby_state_map
= g_malloc0(mhd
->standby_mem_size
/
110 mhd
->padded_ram_size
= ram_size
+ mhd
->pad_size
;
111 mhd
->rzm
= 1 << mhd
->increment_size
;
113 read_info
->facilities
|= cpu_to_be64(SCLP_FC_ASSIGN_ATTACH_READ_STOR
);
115 read_info
->mha_pow
= s390_get_mha_pow();
116 read_info
->hmfai
= cpu_to_be32(s390_get_hmfai());
118 rnsize
= 1 << (sclp
->increment_size
- 20);
120 read_info
->rnsize
= rnsize
;
122 read_info
->rnsize
= 0;
123 read_info
->rnsize2
= cpu_to_be32(rnsize
);
126 rnmax
= machine
->maxram_size
>> sclp
->increment_size
;
127 if (rnmax
< 0x10000) {
128 read_info
->rnmax
= cpu_to_be16(rnmax
);
130 read_info
->rnmax
= cpu_to_be16(0);
131 read_info
->rnmax2
= cpu_to_be64(rnmax
);
134 if (ipib
&& ipib
->flags
& DIAG308_FLAGS_LP_VALID
) {
135 memcpy(&read_info
->loadparm
, &ipib
->loadparm
,
136 sizeof(read_info
->loadparm
));
138 s390_ipl_set_loadparm(read_info
->loadparm
);
141 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION
);
144 static void read_storage_element0_info(SCLPDevice
*sclp
, SCCB
*sccb
)
147 int subincrement_id
= SCLP_STARTING_SUBINCREMENT_ID
;
148 ReadStorageElementInfo
*storage_info
= (ReadStorageElementInfo
*) sccb
;
149 sclpMemoryHotplugDev
*mhd
= get_sclp_memory_hotplug_dev();
152 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
156 if ((ram_size
>> mhd
->increment_size
) >= 0x10000) {
157 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION
);
161 /* Return information regarding core memory */
162 storage_info
->max_id
= cpu_to_be16(mhd
->standby_mem_size
? 1 : 0);
163 assigned
= ram_size
>> mhd
->increment_size
;
164 storage_info
->assigned
= cpu_to_be16(assigned
);
166 for (i
= 0; i
< assigned
; i
++) {
167 storage_info
->entries
[i
] = cpu_to_be32(subincrement_id
);
168 subincrement_id
+= SCLP_INCREMENT_UNIT
;
170 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION
);
173 static void read_storage_element1_info(SCLPDevice
*sclp
, SCCB
*sccb
)
175 ReadStorageElementInfo
*storage_info
= (ReadStorageElementInfo
*) sccb
;
176 sclpMemoryHotplugDev
*mhd
= get_sclp_memory_hotplug_dev();
179 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
183 if ((mhd
->standby_mem_size
>> mhd
->increment_size
) >= 0x10000) {
184 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION
);
188 /* Return information regarding standby memory */
189 storage_info
->max_id
= cpu_to_be16(mhd
->standby_mem_size
? 1 : 0);
190 storage_info
->assigned
= cpu_to_be16(mhd
->standby_mem_size
>>
191 mhd
->increment_size
);
192 storage_info
->standby
= cpu_to_be16(mhd
->standby_mem_size
>>
193 mhd
->increment_size
);
194 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_STANDBY_READ_COMPLETION
);
197 static void attach_storage_element(SCLPDevice
*sclp
, SCCB
*sccb
,
200 int i
, assigned
, subincrement_id
;
201 AttachStorageElement
*attach_info
= (AttachStorageElement
*) sccb
;
202 sclpMemoryHotplugDev
*mhd
= get_sclp_memory_hotplug_dev();
205 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
210 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
214 assigned
= mhd
->standby_mem_size
>> mhd
->increment_size
;
215 attach_info
->assigned
= cpu_to_be16(assigned
);
216 subincrement_id
= ((ram_size
>> mhd
->increment_size
) << 16)
217 + SCLP_STARTING_SUBINCREMENT_ID
;
218 for (i
= 0; i
< assigned
; i
++) {
219 attach_info
->entries
[i
] = cpu_to_be32(subincrement_id
);
220 subincrement_id
+= SCLP_INCREMENT_UNIT
;
222 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_COMPLETION
);
225 static void assign_storage(SCLPDevice
*sclp
, SCCB
*sccb
)
227 MemoryRegion
*mr
= NULL
;
228 uint64_t this_subregion_size
;
229 AssignStorage
*assign_info
= (AssignStorage
*) sccb
;
230 sclpMemoryHotplugDev
*mhd
= get_sclp_memory_hotplug_dev();
231 ram_addr_t assign_addr
;
232 MemoryRegion
*sysmem
= get_system_memory();
235 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
238 assign_addr
= (assign_info
->rn
- 1) * mhd
->rzm
;
240 if ((assign_addr
% MEM_SECTION_SIZE
== 0) &&
241 (assign_addr
>= mhd
->padded_ram_size
)) {
242 /* Re-use existing memory region if found */
243 mr
= memory_region_find(sysmem
, assign_addr
, 1).mr
;
244 memory_region_unref(mr
);
247 MemoryRegion
*standby_ram
= g_new(MemoryRegion
, 1);
249 /* offset to align to standby_subregion_size for allocation */
250 ram_addr_t offset
= assign_addr
-
251 (assign_addr
- mhd
->padded_ram_size
)
252 % mhd
->standby_subregion_size
;
254 /* strlen("standby.ram") + 4 (Max of KVM_MEMORY_SLOTS) + NULL */
256 snprintf(id
, 16, "standby.ram%d",
257 (int)((offset
- mhd
->padded_ram_size
) /
258 mhd
->standby_subregion_size
) + 1);
260 /* Allocate a subregion of the calculated standby_subregion_size */
261 if (offset
+ mhd
->standby_subregion_size
>
262 mhd
->padded_ram_size
+ mhd
->standby_mem_size
) {
263 this_subregion_size
= mhd
->padded_ram_size
+
264 mhd
->standby_mem_size
- offset
;
266 this_subregion_size
= mhd
->standby_subregion_size
;
269 memory_region_init_ram(standby_ram
, NULL
, id
, this_subregion_size
,
271 /* This is a hack to make memory hotunplug work again. Once we have
272 * subdevices, we have to unparent them when unassigning memory,
273 * instead of doing it via the ref count of the MemoryRegion. */
274 object_ref(OBJECT(standby_ram
));
275 object_unparent(OBJECT(standby_ram
));
276 vmstate_register_ram_global(standby_ram
);
277 memory_region_add_subregion(sysmem
, offset
, standby_ram
);
279 /* The specified subregion is no longer in standby */
280 mhd
->standby_state_map
[(assign_addr
- mhd
->padded_ram_size
)
281 / MEM_SECTION_SIZE
] = 1;
283 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_COMPLETION
);
286 static void unassign_storage(SCLPDevice
*sclp
, SCCB
*sccb
)
288 MemoryRegion
*mr
= NULL
;
289 AssignStorage
*assign_info
= (AssignStorage
*) sccb
;
290 sclpMemoryHotplugDev
*mhd
= get_sclp_memory_hotplug_dev();
291 ram_addr_t unassign_addr
;
292 MemoryRegion
*sysmem
= get_system_memory();
295 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
298 unassign_addr
= (assign_info
->rn
- 1) * mhd
->rzm
;
300 /* if the addr is a multiple of 256 MB */
301 if ((unassign_addr
% MEM_SECTION_SIZE
== 0) &&
302 (unassign_addr
>= mhd
->padded_ram_size
)) {
303 mhd
->standby_state_map
[(unassign_addr
-
304 mhd
->padded_ram_size
) / MEM_SECTION_SIZE
] = 0;
306 /* find the specified memory region and destroy it */
307 mr
= memory_region_find(sysmem
, unassign_addr
, 1).mr
;
308 memory_region_unref(mr
);
311 int is_removable
= 1;
312 ram_addr_t map_offset
= (unassign_addr
- mhd
->padded_ram_size
-
313 (unassign_addr
- mhd
->padded_ram_size
)
314 % mhd
->standby_subregion_size
);
315 /* Mark all affected subregions as 'standby' once again */
317 i
< (mhd
->standby_subregion_size
/ MEM_SECTION_SIZE
);
320 if (mhd
->standby_state_map
[i
+ map_offset
/ MEM_SECTION_SIZE
]) {
326 memory_region_del_subregion(sysmem
, mr
);
327 object_unref(OBJECT(mr
));
331 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_COMPLETION
);
334 /* Provide information about the CPU */
335 static void sclp_read_cpu_info(SCLPDevice
*sclp
, SCCB
*sccb
)
337 ReadCpuInfo
*cpu_info
= (ReadCpuInfo
*) sccb
;
345 cpu_info
->nr_configured
= cpu_to_be16(cpu_count
);
346 cpu_info
->offset_configured
= cpu_to_be16(offsetof(ReadCpuInfo
, entries
));
347 cpu_info
->nr_standby
= cpu_to_be16(0);
349 /* The standby offset is 16-byte for each CPU */
350 cpu_info
->offset_standby
= cpu_to_be16(cpu_info
->offset_configured
351 + cpu_info
->nr_configured
*sizeof(CPUEntry
));
353 prepare_cpu_entries(sclp
, cpu_info
->entries
, cpu_count
);
355 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION
);
358 static void sclp_execute(SCLPDevice
*sclp
, SCCB
*sccb
, uint32_t code
)
360 SCLPDeviceClass
*sclp_c
= SCLP_GET_CLASS(sclp
);
361 SCLPEventFacility
*ef
= sclp
->event_facility
;
362 SCLPEventFacilityClass
*efc
= EVENT_FACILITY_GET_CLASS(ef
);
364 switch (code
& SCLP_CMD_CODE_MASK
) {
365 case SCLP_CMDW_READ_SCP_INFO
:
366 case SCLP_CMDW_READ_SCP_INFO_FORCED
:
367 sclp_c
->read_SCP_info(sclp
, sccb
);
369 case SCLP_CMDW_READ_CPU_INFO
:
370 sclp_c
->read_cpu_info(sclp
, sccb
);
372 case SCLP_READ_STORAGE_ELEMENT_INFO
:
374 sclp_c
->read_storage_element1_info(sclp
, sccb
);
376 sclp_c
->read_storage_element0_info(sclp
, sccb
);
379 case SCLP_ATTACH_STORAGE_ELEMENT
:
380 sclp_c
->attach_storage_element(sclp
, sccb
, (code
& 0xff00) >> 8);
382 case SCLP_ASSIGN_STORAGE
:
383 sclp_c
->assign_storage(sclp
, sccb
);
385 case SCLP_UNASSIGN_STORAGE
:
386 sclp_c
->unassign_storage(sclp
, sccb
);
388 case SCLP_CMDW_CONFIGURE_PCI
:
389 s390_pci_sclp_configure(sccb
);
391 case SCLP_CMDW_DECONFIGURE_PCI
:
392 s390_pci_sclp_deconfigure(sccb
);
395 efc
->command_handler(ef
, sccb
, code
);
400 int sclp_service_call(CPUS390XState
*env
, uint64_t sccb
, uint32_t code
)
402 SCLPDevice
*sclp
= get_sclp_device();
403 SCLPDeviceClass
*sclp_c
= SCLP_GET_CLASS(sclp
);
407 hwaddr sccb_len
= sizeof(SCCB
);
409 /* first some basic checks on program checks */
410 if (env
->psw
.mask
& PSW_MASK_PSTATE
) {
414 if (cpu_physical_memory_is_io(sccb
)) {
418 if ((sccb
& ~0x1fffUL
) == 0 || (sccb
& ~0x1fffUL
) == env
->psa
419 || (sccb
& ~0x7ffffff8UL
) != 0) {
420 r
= -PGM_SPECIFICATION
;
425 * we want to work on a private copy of the sccb, to prevent guests
426 * from playing dirty tricks by modifying the memory content after
427 * the host has checked the values
429 cpu_physical_memory_read(sccb
, &work_sccb
, sccb_len
);
431 /* Valid sccb sizes */
432 if (be16_to_cpu(work_sccb
.h
.length
) < sizeof(SCCBHeader
) ||
433 be16_to_cpu(work_sccb
.h
.length
) > SCCB_SIZE
) {
434 r
= -PGM_SPECIFICATION
;
438 sclp_c
->execute(sclp
, &work_sccb
, code
);
440 cpu_physical_memory_write(sccb
, &work_sccb
,
441 be16_to_cpu(work_sccb
.h
.length
));
443 sclp_c
->service_interrupt(sclp
, sccb
);
449 static void service_interrupt(SCLPDevice
*sclp
, uint32_t sccb
)
451 SCLPEventFacility
*ef
= sclp
->event_facility
;
452 SCLPEventFacilityClass
*efc
= EVENT_FACILITY_GET_CLASS(ef
);
454 uint32_t param
= sccb
& ~3;
456 /* Indicate whether an event is still pending */
457 param
|= efc
->event_pending(ef
) ? 1 : 0;
460 /* No need to send an interrupt, there's nothing to be notified about */
463 s390_sclp_extint(param
);
466 void sclp_service_interrupt(uint32_t sccb
)
468 SCLPDevice
*sclp
= get_sclp_device();
469 SCLPDeviceClass
*sclp_c
= SCLP_GET_CLASS(sclp
);
471 sclp_c
->service_interrupt(sclp
, sccb
);
474 /* qemu object creation and initialization functions */
476 void s390_sclp_init(void)
478 Object
*new = object_new(TYPE_SCLP
);
480 object_property_add_child(qdev_get_machine(), TYPE_SCLP
, new,
482 object_unref(OBJECT(new));
483 qdev_init_nofail(DEVICE(new));
486 static void sclp_realize(DeviceState
*dev
, Error
**errp
)
488 MachineState
*machine
= MACHINE(qdev_get_machine());
489 SCLPDevice
*sclp
= SCLP(dev
);
494 object_property_set_bool(OBJECT(sclp
->event_facility
), true, "realized",
500 * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long
501 * as we can't find a fitting bus via the qom tree, we have to add the
502 * event facility to the sysbus, so e.g. a sclp console can be created.
504 qdev_set_parent_bus(DEVICE(sclp
->event_facility
), sysbus_get_default());
506 ret
= s390_set_memory_limit(machine
->maxram_size
, &hw_limit
);
508 error_setg(&err
, "qemu: host supports a maximum of %" PRIu64
" GB",
511 error_setg(&err
, "qemu: setting the guest size failed");
515 error_propagate(errp
, err
);
518 static void sclp_memory_init(SCLPDevice
*sclp
)
520 MachineState
*machine
= MACHINE(qdev_get_machine());
521 ram_addr_t initial_mem
= machine
->ram_size
;
522 ram_addr_t max_mem
= machine
->maxram_size
;
523 ram_addr_t standby_mem
= max_mem
- initial_mem
;
524 ram_addr_t pad_mem
= 0;
525 int increment_size
= 20;
527 /* The storage increment size is a multiple of 1M and is a power of 2.
528 * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer.
529 * The variable 'increment_size' is an exponent of 2 that can be
530 * used to calculate the size (in bytes) of an increment. */
531 while ((initial_mem
>> increment_size
) > MAX_STORAGE_INCREMENTS
) {
534 if (machine
->ram_slots
) {
535 while ((standby_mem
>> increment_size
) > MAX_STORAGE_INCREMENTS
) {
539 sclp
->increment_size
= increment_size
;
541 /* The core and standby memory areas need to be aligned with
542 * the increment size. In effect, this can cause the
543 * user-specified memory size to be rounded down to align
544 * with the nearest increment boundary. */
545 initial_mem
= initial_mem
>> increment_size
<< increment_size
;
546 standby_mem
= standby_mem
>> increment_size
<< increment_size
;
548 /* If the size of ram is not on a MEM_SECTION_SIZE boundary,
549 calculate the pad size necessary to force this boundary. */
550 if (machine
->ram_slots
&& standby_mem
) {
551 sclpMemoryHotplugDev
*mhd
= init_sclp_memory_hotplug_dev();
553 if (initial_mem
% MEM_SECTION_SIZE
) {
554 pad_mem
= MEM_SECTION_SIZE
- initial_mem
% MEM_SECTION_SIZE
;
556 mhd
->increment_size
= increment_size
;
557 mhd
->pad_size
= pad_mem
;
558 mhd
->standby_mem_size
= standby_mem
;
560 machine
->ram_size
= initial_mem
;
561 machine
->maxram_size
= initial_mem
+ pad_mem
+ standby_mem
;
562 /* let's propagate the changed ram size into the global variable. */
563 ram_size
= initial_mem
;
566 static void sclp_init(Object
*obj
)
568 SCLPDevice
*sclp
= SCLP(obj
);
571 new = object_new(TYPE_SCLP_EVENT_FACILITY
);
572 object_property_add_child(obj
, TYPE_SCLP_EVENT_FACILITY
, new, NULL
);
574 sclp
->event_facility
= EVENT_FACILITY(new);
576 sclp_memory_init(sclp
);
579 static void sclp_class_init(ObjectClass
*oc
, void *data
)
581 SCLPDeviceClass
*sc
= SCLP_CLASS(oc
);
582 DeviceClass
*dc
= DEVICE_CLASS(oc
);
584 dc
->desc
= "SCLP (Service-Call Logical Processor)";
585 dc
->realize
= sclp_realize
;
586 dc
->hotpluggable
= false;
587 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
589 sc
->read_SCP_info
= read_SCP_info
;
590 sc
->read_storage_element0_info
= read_storage_element0_info
;
591 sc
->read_storage_element1_info
= read_storage_element1_info
;
592 sc
->attach_storage_element
= attach_storage_element
;
593 sc
->assign_storage
= assign_storage
;
594 sc
->unassign_storage
= unassign_storage
;
595 sc
->read_cpu_info
= sclp_read_cpu_info
;
596 sc
->execute
= sclp_execute
;
597 sc
->service_interrupt
= service_interrupt
;
600 static TypeInfo sclp_info
= {
602 .parent
= TYPE_DEVICE
,
603 .instance_init
= sclp_init
,
604 .instance_size
= sizeof(SCLPDevice
),
605 .class_init
= sclp_class_init
,
606 .class_size
= sizeof(SCLPDeviceClass
),
609 sclpMemoryHotplugDev
*init_sclp_memory_hotplug_dev(void)
612 dev
= qdev_create(NULL
, TYPE_SCLP_MEMORY_HOTPLUG_DEV
);
613 object_property_add_child(qdev_get_machine(),
614 TYPE_SCLP_MEMORY_HOTPLUG_DEV
,
616 qdev_init_nofail(dev
);
617 return SCLP_MEMORY_HOTPLUG_DEV(object_resolve_path(
618 TYPE_SCLP_MEMORY_HOTPLUG_DEV
, NULL
));
621 sclpMemoryHotplugDev
*get_sclp_memory_hotplug_dev(void)
623 return SCLP_MEMORY_HOTPLUG_DEV(object_resolve_path(
624 TYPE_SCLP_MEMORY_HOTPLUG_DEV
, NULL
));
627 static void sclp_memory_hotplug_dev_class_init(ObjectClass
*klass
,
630 DeviceClass
*dc
= DEVICE_CLASS(klass
);
632 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
635 static TypeInfo sclp_memory_hotplug_dev_info
= {
636 .name
= TYPE_SCLP_MEMORY_HOTPLUG_DEV
,
637 .parent
= TYPE_SYS_BUS_DEVICE
,
638 .instance_size
= sizeof(sclpMemoryHotplugDev
),
639 .class_init
= sclp_memory_hotplug_dev_class_init
,
642 static void register_types(void)
644 type_register_static(&sclp_memory_hotplug_dev_info
);
645 type_register_static(&sclp_info
);
647 type_init(register_types
);