2 * Copyright IBM Corp. 2007,2012
4 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>,
5 * Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
8 #define KMSG_COMPONENT "sclp_cmd"
9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11 #include <linux/completion.h>
12 #include <linux/init.h>
13 #include <linux/errno.h>
14 #include <linux/err.h>
15 #include <linux/export.h>
16 #include <linux/slab.h>
17 #include <linux/string.h>
19 #include <linux/mmzone.h>
20 #include <linux/memory.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <asm/ctl_reg.h>
24 #include <asm/chpid.h>
25 #include <asm/setup.h>
31 #define SCLP_CMDW_READ_SCP_INFO 0x00020001
32 #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
34 struct read_info_sccb
{
35 struct sccb_header header
; /* 0-7 */
38 u8 _reserved0
[24 - 11]; /* 11-15 */
39 u8 loadparm
[8]; /* 24-31 */
40 u8 _reserved1
[48 - 32]; /* 32-47 */
41 u64 facilities
; /* 48-55 */
42 u8 _reserved2
[84 - 56]; /* 56-83 */
45 u8 _reserved3
[91 - 86]; /* 86-90 */
47 u8 _reserved4
[100 - 92]; /* 92-99 */
48 u32 rnsize2
; /* 100-103 */
49 u64 rnmax2
; /* 104-111 */
50 u8 _reserved5
[4096 - 112]; /* 112-4095 */
51 } __attribute__((packed
, aligned(PAGE_SIZE
)));
53 static struct init_sccb __initdata early_event_mask_sccb
__aligned(PAGE_SIZE
);
54 static struct read_info_sccb __initdata early_read_info_sccb
;
55 static int __initdata early_read_info_sccb_valid
;
59 static unsigned long long rzm
;
60 static unsigned long long rnmax
;
62 static int __init
sclp_cmd_sync_early(sclp_cmdw_t cmd
, void *sccb
)
67 rc
= sclp_service_call(cmd
, sccb
);
70 __load_psw_mask(PSW_DEFAULT_KEY
| PSW_MASK_BASE
| PSW_MASK_EA
|
71 PSW_MASK_BA
| PSW_MASK_EXT
| PSW_MASK_WAIT
);
74 /* Contents of the sccb might have changed. */
76 __ctl_clear_bit(0, 9);
80 static void __init
sclp_read_info_early(void)
84 struct read_info_sccb
*sccb
;
85 sclp_cmdw_t commands
[] = {SCLP_CMDW_READ_SCP_INFO_FORCED
,
86 SCLP_CMDW_READ_SCP_INFO
};
88 sccb
= &early_read_info_sccb
;
89 for (i
= 0; i
< ARRAY_SIZE(commands
); i
++) {
91 memset(sccb
, 0, sizeof(*sccb
));
92 sccb
->header
.length
= sizeof(*sccb
);
93 sccb
->header
.function_code
= 0x80;
94 sccb
->header
.control_mask
[2] = 0x80;
95 rc
= sclp_cmd_sync_early(commands
[i
], sccb
);
96 } while (rc
== -EBUSY
);
100 if (sccb
->header
.response_code
== 0x10) {
101 early_read_info_sccb_valid
= 1;
104 if (sccb
->header
.response_code
!= 0x1f0)
109 static void __init
sclp_event_mask_early(void)
111 struct init_sccb
*sccb
= &early_event_mask_sccb
;
115 memset(sccb
, 0, sizeof(*sccb
));
116 sccb
->header
.length
= sizeof(*sccb
);
117 sccb
->mask_length
= sizeof(sccb_mask_t
);
118 rc
= sclp_cmd_sync_early(SCLP_CMDW_WRITE_EVENT_MASK
, sccb
);
119 } while (rc
== -EBUSY
);
122 void __init
sclp_facilities_detect(void)
124 struct read_info_sccb
*sccb
;
126 sclp_read_info_early();
127 if (!early_read_info_sccb_valid
)
130 sccb
= &early_read_info_sccb
;
131 sclp_facilities
= sccb
->facilities
;
132 sclp_fac84
= sccb
->fac84
;
133 if (sccb
->fac85
& 0x02)
134 S390_lowcore
.machine_flags
|= MACHINE_FLAG_ESOP
;
135 rnmax
= sccb
->rnmax
? sccb
->rnmax
: sccb
->rnmax2
;
136 rzm
= sccb
->rnsize
? sccb
->rnsize
: sccb
->rnsize2
;
139 sclp_event_mask_early();
142 bool __init
sclp_has_linemode(void)
144 struct init_sccb
*sccb
= &early_event_mask_sccb
;
146 if (sccb
->header
.response_code
!= 0x20)
148 if (sccb
->sclp_send_mask
& (EVTYP_MSG_MASK
| EVTYP_PMSGCMD_MASK
))
153 bool __init
sclp_has_vt220(void)
155 struct init_sccb
*sccb
= &early_event_mask_sccb
;
157 if (sccb
->header
.response_code
!= 0x20)
159 if (sccb
->sclp_send_mask
& EVTYP_VT220MSG_MASK
)
164 unsigned long long sclp_get_rnmax(void)
169 unsigned long long sclp_get_rzm(void)
175 * This function will be called after sclp_facilities_detect(), which gets
176 * called from early.c code. Therefore the sccb should have valid contents.
178 void __init
sclp_get_ipl_info(struct sclp_ipl_info
*info
)
180 struct read_info_sccb
*sccb
;
182 if (!early_read_info_sccb_valid
)
184 sccb
= &early_read_info_sccb
;
186 if (sccb
->flags
& 0x2)
188 memcpy(&info
->loadparm
, &sccb
->loadparm
, LOADPARM_LEN
);
191 static void sclp_sync_callback(struct sclp_req
*req
, void *data
)
193 struct completion
*completion
= data
;
195 complete(completion
);
198 static int do_sync_request(sclp_cmdw_t cmd
, void *sccb
)
200 struct completion completion
;
201 struct sclp_req
*request
;
204 request
= kzalloc(sizeof(*request
), GFP_KERNEL
);
207 request
->command
= cmd
;
208 request
->sccb
= sccb
;
209 request
->status
= SCLP_REQ_FILLED
;
210 request
->callback
= sclp_sync_callback
;
211 request
->callback_data
= &completion
;
212 init_completion(&completion
);
214 /* Perform sclp request. */
215 rc
= sclp_add_request(request
);
218 wait_for_completion(&completion
);
220 /* Check response. */
221 if (request
->status
!= SCLP_REQ_DONE
) {
222 pr_warning("sync request failed (cmd=0x%08x, "
223 "status=0x%02x)\n", cmd
, request
->status
);
232 * CPU configuration related functions.
235 #define SCLP_CMDW_READ_CPU_INFO 0x00010001
236 #define SCLP_CMDW_CONFIGURE_CPU 0x00110001
237 #define SCLP_CMDW_DECONFIGURE_CPU 0x00100001
239 struct read_cpu_info_sccb
{
240 struct sccb_header header
;
242 u16 offset_configured
;
245 u8 reserved
[4096 - 16];
246 } __attribute__((packed
, aligned(PAGE_SIZE
)));
248 static void sclp_fill_cpu_info(struct sclp_cpu_info
*info
,
249 struct read_cpu_info_sccb
*sccb
)
251 char *page
= (char *) sccb
;
253 memset(info
, 0, sizeof(*info
));
254 info
->configured
= sccb
->nr_configured
;
255 info
->standby
= sccb
->nr_standby
;
256 info
->combined
= sccb
->nr_configured
+ sccb
->nr_standby
;
257 info
->has_cpu_type
= sclp_fac84
& 0x1;
258 memcpy(&info
->cpu
, page
+ sccb
->offset_configured
,
259 info
->combined
* sizeof(struct sclp_cpu_entry
));
262 int sclp_get_cpu_info(struct sclp_cpu_info
*info
)
265 struct read_cpu_info_sccb
*sccb
;
267 if (!SCLP_HAS_CPU_INFO
)
269 sccb
= (void *) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
272 sccb
->header
.length
= sizeof(*sccb
);
273 rc
= do_sync_request(SCLP_CMDW_READ_CPU_INFO
, sccb
);
276 if (sccb
->header
.response_code
!= 0x0010) {
277 pr_warning("readcpuinfo failed (response=0x%04x)\n",
278 sccb
->header
.response_code
);
282 sclp_fill_cpu_info(info
, sccb
);
284 free_page((unsigned long) sccb
);
288 struct cpu_configure_sccb
{
289 struct sccb_header header
;
290 } __attribute__((packed
, aligned(8)));
292 static int do_cpu_configure(sclp_cmdw_t cmd
)
294 struct cpu_configure_sccb
*sccb
;
297 if (!SCLP_HAS_CPU_RECONFIG
)
300 * This is not going to cross a page boundary since we force
301 * kmalloc to have a minimum alignment of 8 bytes on s390.
303 sccb
= kzalloc(sizeof(*sccb
), GFP_KERNEL
| GFP_DMA
);
306 sccb
->header
.length
= sizeof(*sccb
);
307 rc
= do_sync_request(cmd
, sccb
);
310 switch (sccb
->header
.response_code
) {
315 pr_warning("configure cpu failed (cmd=0x%08x, "
316 "response=0x%04x)\n", cmd
,
317 sccb
->header
.response_code
);
326 int sclp_cpu_configure(u8 cpu
)
328 return do_cpu_configure(SCLP_CMDW_CONFIGURE_CPU
| cpu
<< 8);
331 int sclp_cpu_deconfigure(u8 cpu
)
333 return do_cpu_configure(SCLP_CMDW_DECONFIGURE_CPU
| cpu
<< 8);
336 #ifdef CONFIG_MEMORY_HOTPLUG
338 static DEFINE_MUTEX(sclp_mem_mutex
);
339 static LIST_HEAD(sclp_mem_list
);
340 static u8 sclp_max_storage_id
;
341 static unsigned long sclp_storage_ids
[256 / BITS_PER_LONG
];
342 static int sclp_mem_state_changed
;
344 struct memory_increment
{
345 struct list_head list
;
351 struct assign_storage_sccb
{
352 struct sccb_header header
;
356 int arch_get_memory_phys_device(unsigned long start_pfn
)
360 return PFN_PHYS(start_pfn
) >> ilog2(rzm
);
363 static unsigned long long rn2addr(u16 rn
)
365 return (unsigned long long) (rn
- 1) * rzm
;
368 static int do_assign_storage(sclp_cmdw_t cmd
, u16 rn
)
370 struct assign_storage_sccb
*sccb
;
373 sccb
= (void *) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
376 sccb
->header
.length
= PAGE_SIZE
;
378 rc
= do_sync_request(cmd
, sccb
);
381 switch (sccb
->header
.response_code
) {
386 pr_warning("assign storage failed (cmd=0x%08x, "
387 "response=0x%04x, rn=0x%04x)\n", cmd
,
388 sccb
->header
.response_code
, rn
);
393 free_page((unsigned long) sccb
);
397 static int sclp_assign_storage(u16 rn
)
399 unsigned long long start
;
402 rc
= do_assign_storage(0x000d0001, rn
);
406 storage_key_init_range(start
, start
+ rzm
);
410 static int sclp_unassign_storage(u16 rn
)
412 return do_assign_storage(0x000c0001, rn
);
415 struct attach_storage_sccb
{
416 struct sccb_header header
;
423 static int sclp_attach_storage(u8 id
)
425 struct attach_storage_sccb
*sccb
;
429 sccb
= (void *) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
432 sccb
->header
.length
= PAGE_SIZE
;
433 rc
= do_sync_request(0x00080001 | id
<< 8, sccb
);
436 switch (sccb
->header
.response_code
) {
438 set_bit(id
, sclp_storage_ids
);
439 for (i
= 0; i
< sccb
->assigned
; i
++) {
440 if (sccb
->entries
[i
])
441 sclp_unassign_storage(sccb
->entries
[i
] >> 16);
449 free_page((unsigned long) sccb
);
453 static int sclp_mem_change_state(unsigned long start
, unsigned long size
,
456 struct memory_increment
*incr
;
457 unsigned long long istart
;
460 list_for_each_entry(incr
, &sclp_mem_list
, list
) {
461 istart
= rn2addr(incr
->rn
);
462 if (start
+ size
- 1 < istart
)
464 if (start
> istart
+ rzm
- 1)
467 if (incr
->usecount
++)
470 * Don't break the loop if one assign fails. Loop may
471 * be walked again on CANCEL and we can't save
472 * information if state changed before or not.
473 * So continue and increase usecount for all increments.
475 rc
|= sclp_assign_storage(incr
->rn
);
477 if (--incr
->usecount
)
479 sclp_unassign_storage(incr
->rn
);
482 return rc
? -EIO
: 0;
485 static int sclp_mem_notifier(struct notifier_block
*nb
,
486 unsigned long action
, void *data
)
488 unsigned long start
, size
;
489 struct memory_notify
*arg
;
494 start
= arg
->start_pfn
<< PAGE_SHIFT
;
495 size
= arg
->nr_pages
<< PAGE_SHIFT
;
496 mutex_lock(&sclp_mem_mutex
);
497 for_each_clear_bit(id
, sclp_storage_ids
, sclp_max_storage_id
+ 1)
498 sclp_attach_storage(id
);
501 case MEM_GOING_OFFLINE
:
502 case MEM_CANCEL_OFFLINE
:
504 case MEM_GOING_ONLINE
:
505 rc
= sclp_mem_change_state(start
, size
, 1);
507 case MEM_CANCEL_ONLINE
:
508 sclp_mem_change_state(start
, size
, 0);
511 sclp_mem_change_state(start
, size
, 0);
518 sclp_mem_state_changed
= 1;
519 mutex_unlock(&sclp_mem_mutex
);
520 return rc
? NOTIFY_BAD
: NOTIFY_OK
;
523 static struct notifier_block sclp_mem_nb
= {
524 .notifier_call
= sclp_mem_notifier
,
527 static void __init
add_memory_merged(u16 rn
)
529 static u16 first_rn
, num
;
530 unsigned long long start
, size
;
532 if (rn
&& first_rn
&& (first_rn
+ num
== rn
)) {
538 start
= rn2addr(first_rn
);
539 size
= (unsigned long long ) num
* rzm
;
540 if (start
>= VMEM_MAX_PHYS
)
542 if (start
+ size
> VMEM_MAX_PHYS
)
543 size
= VMEM_MAX_PHYS
- start
;
544 if (memory_end_set
&& (start
>= memory_end
))
546 if (memory_end_set
&& (start
+ size
> memory_end
))
547 size
= memory_end
- start
;
548 add_memory(0, start
, size
);
554 static void __init
sclp_add_standby_memory(void)
556 struct memory_increment
*incr
;
558 list_for_each_entry(incr
, &sclp_mem_list
, list
)
560 add_memory_merged(incr
->rn
);
561 add_memory_merged(0);
564 static void __init
insert_increment(u16 rn
, int standby
, int assigned
)
566 struct memory_increment
*incr
, *new_incr
;
567 struct list_head
*prev
;
570 new_incr
= kzalloc(sizeof(*new_incr
), GFP_KERNEL
);
574 new_incr
->standby
= standby
;
576 new_incr
->usecount
= 1;
578 prev
= &sclp_mem_list
;
579 list_for_each_entry(incr
, &sclp_mem_list
, list
) {
580 if (assigned
&& incr
->rn
> rn
)
582 if (!assigned
&& incr
->rn
- last_rn
> 1)
588 new_incr
->rn
= last_rn
+ 1;
589 if (new_incr
->rn
> rnmax
) {
593 list_add(&new_incr
->list
, prev
);
596 static int sclp_mem_freeze(struct device
*dev
)
598 if (!sclp_mem_state_changed
)
600 pr_err("Memory hotplug state changed, suspend refused.\n");
604 struct read_storage_sccb
{
605 struct sccb_header header
;
613 static const struct dev_pm_ops sclp_mem_pm_ops
= {
614 .freeze
= sclp_mem_freeze
,
617 static struct platform_driver sclp_mem_pdrv
= {
620 .pm
= &sclp_mem_pm_ops
,
624 static int __init
sclp_detect_standby_memory(void)
626 struct platform_device
*sclp_pdev
;
627 struct read_storage_sccb
*sccb
;
628 int i
, id
, assigned
, rc
;
630 if (!early_read_info_sccb_valid
)
632 if ((sclp_facilities
& 0xe00000000000ULL
) != 0xe00000000000ULL
)
635 sccb
= (void *) __get_free_page(GFP_KERNEL
| GFP_DMA
);
639 for (id
= 0; id
<= sclp_max_storage_id
; id
++) {
640 memset(sccb
, 0, PAGE_SIZE
);
641 sccb
->header
.length
= PAGE_SIZE
;
642 rc
= do_sync_request(0x00040001 | id
<< 8, sccb
);
645 switch (sccb
->header
.response_code
) {
647 set_bit(id
, sclp_storage_ids
);
648 for (i
= 0; i
< sccb
->assigned
; i
++) {
649 if (!sccb
->entries
[i
])
652 insert_increment(sccb
->entries
[i
] >> 16, 0, 1);
658 for (i
= 0; i
< sccb
->assigned
; i
++) {
659 if (!sccb
->entries
[i
])
662 insert_increment(sccb
->entries
[i
] >> 16, 1, 1);
670 sclp_max_storage_id
= sccb
->max_id
;
672 if (rc
|| list_empty(&sclp_mem_list
))
674 for (i
= 1; i
<= rnmax
- assigned
; i
++)
675 insert_increment(0, 1, 0);
676 rc
= register_memory_notifier(&sclp_mem_nb
);
679 rc
= platform_driver_register(&sclp_mem_pdrv
);
682 sclp_pdev
= platform_device_register_simple("sclp_mem", -1, NULL
, 0);
683 rc
= IS_ERR(sclp_pdev
) ? PTR_ERR(sclp_pdev
) : 0;
686 sclp_add_standby_memory();
689 platform_driver_unregister(&sclp_mem_pdrv
);
691 free_page((unsigned long) sccb
);
694 __initcall(sclp_detect_standby_memory
);
696 #endif /* CONFIG_MEMORY_HOTPLUG */
699 * PCI I/O adapter configuration related functions.
701 #define SCLP_CMDW_CONFIGURE_PCI 0x001a0001
702 #define SCLP_CMDW_DECONFIGURE_PCI 0x001b0001
704 #define SCLP_RECONFIG_PCI_ATPYE 2
706 struct pci_cfg_sccb
{
707 struct sccb_header header
;
708 u8 atype
; /* adapter type */
711 u32 aid
; /* adapter identifier */
714 static int do_pci_configure(sclp_cmdw_t cmd
, u32 fid
)
716 struct pci_cfg_sccb
*sccb
;
719 if (!SCLP_HAS_PCI_RECONFIG
)
722 sccb
= (struct pci_cfg_sccb
*) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
726 sccb
->header
.length
= PAGE_SIZE
;
727 sccb
->atype
= SCLP_RECONFIG_PCI_ATPYE
;
729 rc
= do_sync_request(cmd
, sccb
);
732 switch (sccb
->header
.response_code
) {
737 pr_warn("configure PCI I/O adapter failed: cmd=0x%08x response=0x%04x\n",
738 cmd
, sccb
->header
.response_code
);
743 free_page((unsigned long) sccb
);
747 int sclp_pci_configure(u32 fid
)
749 return do_pci_configure(SCLP_CMDW_CONFIGURE_PCI
, fid
);
751 EXPORT_SYMBOL(sclp_pci_configure
);
753 int sclp_pci_deconfigure(u32 fid
)
755 return do_pci_configure(SCLP_CMDW_DECONFIGURE_PCI
, fid
);
757 EXPORT_SYMBOL(sclp_pci_deconfigure
);
760 * Channel path configuration related functions.
763 #define SCLP_CMDW_CONFIGURE_CHPATH 0x000f0001
764 #define SCLP_CMDW_DECONFIGURE_CHPATH 0x000e0001
765 #define SCLP_CMDW_READ_CHPATH_INFORMATION 0x00030001
767 struct chp_cfg_sccb
{
768 struct sccb_header header
;
772 } __attribute__((packed
));
774 static int do_chp_configure(sclp_cmdw_t cmd
)
776 struct chp_cfg_sccb
*sccb
;
779 if (!SCLP_HAS_CHP_RECONFIG
)
782 sccb
= (struct chp_cfg_sccb
*) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
785 sccb
->header
.length
= sizeof(*sccb
);
786 rc
= do_sync_request(cmd
, sccb
);
789 switch (sccb
->header
.response_code
) {
796 pr_warning("configure channel-path failed "
797 "(cmd=0x%08x, response=0x%04x)\n", cmd
,
798 sccb
->header
.response_code
);
803 free_page((unsigned long) sccb
);
808 * sclp_chp_configure - perform configure channel-path sclp command
809 * @chpid: channel-path ID
811 * Perform configure channel-path command sclp command for specified chpid.
812 * Return 0 after command successfully finished, non-zero otherwise.
814 int sclp_chp_configure(struct chp_id chpid
)
816 return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH
| chpid
.id
<< 8);
820 * sclp_chp_deconfigure - perform deconfigure channel-path sclp command
821 * @chpid: channel-path ID
823 * Perform deconfigure channel-path command sclp command for specified chpid
824 * and wait for completion. On success return 0. Return non-zero otherwise.
826 int sclp_chp_deconfigure(struct chp_id chpid
)
828 return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH
| chpid
.id
<< 8);
831 struct chp_info_sccb
{
832 struct sccb_header header
;
833 u8 recognized
[SCLP_CHP_INFO_MASK_SIZE
];
834 u8 standby
[SCLP_CHP_INFO_MASK_SIZE
];
835 u8 configured
[SCLP_CHP_INFO_MASK_SIZE
];
839 } __attribute__((packed
));
842 * sclp_chp_read_info - perform read channel-path information sclp command
843 * @info: resulting channel-path information data
845 * Perform read channel-path information sclp command and wait for completion.
846 * On success, store channel-path information in @info and return 0. Return
847 * non-zero otherwise.
849 int sclp_chp_read_info(struct sclp_chp_info
*info
)
851 struct chp_info_sccb
*sccb
;
854 if (!SCLP_HAS_CHP_INFO
)
857 sccb
= (struct chp_info_sccb
*) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
860 sccb
->header
.length
= sizeof(*sccb
);
861 rc
= do_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION
, sccb
);
864 if (sccb
->header
.response_code
!= 0x0010) {
865 pr_warning("read channel-path info failed "
866 "(response=0x%04x)\n", sccb
->header
.response_code
);
870 memcpy(info
->recognized
, sccb
->recognized
, SCLP_CHP_INFO_MASK_SIZE
);
871 memcpy(info
->standby
, sccb
->standby
, SCLP_CHP_INFO_MASK_SIZE
);
872 memcpy(info
->configured
, sccb
->configured
, SCLP_CHP_INFO_MASK_SIZE
);
874 free_page((unsigned long) sccb
);