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