[deliverable/linux.git] / drivers / staging / unisys / visorchipset / file.c

/* file.c
 *
 * Copyright (C) 2010 - 2013 UNISYS CORPORATION
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  See the GNU General Public License for more
 * details.
 */

/* This contains the implementation that allows a usermode program to
 * communicate with the visorchipset driver using a device/file interface.
 */

#include "globals.h"
#include "visorchannel.h"
#include <linux/mm.h>
#include <linux/fs.h>
#include "uisutils.h"
#include "file.h"

#define CURRENT_FILE_PC VISOR_CHIPSET_PC_file_c

typedef u64 GUEST_PHYSICAL_ADDRESS;

static struct cdev Cdev;
static VISORCHANNEL **PControlVm_channel;
static dev_t MajorDev = -1; /**< indicates major num for device */
static BOOL Registered = FALSE;

static int visorchipset_open(struct inode *inode, struct file *file);
static int visorchipset_release(struct inode *inode, struct file *file);
static int visorchipset_mmap(struct file *file, struct vm_area_struct *vma);
#ifdef HAVE_UNLOCKED_IOCTL
long visorchipset_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
#else
int visorchipset_ioctl(struct inode *inode, struct file *file,
		       unsigned int cmd, unsigned long arg);
#endif

static const struct file_operations visorchipset_fops = {
	.owner = THIS_MODULE,
	.open = visorchipset_open,
	.read = NULL,
	.write = NULL,
#ifdef HAVE_UNLOCKED_IOCTL
	.unlocked_ioctl = visorchipset_ioctl,
#else
	.ioctl = visorchipset_ioctl,
#endif
	.release = visorchipset_release,
	.mmap = visorchipset_mmap,
};

int
visorchipset_file_init(dev_t majorDev, VISORCHANNEL **pControlVm_channel)
{
	int rc = -1;

	PControlVm_channel = pControlVm_channel;
	MajorDev = majorDev;
	cdev_init(&Cdev, &visorchipset_fops);
	Cdev.owner = THIS_MODULE;
	if (MAJOR(MajorDev) == 0) {
		/* dynamic major device number registration required */
		if (alloc_chrdev_region(&MajorDev, 0, 1, MYDRVNAME) < 0) {
			ERRDRV("Unable to allocate+register char device %s",
			       MYDRVNAME);
			goto Away;
		}
		Registered = TRUE;
		INFODRV("New major number %d registered\n", MAJOR(MajorDev));
	} else {
		/* static major device number registration required */
		if (register_chrdev_region(MajorDev, 1, MYDRVNAME) < 0) {
			ERRDRV("Unable to register char device %s", MYDRVNAME);
			goto Away;
		}
		Registered = TRUE;
		INFODRV("Static major number %d registered\n", MAJOR(MajorDev));
	}
	if (cdev_add(&Cdev, MKDEV(MAJOR(MajorDev), 0), 1) < 0) {
		ERRDRV("failed to create char device: (status=%d)\n", rc);
		goto Away;
	}
	INFODRV("Registered char device for %s (major=%d)",
		MYDRVNAME, MAJOR(MajorDev));
	rc = 0;
Away:
	return rc;
}

void
visorchipset_file_cleanup(void)
{
	if (Cdev.ops != NULL)
		cdev_del(&Cdev);
	Cdev.ops = NULL;
	if (Registered) {
		if (MAJOR(MajorDev) >= 0) {
			unregister_chrdev_region(MajorDev, 1);
			MajorDev = MKDEV(0, 0);
		}
		Registered = FALSE;
	}
}

static int
visorchipset_open(struct inode *inode, struct file *file)
{
	unsigned minor_number = iminor(inode);
	int rc = -ENODEV;

	DEBUGDRV("%s", __func__);
	if (minor_number != 0)
		goto Away;
	file->private_data = NULL;
	rc = 0;
Away:
	if (rc < 0)
		ERRDRV("%s minor=%d failed", __func__, minor_number);
	return rc;
}

static int
visorchipset_release(struct inode *inode, struct file *file)
{
	DEBUGDRV("%s", __func__);
	return 0;
}

static int
visorchipset_mmap(struct file *file, struct vm_area_struct *vma)
{
	ulong physAddr = 0;
	ulong offset = vma->vm_pgoff << PAGE_SHIFT;
	GUEST_PHYSICAL_ADDRESS addr = 0;

	/* sv_enable_dfp(); */
	DEBUGDRV("%s", __func__);
	if (offset & (PAGE_SIZE - 1)) {
		ERRDRV("%s virtual address NOT page-aligned!", __func__);
		return -ENXIO;	/* need aligned offsets */
	}
	switch (offset) {
	case VISORCHIPSET_MMAP_CONTROLCHANOFFSET:
		vma->vm_flags |= VM_IO;
		if (*PControlVm_channel == NULL) {
			ERRDRV("%s no controlvm channel yet", __func__);
			return -ENXIO;
		}
		visorchannel_read(*PControlVm_channel,
				  offsetof(ULTRA_CONTROLVM_CHANNEL_PROTOCOL,
					   gpControlChannel), &addr,
				  sizeof(addr));
		if (addr == 0) {
			ERRDRV("%s control channel address is 0", __func__);
			return -ENXIO;
		}
		physAddr = (ulong) (addr);
		DEBUGDRV("mapping physical address = 0x%lx", physAddr);
		if (remap_pfn_range(vma, vma->vm_start,
				    physAddr >> PAGE_SHIFT,
				    vma->vm_end - vma->vm_start,
				    /*pgprot_noncached */
				    (vma->vm_page_prot))) {
			ERRDRV("%s remap_pfn_range failed", __func__);
			return -EAGAIN;
		}
		break;
	default:
		return -ENOSYS;
	}
	DEBUGDRV("%s success!", __func__);
	return 0;
}

#ifdef HAVE_UNLOCKED_IOCTL
long
visorchipset_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
#else
int
visorchipset_ioctl(struct inode *inode, struct file *file,
		   unsigned int cmd, unsigned long arg)
#endif
{
	int rc = SUCCESS;
	s64 adjustment;
	s64 vrtc_offset;
	DBGINF("entered visorchipset_ioctl, cmd=%d", cmd);
	switch (cmd) {
	case VMCALL_QUERY_GUEST_VIRTUAL_TIME_OFFSET:
		/* get the physical rtc offset */
		vrtc_offset = Issue_VMCALL_QUERY_GUEST_VIRTUAL_TIME_OFFSET();
		if (copy_to_user
		    ((void __user *)arg, &vrtc_offset, sizeof(vrtc_offset))) {
			rc = -EFAULT;
			goto Away;
		}
		DBGINF("insde visorchipset_ioctl, cmd=%d, vrtc_offset=%lld",
		       cmd, vrtc_offset);
		break;
	case VMCALL_UPDATE_PHYSICAL_TIME:
		if (copy_from_user
		    (&adjustment, (void __user *)arg, sizeof(adjustment))) {
			rc = -EFAULT;
			goto Away;
		}
		DBGINF("insde visorchipset_ioctl, cmd=%d, adjustment=%lld", cmd,
		       adjustment);
		rc = Issue_VMCALL_UPDATE_PHYSICAL_TIME(adjustment);
		break;
	default:
		LOGERR("visorchipset_ioctl received invalid command");
		rc = -EFAULT;
		break;
	}
Away:
	DBGINF("exiting %d!", rc);
	return rc;
}
Commit	Line	Data
12e364b9 KC	1	/* file.c
12e364b9 KC	2	*
f6d0c1e6	3	* Copyright (C) 2010 - 2013 UNISYS CORPORATION
12e364b9 KC	4	* All rights reserved.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or (at
	9	* your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	14	* NON INFRINGEMENT. See the GNU General Public License for more
	15	* details.
	16	*/
	17
	18	/* This contains the implementation that allows a usermode program to
	19	* communicate with the visorchipset driver using a device/file interface.
	20	*/
	21
	22	#include "globals.h"
	23	#include "visorchannel.h"
	24	#include <linux/mm.h>
	25	#include <linux/fs.h>
	26	#include "uisutils.h"
bd5b9b32	27	#include "file.h"
12e364b9 KC	28
	29	#define CURRENT_FILE_PC VISOR_CHIPSET_PC_file_c
	30
af96e9c0 BR	31	typedef u64 GUEST_PHYSICAL_ADDRESS;
af96e9c0 BR	32
12e364b9 KC	33	static struct cdev Cdev;
	34	static VISORCHANNEL **PControlVm_channel;
	35	static dev_t MajorDev = -1; /*< indicates major num for device /
	36	static BOOL Registered = FALSE;
	37
	38	static int visorchipset_open(struct inode inode, struct file file);
	39	static int visorchipset_release(struct inode inode, struct file file);
	40	static int visorchipset_mmap(struct file file, struct vm_area_struct vma);
	41	#ifdef HAVE_UNLOCKED_IOCTL
	42	long visorchipset_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
	43	#else
	44	int visorchipset_ioctl(struct inode inode, struct file file,
	45	unsigned int cmd, unsigned long arg);
	46	#endif
	47
	48	static const struct file_operations visorchipset_fops = {
	49	.owner = THIS_MODULE,
	50	.open = visorchipset_open,
	51	.read = NULL,
	52	.write = NULL,
	53	#ifdef HAVE_UNLOCKED_IOCTL
	54	.unlocked_ioctl = visorchipset_ioctl,
	55	#else
	56	.ioctl = visorchipset_ioctl,
	57	#endif
	58	.release = visorchipset_release,
	59	.mmap = visorchipset_mmap,
	60	};
	61
	62	int
	63	visorchipset_file_init(dev_t majorDev, VISORCHANNEL **pControlVm_channel)
	64	{
	65	int rc = -1;
	66
	67	PControlVm_channel = pControlVm_channel;
	68	MajorDev = majorDev;
	69	cdev_init(&Cdev, &visorchipset_fops);
	70	Cdev.owner = THIS_MODULE;
	71	if (MAJOR(MajorDev) == 0) {
	72	/* dynamic major device number registration required */
	73	if (alloc_chrdev_region(&MajorDev, 0, 1, MYDRVNAME) < 0) {
	74	ERRDRV("Unable to allocate+register char device %s",
	75	MYDRVNAME);
22ad57ba	76	goto Away;
12e364b9 KC	77	}
	78	Registered = TRUE;
	79	INFODRV("New major number %d registered\n", MAJOR(MajorDev));
	80	} else {
	81	/* static major device number registration required */
	82	if (register_chrdev_region(MajorDev, 1, MYDRVNAME) < 0) {
	83	ERRDRV("Unable to register char device %s", MYDRVNAME);
22ad57ba	84	goto Away;
12e364b9 KC	85	}
	86	Registered = TRUE;
	87	INFODRV("Static major number %d registered\n", MAJOR(MajorDev));
	88	}
5e54c97d	89	if (cdev_add(&Cdev, MKDEV(MAJOR(MajorDev), 0), 1) < 0) {
22ad57ba	90	ERRDRV("failed to create char device: (status=%d)\n", rc);
5e54c97d KC	91	goto Away;
5e54c97d KC	92	}
12e364b9 KC	93	INFODRV("Registered char device for %s (major=%d)",
12e364b9 KC	94	MYDRVNAME, MAJOR(MajorDev));
22ad57ba	95	rc = 0;
12e364b9 KC	96	Away:
	97	return rc;
	98	}
	99
	100	void
	101	visorchipset_file_cleanup(void)
	102	{
	103	if (Cdev.ops != NULL)
	104	cdev_del(&Cdev);
	105	Cdev.ops = NULL;
	106	if (Registered) {
	107	if (MAJOR(MajorDev) >= 0) {
	108	unregister_chrdev_region(MajorDev, 1);
	109	MajorDev = MKDEV(0, 0);
	110	}
	111	Registered = FALSE;
	112	}
	113	}
	114
	115	static int
	116	visorchipset_open(struct inode inode, struct file file)
	117	{
	118	unsigned minor_number = iminor(inode);
	119	int rc = -ENODEV;
	120
	121	DEBUGDRV("%s", __func__);
	122	if (minor_number != 0)
22ad57ba	123	goto Away;
12e364b9	124	file->private_data = NULL;
22ad57ba	125	rc = 0;
12e364b9 KC	126	Away:
	127	if (rc < 0)
	128	ERRDRV("%s minor=%d failed", __func__, minor_number);
	129	return rc;
	130	}
	131
	132	static int
	133	visorchipset_release(struct inode inode, struct file file)
	134	{
12e364b9	135	DEBUGDRV("%s", __func__);
22ad57ba	136	return 0;
12e364b9 KC	137	}
	138
	139	static int
	140	visorchipset_mmap(struct file file, struct vm_area_struct vma)
	141	{
	142	ulong physAddr = 0;
	143	ulong offset = vma->vm_pgoff << PAGE_SHIFT;
	144	GUEST_PHYSICAL_ADDRESS addr = 0;
	145
	146	/* sv_enable_dfp(); */
	147	DEBUGDRV("%s", __func__);
	148	if (offset & (PAGE_SIZE - 1)) {
	149	ERRDRV("%s virtual address NOT page-aligned!", __func__);
	150	return -ENXIO; /* need aligned offsets */
	151	}
	152	switch (offset) {
	153	case VISORCHIPSET_MMAP_CONTROLCHANOFFSET:
	154	vma->vm_flags \|= VM_IO;
	155	if (*PControlVm_channel == NULL) {
	156	ERRDRV("%s no controlvm channel yet", __func__);
	157	return -ENXIO;
	158	}
	159	visorchannel_read(*PControlVm_channel,
	160	offsetof(ULTRA_CONTROLVM_CHANNEL_PROTOCOL,
	161	gpControlChannel), &addr,
	162	sizeof(addr));
	163	if (addr == 0) {
	164	ERRDRV("%s control channel address is 0", __func__);
	165	return -ENXIO;
	166	}
	167	physAddr = (ulong) (addr);
	168	DEBUGDRV("mapping physical address = 0x%lx", physAddr);
	169	if (remap_pfn_range(vma, vma->vm_start,
	170	physAddr >> PAGE_SHIFT,
	171	vma->vm_end - vma->vm_start,
	172	/pgprot_noncached /
	173	(vma->vm_page_prot))) {
	174	ERRDRV("%s remap_pfn_range failed", __func__);
	175	return -EAGAIN;
	176	}
	177	break;
	178	default:
	179	return -ENOSYS;
	180	}
	181	DEBUGDRV("%s success!", __func__);
	182	return 0;
	183	}
	184
	185	#ifdef HAVE_UNLOCKED_IOCTL
	186	long
	187	visorchipset_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	188	#else
	189	int
	190	visorchipset_ioctl(struct inode inode, struct file file,
	191	unsigned int cmd, unsigned long arg)
	192	#endif
	193	{
	194	int rc = SUCCESS;
ec03a7db BR	195	s64 adjustment;
ec03a7db BR	196	s64 vrtc_offset;
12e364b9 KC	197	DBGINF("entered visorchipset_ioctl, cmd=%d", cmd);
	198	switch (cmd) {
	199	case VMCALL_QUERY_GUEST_VIRTUAL_TIME_OFFSET:
	200	/* get the physical rtc offset */
	201	vrtc_offset = Issue_VMCALL_QUERY_GUEST_VIRTUAL_TIME_OFFSET();
	202	if (copy_to_user
22ad57ba KC	203	((void __user *)arg, &vrtc_offset, sizeof(vrtc_offset))) {
	204	rc = -EFAULT;
	205	goto Away;
	206	}
12e364b9 KC	207	DBGINF("insde visorchipset_ioctl, cmd=%d, vrtc_offset=%lld",
	208	cmd, vrtc_offset);
	209	break;
	210	case VMCALL_UPDATE_PHYSICAL_TIME:
	211	if (copy_from_user
22ad57ba KC	212	(&adjustment, (void __user *)arg, sizeof(adjustment))) {
	213	rc = -EFAULT;
	214	goto Away;
	215	}
12e364b9 KC	216	DBGINF("insde visorchipset_ioctl, cmd=%d, adjustment=%lld", cmd,
	217	adjustment);
	218	rc = Issue_VMCALL_UPDATE_PHYSICAL_TIME(adjustment);
	219	break;
	220	default:
	221	LOGERR("visorchipset_ioctl received invalid command");
22ad57ba	222	rc = -EFAULT;
12e364b9 KC	223	break;
12e364b9 KC	224	}
12e364b9 KC	225	Away:
	226	DBGINF("exiting %d!", rc);
	227	return rc;
	228	}