mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-06 02:50:43 +00:00
![Alexander Egorenkov](/assets/img/avatar_default.png)
To make the decompressor relocatable, the early SCLP buffer with a fixed address must be replaced with a relocatable C buffer of the according size and alignment as required by SCLP. Introduce a new function sclp_early_set_buffer() into the SCLP driver which enables the decompressor to change the SCLP early buffer at any time. This will be useful when the decompressor becomes fully relocatable and might need to change the SCLP early buffer to one with an address < 2G as required by SCLP because it was loaded at an address >= 2G. Signed-off-by: Alexander Egorenkov <egorenar@linux.ibm.com> Acked-by: Heiko Carstens <hca@linux.ibm.com> Signed-off-by: Heiko Carstens <hca@linux.ibm.com>
363 lines
9.2 KiB
C
363 lines
9.2 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright IBM Corp. 2015
|
|
* Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <asm/processor.h>
|
|
#include <asm/lowcore.h>
|
|
#include <asm/ebcdic.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/sections.h>
|
|
#include <asm/mem_detect.h>
|
|
#include <asm/facility.h>
|
|
#include "sclp.h"
|
|
#include "sclp_rw.h"
|
|
|
|
static struct read_info_sccb __bootdata(sclp_info_sccb);
|
|
static int __bootdata(sclp_info_sccb_valid);
|
|
char *__bootdata(sclp_early_sccb);
|
|
int sclp_init_state = sclp_init_state_uninitialized;
|
|
/*
|
|
* Used to keep track of the size of the event masks. Qemu until version 2.11
|
|
* only supports 4 and needs a workaround.
|
|
*/
|
|
bool sclp_mask_compat_mode;
|
|
|
|
void sclp_early_wait_irq(void)
|
|
{
|
|
unsigned long psw_mask, addr;
|
|
psw_t psw_ext_save, psw_wait;
|
|
union ctlreg0 cr0, cr0_new;
|
|
|
|
__ctl_store(cr0.val, 0, 0);
|
|
cr0_new.val = cr0.val & ~CR0_IRQ_SUBCLASS_MASK;
|
|
cr0_new.lap = 0;
|
|
cr0_new.sssm = 1;
|
|
__ctl_load(cr0_new.val, 0, 0);
|
|
|
|
psw_ext_save = S390_lowcore.external_new_psw;
|
|
psw_mask = __extract_psw();
|
|
S390_lowcore.external_new_psw.mask = psw_mask;
|
|
psw_wait.mask = psw_mask | PSW_MASK_EXT | PSW_MASK_WAIT;
|
|
S390_lowcore.ext_int_code = 0;
|
|
|
|
do {
|
|
asm volatile(
|
|
" larl %[addr],0f\n"
|
|
" stg %[addr],%[psw_wait_addr]\n"
|
|
" stg %[addr],%[psw_ext_addr]\n"
|
|
" lpswe %[psw_wait]\n"
|
|
"0:\n"
|
|
: [addr] "=&d" (addr),
|
|
[psw_wait_addr] "=Q" (psw_wait.addr),
|
|
[psw_ext_addr] "=Q" (S390_lowcore.external_new_psw.addr)
|
|
: [psw_wait] "Q" (psw_wait)
|
|
: "cc", "memory");
|
|
} while (S390_lowcore.ext_int_code != EXT_IRQ_SERVICE_SIG);
|
|
|
|
S390_lowcore.external_new_psw = psw_ext_save;
|
|
__ctl_load(cr0.val, 0, 0);
|
|
}
|
|
|
|
int sclp_early_cmd(sclp_cmdw_t cmd, void *sccb)
|
|
{
|
|
unsigned long flags;
|
|
int rc;
|
|
|
|
flags = arch_local_irq_save();
|
|
rc = sclp_service_call(cmd, sccb);
|
|
if (rc)
|
|
goto out;
|
|
sclp_early_wait_irq();
|
|
out:
|
|
arch_local_irq_restore(flags);
|
|
return rc;
|
|
}
|
|
|
|
struct write_sccb {
|
|
struct sccb_header header;
|
|
struct msg_buf msg;
|
|
} __packed;
|
|
|
|
/* Output multi-line text using SCLP Message interface. */
|
|
static void sclp_early_print_lm(const char *str, unsigned int len)
|
|
{
|
|
unsigned char *ptr, *end, ch;
|
|
unsigned int count, offset;
|
|
struct write_sccb *sccb;
|
|
struct msg_buf *msg;
|
|
struct mdb *mdb;
|
|
struct mto *mto;
|
|
struct go *go;
|
|
|
|
sccb = (struct write_sccb *) sclp_early_sccb;
|
|
end = (unsigned char *) sccb + EARLY_SCCB_SIZE - 1;
|
|
memset(sccb, 0, sizeof(*sccb));
|
|
ptr = (unsigned char *) &sccb->msg.mdb.mto;
|
|
offset = 0;
|
|
do {
|
|
for (count = sizeof(*mto); offset < len; count++) {
|
|
ch = str[offset++];
|
|
if ((ch == 0x0a) || (ptr + count > end))
|
|
break;
|
|
ptr[count] = _ascebc[ch];
|
|
}
|
|
mto = (struct mto *) ptr;
|
|
memset(mto, 0, sizeof(*mto));
|
|
mto->length = count;
|
|
mto->type = 4;
|
|
mto->line_type_flags = LNTPFLGS_ENDTEXT;
|
|
ptr += count;
|
|
} while ((offset < len) && (ptr + sizeof(*mto) <= end));
|
|
len = ptr - (unsigned char *) sccb;
|
|
sccb->header.length = len - offsetof(struct write_sccb, header);
|
|
msg = &sccb->msg;
|
|
msg->header.type = EVTYP_MSG;
|
|
msg->header.length = len - offsetof(struct write_sccb, msg.header);
|
|
mdb = &msg->mdb;
|
|
mdb->header.type = 1;
|
|
mdb->header.tag = 0xD4C4C240;
|
|
mdb->header.revision_code = 1;
|
|
mdb->header.length = len - offsetof(struct write_sccb, msg.mdb.header);
|
|
go = &mdb->go;
|
|
go->length = sizeof(*go);
|
|
go->type = 1;
|
|
sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_DATA, sccb);
|
|
}
|
|
|
|
struct vt220_sccb {
|
|
struct sccb_header header;
|
|
struct {
|
|
struct evbuf_header header;
|
|
char data[];
|
|
} msg;
|
|
} __packed;
|
|
|
|
/* Output multi-line text using SCLP VT220 interface. */
|
|
static void sclp_early_print_vt220(const char *str, unsigned int len)
|
|
{
|
|
struct vt220_sccb *sccb;
|
|
|
|
sccb = (struct vt220_sccb *) sclp_early_sccb;
|
|
if (sizeof(*sccb) + len >= EARLY_SCCB_SIZE)
|
|
len = EARLY_SCCB_SIZE - sizeof(*sccb);
|
|
memset(sccb, 0, sizeof(*sccb));
|
|
memcpy(&sccb->msg.data, str, len);
|
|
sccb->header.length = sizeof(*sccb) + len;
|
|
sccb->msg.header.length = sizeof(sccb->msg) + len;
|
|
sccb->msg.header.type = EVTYP_VT220MSG;
|
|
sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_DATA, sccb);
|
|
}
|
|
|
|
int sclp_early_set_event_mask(struct init_sccb *sccb,
|
|
sccb_mask_t receive_mask,
|
|
sccb_mask_t send_mask)
|
|
{
|
|
retry:
|
|
memset(sccb, 0, sizeof(*sccb));
|
|
sccb->header.length = sizeof(*sccb);
|
|
if (sclp_mask_compat_mode)
|
|
sccb->mask_length = SCLP_MASK_SIZE_COMPAT;
|
|
else
|
|
sccb->mask_length = sizeof(sccb_mask_t);
|
|
sccb_set_recv_mask(sccb, receive_mask);
|
|
sccb_set_send_mask(sccb, send_mask);
|
|
if (sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_MASK, sccb))
|
|
return -EIO;
|
|
if ((sccb->header.response_code == 0x74f0) && !sclp_mask_compat_mode) {
|
|
sclp_mask_compat_mode = true;
|
|
goto retry;
|
|
}
|
|
if (sccb->header.response_code != 0x20)
|
|
return -EIO;
|
|
return 0;
|
|
}
|
|
|
|
unsigned int sclp_early_con_check_linemode(struct init_sccb *sccb)
|
|
{
|
|
if (!(sccb_get_sclp_send_mask(sccb) & EVTYP_OPCMD_MASK))
|
|
return 0;
|
|
if (!(sccb_get_sclp_recv_mask(sccb) & (EVTYP_MSG_MASK | EVTYP_PMSGCMD_MASK)))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
unsigned int sclp_early_con_check_vt220(struct init_sccb *sccb)
|
|
{
|
|
if (sccb_get_sclp_send_mask(sccb) & EVTYP_VT220MSG_MASK)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int sclp_early_setup(int disable, int *have_linemode, int *have_vt220)
|
|
{
|
|
unsigned long receive_mask, send_mask;
|
|
struct init_sccb *sccb;
|
|
int rc;
|
|
|
|
BUILD_BUG_ON(sizeof(struct init_sccb) > PAGE_SIZE);
|
|
|
|
*have_linemode = *have_vt220 = 0;
|
|
sccb = (struct init_sccb *) sclp_early_sccb;
|
|
receive_mask = disable ? 0 : EVTYP_OPCMD_MASK;
|
|
send_mask = disable ? 0 : EVTYP_VT220MSG_MASK | EVTYP_MSG_MASK;
|
|
rc = sclp_early_set_event_mask(sccb, receive_mask, send_mask);
|
|
if (rc)
|
|
return rc;
|
|
*have_linemode = sclp_early_con_check_linemode(sccb);
|
|
*have_vt220 = !!(sccb_get_send_mask(sccb) & EVTYP_VT220MSG_MASK);
|
|
return rc;
|
|
}
|
|
|
|
void sclp_early_set_buffer(void *sccb)
|
|
{
|
|
sclp_early_sccb = sccb;
|
|
}
|
|
|
|
/*
|
|
* Output one or more lines of text on the SCLP console (VT220 and /
|
|
* or line-mode).
|
|
*/
|
|
void __sclp_early_printk(const char *str, unsigned int len)
|
|
{
|
|
int have_linemode, have_vt220;
|
|
|
|
if (sclp_init_state != sclp_init_state_uninitialized)
|
|
return;
|
|
if (sclp_early_setup(0, &have_linemode, &have_vt220) != 0)
|
|
return;
|
|
if (have_linemode)
|
|
sclp_early_print_lm(str, len);
|
|
if (have_vt220)
|
|
sclp_early_print_vt220(str, len);
|
|
sclp_early_setup(1, &have_linemode, &have_vt220);
|
|
}
|
|
|
|
void sclp_early_printk(const char *str)
|
|
{
|
|
__sclp_early_printk(str, strlen(str));
|
|
}
|
|
|
|
/*
|
|
* We can't pass sclp_info_sccb to sclp_early_cmd() here directly,
|
|
* because it might not fulfil the requiremets for a SCLP communication buffer:
|
|
* - lie below 2G in memory
|
|
* - be page-aligned
|
|
* Therefore, we use the buffer sclp_early_sccb (which fulfils all those
|
|
* requirements) temporarily for communication and copy a received response
|
|
* back into the buffer sclp_info_sccb upon successful completion.
|
|
*/
|
|
int __init sclp_early_read_info(void)
|
|
{
|
|
int i;
|
|
int length = test_facility(140) ? EXT_SCCB_READ_SCP : PAGE_SIZE;
|
|
struct read_info_sccb *sccb = (struct read_info_sccb *)sclp_early_sccb;
|
|
sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED,
|
|
SCLP_CMDW_READ_SCP_INFO};
|
|
|
|
for (i = 0; i < ARRAY_SIZE(commands); i++) {
|
|
memset(sccb, 0, length);
|
|
sccb->header.length = length;
|
|
sccb->header.function_code = 0x80;
|
|
sccb->header.control_mask[2] = 0x80;
|
|
if (sclp_early_cmd(commands[i], sccb))
|
|
break;
|
|
if (sccb->header.response_code == 0x10) {
|
|
memcpy(&sclp_info_sccb, sccb, length);
|
|
sclp_info_sccb_valid = 1;
|
|
return 0;
|
|
}
|
|
if (sccb->header.response_code != 0x1f0)
|
|
break;
|
|
}
|
|
return -EIO;
|
|
}
|
|
|
|
struct read_info_sccb * __init sclp_early_get_info(void)
|
|
{
|
|
if (!sclp_info_sccb_valid)
|
|
return NULL;
|
|
|
|
return &sclp_info_sccb;
|
|
}
|
|
|
|
int __init sclp_early_get_memsize(unsigned long *mem)
|
|
{
|
|
unsigned long rnmax;
|
|
unsigned long rnsize;
|
|
struct read_info_sccb *sccb = &sclp_info_sccb;
|
|
|
|
if (!sclp_info_sccb_valid)
|
|
return -EIO;
|
|
|
|
rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;
|
|
rnsize = sccb->rnsize ? sccb->rnsize : sccb->rnsize2;
|
|
rnsize <<= 20;
|
|
*mem = rnsize * rnmax;
|
|
return 0;
|
|
}
|
|
|
|
int __init sclp_early_get_hsa_size(unsigned long *hsa_size)
|
|
{
|
|
if (!sclp_info_sccb_valid)
|
|
return -EIO;
|
|
|
|
*hsa_size = 0;
|
|
if (sclp_info_sccb.hsa_size)
|
|
*hsa_size = (sclp_info_sccb.hsa_size - 1) * PAGE_SIZE;
|
|
return 0;
|
|
}
|
|
|
|
#define SCLP_STORAGE_INFO_FACILITY 0x0000400000000000UL
|
|
|
|
void __weak __init add_mem_detect_block(u64 start, u64 end) {}
|
|
int __init sclp_early_read_storage_info(void)
|
|
{
|
|
struct read_storage_sccb *sccb = (struct read_storage_sccb *)sclp_early_sccb;
|
|
int rc, id, max_id = 0;
|
|
unsigned long rn, rzm;
|
|
sclp_cmdw_t command;
|
|
u16 sn;
|
|
|
|
if (!sclp_info_sccb_valid)
|
|
return -EIO;
|
|
|
|
if (!(sclp_info_sccb.facilities & SCLP_STORAGE_INFO_FACILITY))
|
|
return -EOPNOTSUPP;
|
|
|
|
rzm = sclp_info_sccb.rnsize ?: sclp_info_sccb.rnsize2;
|
|
rzm <<= 20;
|
|
|
|
for (id = 0; id <= max_id; id++) {
|
|
memset(sclp_early_sccb, 0, EARLY_SCCB_SIZE);
|
|
sccb->header.length = EARLY_SCCB_SIZE;
|
|
command = SCLP_CMDW_READ_STORAGE_INFO | (id << 8);
|
|
rc = sclp_early_cmd(command, sccb);
|
|
if (rc)
|
|
goto fail;
|
|
|
|
max_id = sccb->max_id;
|
|
switch (sccb->header.response_code) {
|
|
case 0x0010:
|
|
for (sn = 0; sn < sccb->assigned; sn++) {
|
|
if (!sccb->entries[sn])
|
|
continue;
|
|
rn = sccb->entries[sn] >> 16;
|
|
add_mem_detect_block((rn - 1) * rzm, rn * rzm);
|
|
}
|
|
break;
|
|
case 0x0310:
|
|
case 0x0410:
|
|
break;
|
|
default:
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
fail:
|
|
mem_detect.count = 0;
|
|
return -EIO;
|
|
}
|