[deliverable/linux.git] / drivers / misc / cxl / api.c

/*
 * Copyright 2014 IBM Corp.
 *
 * 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.
 */

#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/anon_inodes.h>
#include <linux/file.h>
#include <misc/cxl.h>
#include <linux/fs.h>

#include "cxl.h"

struct cxl_context *cxl_dev_context_init(struct pci_dev *dev)
{
	struct address_space *mapping;
	struct cxl_afu *afu;
	struct cxl_context  *ctx;
	int rc;

	afu = cxl_pci_to_afu(dev);

	get_device(&afu->dev);
	ctx = cxl_context_alloc();
	if (IS_ERR(ctx)) {
		rc = PTR_ERR(ctx);
		goto err_dev;
	}

	ctx->kernelapi = true;

	/*
	 * Make our own address space since we won't have one from the
	 * filesystem like the user api has, and even if we do associate a file
	 * with this context we don't want to use the global anonymous inode's
	 * address space as that can invalidate unrelated users:
	 */
	mapping = kmalloc(sizeof(struct address_space), GFP_KERNEL);
	if (!mapping) {
		rc = -ENOMEM;
		goto err_ctx;
	}
	address_space_init_once(mapping);

	/* Make it a slave context.  We can promote it later? */
	rc = cxl_context_init(ctx, afu, false, mapping);
	if (rc)
		goto err_mapping;

	cxl_assign_psn_space(ctx);

	return ctx;

err_mapping:
	kfree(mapping);
err_ctx:
	kfree(ctx);
err_dev:
	put_device(&afu->dev);
	return ERR_PTR(rc);
}
EXPORT_SYMBOL_GPL(cxl_dev_context_init);

struct cxl_context *cxl_get_context(struct pci_dev *dev)
{
	return dev->dev.archdata.cxl_ctx;
}
EXPORT_SYMBOL_GPL(cxl_get_context);

struct device *cxl_get_phys_dev(struct pci_dev *dev)
{
	struct cxl_afu *afu;

	afu = cxl_pci_to_afu(dev);

	return afu->adapter->dev.parent;
}
EXPORT_SYMBOL_GPL(cxl_get_phys_dev);

int cxl_release_context(struct cxl_context *ctx)
{
	if (ctx->status >= STARTED)
		return -EBUSY;

	put_device(&ctx->afu->dev);

	cxl_context_free(ctx);

	return 0;
}
EXPORT_SYMBOL_GPL(cxl_release_context);

int cxl_allocate_afu_irqs(struct cxl_context *ctx, int num)
{
	if (num == 0)
		num = ctx->afu->pp_irqs;
	return afu_allocate_irqs(ctx, num);
}
EXPORT_SYMBOL_GPL(cxl_allocate_afu_irqs);

void cxl_free_afu_irqs(struct cxl_context *ctx)
{
	cxl_release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
}
EXPORT_SYMBOL_GPL(cxl_free_afu_irqs);

static irq_hw_number_t cxl_find_afu_irq(struct cxl_context *ctx, int num)
{
	__u16 range;
	int r;

	WARN_ON(num == 0);

	for (r = 0; r < CXL_IRQ_RANGES; r++) {
		range = ctx->irqs.range[r];
		if (num < range) {
			return ctx->irqs.offset[r] + num;
		}
		num -= range;
	}
	return 0;
}

int cxl_map_afu_irq(struct cxl_context *ctx, int num,
		    irq_handler_t handler, void *cookie, char *name)
{
	irq_hw_number_t hwirq;

	/*
	 * Find interrupt we are to register.
	 */
	hwirq = cxl_find_afu_irq(ctx, num);
	if (!hwirq)
		return -ENOENT;

	return cxl_map_irq(ctx->afu->adapter, hwirq, handler, cookie, name);
}
EXPORT_SYMBOL_GPL(cxl_map_afu_irq);

void cxl_unmap_afu_irq(struct cxl_context *ctx, int num, void *cookie)
{
	irq_hw_number_t hwirq;
	unsigned int virq;

	hwirq = cxl_find_afu_irq(ctx, num);
	if (!hwirq)
		return;

	virq = irq_find_mapping(NULL, hwirq);
	if (virq)
		cxl_unmap_irq(virq, cookie);
}
EXPORT_SYMBOL_GPL(cxl_unmap_afu_irq);

/*
 * Start a context
 * Code here similar to afu_ioctl_start_work().
 */
int cxl_start_context(struct cxl_context *ctx, u64 wed,
		      struct task_struct *task)
{
	int rc = 0;
	bool kernel = true;

	pr_devel("%s: pe: %i\n", __func__, ctx->pe);

	mutex_lock(&ctx->status_mutex);
	if (ctx->status == STARTED)
		goto out; /* already started */

	if (task) {
		ctx->pid = get_task_pid(task, PIDTYPE_PID);
		get_pid(ctx->pid);
		kernel = false;
	}

	cxl_ctx_get();

	if ((rc = cxl_attach_process(ctx, kernel, wed , 0))) {
		put_pid(ctx->pid);
		cxl_ctx_put();
		goto out;
	}

	ctx->status = STARTED;
out:
	mutex_unlock(&ctx->status_mutex);
	return rc;
}
EXPORT_SYMBOL_GPL(cxl_start_context);

int cxl_process_element(struct cxl_context *ctx)
{
	return ctx->pe;
}
EXPORT_SYMBOL_GPL(cxl_process_element);

/* Stop a context.  Returns 0 on success, otherwise -Errno */
int cxl_stop_context(struct cxl_context *ctx)
{
	return __detach_context(ctx);
}
EXPORT_SYMBOL_GPL(cxl_stop_context);

void cxl_set_master(struct cxl_context *ctx)
{
	ctx->master = true;
	cxl_assign_psn_space(ctx);
}
EXPORT_SYMBOL_GPL(cxl_set_master);

/* wrappers around afu_* file ops which are EXPORTED */
int cxl_fd_open(struct inode *inode, struct file *file)
{
	return afu_open(inode, file);
}
EXPORT_SYMBOL_GPL(cxl_fd_open);
int cxl_fd_release(struct inode *inode, struct file *file)
{
	return afu_release(inode, file);
}
EXPORT_SYMBOL_GPL(cxl_fd_release);
long cxl_fd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	return afu_ioctl(file, cmd, arg);
}
EXPORT_SYMBOL_GPL(cxl_fd_ioctl);
int cxl_fd_mmap(struct file *file, struct vm_area_struct *vm)
{
	return afu_mmap(file, vm);
}
EXPORT_SYMBOL_GPL(cxl_fd_mmap);
unsigned int cxl_fd_poll(struct file *file, struct poll_table_struct *poll)
{
	return afu_poll(file, poll);
}
EXPORT_SYMBOL_GPL(cxl_fd_poll);
ssize_t cxl_fd_read(struct file *file, char __user *buf, size_t count,
			loff_t *off)
{
	return afu_read(file, buf, count, off);
}
EXPORT_SYMBOL_GPL(cxl_fd_read);

#define PATCH_FOPS(NAME) if (!fops->NAME) fops->NAME = afu_fops.NAME

/* Get a struct file and fd for a context and attach the ops */
struct file *cxl_get_fd(struct cxl_context *ctx, struct file_operations *fops,
			int *fd)
{
	struct file *file;
	int rc, flags, fdtmp;

	flags = O_RDWR | O_CLOEXEC;

	/* This code is similar to anon_inode_getfd() */
	rc = get_unused_fd_flags(flags);
	if (rc < 0)
		return ERR_PTR(rc);
	fdtmp = rc;

	/*
	 * Patch the file ops.  Needs to be careful that this is rentrant safe.
	 */
	if (fops) {
		PATCH_FOPS(open);
		PATCH_FOPS(poll);
		PATCH_FOPS(read);
		PATCH_FOPS(release);
		PATCH_FOPS(unlocked_ioctl);
		PATCH_FOPS(compat_ioctl);
		PATCH_FOPS(mmap);
	} else /* use default ops */
		fops = (struct file_operations *)&afu_fops;

	file = anon_inode_getfile("cxl", fops, ctx, flags);
	if (IS_ERR(file))
		goto err_fd;

	file->f_mapping = ctx->mapping;

	*fd = fdtmp;
	return file;

err_fd:
	put_unused_fd(fdtmp);
	return NULL;
}
EXPORT_SYMBOL_GPL(cxl_get_fd);

struct cxl_context *cxl_fops_get_context(struct file *file)
{
	return file->private_data;
}
EXPORT_SYMBOL_GPL(cxl_fops_get_context);

int cxl_start_work(struct cxl_context *ctx,
		   struct cxl_ioctl_start_work *work)
{
	int rc;

	/* code taken from afu_ioctl_start_work */
	if (!(work->flags & CXL_START_WORK_NUM_IRQS))
		work->num_interrupts = ctx->afu->pp_irqs;
	else if ((work->num_interrupts < ctx->afu->pp_irqs) ||
		 (work->num_interrupts > ctx->afu->irqs_max)) {
		return -EINVAL;
	}

	rc = afu_register_irqs(ctx, work->num_interrupts);
	if (rc)
		return rc;

	rc = cxl_start_context(ctx, work->work_element_descriptor, current);
	if (rc < 0) {
		afu_release_irqs(ctx, ctx);
		return rc;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(cxl_start_work);

void __iomem *cxl_psa_map(struct cxl_context *ctx)
{
	struct cxl_afu *afu = ctx->afu;
	int rc;

	rc = cxl_afu_check_and_enable(afu);
	if (rc)
		return NULL;

	pr_devel("%s: psn_phys%llx size:%llx\n",
		 __func__, afu->psn_phys, afu->adapter->ps_size);
	return ioremap(ctx->psn_phys, ctx->psn_size);
}
EXPORT_SYMBOL_GPL(cxl_psa_map);

void cxl_psa_unmap(void __iomem *addr)
{
	iounmap(addr);
}
EXPORT_SYMBOL_GPL(cxl_psa_unmap);

int cxl_afu_reset(struct cxl_context *ctx)
{
	struct cxl_afu *afu = ctx->afu;
	int rc;

	rc = __cxl_afu_reset(afu);
	if (rc)
		return rc;

	return cxl_afu_check_and_enable(afu);
}
EXPORT_SYMBOL_GPL(cxl_afu_reset);

void cxl_perst_reloads_same_image(struct cxl_afu *afu,
				  bool perst_reloads_same_image)
{
	afu->adapter->perst_same_image = perst_reloads_same_image;
}
EXPORT_SYMBOL_GPL(cxl_perst_reloads_same_image);
Commit	Line	Data
6f7f0b3d MN	1	/*
	2	* Copyright 2014 IBM Corp.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*/
	9
	10	#include <linux/pci.h>
	11	#include <linux/slab.h>
	12	#include <linux/anon_inodes.h>
	13	#include <linux/file.h>
	14	#include <misc/cxl.h>
55e07668	15	#include <linux/fs.h>
6f7f0b3d MN	16
	17	#include "cxl.h"
	18
	19	struct cxl_context cxl_dev_context_init(struct pci_dev dev)
	20	{
55e07668	21	struct address_space *mapping;
6f7f0b3d MN	22	struct cxl_afu *afu;
	23	struct cxl_context *ctx;
	24	int rc;
	25
	26	afu = cxl_pci_to_afu(dev);
	27
3f8dc44d	28	get_device(&afu->dev);
6f7f0b3d	29	ctx = cxl_context_alloc();
af2a50bb IM	30	if (IS_ERR(ctx)) {
	31	rc = PTR_ERR(ctx);
	32	goto err_dev;
	33	}
6f7f0b3d	34
55e07668 IM	35	ctx->kernelapi = true;
	36
	37	/*
	38	* Make our own address space since we won't have one from the
	39	* filesystem like the user api has, and even if we do associate a file
	40	* with this context we don't want to use the global anonymous inode's
	41	* address space as that can invalidate unrelated users:
	42	*/
	43	mapping = kmalloc(sizeof(struct address_space), GFP_KERNEL);
	44	if (!mapping) {
	45	rc = -ENOMEM;
	46	goto err_ctx;
	47	}
	48	address_space_init_once(mapping);
	49
6f7f0b3d	50	/* Make it a slave context. We can promote it later? */
55e07668	51	rc = cxl_context_init(ctx, afu, false, mapping);
af2a50bb	52	if (rc)
55e07668 IM	53	goto err_mapping;
55e07668 IM	54
6f7f0b3d MN	55	cxl_assign_psn_space(ctx);
	56
	57	return ctx;
af2a50bb	58
55e07668 IM	59	err_mapping:
55e07668 IM	60	kfree(mapping);
af2a50bb IM	61	err_ctx:
	62	kfree(ctx);
	63	err_dev:
	64	put_device(&afu->dev);
	65	return ERR_PTR(rc);
6f7f0b3d MN	66	}
	67	EXPORT_SYMBOL_GPL(cxl_dev_context_init);
	68
	69	struct cxl_context cxl_get_context(struct pci_dev dev)
	70	{
	71	return dev->dev.archdata.cxl_ctx;
	72	}
	73	EXPORT_SYMBOL_GPL(cxl_get_context);
	74
	75	struct device cxl_get_phys_dev(struct pci_dev dev)
	76	{
	77	struct cxl_afu *afu;
	78
	79	afu = cxl_pci_to_afu(dev);
	80
	81	return afu->adapter->dev.parent;
	82	}
	83	EXPORT_SYMBOL_GPL(cxl_get_phys_dev);
	84
	85	int cxl_release_context(struct cxl_context *ctx)
	86	{
7c26b9cf	87	if (ctx->status >= STARTED)
6f7f0b3d MN	88	return -EBUSY;
6f7f0b3d MN	89
3f8dc44d MN	90	put_device(&ctx->afu->dev);
3f8dc44d MN	91
6f7f0b3d MN	92	cxl_context_free(ctx);
	93
	94	return 0;
	95	}
	96	EXPORT_SYMBOL_GPL(cxl_release_context);
	97
	98	int cxl_allocate_afu_irqs(struct cxl_context *ctx, int num)
	99	{
	100	if (num == 0)
	101	num = ctx->afu->pp_irqs;
	102	return afu_allocate_irqs(ctx, num);
	103	}
	104	EXPORT_SYMBOL_GPL(cxl_allocate_afu_irqs);
	105
	106	void cxl_free_afu_irqs(struct cxl_context *ctx)
	107	{
	108	cxl_release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
	109	}
	110	EXPORT_SYMBOL_GPL(cxl_free_afu_irqs);
	111
	112	static irq_hw_number_t cxl_find_afu_irq(struct cxl_context *ctx, int num)
	113	{
	114	__u16 range;
	115	int r;
	116
	117	WARN_ON(num == 0);
	118
	119	for (r = 0; r < CXL_IRQ_RANGES; r++) {
	120	range = ctx->irqs.range[r];
	121	if (num < range) {
	122	return ctx->irqs.offset[r] + num;
	123	}
	124	num -= range;
	125	}
	126	return 0;
	127	}
	128
	129	int cxl_map_afu_irq(struct cxl_context *ctx, int num,
	130	irq_handler_t handler, void cookie, char name)
	131	{
	132	irq_hw_number_t hwirq;
	133
	134	/*
	135	* Find interrupt we are to register.
	136	*/
	137	hwirq = cxl_find_afu_irq(ctx, num);
	138	if (!hwirq)
	139	return -ENOENT;
	140
	141	return cxl_map_irq(ctx->afu->adapter, hwirq, handler, cookie, name);
	142	}
	143	EXPORT_SYMBOL_GPL(cxl_map_afu_irq);
	144
	145	void cxl_unmap_afu_irq(struct cxl_context ctx, int num, void cookie)
	146	{
	147	irq_hw_number_t hwirq;
	148	unsigned int virq;
	149
	150	hwirq = cxl_find_afu_irq(ctx, num);
	151	if (!hwirq)
	152	return;
	153
	154	virq = irq_find_mapping(NULL, hwirq);
	155	if (virq)
156	cxl_unmap_irq(virq, cookie);
157	}
158	EXPORT_SYMBOL_GPL(cxl_unmap_afu_irq);
159
160	/*
161	* Start a context
162	* Code here similar to afu_ioctl_start_work().
163	*/
164	int cxl_start_context(struct cxl_context *ctx, u64 wed,
165	struct task_struct *task)
166	{
167	int rc = 0;
168	bool kernel = true;
169
170	pr_devel("%s: pe: %i\n", __func__, ctx->pe);
171
172	mutex_lock(&ctx->status_mutex);
173	if (ctx->status == STARTED)
174	goto out; /* already started */
175
176	if (task) {
177	ctx->pid = get_task_pid(task, PIDTYPE_PID);
178	get_pid(ctx->pid);
179	kernel = false;
180	}
181
182	cxl_ctx_get();
183
184	if ((rc = cxl_attach_process(ctx, kernel, wed , 0))) {
185	put_pid(ctx->pid);
186	cxl_ctx_put();
187	goto out;
188	}
189
190	ctx->status = STARTED;
6f7f0b3d MN	191	out:
	192	mutex_unlock(&ctx->status_mutex);
	193	return rc;
	194	}
	195	EXPORT_SYMBOL_GPL(cxl_start_context);
	196
	197	int cxl_process_element(struct cxl_context *ctx)
	198	{
	199	return ctx->pe;
	200	}
	201	EXPORT_SYMBOL_GPL(cxl_process_element);
	202
	203	/* Stop a context. Returns 0 on success, otherwise -Errno */
	204	int cxl_stop_context(struct cxl_context *ctx)
	205	{
3f8dc44d	206	return __detach_context(ctx);
6f7f0b3d MN	207	}
	208	EXPORT_SYMBOL_GPL(cxl_stop_context);
	209
	210	void cxl_set_master(struct cxl_context *ctx)
	211	{
	212	ctx->master = true;
	213	cxl_assign_psn_space(ctx);
	214	}
	215	EXPORT_SYMBOL_GPL(cxl_set_master);
	216
	217	/* wrappers around afu_* file ops which are EXPORTED */
	218	int cxl_fd_open(struct inode inode, struct file file)
	219	{
	220	return afu_open(inode, file);
	221	}
	222	EXPORT_SYMBOL_GPL(cxl_fd_open);
	223	int cxl_fd_release(struct inode inode, struct file file)
	224	{
	225	return afu_release(inode, file);
	226	}
	227	EXPORT_SYMBOL_GPL(cxl_fd_release);
	228	long cxl_fd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	229	{
	230	return afu_ioctl(file, cmd, arg);
	231	}
	232	EXPORT_SYMBOL_GPL(cxl_fd_ioctl);
	233	int cxl_fd_mmap(struct file file, struct vm_area_struct vm)
	234	{
	235	return afu_mmap(file, vm);
	236	}
	237	EXPORT_SYMBOL_GPL(cxl_fd_mmap);
	238	unsigned int cxl_fd_poll(struct file file, struct poll_table_struct poll)
	239	{
	240	return afu_poll(file, poll);
	241	}
	242	EXPORT_SYMBOL_GPL(cxl_fd_poll);
	243	ssize_t cxl_fd_read(struct file file, char __user buf, size_t count,
	244	loff_t *off)
	245	{
	246	return afu_read(file, buf, count, off);
	247	}
	248	EXPORT_SYMBOL_GPL(cxl_fd_read);
	249
	250	#define PATCH_FOPS(NAME) if (!fops->NAME) fops->NAME = afu_fops.NAME
	251
	252	/* Get a struct file and fd for a context and attach the ops */
	253	struct file cxl_get_fd(struct cxl_context ctx, struct file_operations *fops,
	254	int *fd)
	255	{
	256	struct file *file;
	257	int rc, flags, fdtmp;
	258
	259	flags = O_RDWR \| O_CLOEXEC;
	260
	261	/* This code is similar to anon_inode_getfd() */
	262	rc = get_unused_fd_flags(flags);
	263	if (rc < 0)
	264	return ERR_PTR(rc);
	265	fdtmp = rc;
	266
	267	/*
	268	* Patch the file ops. Needs to be careful that this is rentrant safe.
	269	*/
	270	if (fops) {
271	PATCH_FOPS(open);
272	PATCH_FOPS(poll);
273	PATCH_FOPS(read);
274	PATCH_FOPS(release);
275	PATCH_FOPS(unlocked_ioctl);
276	PATCH_FOPS(compat_ioctl);
277	PATCH_FOPS(mmap);
278	} else /* use default ops */
279	fops = (struct file_operations *)&afu_fops;
280
281	file = anon_inode_getfile("cxl", fops, ctx, flags);
282	if (IS_ERR(file))
55e07668 IM	283	goto err_fd;
	284
	285	file->f_mapping = ctx->mapping;
	286
6f7f0b3d MN	287	*fd = fdtmp;
6f7f0b3d MN	288	return file;
55e07668 IM	289
	290	err_fd:
	291	put_unused_fd(fdtmp);
	292	return NULL;
6f7f0b3d MN	293	}
	294	EXPORT_SYMBOL_GPL(cxl_get_fd);
	295
	296	struct cxl_context cxl_fops_get_context(struct file file)
	297	{
	298	return file->private_data;
	299	}
	300	EXPORT_SYMBOL_GPL(cxl_fops_get_context);
	301
	302	int cxl_start_work(struct cxl_context *ctx,
	303	struct cxl_ioctl_start_work *work)
	304	{
	305	int rc;
	306
	307	/* code taken from afu_ioctl_start_work */
	308	if (!(work->flags & CXL_START_WORK_NUM_IRQS))
	309	work->num_interrupts = ctx->afu->pp_irqs;
	310	else if ((work->num_interrupts < ctx->afu->pp_irqs) \|\|
	311	(work->num_interrupts > ctx->afu->irqs_max)) {
	312	return -EINVAL;
	313	}
	314
	315	rc = afu_register_irqs(ctx, work->num_interrupts);
	316	if (rc)
	317	return rc;
	318
	319	rc = cxl_start_context(ctx, work->work_element_descriptor, current);
	320	if (rc < 0) {
	321	afu_release_irqs(ctx, ctx);
	322	return rc;
	323	}
	324
	325	return 0;
	326	}
	327	EXPORT_SYMBOL_GPL(cxl_start_work);
	328
	329	void __iomem cxl_psa_map(struct cxl_context ctx)
	330	{
	331	struct cxl_afu *afu = ctx->afu;
	332	int rc;
	333
	334	rc = cxl_afu_check_and_enable(afu);
	335	if (rc)
	336	return NULL;
	337
	338	pr_devel("%s: psn_phys%llx size:%llx\n",
	339	__func__, afu->psn_phys, afu->adapter->ps_size);
	340	return ioremap(ctx->psn_phys, ctx->psn_size);
	341	}
	342	EXPORT_SYMBOL_GPL(cxl_psa_map);
	343
	344	void cxl_psa_unmap(void __iomem *addr)
	345	{
	346	iounmap(addr);
	347	}
	348	EXPORT_SYMBOL_GPL(cxl_psa_unmap);
	349
	350	int cxl_afu_reset(struct cxl_context *ctx)
	351	{
	352	struct cxl_afu *afu = ctx->afu;
	353	int rc;
	354
	355	rc = __cxl_afu_reset(afu);
	356	if (rc)
357	return rc;
358
359	return cxl_afu_check_and_enable(afu);
360	}
361	EXPORT_SYMBOL_GPL(cxl_afu_reset);
13e68d8b DA	362
	363	void cxl_perst_reloads_same_image(struct cxl_afu *afu,
	364	bool perst_reloads_same_image)
	365	{
	366	afu->adapter->perst_same_image = perst_reloads_same_image;
	367	}
	368	EXPORT_SYMBOL_GPL(cxl_perst_reloads_same_image);