[thirdparty/linux.git] / drivers / s390 / char / sclp_cpi.c

/*
 * Author: Martin Peschke <mpeschke@de.ibm.com>
 * Copyright (C) 2001 IBM Entwicklung GmbH, IBM Corporation
 *
 * SCLP Control-Program Identification.
 */

#include <linux/version.h>
#include <linux/kmod.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <asm/ebcdic.h>
#include <asm/semaphore.h>

#include "sclp.h"
#include "sclp_rw.h"

#define CPI_LENGTH_SYSTEM_TYPE	8
#define CPI_LENGTH_SYSTEM_NAME	8
#define CPI_LENGTH_SYSPLEX_NAME	8

struct cpi_evbuf {
	struct evbuf_header header;
	u8	id_format;
	u8	reserved0;
	u8	system_type[CPI_LENGTH_SYSTEM_TYPE];
	u64	reserved1;
	u8	system_name[CPI_LENGTH_SYSTEM_NAME];
	u64	reserved2;
	u64	system_level;
	u64	reserved3;
	u8	sysplex_name[CPI_LENGTH_SYSPLEX_NAME];
	u8	reserved4[16];
} __attribute__((packed));

struct cpi_sccb {
	struct sccb_header header;
	struct cpi_evbuf cpi_evbuf;
} __attribute__((packed));

/* Event type structure for write message and write priority message */
static struct sclp_register sclp_cpi_event =
{
	.send_mask = EVTYP_CTLPROGIDENT_MASK
};

MODULE_LICENSE("GPL");

MODULE_AUTHOR(
	"Martin Peschke, IBM Deutschland Entwicklung GmbH "
	"<mpeschke@de.ibm.com>");

MODULE_DESCRIPTION(
	"identify this operating system instance to the S/390 "
	"or zSeries hardware");

static char *system_name = NULL;
module_param(system_name, charp, 0);
MODULE_PARM_DESC(system_name, "e.g. hostname - max. 8 characters");

static char *sysplex_name = NULL;
#ifdef ALLOW_SYSPLEX_NAME
module_param(sysplex_name, charp, 0);
MODULE_PARM_DESC(sysplex_name, "if applicable - max. 8 characters");
#endif

/* use default value for this field (as well as for system level) */
static char *system_type = "LINUX";

static int
cpi_check_parms(void)
{
	/* reject if no system type specified */
	if (!system_type) {
		printk("cpi: bug: no system type specified\n");
		return -EINVAL;
	}

	/* reject if system type larger than 8 characters */
	if (strlen(system_type) > CPI_LENGTH_SYSTEM_NAME) {
		printk("cpi: bug: system type has length of %li characters - "
		       "only %i characters supported\n",
		       strlen(system_type), CPI_LENGTH_SYSTEM_TYPE);
		return -EINVAL;
	}

	/* reject if no system name specified */
	if (!system_name) {
		printk("cpi: no system name specified\n");
		return -EINVAL;
	}

	/* reject if system name larger than 8 characters */
	if (strlen(system_name) > CPI_LENGTH_SYSTEM_NAME) {
		printk("cpi: system name has length of %li characters - "
		       "only %i characters supported\n",
		       strlen(system_name), CPI_LENGTH_SYSTEM_NAME);
		return -EINVAL;
	}

	/* reject if specified sysplex name larger than 8 characters */
	if (sysplex_name && strlen(sysplex_name) > CPI_LENGTH_SYSPLEX_NAME) {
		printk("cpi: sysplex name has length of %li characters"
		       " - only %i characters supported\n",
		       strlen(sysplex_name), CPI_LENGTH_SYSPLEX_NAME);
		return -EINVAL;
	}
	return 0;
}

static void
cpi_callback(struct sclp_req *req, void *data)
{
	struct semaphore *sem;

	sem = (struct semaphore *) data;
	up(sem);
}

static struct sclp_req *
cpi_prepare_req(void)
{
	struct sclp_req *req;
	struct cpi_sccb *sccb;
	struct cpi_evbuf *evb;

	req = kmalloc(sizeof(struct sclp_req), GFP_KERNEL);
	if (req == NULL)
		return ERR_PTR(-ENOMEM);
	sccb = (struct cpi_sccb *) __get_free_page(GFP_KERNEL | GFP_DMA);
	if (sccb == NULL) {
		kfree(req);
		return ERR_PTR(-ENOMEM);
	}
	memset(sccb, 0, sizeof(struct cpi_sccb));

	/* setup SCCB for Control-Program Identification */
	sccb->header.length = sizeof(struct cpi_sccb);
	sccb->cpi_evbuf.header.length = sizeof(struct cpi_evbuf);
	sccb->cpi_evbuf.header.type = 0x0B;
	evb = &sccb->cpi_evbuf;

	/* set system type */
	memset(evb->system_type, ' ', CPI_LENGTH_SYSTEM_TYPE);
	memcpy(evb->system_type, system_type, strlen(system_type));
	sclp_ascebc_str(evb->system_type, CPI_LENGTH_SYSTEM_TYPE);
	EBC_TOUPPER(evb->system_type, CPI_LENGTH_SYSTEM_TYPE);

	/* set system name */
	memset(evb->system_name, ' ', CPI_LENGTH_SYSTEM_NAME);
	memcpy(evb->system_name, system_name, strlen(system_name));
	sclp_ascebc_str(evb->system_name, CPI_LENGTH_SYSTEM_NAME);
	EBC_TOUPPER(evb->system_name, CPI_LENGTH_SYSTEM_NAME);

	/* set system level */
	evb->system_level = LINUX_VERSION_CODE;

	/* set sysplex name */
	if (sysplex_name) {
		memset(evb->sysplex_name, ' ', CPI_LENGTH_SYSPLEX_NAME);
		memcpy(evb->sysplex_name, sysplex_name, strlen(sysplex_name));
		sclp_ascebc_str(evb->sysplex_name, CPI_LENGTH_SYSPLEX_NAME);
		EBC_TOUPPER(evb->sysplex_name, CPI_LENGTH_SYSPLEX_NAME);
	}

	/* prepare request data structure presented to SCLP driver */
	req->command = SCLP_CMDW_WRITE_EVENT_DATA;
	req->sccb = sccb;
	req->status = SCLP_REQ_FILLED;
	req->callback = cpi_callback;
	return req;
}

static void
cpi_free_req(struct sclp_req *req)
{
	free_page((unsigned long) req->sccb);
	kfree(req);
}

static int __init
cpi_module_init(void)
{
	struct semaphore sem;
	struct sclp_req *req;
	int rc;

	rc = cpi_check_parms();
	if (rc)
		return rc;

	rc = sclp_register(&sclp_cpi_event);
	if (rc) {
		/* could not register sclp event. Die. */
		printk(KERN_WARNING "cpi: could not register to hardware "
		       "console.\n");
		return -EINVAL;
	}
	if (!(sclp_cpi_event.sclp_send_mask & EVTYP_CTLPROGIDENT_MASK)) {
		printk(KERN_WARNING "cpi: no control program identification "
		       "support\n");
		sclp_unregister(&sclp_cpi_event);
		return -EOPNOTSUPP;
	}

	req = cpi_prepare_req();
	if (IS_ERR(req)) {
		printk(KERN_WARNING "cpi: couldn't allocate request\n");
		sclp_unregister(&sclp_cpi_event);
		return PTR_ERR(req);
	}

	/* Prepare semaphore */
	sema_init(&sem, 0);
	req->callback_data = &sem;
	/* Add request to sclp queue */
	rc = sclp_add_request(req);
	if (rc) {
		printk(KERN_WARNING "cpi: could not start request\n");
		cpi_free_req(req);
		sclp_unregister(&sclp_cpi_event);
		return rc;
	}
	/* make "insmod" sleep until callback arrives */
	down(&sem);

	rc = ((struct cpi_sccb *) req->sccb)->header.response_code;
	if (rc != 0x0020) {
		printk(KERN_WARNING "cpi: failed with response code 0x%x\n",
		       rc);
		rc = -ECOMM;
	} else
		rc = 0;

	cpi_free_req(req);
	sclp_unregister(&sclp_cpi_event);

	return rc;
}


static void __exit cpi_module_exit(void)
{
}


/* declare driver module init/cleanup functions */
module_init(cpi_module_init);
module_exit(cpi_module_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Author: Martin Peschke <mpeschke@de.ibm.com>
	3	* Copyright (C) 2001 IBM Entwicklung GmbH, IBM Corporation
	4	*
	5	* SCLP Control-Program Identification.
	6	*/
	7
1da177e4 LT	8	#include <linux/version.h>
	9	#include <linux/kmod.h>
	10	#include <linux/module.h>
	11	#include <linux/moduleparam.h>
	12	#include <linux/init.h>
	13	#include <linux/timer.h>
	14	#include <linux/string.h>
	15	#include <linux/err.h>
	16	#include <linux/slab.h>
	17	#include <asm/ebcdic.h>
	18	#include <asm/semaphore.h>
	19
	20	#include "sclp.h"
	21	#include "sclp_rw.h"
	22
	23	#define CPI_LENGTH_SYSTEM_TYPE 8
	24	#define CPI_LENGTH_SYSTEM_NAME 8
	25	#define CPI_LENGTH_SYSPLEX_NAME 8
	26
	27	struct cpi_evbuf {
	28	struct evbuf_header header;
	29	u8 id_format;
	30	u8 reserved0;
	31	u8 system_type[CPI_LENGTH_SYSTEM_TYPE];
	32	u64 reserved1;
	33	u8 system_name[CPI_LENGTH_SYSTEM_NAME];
	34	u64 reserved2;
	35	u64 system_level;
	36	u64 reserved3;
	37	u8 sysplex_name[CPI_LENGTH_SYSPLEX_NAME];
	38	u8 reserved4[16];
	39	} __attribute__((packed));
	40
	41	struct cpi_sccb {
	42	struct sccb_header header;
	43	struct cpi_evbuf cpi_evbuf;
	44	} __attribute__((packed));
	45
	46	/* Event type structure for write message and write priority message */
	47	static struct sclp_register sclp_cpi_event =
	48	{
6d4740c8	49	.send_mask = EVTYP_CTLPROGIDENT_MASK
1da177e4 LT	50	};
1da177e4 LT	51
b3c14d0b CB	52	MODULE_LICENSE("GPL");
b3c14d0b CB	53
1da177e4 LT	54	MODULE_AUTHOR(
	55	"Martin Peschke, IBM Deutschland Entwicklung GmbH "
	56	"<mpeschke@de.ibm.com>");
	57
	58	MODULE_DESCRIPTION(
	59	"identify this operating system instance to the S/390 "
	60	"or zSeries hardware");
	61
	62	static char *system_name = NULL;
	63	module_param(system_name, charp, 0);
	64	MODULE_PARM_DESC(system_name, "e.g. hostname - max. 8 characters");
	65
	66	static char *sysplex_name = NULL;
	67	#ifdef ALLOW_SYSPLEX_NAME
	68	module_param(sysplex_name, charp, 0);
	69	MODULE_PARM_DESC(sysplex_name, "if applicable - max. 8 characters");
	70	#endif
	71
	72	/* use default value for this field (as well as for system level) */
	73	static char *system_type = "LINUX";
	74
	75	static int
	76	cpi_check_parms(void)
	77	{
	78	/* reject if no system type specified */
	79	if (!system_type) {
	80	printk("cpi: bug: no system type specified\n");
	81	return -EINVAL;
	82	}
	83
	84	/* reject if system type larger than 8 characters */
	85	if (strlen(system_type) > CPI_LENGTH_SYSTEM_NAME) {
	86	printk("cpi: bug: system type has length of %li characters - "
	87	"only %i characters supported\n",
	88	strlen(system_type), CPI_LENGTH_SYSTEM_TYPE);
	89	return -EINVAL;
	90	}
	91
	92	/* reject if no system name specified */
	93	if (!system_name) {
	94	printk("cpi: no system name specified\n");
	95	return -EINVAL;
	96	}
	97
	98	/* reject if system name larger than 8 characters */
	99	if (strlen(system_name) > CPI_LENGTH_SYSTEM_NAME) {
	100	printk("cpi: system name has length of %li characters - "
	101	"only %i characters supported\n",
	102	strlen(system_name), CPI_LENGTH_SYSTEM_NAME);
	103	return -EINVAL;
	104	}
	105
	106	/* reject if specified sysplex name larger than 8 characters */
	107	if (sysplex_name && strlen(sysplex_name) > CPI_LENGTH_SYSPLEX_NAME) {
	108	printk("cpi: sysplex name has length of %li characters"
	109	" - only %i characters supported\n",
	110	strlen(sysplex_name), CPI_LENGTH_SYSPLEX_NAME);
	111	return -EINVAL;
	112	}
	113	return 0;
	114	}
	115
	116	static void
	117	cpi_callback(struct sclp_req req, void data)
118	{
119	struct semaphore *sem;
120
121	sem = (struct semaphore *) data;
122	up(sem);
123	}
124
125	static struct sclp_req *
126	cpi_prepare_req(void)
127	{
128	struct sclp_req *req;
129	struct cpi_sccb *sccb;
130	struct cpi_evbuf *evb;
131
5cbded58	132	req = kmalloc(sizeof(struct sclp_req), GFP_KERNEL);
1da177e4 LT	133	if (req == NULL)
	134	return ERR_PTR(-ENOMEM);
	135	sccb = (struct cpi_sccb *) __get_free_page(GFP_KERNEL \| GFP_DMA);
	136	if (sccb == NULL) {
	137	kfree(req);
	138	return ERR_PTR(-ENOMEM);
	139	}
	140	memset(sccb, 0, sizeof(struct cpi_sccb));
	141
	142	/* setup SCCB for Control-Program Identification */
	143	sccb->header.length = sizeof(struct cpi_sccb);
	144	sccb->cpi_evbuf.header.length = sizeof(struct cpi_evbuf);
	145	sccb->cpi_evbuf.header.type = 0x0B;
	146	evb = &sccb->cpi_evbuf;
	147
	148	/* set system type */
	149	memset(evb->system_type, ' ', CPI_LENGTH_SYSTEM_TYPE);
	150	memcpy(evb->system_type, system_type, strlen(system_type));
	151	sclp_ascebc_str(evb->system_type, CPI_LENGTH_SYSTEM_TYPE);
	152	EBC_TOUPPER(evb->system_type, CPI_LENGTH_SYSTEM_TYPE);
	153
	154	/* set system name */
	155	memset(evb->system_name, ' ', CPI_LENGTH_SYSTEM_NAME);
	156	memcpy(evb->system_name, system_name, strlen(system_name));
	157	sclp_ascebc_str(evb->system_name, CPI_LENGTH_SYSTEM_NAME);
	158	EBC_TOUPPER(evb->system_name, CPI_LENGTH_SYSTEM_NAME);
	159
3a4fa0a2	160	/* set system level */
1da177e4 LT	161	evb->system_level = LINUX_VERSION_CODE;
	162
	163	/* set sysplex name */
	164	if (sysplex_name) {
	165	memset(evb->sysplex_name, ' ', CPI_LENGTH_SYSPLEX_NAME);
	166	memcpy(evb->sysplex_name, sysplex_name, strlen(sysplex_name));
	167	sclp_ascebc_str(evb->sysplex_name, CPI_LENGTH_SYSPLEX_NAME);
	168	EBC_TOUPPER(evb->sysplex_name, CPI_LENGTH_SYSPLEX_NAME);
	169	}
	170
	171	/* prepare request data structure presented to SCLP driver */
ab14de6c	172	req->command = SCLP_CMDW_WRITE_EVENT_DATA;
1da177e4 LT	173	req->sccb = sccb;
	174	req->status = SCLP_REQ_FILLED;
	175	req->callback = cpi_callback;
	176	return req;
	177	}
	178
	179	static void
	180	cpi_free_req(struct sclp_req *req)
	181	{
	182	free_page((unsigned long) req->sccb);
	183	kfree(req);
	184	}
	185
	186	static int __init
	187	cpi_module_init(void)
	188	{
	189	struct semaphore sem;
	190	struct sclp_req *req;
	191	int rc;
	192
	193	rc = cpi_check_parms();
	194	if (rc)
	195	return rc;
	196
	197	rc = sclp_register(&sclp_cpi_event);
	198	if (rc) {
	199	/* could not register sclp event. Die. */
	200	printk(KERN_WARNING "cpi: could not register to hardware "
	201	"console.\n");
	202	return -EINVAL;
	203	}
6d4740c8	204	if (!(sclp_cpi_event.sclp_send_mask & EVTYP_CTLPROGIDENT_MASK)) {
1da177e4 LT	205	printk(KERN_WARNING "cpi: no control program identification "
	206	"support\n");
	207	sclp_unregister(&sclp_cpi_event);
9bbc8346	208	return -EOPNOTSUPP;
1da177e4 LT	209	}
	210
	211	req = cpi_prepare_req();
	212	if (IS_ERR(req)) {
	213	printk(KERN_WARNING "cpi: couldn't allocate request\n");
	214	sclp_unregister(&sclp_cpi_event);
	215	return PTR_ERR(req);
	216	}
	217
	218	/* Prepare semaphore */
	219	sema_init(&sem, 0);
	220	req->callback_data = &sem;
	221	/* Add request to sclp queue */
	222	rc = sclp_add_request(req);
	223	if (rc) {
	224	printk(KERN_WARNING "cpi: could not start request\n");
	225	cpi_free_req(req);
	226	sclp_unregister(&sclp_cpi_event);
	227	return rc;
	228	}
	229	/* make "insmod" sleep until callback arrives */
	230	down(&sem);
	231
	232	rc = ((struct cpi_sccb *) req->sccb)->header.response_code;
	233	if (rc != 0x0020) {
	234	printk(KERN_WARNING "cpi: failed with response code 0x%x\n",
	235	rc);
	236	rc = -ECOMM;
	237	} else
	238	rc = 0;
	239
	240	cpi_free_req(req);
	241	sclp_unregister(&sclp_cpi_event);
	242
	243	return rc;
	244	}
	245
	246
	247	static void __exit cpi_module_exit(void)
	248	{
	249	}
	250
	251
	252	/* declare driver module init/cleanup functions */
	253	module_init(cpi_module_init);
	254	module_exit(cpi_module_exit);
	255