[mirror_ubuntu-artful-kernel.git] / arch / s390 / kernel / cpcmd.c

/*
 *  arch/s390/kernel/cpcmd.c
 *
 *  S390 version
 *    Copyright (C) 1999,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
 *               Christian Borntraeger (cborntra@de.ibm.com),
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <asm/ebcdic.h>
#include <asm/cpcmd.h>
#include <asm/system.h>

static DEFINE_SPINLOCK(cpcmd_lock);
static char cpcmd_buf[241];

/*
 * the caller of __cpcmd has to ensure that the response buffer is below 2 GB
 */
int  __cpcmd(const char *cmd, char *response, int rlen, int *response_code)
{
	const int mask = 0x40000000L;
	unsigned long flags;
	int return_code;
	int return_len;
	int cmdlen;

	spin_lock_irqsave(&cpcmd_lock, flags);
	cmdlen = strlen(cmd);
	BUG_ON(cmdlen > 240);
	memcpy(cpcmd_buf, cmd, cmdlen);
	ASCEBC(cpcmd_buf, cmdlen);

	if (response != NULL && rlen > 0) {
		memset(response, 0, rlen);
#ifndef CONFIG_64BIT
		asm volatile (	"lra	2,0(%2)\n"
				"lr	4,%3\n"
				"o	4,%6\n"
				"lra	3,0(%4)\n"
				"lr	5,%5\n"
				"diag	2,4,0x8\n"
				"brc	8, 1f\n"
				"ar	5, %5\n"
				"1: \n"
				"lr	%0,4\n"
				"lr	%1,5\n"
				: "=d" (return_code), "=d" (return_len)
				: "a" (cpcmd_buf), "d" (cmdlen),
				"a" (response), "d" (rlen), "m" (mask)
				: "cc", "2", "3", "4", "5" );
#else /* CONFIG_64BIT */
                asm volatile (	"lrag	2,0(%2)\n"
				"lgr	4,%3\n"
				"o	4,%6\n"
				"lrag	3,0(%4)\n"
				"lgr	5,%5\n"
				"sam31\n"
				"diag	2,4,0x8\n"
				"sam64\n"
				"brc	8, 1f\n"
				"agr	5, %5\n"
				"1: \n"
				"lgr	%0,4\n"
				"lgr	%1,5\n"
				: "=d" (return_code), "=d" (return_len)
				: "a" (cpcmd_buf), "d" (cmdlen),
				"a" (response), "d" (rlen), "m" (mask)
				: "cc", "2", "3", "4", "5" );
#endif /* CONFIG_64BIT */
                EBCASC(response, rlen);
        } else {
		return_len = 0;
#ifndef CONFIG_64BIT
                asm volatile (	"lra	2,0(%1)\n"
				"lr	3,%2\n"
				"diag	2,3,0x8\n"
				"lr	%0,3\n"
				: "=d" (return_code)
				: "a" (cpcmd_buf), "d" (cmdlen)
				: "2", "3"  );
#else /* CONFIG_64BIT */
                asm volatile (	"lrag	2,0(%1)\n"
				"lgr	3,%2\n"
				"sam31\n"
				"diag	2,3,0x8\n"
				"sam64\n"
				"lgr	%0,3\n"
				: "=d" (return_code)
				: "a" (cpcmd_buf), "d" (cmdlen)
				: "2", "3" );
#endif /* CONFIG_64BIT */
        }
	spin_unlock_irqrestore(&cpcmd_lock, flags);
	if (response_code != NULL)
		*response_code = return_code;
	return return_len;
}

EXPORT_SYMBOL(__cpcmd);

#ifdef CONFIG_64BIT
int cpcmd(const char *cmd, char *response, int rlen, int *response_code)
{
	char *lowbuf;
	int len;

	if ((rlen == 0) || (response == NULL)
	    || !((unsigned long)response >> 31))
		len = __cpcmd(cmd, response, rlen, response_code);
	else {
		lowbuf = kmalloc(rlen, GFP_KERNEL | GFP_DMA);
		if (!lowbuf) {
			printk(KERN_WARNING
				"cpcmd: could not allocate response buffer\n");
			return -ENOMEM;
		}
		len = __cpcmd(cmd, lowbuf, rlen, response_code);
		memcpy(response, lowbuf, rlen);
		kfree(lowbuf);
	}
	return len;
}

EXPORT_SYMBOL(cpcmd);
#endif		/* CONFIG_64BIT */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/s390/kernel/cpcmd.c
	3	*
	4	* S390 version
6b979de3	5	* Copyright (C) 1999,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
1da177e4 LT	6	* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
	7	* Christian Borntraeger (cborntra@de.ibm.com),
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/slab.h>
	13	#include <linux/spinlock.h>
	14	#include <linux/stddef.h>
	15	#include <linux/string.h>
	16	#include <asm/ebcdic.h>
	17	#include <asm/cpcmd.h>
	18	#include <asm/system.h>
	19
	20	static DEFINE_SPINLOCK(cpcmd_lock);
6b979de3	21	static char cpcmd_buf[241];
1da177e4 LT	22
	23	/*
	24	* the caller of __cpcmd has to ensure that the response buffer is below 2 GB
	25	*/
6b979de3	26	int __cpcmd(const char cmd, char response, int rlen, int *response_code)
1da177e4 LT	27	{
	28	const int mask = 0x40000000L;
	29	unsigned long flags;
6b979de3 CB	30	int return_code;
6b979de3 CB	31	int return_len;
1da177e4 LT	32	int cmdlen;
	33
	34	spin_lock_irqsave(&cpcmd_lock, flags);
	35	cmdlen = strlen(cmd);
	36	BUG_ON(cmdlen > 240);
6b979de3	37	memcpy(cpcmd_buf, cmd, cmdlen);
1da177e4 LT	38	ASCEBC(cpcmd_buf, cmdlen);
	39
	40	if (response != NULL && rlen > 0) {
	41	memset(response, 0, rlen);
347a8dc3	42	#ifndef CONFIG_64BIT
6b979de3 CB	43	asm volatile ( "lra 2,0(%2)\n"
	44	"lr 4,%3\n"
	45	"o 4,%6\n"
	46	"lra 3,0(%4)\n"
	47	"lr 5,%5\n"
	48	"diag 2,4,0x8\n"
0cbdff4f	49	"brc 8, 1f\n"
6b979de3	50	"ar 5, %5\n"
0cbdff4f	51	"1: \n"
6b979de3 CB	52	"lr %0,4\n"
	53	"lr %1,5\n"
	54	: "=d" (return_code), "=d" (return_len)
	55	: "a" (cpcmd_buf), "d" (cmdlen),
	56	"a" (response), "d" (rlen), "m" (mask)
	57	: "cc", "2", "3", "4", "5" );
347a8dc3	58	#else /* CONFIG_64BIT */
6b979de3 CB	59	asm volatile ( "lrag 2,0(%2)\n"
	60	"lgr 4,%3\n"
	61	"o 4,%6\n"
	62	"lrag 3,0(%4)\n"
	63	"lgr 5,%5\n"
	64	"sam31\n"
	65	"diag 2,4,0x8\n"
	66	"sam64\n"
0cbdff4f	67	"brc 8, 1f\n"
6b979de3	68	"agr 5, %5\n"
0cbdff4f	69	"1: \n"
6b979de3 CB	70	"lgr %0,4\n"
	71	"lgr %1,5\n"
	72	: "=d" (return_code), "=d" (return_len)
	73	: "a" (cpcmd_buf), "d" (cmdlen),
	74	"a" (response), "d" (rlen), "m" (mask)
	75	: "cc", "2", "3", "4", "5" );
347a8dc3	76	#endif /* CONFIG_64BIT */
1da177e4 LT	77	EBCASC(response, rlen);
1da177e4 LT	78	} else {
6b979de3	79	return_len = 0;
347a8dc3	80	#ifndef CONFIG_64BIT
6b979de3 CB	81	asm volatile ( "lra 2,0(%1)\n"
	82	"lr 3,%2\n"
	83	"diag 2,3,0x8\n"
	84	"lr %0,3\n"
	85	: "=d" (return_code)
	86	: "a" (cpcmd_buf), "d" (cmdlen)
	87	: "2", "3" );
347a8dc3	88	#else /* CONFIG_64BIT */
6b979de3 CB	89	asm volatile ( "lrag 2,0(%1)\n"
	90	"lgr 3,%2\n"
	91	"sam31\n"
	92	"diag 2,3,0x8\n"
	93	"sam64\n"
	94	"lgr %0,3\n"
	95	: "=d" (return_code)
	96	: "a" (cpcmd_buf), "d" (cmdlen)
	97	: "2", "3" );
347a8dc3	98	#endif /* CONFIG_64BIT */
1da177e4 LT	99	}
1da177e4 LT	100	spin_unlock_irqrestore(&cpcmd_lock, flags);
6b979de3 CB	101	if (response_code != NULL)
	102	*response_code = return_code;
	103	return return_len;
1da177e4 LT	104	}
	105
	106	EXPORT_SYMBOL(__cpcmd);
	107
347a8dc3	108	#ifdef CONFIG_64BIT
6b979de3	109	int cpcmd(const char cmd, char response, int rlen, int *response_code)
1da177e4 LT	110	{
1da177e4 LT	111	char *lowbuf;
6b979de3 CB	112	int len;
6b979de3 CB	113
1da177e4 LT	114	if ((rlen == 0) \|\| (response == NULL)
1da177e4 LT	115	\|\| !((unsigned long)response >> 31))
6b979de3	116	len = __cpcmd(cmd, response, rlen, response_code);
1da177e4 LT	117	else {
	118	lowbuf = kmalloc(rlen, GFP_KERNEL \| GFP_DMA);
	119	if (!lowbuf) {
	120	printk(KERN_WARNING
	121	"cpcmd: could not allocate response buffer\n");
6b979de3	122	return -ENOMEM;
1da177e4	123	}
6b979de3	124	len = __cpcmd(cmd, lowbuf, rlen, response_code);
1da177e4 LT	125	memcpy(response, lowbuf, rlen);
	126	kfree(lowbuf);
	127	}
6b979de3	128	return len;
1da177e4 LT	129	}
	130
	131	EXPORT_SYMBOL(cpcmd);
347a8dc3	132	#endif /* CONFIG_64BIT */