xref: /openbmc/linux/drivers/scsi/cxlflash/ocxl_hw.c (revision 1c71222e)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * CXL Flash Device Driver
4  *
5  * Written by: Matthew R. Ochs <mrochs@linux.vnet.ibm.com>, IBM Corporation
6  *             Uma Krishnan <ukrishn@linux.vnet.ibm.com>, IBM Corporation
7  *
8  * Copyright (C) 2018 IBM Corporation
9  */
10 
11 #include <linux/file.h>
12 #include <linux/idr.h>
13 #include <linux/module.h>
14 #include <linux/mount.h>
15 #include <linux/pseudo_fs.h>
16 #include <linux/poll.h>
17 #include <linux/sched/signal.h>
18 #include <linux/interrupt.h>
19 #include <linux/irqdomain.h>
20 #include <asm/xive.h>
21 #include <misc/ocxl.h>
22 
23 #include <uapi/misc/cxl.h>
24 
25 #include "backend.h"
26 #include "ocxl_hw.h"
27 
28 /*
29  * Pseudo-filesystem to allocate inodes.
30  */
31 
32 #define OCXLFLASH_FS_MAGIC      0x1697698f
33 
34 static int ocxlflash_fs_cnt;
35 static struct vfsmount *ocxlflash_vfs_mount;
36 
ocxlflash_fs_init_fs_context(struct fs_context * fc)37 static int ocxlflash_fs_init_fs_context(struct fs_context *fc)
38 {
39 	return init_pseudo(fc, OCXLFLASH_FS_MAGIC) ? 0 : -ENOMEM;
40 }
41 
42 static struct file_system_type ocxlflash_fs_type = {
43 	.name		= "ocxlflash",
44 	.owner		= THIS_MODULE,
45 	.init_fs_context = ocxlflash_fs_init_fs_context,
46 	.kill_sb	= kill_anon_super,
47 };
48 
49 /*
50  * ocxlflash_release_mapping() - release the memory mapping
51  * @ctx:	Context whose mapping is to be released.
52  */
ocxlflash_release_mapping(struct ocxlflash_context * ctx)53 static void ocxlflash_release_mapping(struct ocxlflash_context *ctx)
54 {
55 	if (ctx->mapping)
56 		simple_release_fs(&ocxlflash_vfs_mount, &ocxlflash_fs_cnt);
57 	ctx->mapping = NULL;
58 }
59 
60 /*
61  * ocxlflash_getfile() - allocate pseudo filesystem, inode, and the file
62  * @dev:	Generic device of the host.
63  * @name:	Name of the pseudo filesystem.
64  * @fops:	File operations.
65  * @priv:	Private data.
66  * @flags:	Flags for the file.
67  *
68  * Return: pointer to the file on success, ERR_PTR on failure
69  */
ocxlflash_getfile(struct device * dev,const char * name,const struct file_operations * fops,void * priv,int flags)70 static struct file *ocxlflash_getfile(struct device *dev, const char *name,
71 				      const struct file_operations *fops,
72 				      void *priv, int flags)
73 {
74 	struct file *file;
75 	struct inode *inode;
76 	int rc;
77 
78 	if (fops->owner && !try_module_get(fops->owner)) {
79 		dev_err(dev, "%s: Owner does not exist\n", __func__);
80 		rc = -ENOENT;
81 		goto err1;
82 	}
83 
84 	rc = simple_pin_fs(&ocxlflash_fs_type, &ocxlflash_vfs_mount,
85 			   &ocxlflash_fs_cnt);
86 	if (unlikely(rc < 0)) {
87 		dev_err(dev, "%s: Cannot mount ocxlflash pseudofs rc=%d\n",
88 			__func__, rc);
89 		goto err2;
90 	}
91 
92 	inode = alloc_anon_inode(ocxlflash_vfs_mount->mnt_sb);
93 	if (IS_ERR(inode)) {
94 		rc = PTR_ERR(inode);
95 		dev_err(dev, "%s: alloc_anon_inode failed rc=%d\n",
96 			__func__, rc);
97 		goto err3;
98 	}
99 
100 	file = alloc_file_pseudo(inode, ocxlflash_vfs_mount, name,
101 				 flags & (O_ACCMODE | O_NONBLOCK), fops);
102 	if (IS_ERR(file)) {
103 		rc = PTR_ERR(file);
104 		dev_err(dev, "%s: alloc_file failed rc=%d\n",
105 			__func__, rc);
106 		goto err4;
107 	}
108 
109 	file->private_data = priv;
110 out:
111 	return file;
112 err4:
113 	iput(inode);
114 err3:
115 	simple_release_fs(&ocxlflash_vfs_mount, &ocxlflash_fs_cnt);
116 err2:
117 	module_put(fops->owner);
118 err1:
119 	file = ERR_PTR(rc);
120 	goto out;
121 }
122 
123 /**
124  * ocxlflash_psa_map() - map the process specific MMIO space
125  * @ctx_cookie:	Adapter context for which the mapping needs to be done.
126  *
127  * Return: MMIO pointer of the mapped region
128  */
ocxlflash_psa_map(void * ctx_cookie)129 static void __iomem *ocxlflash_psa_map(void *ctx_cookie)
130 {
131 	struct ocxlflash_context *ctx = ctx_cookie;
132 	struct device *dev = ctx->hw_afu->dev;
133 
134 	mutex_lock(&ctx->state_mutex);
135 	if (ctx->state != STARTED) {
136 		dev_err(dev, "%s: Context not started, state=%d\n", __func__,
137 			ctx->state);
138 		mutex_unlock(&ctx->state_mutex);
139 		return NULL;
140 	}
141 	mutex_unlock(&ctx->state_mutex);
142 
143 	return ioremap(ctx->psn_phys, ctx->psn_size);
144 }
145 
146 /**
147  * ocxlflash_psa_unmap() - unmap the process specific MMIO space
148  * @addr:	MMIO pointer to unmap.
149  */
ocxlflash_psa_unmap(void __iomem * addr)150 static void ocxlflash_psa_unmap(void __iomem *addr)
151 {
152 	iounmap(addr);
153 }
154 
155 /**
156  * ocxlflash_process_element() - get process element of the adapter context
157  * @ctx_cookie:	Adapter context associated with the process element.
158  *
159  * Return: process element of the adapter context
160  */
ocxlflash_process_element(void * ctx_cookie)161 static int ocxlflash_process_element(void *ctx_cookie)
162 {
163 	struct ocxlflash_context *ctx = ctx_cookie;
164 
165 	return ctx->pe;
166 }
167 
168 /**
169  * afu_map_irq() - map the interrupt of the adapter context
170  * @flags:	Flags.
171  * @ctx:	Adapter context.
172  * @num:	Per-context AFU interrupt number.
173  * @handler:	Interrupt handler to register.
174  * @cookie:	Interrupt handler private data.
175  * @name:	Name of the interrupt.
176  *
177  * Return: 0 on success, -errno on failure
178  */
afu_map_irq(u64 flags,struct ocxlflash_context * ctx,int num,irq_handler_t handler,void * cookie,char * name)179 static int afu_map_irq(u64 flags, struct ocxlflash_context *ctx, int num,
180 		       irq_handler_t handler, void *cookie, char *name)
181 {
182 	struct ocxl_hw_afu *afu = ctx->hw_afu;
183 	struct device *dev = afu->dev;
184 	struct ocxlflash_irqs *irq;
185 	struct xive_irq_data *xd;
186 	u32 virq;
187 	int rc = 0;
188 
189 	if (num < 0 || num >= ctx->num_irqs) {
190 		dev_err(dev, "%s: Interrupt %d not allocated\n", __func__, num);
191 		rc = -ENOENT;
192 		goto out;
193 	}
194 
195 	irq = &ctx->irqs[num];
196 	virq = irq_create_mapping(NULL, irq->hwirq);
197 	if (unlikely(!virq)) {
198 		dev_err(dev, "%s: irq_create_mapping failed\n", __func__);
199 		rc = -ENOMEM;
200 		goto out;
201 	}
202 
203 	rc = request_irq(virq, handler, 0, name, cookie);
204 	if (unlikely(rc)) {
205 		dev_err(dev, "%s: request_irq failed rc=%d\n", __func__, rc);
206 		goto err1;
207 	}
208 
209 	xd = irq_get_handler_data(virq);
210 	if (unlikely(!xd)) {
211 		dev_err(dev, "%s: Can't get interrupt data\n", __func__);
212 		rc = -ENXIO;
213 		goto err2;
214 	}
215 
216 	irq->virq = virq;
217 	irq->vtrig = xd->trig_mmio;
218 out:
219 	return rc;
220 err2:
221 	free_irq(virq, cookie);
222 err1:
223 	irq_dispose_mapping(virq);
224 	goto out;
225 }
226 
227 /**
228  * ocxlflash_map_afu_irq() - map the interrupt of the adapter context
229  * @ctx_cookie:	Adapter context.
230  * @num:	Per-context AFU interrupt number.
231  * @handler:	Interrupt handler to register.
232  * @cookie:	Interrupt handler private data.
233  * @name:	Name of the interrupt.
234  *
235  * Return: 0 on success, -errno on failure
236  */
ocxlflash_map_afu_irq(void * ctx_cookie,int num,irq_handler_t handler,void * cookie,char * name)237 static int ocxlflash_map_afu_irq(void *ctx_cookie, int num,
238 				 irq_handler_t handler, void *cookie,
239 				 char *name)
240 {
241 	return afu_map_irq(0, ctx_cookie, num, handler, cookie, name);
242 }
243 
244 /**
245  * afu_unmap_irq() - unmap the interrupt
246  * @flags:	Flags.
247  * @ctx:	Adapter context.
248  * @num:	Per-context AFU interrupt number.
249  * @cookie:	Interrupt handler private data.
250  */
afu_unmap_irq(u64 flags,struct ocxlflash_context * ctx,int num,void * cookie)251 static void afu_unmap_irq(u64 flags, struct ocxlflash_context *ctx, int num,
252 			  void *cookie)
253 {
254 	struct ocxl_hw_afu *afu = ctx->hw_afu;
255 	struct device *dev = afu->dev;
256 	struct ocxlflash_irqs *irq;
257 
258 	if (num < 0 || num >= ctx->num_irqs) {
259 		dev_err(dev, "%s: Interrupt %d not allocated\n", __func__, num);
260 		return;
261 	}
262 
263 	irq = &ctx->irqs[num];
264 
265 	if (irq_find_mapping(NULL, irq->hwirq)) {
266 		free_irq(irq->virq, cookie);
267 		irq_dispose_mapping(irq->virq);
268 	}
269 
270 	memset(irq, 0, sizeof(*irq));
271 }
272 
273 /**
274  * ocxlflash_unmap_afu_irq() - unmap the interrupt
275  * @ctx_cookie:	Adapter context.
276  * @num:	Per-context AFU interrupt number.
277  * @cookie:	Interrupt handler private data.
278  */
ocxlflash_unmap_afu_irq(void * ctx_cookie,int num,void * cookie)279 static void ocxlflash_unmap_afu_irq(void *ctx_cookie, int num, void *cookie)
280 {
281 	return afu_unmap_irq(0, ctx_cookie, num, cookie);
282 }
283 
284 /**
285  * ocxlflash_get_irq_objhndl() - get the object handle for an interrupt
286  * @ctx_cookie:	Context associated with the interrupt.
287  * @irq:	Interrupt number.
288  *
289  * Return: effective address of the mapped region
290  */
ocxlflash_get_irq_objhndl(void * ctx_cookie,int irq)291 static u64 ocxlflash_get_irq_objhndl(void *ctx_cookie, int irq)
292 {
293 	struct ocxlflash_context *ctx = ctx_cookie;
294 
295 	if (irq < 0 || irq >= ctx->num_irqs)
296 		return 0;
297 
298 	return (__force u64)ctx->irqs[irq].vtrig;
299 }
300 
301 /**
302  * ocxlflash_xsl_fault() - callback when translation error is triggered
303  * @data:	Private data provided at callback registration, the context.
304  * @addr:	Address that triggered the error.
305  * @dsisr:	Value of dsisr register.
306  */
ocxlflash_xsl_fault(void * data,u64 addr,u64 dsisr)307 static void ocxlflash_xsl_fault(void *data, u64 addr, u64 dsisr)
308 {
309 	struct ocxlflash_context *ctx = data;
310 
311 	spin_lock(&ctx->slock);
312 	ctx->fault_addr = addr;
313 	ctx->fault_dsisr = dsisr;
314 	ctx->pending_fault = true;
315 	spin_unlock(&ctx->slock);
316 
317 	wake_up_all(&ctx->wq);
318 }
319 
320 /**
321  * start_context() - local routine to start a context
322  * @ctx:	Adapter context to be started.
323  *
324  * Assign the context specific MMIO space, add and enable the PE.
325  *
326  * Return: 0 on success, -errno on failure
327  */
start_context(struct ocxlflash_context * ctx)328 static int start_context(struct ocxlflash_context *ctx)
329 {
330 	struct ocxl_hw_afu *afu = ctx->hw_afu;
331 	struct ocxl_afu_config *acfg = &afu->acfg;
332 	void *link_token = afu->link_token;
333 	struct pci_dev *pdev = afu->pdev;
334 	struct device *dev = afu->dev;
335 	bool master = ctx->master;
336 	struct mm_struct *mm;
337 	int rc = 0;
338 	u32 pid;
339 
340 	mutex_lock(&ctx->state_mutex);
341 	if (ctx->state != OPENED) {
342 		dev_err(dev, "%s: Context state invalid, state=%d\n",
343 			__func__, ctx->state);
344 		rc = -EINVAL;
345 		goto out;
346 	}
347 
348 	if (master) {
349 		ctx->psn_size = acfg->global_mmio_size;
350 		ctx->psn_phys = afu->gmmio_phys;
351 	} else {
352 		ctx->psn_size = acfg->pp_mmio_stride;
353 		ctx->psn_phys = afu->ppmmio_phys + (ctx->pe * ctx->psn_size);
354 	}
355 
356 	/* pid and mm not set for master contexts */
357 	if (master) {
358 		pid = 0;
359 		mm = NULL;
360 	} else {
361 		pid = current->mm->context.id;
362 		mm = current->mm;
363 	}
364 
365 	rc = ocxl_link_add_pe(link_token, ctx->pe, pid, 0, 0,
366 			      pci_dev_id(pdev), mm, ocxlflash_xsl_fault,
367 			      ctx);
368 	if (unlikely(rc)) {
369 		dev_err(dev, "%s: ocxl_link_add_pe failed rc=%d\n",
370 			__func__, rc);
371 		goto out;
372 	}
373 
374 	ctx->state = STARTED;
375 out:
376 	mutex_unlock(&ctx->state_mutex);
377 	return rc;
378 }
379 
380 /**
381  * ocxlflash_start_context() - start a kernel context
382  * @ctx_cookie:	Adapter context to be started.
383  *
384  * Return: 0 on success, -errno on failure
385  */
ocxlflash_start_context(void * ctx_cookie)386 static int ocxlflash_start_context(void *ctx_cookie)
387 {
388 	struct ocxlflash_context *ctx = ctx_cookie;
389 
390 	return start_context(ctx);
391 }
392 
393 /**
394  * ocxlflash_stop_context() - stop a context
395  * @ctx_cookie:	Adapter context to be stopped.
396  *
397  * Return: 0 on success, -errno on failure
398  */
ocxlflash_stop_context(void * ctx_cookie)399 static int ocxlflash_stop_context(void *ctx_cookie)
400 {
401 	struct ocxlflash_context *ctx = ctx_cookie;
402 	struct ocxl_hw_afu *afu = ctx->hw_afu;
403 	struct ocxl_afu_config *acfg = &afu->acfg;
404 	struct pci_dev *pdev = afu->pdev;
405 	struct device *dev = afu->dev;
406 	enum ocxlflash_ctx_state state;
407 	int rc = 0;
408 
409 	mutex_lock(&ctx->state_mutex);
410 	state = ctx->state;
411 	ctx->state = CLOSED;
412 	mutex_unlock(&ctx->state_mutex);
413 	if (state != STARTED)
414 		goto out;
415 
416 	rc = ocxl_config_terminate_pasid(pdev, acfg->dvsec_afu_control_pos,
417 					 ctx->pe);
418 	if (unlikely(rc)) {
419 		dev_err(dev, "%s: ocxl_config_terminate_pasid failed rc=%d\n",
420 			__func__, rc);
421 		/* If EBUSY, PE could be referenced in future by the AFU */
422 		if (rc == -EBUSY)
423 			goto out;
424 	}
425 
426 	rc = ocxl_link_remove_pe(afu->link_token, ctx->pe);
427 	if (unlikely(rc)) {
428 		dev_err(dev, "%s: ocxl_link_remove_pe failed rc=%d\n",
429 			__func__, rc);
430 		goto out;
431 	}
432 out:
433 	return rc;
434 }
435 
436 /**
437  * ocxlflash_afu_reset() - reset the AFU
438  * @ctx_cookie:	Adapter context.
439  */
ocxlflash_afu_reset(void * ctx_cookie)440 static int ocxlflash_afu_reset(void *ctx_cookie)
441 {
442 	struct ocxlflash_context *ctx = ctx_cookie;
443 	struct device *dev = ctx->hw_afu->dev;
444 
445 	/* Pending implementation from OCXL transport services */
446 	dev_err_once(dev, "%s: afu_reset() fop not supported\n", __func__);
447 
448 	/* Silently return success until it is implemented */
449 	return 0;
450 }
451 
452 /**
453  * ocxlflash_set_master() - sets the context as master
454  * @ctx_cookie:	Adapter context to set as master.
455  */
ocxlflash_set_master(void * ctx_cookie)456 static void ocxlflash_set_master(void *ctx_cookie)
457 {
458 	struct ocxlflash_context *ctx = ctx_cookie;
459 
460 	ctx->master = true;
461 }
462 
463 /**
464  * ocxlflash_get_context() - obtains the context associated with the host
465  * @pdev:	PCI device associated with the host.
466  * @afu_cookie:	Hardware AFU associated with the host.
467  *
468  * Return: returns the pointer to host adapter context
469  */
ocxlflash_get_context(struct pci_dev * pdev,void * afu_cookie)470 static void *ocxlflash_get_context(struct pci_dev *pdev, void *afu_cookie)
471 {
472 	struct ocxl_hw_afu *afu = afu_cookie;
473 
474 	return afu->ocxl_ctx;
475 }
476 
477 /**
478  * ocxlflash_dev_context_init() - allocate and initialize an adapter context
479  * @pdev:	PCI device associated with the host.
480  * @afu_cookie:	Hardware AFU associated with the host.
481  *
482  * Return: returns the adapter context on success, ERR_PTR on failure
483  */
ocxlflash_dev_context_init(struct pci_dev * pdev,void * afu_cookie)484 static void *ocxlflash_dev_context_init(struct pci_dev *pdev, void *afu_cookie)
485 {
486 	struct ocxl_hw_afu *afu = afu_cookie;
487 	struct device *dev = afu->dev;
488 	struct ocxlflash_context *ctx;
489 	int rc;
490 
491 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
492 	if (unlikely(!ctx)) {
493 		dev_err(dev, "%s: Context allocation failed\n", __func__);
494 		rc = -ENOMEM;
495 		goto err1;
496 	}
497 
498 	idr_preload(GFP_KERNEL);
499 	rc = idr_alloc(&afu->idr, ctx, 0, afu->max_pasid, GFP_NOWAIT);
500 	idr_preload_end();
501 	if (unlikely(rc < 0)) {
502 		dev_err(dev, "%s: idr_alloc failed rc=%d\n", __func__, rc);
503 		goto err2;
504 	}
505 
506 	spin_lock_init(&ctx->slock);
507 	init_waitqueue_head(&ctx->wq);
508 	mutex_init(&ctx->state_mutex);
509 
510 	ctx->state = OPENED;
511 	ctx->pe = rc;
512 	ctx->master = false;
513 	ctx->mapping = NULL;
514 	ctx->hw_afu = afu;
515 	ctx->irq_bitmap = 0;
516 	ctx->pending_irq = false;
517 	ctx->pending_fault = false;
518 out:
519 	return ctx;
520 err2:
521 	kfree(ctx);
522 err1:
523 	ctx = ERR_PTR(rc);
524 	goto out;
525 }
526 
527 /**
528  * ocxlflash_release_context() - releases an adapter context
529  * @ctx_cookie:	Adapter context to be released.
530  *
531  * Return: 0 on success, -errno on failure
532  */
ocxlflash_release_context(void * ctx_cookie)533 static int ocxlflash_release_context(void *ctx_cookie)
534 {
535 	struct ocxlflash_context *ctx = ctx_cookie;
536 	struct device *dev;
537 	int rc = 0;
538 
539 	if (!ctx)
540 		goto out;
541 
542 	dev = ctx->hw_afu->dev;
543 	mutex_lock(&ctx->state_mutex);
544 	if (ctx->state >= STARTED) {
545 		dev_err(dev, "%s: Context in use, state=%d\n", __func__,
546 			ctx->state);
547 		mutex_unlock(&ctx->state_mutex);
548 		rc = -EBUSY;
549 		goto out;
550 	}
551 	mutex_unlock(&ctx->state_mutex);
552 
553 	idr_remove(&ctx->hw_afu->idr, ctx->pe);
554 	ocxlflash_release_mapping(ctx);
555 	kfree(ctx);
556 out:
557 	return rc;
558 }
559 
560 /**
561  * ocxlflash_perst_reloads_same_image() - sets the image reload policy
562  * @afu_cookie:	Hardware AFU associated with the host.
563  * @image:	Whether to load the same image on PERST.
564  */
ocxlflash_perst_reloads_same_image(void * afu_cookie,bool image)565 static void ocxlflash_perst_reloads_same_image(void *afu_cookie, bool image)
566 {
567 	struct ocxl_hw_afu *afu = afu_cookie;
568 
569 	afu->perst_same_image = image;
570 }
571 
572 /**
573  * ocxlflash_read_adapter_vpd() - reads the adapter VPD
574  * @pdev:	PCI device associated with the host.
575  * @buf:	Buffer to get the VPD data.
576  * @count:	Size of buffer (maximum bytes that can be read).
577  *
578  * Return: size of VPD on success, -errno on failure
579  */
ocxlflash_read_adapter_vpd(struct pci_dev * pdev,void * buf,size_t count)580 static ssize_t ocxlflash_read_adapter_vpd(struct pci_dev *pdev, void *buf,
581 					  size_t count)
582 {
583 	return pci_read_vpd(pdev, 0, count, buf);
584 }
585 
586 /**
587  * free_afu_irqs() - internal service to free interrupts
588  * @ctx:	Adapter context.
589  */
free_afu_irqs(struct ocxlflash_context * ctx)590 static void free_afu_irqs(struct ocxlflash_context *ctx)
591 {
592 	struct ocxl_hw_afu *afu = ctx->hw_afu;
593 	struct device *dev = afu->dev;
594 	int i;
595 
596 	if (!ctx->irqs) {
597 		dev_err(dev, "%s: Interrupts not allocated\n", __func__);
598 		return;
599 	}
600 
601 	for (i = ctx->num_irqs; i >= 0; i--)
602 		ocxl_link_free_irq(afu->link_token, ctx->irqs[i].hwirq);
603 
604 	kfree(ctx->irqs);
605 	ctx->irqs = NULL;
606 }
607 
608 /**
609  * alloc_afu_irqs() - internal service to allocate interrupts
610  * @ctx:	Context associated with the request.
611  * @num:	Number of interrupts requested.
612  *
613  * Return: 0 on success, -errno on failure
614  */
alloc_afu_irqs(struct ocxlflash_context * ctx,int num)615 static int alloc_afu_irqs(struct ocxlflash_context *ctx, int num)
616 {
617 	struct ocxl_hw_afu *afu = ctx->hw_afu;
618 	struct device *dev = afu->dev;
619 	struct ocxlflash_irqs *irqs;
620 	int rc = 0;
621 	int hwirq;
622 	int i;
623 
624 	if (ctx->irqs) {
625 		dev_err(dev, "%s: Interrupts already allocated\n", __func__);
626 		rc = -EEXIST;
627 		goto out;
628 	}
629 
630 	if (num > OCXL_MAX_IRQS) {
631 		dev_err(dev, "%s: Too many interrupts num=%d\n", __func__, num);
632 		rc = -EINVAL;
633 		goto out;
634 	}
635 
636 	irqs = kcalloc(num, sizeof(*irqs), GFP_KERNEL);
637 	if (unlikely(!irqs)) {
638 		dev_err(dev, "%s: Context irqs allocation failed\n", __func__);
639 		rc = -ENOMEM;
640 		goto out;
641 	}
642 
643 	for (i = 0; i < num; i++) {
644 		rc = ocxl_link_irq_alloc(afu->link_token, &hwirq);
645 		if (unlikely(rc)) {
646 			dev_err(dev, "%s: ocxl_link_irq_alloc failed rc=%d\n",
647 				__func__, rc);
648 			goto err;
649 		}
650 
651 		irqs[i].hwirq = hwirq;
652 	}
653 
654 	ctx->irqs = irqs;
655 	ctx->num_irqs = num;
656 out:
657 	return rc;
658 err:
659 	for (i = i-1; i >= 0; i--)
660 		ocxl_link_free_irq(afu->link_token, irqs[i].hwirq);
661 	kfree(irqs);
662 	goto out;
663 }
664 
665 /**
666  * ocxlflash_allocate_afu_irqs() - allocates the requested number of interrupts
667  * @ctx_cookie:	Context associated with the request.
668  * @num:	Number of interrupts requested.
669  *
670  * Return: 0 on success, -errno on failure
671  */
ocxlflash_allocate_afu_irqs(void * ctx_cookie,int num)672 static int ocxlflash_allocate_afu_irqs(void *ctx_cookie, int num)
673 {
674 	return alloc_afu_irqs(ctx_cookie, num);
675 }
676 
677 /**
678  * ocxlflash_free_afu_irqs() - frees the interrupts of an adapter context
679  * @ctx_cookie:	Adapter context.
680  */
ocxlflash_free_afu_irqs(void * ctx_cookie)681 static void ocxlflash_free_afu_irqs(void *ctx_cookie)
682 {
683 	free_afu_irqs(ctx_cookie);
684 }
685 
686 /**
687  * ocxlflash_unconfig_afu() - unconfigure the AFU
688  * @afu: AFU associated with the host.
689  */
ocxlflash_unconfig_afu(struct ocxl_hw_afu * afu)690 static void ocxlflash_unconfig_afu(struct ocxl_hw_afu *afu)
691 {
692 	if (afu->gmmio_virt) {
693 		iounmap(afu->gmmio_virt);
694 		afu->gmmio_virt = NULL;
695 	}
696 }
697 
698 /**
699  * ocxlflash_destroy_afu() - destroy the AFU structure
700  * @afu_cookie:	AFU to be freed.
701  */
ocxlflash_destroy_afu(void * afu_cookie)702 static void ocxlflash_destroy_afu(void *afu_cookie)
703 {
704 	struct ocxl_hw_afu *afu = afu_cookie;
705 	int pos;
706 
707 	if (!afu)
708 		return;
709 
710 	ocxlflash_release_context(afu->ocxl_ctx);
711 	idr_destroy(&afu->idr);
712 
713 	/* Disable the AFU */
714 	pos = afu->acfg.dvsec_afu_control_pos;
715 	ocxl_config_set_afu_state(afu->pdev, pos, 0);
716 
717 	ocxlflash_unconfig_afu(afu);
718 	kfree(afu);
719 }
720 
721 /**
722  * ocxlflash_config_fn() - configure the host function
723  * @pdev:	PCI device associated with the host.
724  * @afu:	AFU associated with the host.
725  *
726  * Return: 0 on success, -errno on failure
727  */
ocxlflash_config_fn(struct pci_dev * pdev,struct ocxl_hw_afu * afu)728 static int ocxlflash_config_fn(struct pci_dev *pdev, struct ocxl_hw_afu *afu)
729 {
730 	struct ocxl_fn_config *fcfg = &afu->fcfg;
731 	struct device *dev = &pdev->dev;
732 	u16 base, enabled, supported;
733 	int rc = 0;
734 
735 	/* Read DVSEC config of the function */
736 	rc = ocxl_config_read_function(pdev, fcfg);
737 	if (unlikely(rc)) {
738 		dev_err(dev, "%s: ocxl_config_read_function failed rc=%d\n",
739 			__func__, rc);
740 		goto out;
741 	}
742 
743 	/* Check if function has AFUs defined, only 1 per function supported */
744 	if (fcfg->max_afu_index >= 0) {
745 		afu->is_present = true;
746 		if (fcfg->max_afu_index != 0)
747 			dev_warn(dev, "%s: Unexpected AFU index value %d\n",
748 				 __func__, fcfg->max_afu_index);
749 	}
750 
751 	rc = ocxl_config_get_actag_info(pdev, &base, &enabled, &supported);
752 	if (unlikely(rc)) {
753 		dev_err(dev, "%s: ocxl_config_get_actag_info failed rc=%d\n",
754 			__func__, rc);
755 		goto out;
756 	}
757 
758 	afu->fn_actag_base = base;
759 	afu->fn_actag_enabled = enabled;
760 
761 	ocxl_config_set_actag(pdev, fcfg->dvsec_function_pos, base, enabled);
762 	dev_dbg(dev, "%s: Function acTag range base=%u enabled=%u\n",
763 		__func__, base, enabled);
764 
765 	rc = ocxl_link_setup(pdev, 0, &afu->link_token);
766 	if (unlikely(rc)) {
767 		dev_err(dev, "%s: ocxl_link_setup failed rc=%d\n",
768 			__func__, rc);
769 		goto out;
770 	}
771 
772 	rc = ocxl_config_set_TL(pdev, fcfg->dvsec_tl_pos);
773 	if (unlikely(rc)) {
774 		dev_err(dev, "%s: ocxl_config_set_TL failed rc=%d\n",
775 			__func__, rc);
776 		goto err;
777 	}
778 out:
779 	return rc;
780 err:
781 	ocxl_link_release(pdev, afu->link_token);
782 	goto out;
783 }
784 
785 /**
786  * ocxlflash_unconfig_fn() - unconfigure the host function
787  * @pdev:	PCI device associated with the host.
788  * @afu:	AFU associated with the host.
789  */
ocxlflash_unconfig_fn(struct pci_dev * pdev,struct ocxl_hw_afu * afu)790 static void ocxlflash_unconfig_fn(struct pci_dev *pdev, struct ocxl_hw_afu *afu)
791 {
792 	ocxl_link_release(pdev, afu->link_token);
793 }
794 
795 /**
796  * ocxlflash_map_mmio() - map the AFU MMIO space
797  * @afu: AFU associated with the host.
798  *
799  * Return: 0 on success, -errno on failure
800  */
ocxlflash_map_mmio(struct ocxl_hw_afu * afu)801 static int ocxlflash_map_mmio(struct ocxl_hw_afu *afu)
802 {
803 	struct ocxl_afu_config *acfg = &afu->acfg;
804 	struct pci_dev *pdev = afu->pdev;
805 	struct device *dev = afu->dev;
806 	phys_addr_t gmmio, ppmmio;
807 	int rc = 0;
808 
809 	rc = pci_request_region(pdev, acfg->global_mmio_bar, "ocxlflash");
810 	if (unlikely(rc)) {
811 		dev_err(dev, "%s: pci_request_region for global failed rc=%d\n",
812 			__func__, rc);
813 		goto out;
814 	}
815 	gmmio = pci_resource_start(pdev, acfg->global_mmio_bar);
816 	gmmio += acfg->global_mmio_offset;
817 
818 	rc = pci_request_region(pdev, acfg->pp_mmio_bar, "ocxlflash");
819 	if (unlikely(rc)) {
820 		dev_err(dev, "%s: pci_request_region for pp bar failed rc=%d\n",
821 			__func__, rc);
822 		goto err1;
823 	}
824 	ppmmio = pci_resource_start(pdev, acfg->pp_mmio_bar);
825 	ppmmio += acfg->pp_mmio_offset;
826 
827 	afu->gmmio_virt = ioremap(gmmio, acfg->global_mmio_size);
828 	if (unlikely(!afu->gmmio_virt)) {
829 		dev_err(dev, "%s: MMIO mapping failed\n", __func__);
830 		rc = -ENOMEM;
831 		goto err2;
832 	}
833 
834 	afu->gmmio_phys = gmmio;
835 	afu->ppmmio_phys = ppmmio;
836 out:
837 	return rc;
838 err2:
839 	pci_release_region(pdev, acfg->pp_mmio_bar);
840 err1:
841 	pci_release_region(pdev, acfg->global_mmio_bar);
842 	goto out;
843 }
844 
845 /**
846  * ocxlflash_config_afu() - configure the host AFU
847  * @pdev:	PCI device associated with the host.
848  * @afu:	AFU associated with the host.
849  *
850  * Must be called _after_ host function configuration.
851  *
852  * Return: 0 on success, -errno on failure
853  */
ocxlflash_config_afu(struct pci_dev * pdev,struct ocxl_hw_afu * afu)854 static int ocxlflash_config_afu(struct pci_dev *pdev, struct ocxl_hw_afu *afu)
855 {
856 	struct ocxl_afu_config *acfg = &afu->acfg;
857 	struct ocxl_fn_config *fcfg = &afu->fcfg;
858 	struct device *dev = &pdev->dev;
859 	int count;
860 	int base;
861 	int pos;
862 	int rc = 0;
863 
864 	/* This HW AFU function does not have any AFUs defined */
865 	if (!afu->is_present)
866 		goto out;
867 
868 	/* Read AFU config at index 0 */
869 	rc = ocxl_config_read_afu(pdev, fcfg, acfg, 0);
870 	if (unlikely(rc)) {
871 		dev_err(dev, "%s: ocxl_config_read_afu failed rc=%d\n",
872 			__func__, rc);
873 		goto out;
874 	}
875 
876 	/* Only one AFU per function is supported, so actag_base is same */
877 	base = afu->fn_actag_base;
878 	count = min_t(int, acfg->actag_supported, afu->fn_actag_enabled);
879 	pos = acfg->dvsec_afu_control_pos;
880 
881 	ocxl_config_set_afu_actag(pdev, pos, base, count);
882 	dev_dbg(dev, "%s: acTag base=%d enabled=%d\n", __func__, base, count);
883 	afu->afu_actag_base = base;
884 	afu->afu_actag_enabled = count;
885 	afu->max_pasid = 1 << acfg->pasid_supported_log;
886 
887 	ocxl_config_set_afu_pasid(pdev, pos, 0, acfg->pasid_supported_log);
888 
889 	rc = ocxlflash_map_mmio(afu);
890 	if (unlikely(rc)) {
891 		dev_err(dev, "%s: ocxlflash_map_mmio failed rc=%d\n",
892 			__func__, rc);
893 		goto out;
894 	}
895 
896 	/* Enable the AFU */
897 	ocxl_config_set_afu_state(pdev, acfg->dvsec_afu_control_pos, 1);
898 out:
899 	return rc;
900 }
901 
902 /**
903  * ocxlflash_create_afu() - create the AFU for OCXL
904  * @pdev:	PCI device associated with the host.
905  *
906  * Return: AFU on success, NULL on failure
907  */
ocxlflash_create_afu(struct pci_dev * pdev)908 static void *ocxlflash_create_afu(struct pci_dev *pdev)
909 {
910 	struct device *dev = &pdev->dev;
911 	struct ocxlflash_context *ctx;
912 	struct ocxl_hw_afu *afu;
913 	int rc;
914 
915 	afu = kzalloc(sizeof(*afu), GFP_KERNEL);
916 	if (unlikely(!afu)) {
917 		dev_err(dev, "%s: HW AFU allocation failed\n", __func__);
918 		goto out;
919 	}
920 
921 	afu->pdev = pdev;
922 	afu->dev = dev;
923 	idr_init(&afu->idr);
924 
925 	rc = ocxlflash_config_fn(pdev, afu);
926 	if (unlikely(rc)) {
927 		dev_err(dev, "%s: Function configuration failed rc=%d\n",
928 			__func__, rc);
929 		goto err1;
930 	}
931 
932 	rc = ocxlflash_config_afu(pdev, afu);
933 	if (unlikely(rc)) {
934 		dev_err(dev, "%s: AFU configuration failed rc=%d\n",
935 			__func__, rc);
936 		goto err2;
937 	}
938 
939 	ctx = ocxlflash_dev_context_init(pdev, afu);
940 	if (IS_ERR(ctx)) {
941 		rc = PTR_ERR(ctx);
942 		dev_err(dev, "%s: ocxlflash_dev_context_init failed rc=%d\n",
943 			__func__, rc);
944 		goto err3;
945 	}
946 
947 	afu->ocxl_ctx = ctx;
948 out:
949 	return afu;
950 err3:
951 	ocxlflash_unconfig_afu(afu);
952 err2:
953 	ocxlflash_unconfig_fn(pdev, afu);
954 err1:
955 	idr_destroy(&afu->idr);
956 	kfree(afu);
957 	afu = NULL;
958 	goto out;
959 }
960 
961 /**
962  * ctx_event_pending() - check for any event pending on the context
963  * @ctx:	Context to be checked.
964  *
965  * Return: true if there is an event pending, false if none pending
966  */
ctx_event_pending(struct ocxlflash_context * ctx)967 static inline bool ctx_event_pending(struct ocxlflash_context *ctx)
968 {
969 	if (ctx->pending_irq || ctx->pending_fault)
970 		return true;
971 
972 	return false;
973 }
974 
975 /**
976  * afu_poll() - poll the AFU for events on the context
977  * @file:	File associated with the adapter context.
978  * @poll:	Poll structure from the user.
979  *
980  * Return: poll mask
981  */
afu_poll(struct file * file,struct poll_table_struct * poll)982 static unsigned int afu_poll(struct file *file, struct poll_table_struct *poll)
983 {
984 	struct ocxlflash_context *ctx = file->private_data;
985 	struct device *dev = ctx->hw_afu->dev;
986 	ulong lock_flags;
987 	int mask = 0;
988 
989 	poll_wait(file, &ctx->wq, poll);
990 
991 	spin_lock_irqsave(&ctx->slock, lock_flags);
992 	if (ctx_event_pending(ctx))
993 		mask |= POLLIN | POLLRDNORM;
994 	else if (ctx->state == CLOSED)
995 		mask |= POLLERR;
996 	spin_unlock_irqrestore(&ctx->slock, lock_flags);
997 
998 	dev_dbg(dev, "%s: Poll wait completed for pe %i mask %i\n",
999 		__func__, ctx->pe, mask);
1000 
1001 	return mask;
1002 }
1003 
1004 /**
1005  * afu_read() - perform a read on the context for any event
1006  * @file:	File associated with the adapter context.
1007  * @buf:	Buffer to receive the data.
1008  * @count:	Size of buffer (maximum bytes that can be read).
1009  * @off:	Offset.
1010  *
1011  * Return: size of the data read on success, -errno on failure
1012  */
afu_read(struct file * file,char __user * buf,size_t count,loff_t * off)1013 static ssize_t afu_read(struct file *file, char __user *buf, size_t count,
1014 			loff_t *off)
1015 {
1016 	struct ocxlflash_context *ctx = file->private_data;
1017 	struct device *dev = ctx->hw_afu->dev;
1018 	struct cxl_event event;
1019 	ulong lock_flags;
1020 	ssize_t esize;
1021 	ssize_t rc;
1022 	int bit;
1023 	DEFINE_WAIT(event_wait);
1024 
1025 	if (*off != 0) {
1026 		dev_err(dev, "%s: Non-zero offset not supported, off=%lld\n",
1027 			__func__, *off);
1028 		rc = -EINVAL;
1029 		goto out;
1030 	}
1031 
1032 	spin_lock_irqsave(&ctx->slock, lock_flags);
1033 
1034 	for (;;) {
1035 		prepare_to_wait(&ctx->wq, &event_wait, TASK_INTERRUPTIBLE);
1036 
1037 		if (ctx_event_pending(ctx) || (ctx->state == CLOSED))
1038 			break;
1039 
1040 		if (file->f_flags & O_NONBLOCK) {
1041 			dev_err(dev, "%s: File cannot be blocked on I/O\n",
1042 				__func__);
1043 			rc = -EAGAIN;
1044 			goto err;
1045 		}
1046 
1047 		if (signal_pending(current)) {
1048 			dev_err(dev, "%s: Signal pending on the process\n",
1049 				__func__);
1050 			rc = -ERESTARTSYS;
1051 			goto err;
1052 		}
1053 
1054 		spin_unlock_irqrestore(&ctx->slock, lock_flags);
1055 		schedule();
1056 		spin_lock_irqsave(&ctx->slock, lock_flags);
1057 	}
1058 
1059 	finish_wait(&ctx->wq, &event_wait);
1060 
1061 	memset(&event, 0, sizeof(event));
1062 	event.header.process_element = ctx->pe;
1063 	event.header.size = sizeof(struct cxl_event_header);
1064 	if (ctx->pending_irq) {
1065 		esize = sizeof(struct cxl_event_afu_interrupt);
1066 		event.header.size += esize;
1067 		event.header.type = CXL_EVENT_AFU_INTERRUPT;
1068 
1069 		bit = find_first_bit(&ctx->irq_bitmap, ctx->num_irqs);
1070 		clear_bit(bit, &ctx->irq_bitmap);
1071 		event.irq.irq = bit + 1;
1072 		if (bitmap_empty(&ctx->irq_bitmap, ctx->num_irqs))
1073 			ctx->pending_irq = false;
1074 	} else if (ctx->pending_fault) {
1075 		event.header.size += sizeof(struct cxl_event_data_storage);
1076 		event.header.type = CXL_EVENT_DATA_STORAGE;
1077 		event.fault.addr = ctx->fault_addr;
1078 		event.fault.dsisr = ctx->fault_dsisr;
1079 		ctx->pending_fault = false;
1080 	}
1081 
1082 	spin_unlock_irqrestore(&ctx->slock, lock_flags);
1083 
1084 	if (copy_to_user(buf, &event, event.header.size)) {
1085 		dev_err(dev, "%s: copy_to_user failed\n", __func__);
1086 		rc = -EFAULT;
1087 		goto out;
1088 	}
1089 
1090 	rc = event.header.size;
1091 out:
1092 	return rc;
1093 err:
1094 	finish_wait(&ctx->wq, &event_wait);
1095 	spin_unlock_irqrestore(&ctx->slock, lock_flags);
1096 	goto out;
1097 }
1098 
1099 /**
1100  * afu_release() - release and free the context
1101  * @inode:	File inode pointer.
1102  * @file:	File associated with the context.
1103  *
1104  * Return: 0 on success, -errno on failure
1105  */
afu_release(struct inode * inode,struct file * file)1106 static int afu_release(struct inode *inode, struct file *file)
1107 {
1108 	struct ocxlflash_context *ctx = file->private_data;
1109 	int i;
1110 
1111 	/* Unmap and free the interrupts associated with the context */
1112 	for (i = ctx->num_irqs; i >= 0; i--)
1113 		afu_unmap_irq(0, ctx, i, ctx);
1114 	free_afu_irqs(ctx);
1115 
1116 	return ocxlflash_release_context(ctx);
1117 }
1118 
1119 /**
1120  * ocxlflash_mmap_fault() - mmap fault handler
1121  * @vmf:	VM fault associated with current fault.
1122  *
1123  * Return: 0 on success, -errno on failure
1124  */
ocxlflash_mmap_fault(struct vm_fault * vmf)1125 static vm_fault_t ocxlflash_mmap_fault(struct vm_fault *vmf)
1126 {
1127 	struct vm_area_struct *vma = vmf->vma;
1128 	struct ocxlflash_context *ctx = vma->vm_file->private_data;
1129 	struct device *dev = ctx->hw_afu->dev;
1130 	u64 mmio_area, offset;
1131 
1132 	offset = vmf->pgoff << PAGE_SHIFT;
1133 	if (offset >= ctx->psn_size)
1134 		return VM_FAULT_SIGBUS;
1135 
1136 	mutex_lock(&ctx->state_mutex);
1137 	if (ctx->state != STARTED) {
1138 		dev_err(dev, "%s: Context not started, state=%d\n",
1139 			__func__, ctx->state);
1140 		mutex_unlock(&ctx->state_mutex);
1141 		return VM_FAULT_SIGBUS;
1142 	}
1143 	mutex_unlock(&ctx->state_mutex);
1144 
1145 	mmio_area = ctx->psn_phys;
1146 	mmio_area += offset;
1147 
1148 	return vmf_insert_pfn(vma, vmf->address, mmio_area >> PAGE_SHIFT);
1149 }
1150 
1151 static const struct vm_operations_struct ocxlflash_vmops = {
1152 	.fault = ocxlflash_mmap_fault,
1153 };
1154 
1155 /**
1156  * afu_mmap() - map the fault handler operations
1157  * @file:	File associated with the context.
1158  * @vma:	VM area associated with mapping.
1159  *
1160  * Return: 0 on success, -errno on failure
1161  */
afu_mmap(struct file * file,struct vm_area_struct * vma)1162 static int afu_mmap(struct file *file, struct vm_area_struct *vma)
1163 {
1164 	struct ocxlflash_context *ctx = file->private_data;
1165 
1166 	if ((vma_pages(vma) + vma->vm_pgoff) >
1167 	    (ctx->psn_size >> PAGE_SHIFT))
1168 		return -EINVAL;
1169 
1170 	vm_flags_set(vma, VM_IO | VM_PFNMAP);
1171 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1172 	vma->vm_ops = &ocxlflash_vmops;
1173 	return 0;
1174 }
1175 
1176 static const struct file_operations ocxl_afu_fops = {
1177 	.owner		= THIS_MODULE,
1178 	.poll		= afu_poll,
1179 	.read		= afu_read,
1180 	.release	= afu_release,
1181 	.mmap		= afu_mmap,
1182 };
1183 
1184 #define PATCH_FOPS(NAME)						\
1185 	do { if (!fops->NAME) fops->NAME = ocxl_afu_fops.NAME; } while (0)
1186 
1187 /**
1188  * ocxlflash_get_fd() - get file descriptor for an adapter context
1189  * @ctx_cookie:	Adapter context.
1190  * @fops:	File operations to be associated.
1191  * @fd:		File descriptor to be returned back.
1192  *
1193  * Return: pointer to the file on success, ERR_PTR on failure
1194  */
ocxlflash_get_fd(void * ctx_cookie,struct file_operations * fops,int * fd)1195 static struct file *ocxlflash_get_fd(void *ctx_cookie,
1196 				     struct file_operations *fops, int *fd)
1197 {
1198 	struct ocxlflash_context *ctx = ctx_cookie;
1199 	struct device *dev = ctx->hw_afu->dev;
1200 	struct file *file;
1201 	int flags, fdtmp;
1202 	int rc = 0;
1203 	char *name = NULL;
1204 
1205 	/* Only allow one fd per context */
1206 	if (ctx->mapping) {
1207 		dev_err(dev, "%s: Context is already mapped to an fd\n",
1208 			__func__);
1209 		rc = -EEXIST;
1210 		goto err1;
1211 	}
1212 
1213 	flags = O_RDWR | O_CLOEXEC;
1214 
1215 	/* This code is similar to anon_inode_getfd() */
1216 	rc = get_unused_fd_flags(flags);
1217 	if (unlikely(rc < 0)) {
1218 		dev_err(dev, "%s: get_unused_fd_flags failed rc=%d\n",
1219 			__func__, rc);
1220 		goto err1;
1221 	}
1222 	fdtmp = rc;
1223 
1224 	/* Patch the file ops that are not defined */
1225 	if (fops) {
1226 		PATCH_FOPS(poll);
1227 		PATCH_FOPS(read);
1228 		PATCH_FOPS(release);
1229 		PATCH_FOPS(mmap);
1230 	} else /* Use default ops */
1231 		fops = (struct file_operations *)&ocxl_afu_fops;
1232 
1233 	name = kasprintf(GFP_KERNEL, "ocxlflash:%d", ctx->pe);
1234 	file = ocxlflash_getfile(dev, name, fops, ctx, flags);
1235 	kfree(name);
1236 	if (IS_ERR(file)) {
1237 		rc = PTR_ERR(file);
1238 		dev_err(dev, "%s: ocxlflash_getfile failed rc=%d\n",
1239 			__func__, rc);
1240 		goto err2;
1241 	}
1242 
1243 	ctx->mapping = file->f_mapping;
1244 	*fd = fdtmp;
1245 out:
1246 	return file;
1247 err2:
1248 	put_unused_fd(fdtmp);
1249 err1:
1250 	file = ERR_PTR(rc);
1251 	goto out;
1252 }
1253 
1254 /**
1255  * ocxlflash_fops_get_context() - get the context associated with the file
1256  * @file:	File associated with the adapter context.
1257  *
1258  * Return: pointer to the context
1259  */
ocxlflash_fops_get_context(struct file * file)1260 static void *ocxlflash_fops_get_context(struct file *file)
1261 {
1262 	return file->private_data;
1263 }
1264 
1265 /**
1266  * ocxlflash_afu_irq() - interrupt handler for user contexts
1267  * @irq:	Interrupt number.
1268  * @data:	Private data provided at interrupt registration, the context.
1269  *
1270  * Return: Always return IRQ_HANDLED.
1271  */
ocxlflash_afu_irq(int irq,void * data)1272 static irqreturn_t ocxlflash_afu_irq(int irq, void *data)
1273 {
1274 	struct ocxlflash_context *ctx = data;
1275 	struct device *dev = ctx->hw_afu->dev;
1276 	int i;
1277 
1278 	dev_dbg(dev, "%s: Interrupt raised for pe %i virq %i\n",
1279 		__func__, ctx->pe, irq);
1280 
1281 	for (i = 0; i < ctx->num_irqs; i++) {
1282 		if (ctx->irqs[i].virq == irq)
1283 			break;
1284 	}
1285 	if (unlikely(i >= ctx->num_irqs)) {
1286 		dev_err(dev, "%s: Received AFU IRQ out of range\n", __func__);
1287 		goto out;
1288 	}
1289 
1290 	spin_lock(&ctx->slock);
1291 	set_bit(i - 1, &ctx->irq_bitmap);
1292 	ctx->pending_irq = true;
1293 	spin_unlock(&ctx->slock);
1294 
1295 	wake_up_all(&ctx->wq);
1296 out:
1297 	return IRQ_HANDLED;
1298 }
1299 
1300 /**
1301  * ocxlflash_start_work() - start a user context
1302  * @ctx_cookie:	Context to be started.
1303  * @num_irqs:	Number of interrupts requested.
1304  *
1305  * Return: 0 on success, -errno on failure
1306  */
ocxlflash_start_work(void * ctx_cookie,u64 num_irqs)1307 static int ocxlflash_start_work(void *ctx_cookie, u64 num_irqs)
1308 {
1309 	struct ocxlflash_context *ctx = ctx_cookie;
1310 	struct ocxl_hw_afu *afu = ctx->hw_afu;
1311 	struct device *dev = afu->dev;
1312 	char *name;
1313 	int rc = 0;
1314 	int i;
1315 
1316 	rc = alloc_afu_irqs(ctx, num_irqs);
1317 	if (unlikely(rc < 0)) {
1318 		dev_err(dev, "%s: alloc_afu_irqs failed rc=%d\n", __func__, rc);
1319 		goto out;
1320 	}
1321 
1322 	for (i = 0; i < num_irqs; i++) {
1323 		name = kasprintf(GFP_KERNEL, "ocxlflash-%s-pe%i-%i",
1324 				 dev_name(dev), ctx->pe, i);
1325 		rc = afu_map_irq(0, ctx, i, ocxlflash_afu_irq, ctx, name);
1326 		kfree(name);
1327 		if (unlikely(rc < 0)) {
1328 			dev_err(dev, "%s: afu_map_irq failed rc=%d\n",
1329 				__func__, rc);
1330 			goto err;
1331 		}
1332 	}
1333 
1334 	rc = start_context(ctx);
1335 	if (unlikely(rc)) {
1336 		dev_err(dev, "%s: start_context failed rc=%d\n", __func__, rc);
1337 		goto err;
1338 	}
1339 out:
1340 	return rc;
1341 err:
1342 	for (i = i-1; i >= 0; i--)
1343 		afu_unmap_irq(0, ctx, i, ctx);
1344 	free_afu_irqs(ctx);
1345 	goto out;
1346 };
1347 
1348 /**
1349  * ocxlflash_fd_mmap() - mmap handler for adapter file descriptor
1350  * @file:	File installed with adapter file descriptor.
1351  * @vma:	VM area associated with mapping.
1352  *
1353  * Return: 0 on success, -errno on failure
1354  */
ocxlflash_fd_mmap(struct file * file,struct vm_area_struct * vma)1355 static int ocxlflash_fd_mmap(struct file *file, struct vm_area_struct *vma)
1356 {
1357 	return afu_mmap(file, vma);
1358 }
1359 
1360 /**
1361  * ocxlflash_fd_release() - release the context associated with the file
1362  * @inode:	File inode pointer.
1363  * @file:	File associated with the adapter context.
1364  *
1365  * Return: 0 on success, -errno on failure
1366  */
ocxlflash_fd_release(struct inode * inode,struct file * file)1367 static int ocxlflash_fd_release(struct inode *inode, struct file *file)
1368 {
1369 	return afu_release(inode, file);
1370 }
1371 
1372 /* Backend ops to ocxlflash services */
1373 const struct cxlflash_backend_ops cxlflash_ocxl_ops = {
1374 	.module			= THIS_MODULE,
1375 	.psa_map		= ocxlflash_psa_map,
1376 	.psa_unmap		= ocxlflash_psa_unmap,
1377 	.process_element	= ocxlflash_process_element,
1378 	.map_afu_irq		= ocxlflash_map_afu_irq,
1379 	.unmap_afu_irq		= ocxlflash_unmap_afu_irq,
1380 	.get_irq_objhndl	= ocxlflash_get_irq_objhndl,
1381 	.start_context		= ocxlflash_start_context,
1382 	.stop_context		= ocxlflash_stop_context,
1383 	.afu_reset		= ocxlflash_afu_reset,
1384 	.set_master		= ocxlflash_set_master,
1385 	.get_context		= ocxlflash_get_context,
1386 	.dev_context_init	= ocxlflash_dev_context_init,
1387 	.release_context	= ocxlflash_release_context,
1388 	.perst_reloads_same_image = ocxlflash_perst_reloads_same_image,
1389 	.read_adapter_vpd	= ocxlflash_read_adapter_vpd,
1390 	.allocate_afu_irqs	= ocxlflash_allocate_afu_irqs,
1391 	.free_afu_irqs		= ocxlflash_free_afu_irqs,
1392 	.create_afu		= ocxlflash_create_afu,
1393 	.destroy_afu		= ocxlflash_destroy_afu,
1394 	.get_fd			= ocxlflash_get_fd,
1395 	.fops_get_context	= ocxlflash_fops_get_context,
1396 	.start_work		= ocxlflash_start_work,
1397 	.fd_mmap		= ocxlflash_fd_mmap,
1398 	.fd_release		= ocxlflash_fd_release,
1399 };
1400