1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * IBM Power Systems Virtual Management Channel Support.
4  *
5  * Copyright (c) 2004, 2018 IBM Corp.
6  *   Dave Engebretsen engebret@us.ibm.com
7  *   Steven Royer seroyer@linux.vnet.ibm.com
8  *   Adam Reznechek adreznec@linux.vnet.ibm.com
9  *   Bryant G. Ly <bryantly@linux.vnet.ibm.com>
10  */
11 
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/kthread.h>
15 #include <linux/major.h>
16 #include <linux/string.h>
17 #include <linux/fcntl.h>
18 #include <linux/slab.h>
19 #include <linux/poll.h>
20 #include <linux/init.h>
21 #include <linux/fs.h>
22 #include <linux/interrupt.h>
23 #include <linux/spinlock.h>
24 #include <linux/percpu.h>
25 #include <linux/delay.h>
26 #include <linux/uaccess.h>
27 #include <linux/io.h>
28 #include <linux/miscdevice.h>
29 #include <linux/sched/signal.h>
30 
31 #include <asm/byteorder.h>
32 #include <asm/irq.h>
33 #include <asm/vio.h>
34 
35 #include "ibmvmc.h"
36 
37 #define IBMVMC_DRIVER_VERSION "1.0"
38 
39 /*
40  * Static global variables
41  */
42 static DECLARE_WAIT_QUEUE_HEAD(ibmvmc_read_wait);
43 
44 static const char ibmvmc_driver_name[] = "ibmvmc";
45 
46 static struct ibmvmc_struct ibmvmc;
47 static struct ibmvmc_hmc hmcs[MAX_HMCS];
48 static struct crq_server_adapter ibmvmc_adapter;
49 
50 static int ibmvmc_max_buf_pool_size = DEFAULT_BUF_POOL_SIZE;
51 static int ibmvmc_max_hmcs = DEFAULT_HMCS;
52 static int ibmvmc_max_mtu = DEFAULT_MTU;
53 
h_copy_rdma(s64 length,u64 sliobn,u64 slioba,u64 dliobn,u64 dlioba)54 static inline long h_copy_rdma(s64 length, u64 sliobn, u64 slioba,
55 			       u64 dliobn, u64 dlioba)
56 {
57 	long rc = 0;
58 
59 	/* Ensure all writes to source memory are visible before hcall */
60 	dma_wmb();
61 	pr_debug("ibmvmc: h_copy_rdma(0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx\n",
62 		 length, sliobn, slioba, dliobn, dlioba);
63 	rc = plpar_hcall_norets(H_COPY_RDMA, length, sliobn, slioba,
64 				dliobn, dlioba);
65 	pr_debug("ibmvmc: h_copy_rdma rc = 0x%lx\n", rc);
66 
67 	return rc;
68 }
69 
h_free_crq(uint32_t unit_address)70 static inline void h_free_crq(uint32_t unit_address)
71 {
72 	long rc = 0;
73 
74 	do {
75 		if (H_IS_LONG_BUSY(rc))
76 			msleep(get_longbusy_msecs(rc));
77 
78 		rc = plpar_hcall_norets(H_FREE_CRQ, unit_address);
79 	} while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
80 }
81 
82 /**
83  * h_request_vmc: - request a hypervisor virtual management channel device
84  * @vmc_index: drc index of the vmc device created
85  *
86  * Requests the hypervisor create a new virtual management channel device,
87  * allowing this partition to send hypervisor virtualization control
88  * commands.
89  *
90  * Return:
91  *	0 - Success
92  *	Non-zero - Failure
93  */
h_request_vmc(u32 * vmc_index)94 static inline long h_request_vmc(u32 *vmc_index)
95 {
96 	long rc = 0;
97 	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
98 
99 	do {
100 		if (H_IS_LONG_BUSY(rc))
101 			msleep(get_longbusy_msecs(rc));
102 
103 		/* Call to request the VMC device from phyp */
104 		rc = plpar_hcall(H_REQUEST_VMC, retbuf);
105 		pr_debug("ibmvmc: %s rc = 0x%lx\n", __func__, rc);
106 		*vmc_index = retbuf[0];
107 	} while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
108 
109 	return rc;
110 }
111 
112 /* routines for managing a command/response queue */
113 /**
114  * ibmvmc_handle_event: - Interrupt handler for crq events
115  * @irq:        number of irq to handle, not used
116  * @dev_instance: crq_server_adapter that received interrupt
117  *
118  * Disables interrupts and schedules ibmvmc_task
119  *
120  * Always returns IRQ_HANDLED
121  */
ibmvmc_handle_event(int irq,void * dev_instance)122 static irqreturn_t ibmvmc_handle_event(int irq, void *dev_instance)
123 {
124 	struct crq_server_adapter *adapter =
125 		(struct crq_server_adapter *)dev_instance;
126 
127 	vio_disable_interrupts(to_vio_dev(adapter->dev));
128 	tasklet_schedule(&adapter->work_task);
129 
130 	return IRQ_HANDLED;
131 }
132 
133 /**
134  * ibmvmc_release_crq_queue - Release CRQ Queue
135  *
136  * @adapter:	crq_server_adapter struct
137  *
138  * Return:
139  *	0 - Success
140  *	Non-Zero - Failure
141  */
ibmvmc_release_crq_queue(struct crq_server_adapter * adapter)142 static void ibmvmc_release_crq_queue(struct crq_server_adapter *adapter)
143 {
144 	struct vio_dev *vdev = to_vio_dev(adapter->dev);
145 	struct crq_queue *queue = &adapter->queue;
146 
147 	free_irq(vdev->irq, (void *)adapter);
148 	tasklet_kill(&adapter->work_task);
149 
150 	if (adapter->reset_task)
151 		kthread_stop(adapter->reset_task);
152 
153 	h_free_crq(vdev->unit_address);
154 	dma_unmap_single(adapter->dev,
155 			 queue->msg_token,
156 			 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
157 	free_page((unsigned long)queue->msgs);
158 }
159 
160 /**
161  * ibmvmc_reset_crq_queue - Reset CRQ Queue
162  *
163  * @adapter:	crq_server_adapter struct
164  *
165  * This function calls h_free_crq and then calls H_REG_CRQ and does all the
166  * bookkeeping to get us back to where we can communicate.
167  *
168  * Return:
169  *	0 - Success
170  *	Non-Zero - Failure
171  */
ibmvmc_reset_crq_queue(struct crq_server_adapter * adapter)172 static int ibmvmc_reset_crq_queue(struct crq_server_adapter *adapter)
173 {
174 	struct vio_dev *vdev = to_vio_dev(adapter->dev);
175 	struct crq_queue *queue = &adapter->queue;
176 	int rc = 0;
177 
178 	/* Close the CRQ */
179 	h_free_crq(vdev->unit_address);
180 
181 	/* Clean out the queue */
182 	memset(queue->msgs, 0x00, PAGE_SIZE);
183 	queue->cur = 0;
184 
185 	/* And re-open it again */
186 	rc = plpar_hcall_norets(H_REG_CRQ,
187 				vdev->unit_address,
188 				queue->msg_token, PAGE_SIZE);
189 	if (rc == 2)
190 		/* Adapter is good, but other end is not ready */
191 		dev_warn(adapter->dev, "Partner adapter not ready\n");
192 	else if (rc != 0)
193 		dev_err(adapter->dev, "couldn't register crq--rc 0x%x\n", rc);
194 
195 	return rc;
196 }
197 
198 /**
199  * crq_queue_next_crq: - Returns the next entry in message queue
200  * @queue:      crq_queue to use
201  *
202  * Returns pointer to next entry in queue, or NULL if there are no new
203  * entried in the CRQ.
204  */
crq_queue_next_crq(struct crq_queue * queue)205 static struct ibmvmc_crq_msg *crq_queue_next_crq(struct crq_queue *queue)
206 {
207 	struct ibmvmc_crq_msg *crq;
208 	unsigned long flags;
209 
210 	spin_lock_irqsave(&queue->lock, flags);
211 	crq = &queue->msgs[queue->cur];
212 	if (crq->valid & 0x80) {
213 		if (++queue->cur == queue->size)
214 			queue->cur = 0;
215 
216 		/* Ensure the read of the valid bit occurs before reading any
217 		 * other bits of the CRQ entry
218 		 */
219 		dma_rmb();
220 	} else {
221 		crq = NULL;
222 	}
223 
224 	spin_unlock_irqrestore(&queue->lock, flags);
225 
226 	return crq;
227 }
228 
229 /**
230  * ibmvmc_send_crq - Send CRQ
231  *
232  * @adapter:	crq_server_adapter struct
233  * @word1:	Word1 Data field
234  * @word2:	Word2 Data field
235  *
236  * Return:
237  *	0 - Success
238  *	Non-Zero - Failure
239  */
ibmvmc_send_crq(struct crq_server_adapter * adapter,u64 word1,u64 word2)240 static long ibmvmc_send_crq(struct crq_server_adapter *adapter,
241 			    u64 word1, u64 word2)
242 {
243 	struct vio_dev *vdev = to_vio_dev(adapter->dev);
244 	long rc = 0;
245 
246 	dev_dbg(adapter->dev, "(0x%x, 0x%016llx, 0x%016llx)\n",
247 		vdev->unit_address, word1, word2);
248 
249 	/*
250 	 * Ensure the command buffer is flushed to memory before handing it
251 	 * over to the other side to prevent it from fetching any stale data.
252 	 */
253 	dma_wmb();
254 	rc = plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
255 	dev_dbg(adapter->dev, "rc = 0x%lx\n", rc);
256 
257 	return rc;
258 }
259 
260 /**
261  * alloc_dma_buffer - Create DMA Buffer
262  *
263  * @vdev:	vio_dev struct
264  * @size:	Size field
265  * @dma_handle:	DMA address field
266  *
267  * Allocates memory for the command queue and maps remote memory into an
268  * ioba.
269  *
270  * Returns a pointer to the buffer
271  */
alloc_dma_buffer(struct vio_dev * vdev,size_t size,dma_addr_t * dma_handle)272 static void *alloc_dma_buffer(struct vio_dev *vdev, size_t size,
273 			      dma_addr_t *dma_handle)
274 {
275 	/* allocate memory */
276 	void *buffer = kzalloc(size, GFP_ATOMIC);
277 
278 	if (!buffer) {
279 		*dma_handle = 0;
280 		return NULL;
281 	}
282 
283 	/* DMA map */
284 	*dma_handle = dma_map_single(&vdev->dev, buffer, size,
285 				     DMA_BIDIRECTIONAL);
286 
287 	if (dma_mapping_error(&vdev->dev, *dma_handle)) {
288 		*dma_handle = 0;
289 		kzfree(buffer);
290 		return NULL;
291 	}
292 
293 	return buffer;
294 }
295 
296 /**
297  * free_dma_buffer - Free DMA Buffer
298  *
299  * @vdev:	vio_dev struct
300  * @size:	Size field
301  * @vaddr:	Address field
302  * @dma_handle:	DMA address field
303  *
304  * Releases memory for a command queue and unmaps mapped remote memory.
305  */
free_dma_buffer(struct vio_dev * vdev,size_t size,void * vaddr,dma_addr_t dma_handle)306 static void free_dma_buffer(struct vio_dev *vdev, size_t size, void *vaddr,
307 			    dma_addr_t dma_handle)
308 {
309 	/* DMA unmap */
310 	dma_unmap_single(&vdev->dev, dma_handle, size, DMA_BIDIRECTIONAL);
311 
312 	/* deallocate memory */
313 	kzfree(vaddr);
314 }
315 
316 /**
317  * ibmvmc_get_valid_hmc_buffer - Retrieve Valid HMC Buffer
318  *
319  * @hmc_index:	HMC Index Field
320  *
321  * Return:
322  *	Pointer to ibmvmc_buffer
323  */
ibmvmc_get_valid_hmc_buffer(u8 hmc_index)324 static struct ibmvmc_buffer *ibmvmc_get_valid_hmc_buffer(u8 hmc_index)
325 {
326 	struct ibmvmc_buffer *buffer;
327 	struct ibmvmc_buffer *ret_buf = NULL;
328 	unsigned long i;
329 
330 	if (hmc_index > ibmvmc.max_hmc_index)
331 		return NULL;
332 
333 	buffer = hmcs[hmc_index].buffer;
334 
335 	for (i = 0; i < ibmvmc_max_buf_pool_size; i++) {
336 		if (buffer[i].valid && buffer[i].free &&
337 		    buffer[i].owner == VMC_BUF_OWNER_ALPHA) {
338 			buffer[i].free = 0;
339 			ret_buf = &buffer[i];
340 			break;
341 		}
342 	}
343 
344 	return ret_buf;
345 }
346 
347 /**
348  * ibmvmc_get_free_hmc_buffer - Get Free HMC Buffer
349  *
350  * @adapter:	crq_server_adapter struct
351  * @hmc_index:	Hmc Index field
352  *
353  * Return:
354  *	Pointer to ibmvmc_buffer
355  */
ibmvmc_get_free_hmc_buffer(struct crq_server_adapter * adapter,u8 hmc_index)356 static struct ibmvmc_buffer *ibmvmc_get_free_hmc_buffer(struct crq_server_adapter *adapter,
357 							u8 hmc_index)
358 {
359 	struct ibmvmc_buffer *buffer;
360 	struct ibmvmc_buffer *ret_buf = NULL;
361 	unsigned long i;
362 
363 	if (hmc_index > ibmvmc.max_hmc_index) {
364 		dev_info(adapter->dev, "get_free_hmc_buffer: invalid hmc_index=0x%x\n",
365 			 hmc_index);
366 		return NULL;
367 	}
368 
369 	buffer = hmcs[hmc_index].buffer;
370 
371 	for (i = 0; i < ibmvmc_max_buf_pool_size; i++) {
372 		if (buffer[i].free &&
373 		    buffer[i].owner == VMC_BUF_OWNER_ALPHA) {
374 			buffer[i].free = 0;
375 			ret_buf = &buffer[i];
376 			break;
377 		}
378 	}
379 
380 	return ret_buf;
381 }
382 
383 /**
384  * ibmvmc_free_hmc_buffer - Free an HMC Buffer
385  *
386  * @hmc:	ibmvmc_hmc struct
387  * @buffer:	ibmvmc_buffer struct
388  *
389  */
ibmvmc_free_hmc_buffer(struct ibmvmc_hmc * hmc,struct ibmvmc_buffer * buffer)390 static void ibmvmc_free_hmc_buffer(struct ibmvmc_hmc *hmc,
391 				   struct ibmvmc_buffer *buffer)
392 {
393 	unsigned long flags;
394 
395 	spin_lock_irqsave(&hmc->lock, flags);
396 	buffer->free = 1;
397 	spin_unlock_irqrestore(&hmc->lock, flags);
398 }
399 
400 /**
401  * ibmvmc_count_hmc_buffers - Count HMC Buffers
402  *
403  * @hmc_index:	HMC Index field
404  * @valid:	Valid number of buffers field
405  * @free:	Free number of buffers field
406  *
407  */
ibmvmc_count_hmc_buffers(u8 hmc_index,unsigned int * valid,unsigned int * free)408 static void ibmvmc_count_hmc_buffers(u8 hmc_index, unsigned int *valid,
409 				     unsigned int *free)
410 {
411 	struct ibmvmc_buffer *buffer;
412 	unsigned long i;
413 	unsigned long flags;
414 
415 	if (hmc_index > ibmvmc.max_hmc_index)
416 		return;
417 
418 	if (!valid || !free)
419 		return;
420 
421 	*valid = 0; *free = 0;
422 
423 	buffer = hmcs[hmc_index].buffer;
424 	spin_lock_irqsave(&hmcs[hmc_index].lock, flags);
425 
426 	for (i = 0; i < ibmvmc_max_buf_pool_size; i++) {
427 		if (buffer[i].valid) {
428 			*valid = *valid + 1;
429 			if (buffer[i].free)
430 				*free = *free + 1;
431 		}
432 	}
433 
434 	spin_unlock_irqrestore(&hmcs[hmc_index].lock, flags);
435 }
436 
437 /**
438  * ibmvmc_get_free_hmc - Get Free HMC
439  *
440  * Return:
441  *	Pointer to an available HMC Connection
442  *	Null otherwise
443  */
ibmvmc_get_free_hmc(void)444 static struct ibmvmc_hmc *ibmvmc_get_free_hmc(void)
445 {
446 	unsigned long i;
447 	unsigned long flags;
448 
449 	/*
450 	 * Find an available HMC connection.
451 	 */
452 	for (i = 0; i <= ibmvmc.max_hmc_index; i++) {
453 		spin_lock_irqsave(&hmcs[i].lock, flags);
454 		if (hmcs[i].state == ibmhmc_state_free) {
455 			hmcs[i].index = i;
456 			hmcs[i].state = ibmhmc_state_initial;
457 			spin_unlock_irqrestore(&hmcs[i].lock, flags);
458 			return &hmcs[i];
459 		}
460 		spin_unlock_irqrestore(&hmcs[i].lock, flags);
461 	}
462 
463 	return NULL;
464 }
465 
466 /**
467  * ibmvmc_return_hmc - Return an HMC Connection
468  *
469  * @hmc:		ibmvmc_hmc struct
470  * @release_readers:	Number of readers connected to session
471  *
472  * This function releases the HMC connections back into the pool.
473  *
474  * Return:
475  *	0 - Success
476  *	Non-zero - Failure
477  */
ibmvmc_return_hmc(struct ibmvmc_hmc * hmc,bool release_readers)478 static int ibmvmc_return_hmc(struct ibmvmc_hmc *hmc, bool release_readers)
479 {
480 	struct ibmvmc_buffer *buffer;
481 	struct crq_server_adapter *adapter;
482 	struct vio_dev *vdev;
483 	unsigned long i;
484 	unsigned long flags;
485 
486 	if (!hmc || !hmc->adapter)
487 		return -EIO;
488 
489 	if (release_readers) {
490 		if (hmc->file_session) {
491 			struct ibmvmc_file_session *session = hmc->file_session;
492 
493 			session->valid = 0;
494 			wake_up_interruptible(&ibmvmc_read_wait);
495 		}
496 	}
497 
498 	adapter = hmc->adapter;
499 	vdev = to_vio_dev(adapter->dev);
500 
501 	spin_lock_irqsave(&hmc->lock, flags);
502 	hmc->index = 0;
503 	hmc->state = ibmhmc_state_free;
504 	hmc->queue_head = 0;
505 	hmc->queue_tail = 0;
506 	buffer = hmc->buffer;
507 	for (i = 0; i < ibmvmc_max_buf_pool_size; i++) {
508 		if (buffer[i].valid) {
509 			free_dma_buffer(vdev,
510 					ibmvmc.max_mtu,
511 					buffer[i].real_addr_local,
512 					buffer[i].dma_addr_local);
513 			dev_dbg(adapter->dev, "Forgot buffer id 0x%lx\n", i);
514 		}
515 		memset(&buffer[i], 0, sizeof(struct ibmvmc_buffer));
516 
517 		hmc->queue_outbound_msgs[i] = VMC_INVALID_BUFFER_ID;
518 	}
519 
520 	spin_unlock_irqrestore(&hmc->lock, flags);
521 
522 	return 0;
523 }
524 
525 /**
526  * ibmvmc_send_open - Interface Open
527  * @buffer: Pointer to ibmvmc_buffer struct
528  * @hmc: Pointer to ibmvmc_hmc struct
529  *
530  * This command is sent by the management partition as the result of a
531  * management partition device request. It causes the hypervisor to
532  * prepare a set of data buffers for the management application connection
533  * indicated HMC idx. A unique HMC Idx would be used if multiple management
534  * applications running concurrently were desired. Before responding to this
535  * command, the hypervisor must provide the management partition with at
536  * least one of these new buffers via the Add Buffer. This indicates whether
537  * the messages are inbound or outbound from the hypervisor.
538  *
539  * Return:
540  *	0 - Success
541  *	Non-zero - Failure
542  */
ibmvmc_send_open(struct ibmvmc_buffer * buffer,struct ibmvmc_hmc * hmc)543 static int ibmvmc_send_open(struct ibmvmc_buffer *buffer,
544 			    struct ibmvmc_hmc *hmc)
545 {
546 	struct ibmvmc_crq_msg crq_msg;
547 	struct crq_server_adapter *adapter;
548 	__be64 *crq_as_u64 = (__be64 *)&crq_msg;
549 	int rc = 0;
550 
551 	if (!hmc || !hmc->adapter)
552 		return -EIO;
553 
554 	adapter = hmc->adapter;
555 
556 	dev_dbg(adapter->dev, "send_open: 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
557 		(unsigned long)buffer->size, (unsigned long)adapter->liobn,
558 		(unsigned long)buffer->dma_addr_local,
559 		(unsigned long)adapter->riobn,
560 		(unsigned long)buffer->dma_addr_remote);
561 
562 	rc = h_copy_rdma(buffer->size,
563 			 adapter->liobn,
564 			 buffer->dma_addr_local,
565 			 adapter->riobn,
566 			 buffer->dma_addr_remote);
567 	if (rc) {
568 		dev_err(adapter->dev, "Error: In send_open, h_copy_rdma rc 0x%x\n",
569 			rc);
570 		return -EIO;
571 	}
572 
573 	hmc->state = ibmhmc_state_opening;
574 
575 	crq_msg.valid = 0x80;
576 	crq_msg.type = VMC_MSG_OPEN;
577 	crq_msg.status = 0;
578 	crq_msg.var1.rsvd = 0;
579 	crq_msg.hmc_session = hmc->session;
580 	crq_msg.hmc_index = hmc->index;
581 	crq_msg.var2.buffer_id = cpu_to_be16(buffer->id);
582 	crq_msg.rsvd = 0;
583 	crq_msg.var3.rsvd = 0;
584 
585 	ibmvmc_send_crq(adapter, be64_to_cpu(crq_as_u64[0]),
586 			be64_to_cpu(crq_as_u64[1]));
587 
588 	return rc;
589 }
590 
591 /**
592  * ibmvmc_send_close - Interface Close
593  * @hmc: Pointer to ibmvmc_hmc struct
594  *
595  * This command is sent by the management partition to terminate a
596  * management application to hypervisor connection. When this command is
597  * sent, the management partition has quiesced all I/O operations to all
598  * buffers associated with this management application connection, and
599  * has freed any storage for these buffers.
600  *
601  * Return:
602  *	0 - Success
603  *	Non-zero - Failure
604  */
ibmvmc_send_close(struct ibmvmc_hmc * hmc)605 static int ibmvmc_send_close(struct ibmvmc_hmc *hmc)
606 {
607 	struct ibmvmc_crq_msg crq_msg;
608 	struct crq_server_adapter *adapter;
609 	__be64 *crq_as_u64 = (__be64 *)&crq_msg;
610 	int rc = 0;
611 
612 	if (!hmc || !hmc->adapter)
613 		return -EIO;
614 
615 	adapter = hmc->adapter;
616 
617 	dev_info(adapter->dev, "CRQ send: close\n");
618 
619 	crq_msg.valid = 0x80;
620 	crq_msg.type = VMC_MSG_CLOSE;
621 	crq_msg.status = 0;
622 	crq_msg.var1.rsvd = 0;
623 	crq_msg.hmc_session = hmc->session;
624 	crq_msg.hmc_index = hmc->index;
625 	crq_msg.var2.rsvd = 0;
626 	crq_msg.rsvd = 0;
627 	crq_msg.var3.rsvd = 0;
628 
629 	ibmvmc_send_crq(adapter, be64_to_cpu(crq_as_u64[0]),
630 			be64_to_cpu(crq_as_u64[1]));
631 
632 	return rc;
633 }
634 
635 /**
636  * ibmvmc_send_capabilities - Send VMC Capabilities
637  *
638  * @adapter:	crq_server_adapter struct
639  *
640  * The capabilities message is an administrative message sent after the CRQ
641  * initialization sequence of messages and is used to exchange VMC capabilities
642  * between the management partition and the hypervisor. The management
643  * partition must send this message and the hypervisor must respond with VMC
644  * capabilities Response message before HMC interface message can begin. Any
645  * HMC interface messages received before the exchange of capabilities has
646  * complete are dropped.
647  *
648  * Return:
649  *	0 - Success
650  */
ibmvmc_send_capabilities(struct crq_server_adapter * adapter)651 static int ibmvmc_send_capabilities(struct crq_server_adapter *adapter)
652 {
653 	struct ibmvmc_admin_crq_msg crq_msg;
654 	__be64 *crq_as_u64 = (__be64 *)&crq_msg;
655 
656 	dev_dbg(adapter->dev, "ibmvmc: CRQ send: capabilities\n");
657 	crq_msg.valid = 0x80;
658 	crq_msg.type = VMC_MSG_CAP;
659 	crq_msg.status = 0;
660 	crq_msg.rsvd[0] = 0;
661 	crq_msg.rsvd[1] = 0;
662 	crq_msg.max_hmc = ibmvmc_max_hmcs;
663 	crq_msg.max_mtu = cpu_to_be32(ibmvmc_max_mtu);
664 	crq_msg.pool_size = cpu_to_be16(ibmvmc_max_buf_pool_size);
665 	crq_msg.crq_size = cpu_to_be16(adapter->queue.size);
666 	crq_msg.version = cpu_to_be16(IBMVMC_PROTOCOL_VERSION);
667 
668 	ibmvmc_send_crq(adapter, be64_to_cpu(crq_as_u64[0]),
669 			be64_to_cpu(crq_as_u64[1]));
670 
671 	ibmvmc.state = ibmvmc_state_capabilities;
672 
673 	return 0;
674 }
675 
676 /**
677  * ibmvmc_send_add_buffer_resp - Add Buffer Response
678  *
679  * @adapter:	crq_server_adapter struct
680  * @status:	Status field
681  * @hmc_session: HMC Session field
682  * @hmc_index:	HMC Index field
683  * @buffer_id:	Buffer Id field
684  *
685  * This command is sent by the management partition to the hypervisor in
686  * response to the Add Buffer message. The Status field indicates the result of
687  * the command.
688  *
689  * Return:
690  *	0 - Success
691  */
ibmvmc_send_add_buffer_resp(struct crq_server_adapter * adapter,u8 status,u8 hmc_session,u8 hmc_index,u16 buffer_id)692 static int ibmvmc_send_add_buffer_resp(struct crq_server_adapter *adapter,
693 				       u8 status, u8 hmc_session,
694 				       u8 hmc_index, u16 buffer_id)
695 {
696 	struct ibmvmc_crq_msg crq_msg;
697 	__be64 *crq_as_u64 = (__be64 *)&crq_msg;
698 
699 	dev_dbg(adapter->dev, "CRQ send: add_buffer_resp\n");
700 	crq_msg.valid = 0x80;
701 	crq_msg.type = VMC_MSG_ADD_BUF_RESP;
702 	crq_msg.status = status;
703 	crq_msg.var1.rsvd = 0;
704 	crq_msg.hmc_session = hmc_session;
705 	crq_msg.hmc_index = hmc_index;
706 	crq_msg.var2.buffer_id = cpu_to_be16(buffer_id);
707 	crq_msg.rsvd = 0;
708 	crq_msg.var3.rsvd = 0;
709 
710 	ibmvmc_send_crq(adapter, be64_to_cpu(crq_as_u64[0]),
711 			be64_to_cpu(crq_as_u64[1]));
712 
713 	return 0;
714 }
715 
716 /**
717  * ibmvmc_send_rem_buffer_resp - Remove Buffer Response
718  *
719  * @adapter:	crq_server_adapter struct
720  * @status:	Status field
721  * @hmc_session: HMC Session field
722  * @hmc_index:	HMC Index field
723  * @buffer_id:	Buffer Id field
724  *
725  * This command is sent by the management partition to the hypervisor in
726  * response to the Remove Buffer message. The Buffer ID field indicates
727  * which buffer the management partition selected to remove. The Status
728  * field indicates the result of the command.
729  *
730  * Return:
731  *	0 - Success
732  */
ibmvmc_send_rem_buffer_resp(struct crq_server_adapter * adapter,u8 status,u8 hmc_session,u8 hmc_index,u16 buffer_id)733 static int ibmvmc_send_rem_buffer_resp(struct crq_server_adapter *adapter,
734 				       u8 status, u8 hmc_session,
735 				       u8 hmc_index, u16 buffer_id)
736 {
737 	struct ibmvmc_crq_msg crq_msg;
738 	__be64 *crq_as_u64 = (__be64 *)&crq_msg;
739 
740 	dev_dbg(adapter->dev, "CRQ send: rem_buffer_resp\n");
741 	crq_msg.valid = 0x80;
742 	crq_msg.type = VMC_MSG_REM_BUF_RESP;
743 	crq_msg.status = status;
744 	crq_msg.var1.rsvd = 0;
745 	crq_msg.hmc_session = hmc_session;
746 	crq_msg.hmc_index = hmc_index;
747 	crq_msg.var2.buffer_id = cpu_to_be16(buffer_id);
748 	crq_msg.rsvd = 0;
749 	crq_msg.var3.rsvd = 0;
750 
751 	ibmvmc_send_crq(adapter, be64_to_cpu(crq_as_u64[0]),
752 			be64_to_cpu(crq_as_u64[1]));
753 
754 	return 0;
755 }
756 
757 /**
758  * ibmvmc_send_msg - Signal Message
759  *
760  * @adapter:	crq_server_adapter struct
761  * @buffer:	ibmvmc_buffer struct
762  * @hmc:	ibmvmc_hmc struct
763  * @msg_length:	message length field
764  *
765  * This command is sent between the management partition and the hypervisor
766  * in order to signal the arrival of an HMC protocol message. The command
767  * can be sent by both the management partition and the hypervisor. It is
768  * used for all traffic between the management application and the hypervisor,
769  * regardless of who initiated the communication.
770  *
771  * There is no response to this message.
772  *
773  * Return:
774  *	0 - Success
775  *	Non-zero - Failure
776  */
ibmvmc_send_msg(struct crq_server_adapter * adapter,struct ibmvmc_buffer * buffer,struct ibmvmc_hmc * hmc,int msg_len)777 static int ibmvmc_send_msg(struct crq_server_adapter *adapter,
778 			   struct ibmvmc_buffer *buffer,
779 			   struct ibmvmc_hmc *hmc, int msg_len)
780 {
781 	struct ibmvmc_crq_msg crq_msg;
782 	__be64 *crq_as_u64 = (__be64 *)&crq_msg;
783 	int rc = 0;
784 
785 	dev_dbg(adapter->dev, "CRQ send: rdma to HV\n");
786 	rc = h_copy_rdma(msg_len,
787 			 adapter->liobn,
788 			 buffer->dma_addr_local,
789 			 adapter->riobn,
790 			 buffer->dma_addr_remote);
791 	if (rc) {
792 		dev_err(adapter->dev, "Error in send_msg, h_copy_rdma rc 0x%x\n",
793 			rc);
794 		return rc;
795 	}
796 
797 	crq_msg.valid = 0x80;
798 	crq_msg.type = VMC_MSG_SIGNAL;
799 	crq_msg.status = 0;
800 	crq_msg.var1.rsvd = 0;
801 	crq_msg.hmc_session = hmc->session;
802 	crq_msg.hmc_index = hmc->index;
803 	crq_msg.var2.buffer_id = cpu_to_be16(buffer->id);
804 	crq_msg.var3.msg_len = cpu_to_be32(msg_len);
805 	dev_dbg(adapter->dev, "CRQ send: msg to HV 0x%llx 0x%llx\n",
806 		be64_to_cpu(crq_as_u64[0]), be64_to_cpu(crq_as_u64[1]));
807 
808 	buffer->owner = VMC_BUF_OWNER_HV;
809 	ibmvmc_send_crq(adapter, be64_to_cpu(crq_as_u64[0]),
810 			be64_to_cpu(crq_as_u64[1]));
811 
812 	return rc;
813 }
814 
815 /**
816  * ibmvmc_open - Open Session
817  *
818  * @inode:	inode struct
819  * @file:	file struct
820  *
821  * Return:
822  *	0 - Success
823  *	Non-zero - Failure
824  */
ibmvmc_open(struct inode * inode,struct file * file)825 static int ibmvmc_open(struct inode *inode, struct file *file)
826 {
827 	struct ibmvmc_file_session *session;
828 
829 	pr_debug("%s: inode = 0x%lx, file = 0x%lx, state = 0x%x\n", __func__,
830 		 (unsigned long)inode, (unsigned long)file,
831 		 ibmvmc.state);
832 
833 	session = kzalloc(sizeof(*session), GFP_KERNEL);
834 	if (!session)
835 		return -ENOMEM;
836 
837 	session->file = file;
838 	file->private_data = session;
839 
840 	return 0;
841 }
842 
843 /**
844  * ibmvmc_close - Close Session
845  *
846  * @inode:	inode struct
847  * @file:	file struct
848  *
849  * Return:
850  *	0 - Success
851  *	Non-zero - Failure
852  */
ibmvmc_close(struct inode * inode,struct file * file)853 static int ibmvmc_close(struct inode *inode, struct file *file)
854 {
855 	struct ibmvmc_file_session *session;
856 	struct ibmvmc_hmc *hmc;
857 	int rc = 0;
858 	unsigned long flags;
859 
860 	pr_debug("%s: file = 0x%lx, state = 0x%x\n", __func__,
861 		 (unsigned long)file, ibmvmc.state);
862 
863 	session = file->private_data;
864 	if (!session)
865 		return -EIO;
866 
867 	hmc = session->hmc;
868 	if (hmc) {
869 		if (!hmc->adapter)
870 			return -EIO;
871 
872 		if (ibmvmc.state == ibmvmc_state_failed) {
873 			dev_warn(hmc->adapter->dev, "close: state_failed\n");
874 			return -EIO;
875 		}
876 
877 		spin_lock_irqsave(&hmc->lock, flags);
878 		if (hmc->state >= ibmhmc_state_opening) {
879 			rc = ibmvmc_send_close(hmc);
880 			if (rc)
881 				dev_warn(hmc->adapter->dev, "close: send_close failed.\n");
882 		}
883 		spin_unlock_irqrestore(&hmc->lock, flags);
884 	}
885 
886 	kzfree(session);
887 
888 	return rc;
889 }
890 
891 /**
892  * ibmvmc_read - Read
893  *
894  * @file:	file struct
895  * @buf:	Character buffer
896  * @nbytes:	Size in bytes
897  * @ppos:	Offset
898  *
899  * Return:
900  *	0 - Success
901  *	Non-zero - Failure
902  */
ibmvmc_read(struct file * file,char * buf,size_t nbytes,loff_t * ppos)903 static ssize_t ibmvmc_read(struct file *file, char *buf, size_t nbytes,
904 			   loff_t *ppos)
905 {
906 	struct ibmvmc_file_session *session;
907 	struct ibmvmc_hmc *hmc;
908 	struct crq_server_adapter *adapter;
909 	struct ibmvmc_buffer *buffer;
910 	ssize_t n;
911 	ssize_t retval = 0;
912 	unsigned long flags;
913 	DEFINE_WAIT(wait);
914 
915 	pr_debug("ibmvmc: read: file = 0x%lx, buf = 0x%lx, nbytes = 0x%lx\n",
916 		 (unsigned long)file, (unsigned long)buf,
917 		 (unsigned long)nbytes);
918 
919 	if (nbytes == 0)
920 		return 0;
921 
922 	if (nbytes > ibmvmc.max_mtu) {
923 		pr_warn("ibmvmc: read: nbytes invalid 0x%x\n",
924 			(unsigned int)nbytes);
925 		return -EINVAL;
926 	}
927 
928 	session = file->private_data;
929 	if (!session) {
930 		pr_warn("ibmvmc: read: no session\n");
931 		return -EIO;
932 	}
933 
934 	hmc = session->hmc;
935 	if (!hmc) {
936 		pr_warn("ibmvmc: read: no hmc\n");
937 		return -EIO;
938 	}
939 
940 	adapter = hmc->adapter;
941 	if (!adapter) {
942 		pr_warn("ibmvmc: read: no adapter\n");
943 		return -EIO;
944 	}
945 
946 	do {
947 		prepare_to_wait(&ibmvmc_read_wait, &wait, TASK_INTERRUPTIBLE);
948 
949 		spin_lock_irqsave(&hmc->lock, flags);
950 		if (hmc->queue_tail != hmc->queue_head)
951 			/* Data is available */
952 			break;
953 
954 		spin_unlock_irqrestore(&hmc->lock, flags);
955 
956 		if (!session->valid) {
957 			retval = -EBADFD;
958 			goto out;
959 		}
960 		if (file->f_flags & O_NONBLOCK) {
961 			retval = -EAGAIN;
962 			goto out;
963 		}
964 
965 		schedule();
966 
967 		if (signal_pending(current)) {
968 			retval = -ERESTARTSYS;
969 			goto out;
970 		}
971 	} while (1);
972 
973 	buffer = &(hmc->buffer[hmc->queue_outbound_msgs[hmc->queue_tail]]);
974 	hmc->queue_tail++;
975 	if (hmc->queue_tail == ibmvmc_max_buf_pool_size)
976 		hmc->queue_tail = 0;
977 	spin_unlock_irqrestore(&hmc->lock, flags);
978 
979 	nbytes = min_t(size_t, nbytes, buffer->msg_len);
980 	n = copy_to_user((void *)buf, buffer->real_addr_local, nbytes);
981 	dev_dbg(adapter->dev, "read: copy to user nbytes = 0x%lx.\n", nbytes);
982 	ibmvmc_free_hmc_buffer(hmc, buffer);
983 	retval = nbytes;
984 
985 	if (n) {
986 		dev_warn(adapter->dev, "read: copy to user failed.\n");
987 		retval = -EFAULT;
988 	}
989 
990  out:
991 	finish_wait(&ibmvmc_read_wait, &wait);
992 	dev_dbg(adapter->dev, "read: out %ld\n", retval);
993 	return retval;
994 }
995 
996 /**
997  * ibmvmc_poll - Poll
998  *
999  * @file:	file struct
1000  * @wait:	Poll Table
1001  *
1002  * Return:
1003  *	poll.h return values
1004  */
ibmvmc_poll(struct file * file,poll_table * wait)1005 static unsigned int ibmvmc_poll(struct file *file, poll_table *wait)
1006 {
1007 	struct ibmvmc_file_session *session;
1008 	struct ibmvmc_hmc *hmc;
1009 	unsigned int mask = 0;
1010 
1011 	session = file->private_data;
1012 	if (!session)
1013 		return 0;
1014 
1015 	hmc = session->hmc;
1016 	if (!hmc)
1017 		return 0;
1018 
1019 	poll_wait(file, &ibmvmc_read_wait, wait);
1020 
1021 	if (hmc->queue_head != hmc->queue_tail)
1022 		mask |= POLLIN | POLLRDNORM;
1023 
1024 	return mask;
1025 }
1026 
1027 /**
1028  * ibmvmc_write - Write
1029  *
1030  * @file:	file struct
1031  * @buf:	Character buffer
1032  * @count:	Count field
1033  * @ppos:	Offset
1034  *
1035  * Return:
1036  *	0 - Success
1037  *	Non-zero - Failure
1038  */
ibmvmc_write(struct file * file,const char * buffer,size_t count,loff_t * ppos)1039 static ssize_t ibmvmc_write(struct file *file, const char *buffer,
1040 			    size_t count, loff_t *ppos)
1041 {
1042 	struct ibmvmc_buffer *vmc_buffer;
1043 	struct ibmvmc_file_session *session;
1044 	struct crq_server_adapter *adapter;
1045 	struct ibmvmc_hmc *hmc;
1046 	unsigned char *buf;
1047 	unsigned long flags;
1048 	size_t bytes;
1049 	const char *p = buffer;
1050 	size_t c = count;
1051 	int ret = 0;
1052 
1053 	session = file->private_data;
1054 	if (!session)
1055 		return -EIO;
1056 
1057 	hmc = session->hmc;
1058 	if (!hmc)
1059 		return -EIO;
1060 
1061 	spin_lock_irqsave(&hmc->lock, flags);
1062 	if (hmc->state == ibmhmc_state_free) {
1063 		/* HMC connection is not valid (possibly was reset under us). */
1064 		ret = -EIO;
1065 		goto out;
1066 	}
1067 
1068 	adapter = hmc->adapter;
1069 	if (!adapter) {
1070 		ret = -EIO;
1071 		goto out;
1072 	}
1073 
1074 	if (count > ibmvmc.max_mtu) {
1075 		dev_warn(adapter->dev, "invalid buffer size 0x%lx\n",
1076 			 (unsigned long)count);
1077 		ret = -EIO;
1078 		goto out;
1079 	}
1080 
1081 	/* Waiting for the open resp message to the ioctl(1) - retry */
1082 	if (hmc->state == ibmhmc_state_opening) {
1083 		ret = -EBUSY;
1084 		goto out;
1085 	}
1086 
1087 	/* Make sure the ioctl() was called & the open msg sent, and that
1088 	 * the HMC connection has not failed.
1089 	 */
1090 	if (hmc->state != ibmhmc_state_ready) {
1091 		ret = -EIO;
1092 		goto out;
1093 	}
1094 
1095 	vmc_buffer = ibmvmc_get_valid_hmc_buffer(hmc->index);
1096 	if (!vmc_buffer) {
1097 		/* No buffer available for the msg send, or we have not yet
1098 		 * completed the open/open_resp sequence.  Retry until this is
1099 		 * complete.
1100 		 */
1101 		ret = -EBUSY;
1102 		goto out;
1103 	}
1104 	if (!vmc_buffer->real_addr_local) {
1105 		dev_err(adapter->dev, "no buffer storage assigned\n");
1106 		ret = -EIO;
1107 		goto out;
1108 	}
1109 	buf = vmc_buffer->real_addr_local;
1110 
1111 	while (c > 0) {
1112 		bytes = min_t(size_t, c, vmc_buffer->size);
1113 
1114 		bytes -= copy_from_user(buf, p, bytes);
1115 		if (!bytes) {
1116 			ret = -EFAULT;
1117 			goto out;
1118 		}
1119 		c -= bytes;
1120 		p += bytes;
1121 	}
1122 	if (p == buffer)
1123 		goto out;
1124 
1125 	file->f_path.dentry->d_inode->i_mtime = current_time(file_inode(file));
1126 	mark_inode_dirty(file->f_path.dentry->d_inode);
1127 
1128 	dev_dbg(adapter->dev, "write: file = 0x%lx, count = 0x%lx\n",
1129 		(unsigned long)file, (unsigned long)count);
1130 
1131 	ibmvmc_send_msg(adapter, vmc_buffer, hmc, count);
1132 	ret = p - buffer;
1133  out:
1134 	spin_unlock_irqrestore(&hmc->lock, flags);
1135 	return (ssize_t)(ret);
1136 }
1137 
1138 /**
1139  * ibmvmc_setup_hmc - Setup the HMC
1140  *
1141  * @session:	ibmvmc_file_session struct
1142  *
1143  * Return:
1144  *	0 - Success
1145  *	Non-zero - Failure
1146  */
ibmvmc_setup_hmc(struct ibmvmc_file_session * session)1147 static long ibmvmc_setup_hmc(struct ibmvmc_file_session *session)
1148 {
1149 	struct ibmvmc_hmc *hmc;
1150 	unsigned int valid, free, index;
1151 
1152 	if (ibmvmc.state == ibmvmc_state_failed) {
1153 		pr_warn("ibmvmc: Reserve HMC: state_failed\n");
1154 		return -EIO;
1155 	}
1156 
1157 	if (ibmvmc.state < ibmvmc_state_ready) {
1158 		pr_warn("ibmvmc: Reserve HMC: not state_ready\n");
1159 		return -EAGAIN;
1160 	}
1161 
1162 	/* Device is busy until capabilities have been exchanged and we
1163 	 * have a generic buffer for each possible HMC connection.
1164 	 */
1165 	for (index = 0; index <= ibmvmc.max_hmc_index; index++) {
1166 		valid = 0;
1167 		ibmvmc_count_hmc_buffers(index, &valid, &free);
1168 		if (valid == 0) {
1169 			pr_warn("ibmvmc: buffers not ready for index %d\n",
1170 				index);
1171 			return -ENOBUFS;
1172 		}
1173 	}
1174 
1175 	/* Get an hmc object, and transition to ibmhmc_state_initial */
1176 	hmc = ibmvmc_get_free_hmc();
1177 	if (!hmc) {
1178 		pr_warn("%s: free hmc not found\n", __func__);
1179 		return -EBUSY;
1180 	}
1181 
1182 	hmc->session = hmc->session + 1;
1183 	if (hmc->session == 0xff)
1184 		hmc->session = 1;
1185 
1186 	session->hmc = hmc;
1187 	hmc->adapter = &ibmvmc_adapter;
1188 	hmc->file_session = session;
1189 	session->valid = 1;
1190 
1191 	return 0;
1192 }
1193 
1194 /**
1195  * ibmvmc_ioctl_sethmcid - IOCTL Set HMC ID
1196  *
1197  * @session:	ibmvmc_file_session struct
1198  * @new_hmc_id:	HMC id field
1199  *
1200  * IOCTL command to setup the hmc id
1201  *
1202  * Return:
1203  *	0 - Success
1204  *	Non-zero - Failure
1205  */
ibmvmc_ioctl_sethmcid(struct ibmvmc_file_session * session,unsigned char __user * new_hmc_id)1206 static long ibmvmc_ioctl_sethmcid(struct ibmvmc_file_session *session,
1207 				  unsigned char __user *new_hmc_id)
1208 {
1209 	struct ibmvmc_hmc *hmc;
1210 	struct ibmvmc_buffer *buffer;
1211 	size_t bytes;
1212 	char print_buffer[HMC_ID_LEN + 1];
1213 	unsigned long flags;
1214 	long rc = 0;
1215 
1216 	/* Reserve HMC session */
1217 	hmc = session->hmc;
1218 	if (!hmc) {
1219 		rc = ibmvmc_setup_hmc(session);
1220 		if (rc)
1221 			return rc;
1222 
1223 		hmc = session->hmc;
1224 		if (!hmc) {
1225 			pr_err("ibmvmc: setup_hmc success but no hmc\n");
1226 			return -EIO;
1227 		}
1228 	}
1229 
1230 	if (hmc->state != ibmhmc_state_initial) {
1231 		pr_warn("ibmvmc: sethmcid: invalid state to send open 0x%x\n",
1232 			hmc->state);
1233 		return -EIO;
1234 	}
1235 
1236 	bytes = copy_from_user(hmc->hmc_id, new_hmc_id, HMC_ID_LEN);
1237 	if (bytes)
1238 		return -EFAULT;
1239 
1240 	/* Send Open Session command */
1241 	spin_lock_irqsave(&hmc->lock, flags);
1242 	buffer = ibmvmc_get_valid_hmc_buffer(hmc->index);
1243 	spin_unlock_irqrestore(&hmc->lock, flags);
1244 
1245 	if (!buffer || !buffer->real_addr_local) {
1246 		pr_warn("ibmvmc: sethmcid: no buffer available\n");
1247 		return -EIO;
1248 	}
1249 
1250 	/* Make sure buffer is NULL terminated before trying to print it */
1251 	memset(print_buffer, 0, HMC_ID_LEN + 1);
1252 	strncpy(print_buffer, hmc->hmc_id, HMC_ID_LEN);
1253 	pr_info("ibmvmc: sethmcid: Set HMC ID: \"%s\"\n", print_buffer);
1254 
1255 	memcpy(buffer->real_addr_local, hmc->hmc_id, HMC_ID_LEN);
1256 	/* RDMA over ID, send open msg, change state to ibmhmc_state_opening */
1257 	rc = ibmvmc_send_open(buffer, hmc);
1258 
1259 	return rc;
1260 }
1261 
1262 /**
1263  * ibmvmc_ioctl_query - IOCTL Query
1264  *
1265  * @session:	ibmvmc_file_session struct
1266  * @ret_struct:	ibmvmc_query_struct
1267  *
1268  * Return:
1269  *	0 - Success
1270  *	Non-zero - Failure
1271  */
ibmvmc_ioctl_query(struct ibmvmc_file_session * session,struct ibmvmc_query_struct __user * ret_struct)1272 static long ibmvmc_ioctl_query(struct ibmvmc_file_session *session,
1273 			       struct ibmvmc_query_struct __user *ret_struct)
1274 {
1275 	struct ibmvmc_query_struct query_struct;
1276 	size_t bytes;
1277 
1278 	memset(&query_struct, 0, sizeof(query_struct));
1279 	query_struct.have_vmc = (ibmvmc.state > ibmvmc_state_initial);
1280 	query_struct.state = ibmvmc.state;
1281 	query_struct.vmc_drc_index = ibmvmc.vmc_drc_index;
1282 
1283 	bytes = copy_to_user(ret_struct, &query_struct,
1284 			     sizeof(query_struct));
1285 	if (bytes)
1286 		return -EFAULT;
1287 
1288 	return 0;
1289 }
1290 
1291 /**
1292  * ibmvmc_ioctl_requestvmc - IOCTL Request VMC
1293  *
1294  * @session:	ibmvmc_file_session struct
1295  * @ret_vmc_index:	VMC Index
1296  *
1297  * Return:
1298  *	0 - Success
1299  *	Non-zero - Failure
1300  */
ibmvmc_ioctl_requestvmc(struct ibmvmc_file_session * session,u32 __user * ret_vmc_index)1301 static long ibmvmc_ioctl_requestvmc(struct ibmvmc_file_session *session,
1302 				    u32 __user *ret_vmc_index)
1303 {
1304 	/* TODO: (adreznec) Add locking to control multiple process access */
1305 	size_t bytes;
1306 	long rc;
1307 	u32 vmc_drc_index;
1308 
1309 	/* Call to request the VMC device from phyp*/
1310 	rc = h_request_vmc(&vmc_drc_index);
1311 	pr_debug("ibmvmc: requestvmc: H_REQUEST_VMC rc = 0x%lx\n", rc);
1312 
1313 	if (rc == H_SUCCESS) {
1314 		rc = 0;
1315 	} else if (rc == H_FUNCTION) {
1316 		pr_err("ibmvmc: requestvmc: h_request_vmc not supported\n");
1317 		return -EPERM;
1318 	} else if (rc == H_AUTHORITY) {
1319 		pr_err("ibmvmc: requestvmc: hypervisor denied vmc request\n");
1320 		return -EPERM;
1321 	} else if (rc == H_HARDWARE) {
1322 		pr_err("ibmvmc: requestvmc: hypervisor hardware fault\n");
1323 		return -EIO;
1324 	} else if (rc == H_RESOURCE) {
1325 		pr_err("ibmvmc: requestvmc: vmc resource unavailable\n");
1326 		return -ENODEV;
1327 	} else if (rc == H_NOT_AVAILABLE) {
1328 		pr_err("ibmvmc: requestvmc: system cannot be vmc managed\n");
1329 		return -EPERM;
1330 	} else if (rc == H_PARAMETER) {
1331 		pr_err("ibmvmc: requestvmc: invalid parameter\n");
1332 		return -EINVAL;
1333 	}
1334 
1335 	/* Success, set the vmc index in global struct */
1336 	ibmvmc.vmc_drc_index = vmc_drc_index;
1337 
1338 	bytes = copy_to_user(ret_vmc_index, &vmc_drc_index,
1339 			     sizeof(*ret_vmc_index));
1340 	if (bytes) {
1341 		pr_warn("ibmvmc: requestvmc: copy to user failed.\n");
1342 		return -EFAULT;
1343 	}
1344 	return rc;
1345 }
1346 
1347 /**
1348  * ibmvmc_ioctl - IOCTL
1349  *
1350  * @session:	ibmvmc_file_session struct
1351  * @cmd:	cmd field
1352  * @arg:	Argument field
1353  *
1354  * Return:
1355  *	0 - Success
1356  *	Non-zero - Failure
1357  */
ibmvmc_ioctl(struct file * file,unsigned int cmd,unsigned long arg)1358 static long ibmvmc_ioctl(struct file *file,
1359 			 unsigned int cmd, unsigned long arg)
1360 {
1361 	struct ibmvmc_file_session *session = file->private_data;
1362 
1363 	pr_debug("ibmvmc: ioctl file=0x%lx, cmd=0x%x, arg=0x%lx, ses=0x%lx\n",
1364 		 (unsigned long)file, cmd, arg,
1365 		 (unsigned long)session);
1366 
1367 	if (!session) {
1368 		pr_warn("ibmvmc: ioctl: no session\n");
1369 		return -EIO;
1370 	}
1371 
1372 	switch (cmd) {
1373 	case VMC_IOCTL_SETHMCID:
1374 		return ibmvmc_ioctl_sethmcid(session,
1375 			(unsigned char __user *)arg);
1376 	case VMC_IOCTL_QUERY:
1377 		return ibmvmc_ioctl_query(session,
1378 			(struct ibmvmc_query_struct __user *)arg);
1379 	case VMC_IOCTL_REQUESTVMC:
1380 		return ibmvmc_ioctl_requestvmc(session,
1381 			(unsigned int __user *)arg);
1382 	default:
1383 		pr_warn("ibmvmc: unknown ioctl 0x%x\n", cmd);
1384 		return -EINVAL;
1385 	}
1386 }
1387 
1388 static const struct file_operations ibmvmc_fops = {
1389 	.owner		= THIS_MODULE,
1390 	.read		= ibmvmc_read,
1391 	.write		= ibmvmc_write,
1392 	.poll		= ibmvmc_poll,
1393 	.unlocked_ioctl	= ibmvmc_ioctl,
1394 	.open           = ibmvmc_open,
1395 	.release        = ibmvmc_close,
1396 };
1397 
1398 /**
1399  * ibmvmc_add_buffer - Add Buffer
1400  *
1401  * @adapter: crq_server_adapter struct
1402  * @crq:	ibmvmc_crq_msg struct
1403  *
1404  * This message transfers a buffer from hypervisor ownership to management
1405  * partition ownership. The LIOBA is obtained from the virtual TCE table
1406  * associated with the hypervisor side of the VMC device, and points to a
1407  * buffer of size MTU (as established in the capabilities exchange).
1408  *
1409  * Typical flow for ading buffers:
1410  * 1. A new management application connection is opened by the management
1411  *	partition.
1412  * 2. The hypervisor assigns new buffers for the traffic associated with
1413  *	that connection.
1414  * 3. The hypervisor sends VMC Add Buffer messages to the management
1415  *	partition, informing it of the new buffers.
1416  * 4. The hypervisor sends an HMC protocol message (to the management
1417  *	application) notifying it of the new buffers. This informs the
1418  *	application that it has buffers available for sending HMC
1419  *	commands.
1420  *
1421  * Return:
1422  *	0 - Success
1423  *	Non-zero - Failure
1424  */
ibmvmc_add_buffer(struct crq_server_adapter * adapter,struct ibmvmc_crq_msg * crq)1425 static int ibmvmc_add_buffer(struct crq_server_adapter *adapter,
1426 			     struct ibmvmc_crq_msg *crq)
1427 {
1428 	struct ibmvmc_buffer *buffer;
1429 	u8 hmc_index;
1430 	u8 hmc_session;
1431 	u16 buffer_id;
1432 	unsigned long flags;
1433 	int rc = 0;
1434 
1435 	if (!crq)
1436 		return -1;
1437 
1438 	hmc_session = crq->hmc_session;
1439 	hmc_index = crq->hmc_index;
1440 	buffer_id = be16_to_cpu(crq->var2.buffer_id);
1441 
1442 	if (hmc_index > ibmvmc.max_hmc_index) {
1443 		dev_err(adapter->dev, "add_buffer: invalid hmc_index = 0x%x\n",
1444 			hmc_index);
1445 		ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_INVALID_HMC_INDEX,
1446 					    hmc_session, hmc_index, buffer_id);
1447 		return -1;
1448 	}
1449 
1450 	if (buffer_id >= ibmvmc.max_buffer_pool_size) {
1451 		dev_err(adapter->dev, "add_buffer: invalid buffer_id = 0x%x\n",
1452 			buffer_id);
1453 		ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_INVALID_BUFFER_ID,
1454 					    hmc_session, hmc_index, buffer_id);
1455 		return -1;
1456 	}
1457 
1458 	spin_lock_irqsave(&hmcs[hmc_index].lock, flags);
1459 	buffer = &hmcs[hmc_index].buffer[buffer_id];
1460 
1461 	if (buffer->real_addr_local || buffer->dma_addr_local) {
1462 		dev_warn(adapter->dev, "add_buffer: already allocated id = 0x%lx\n",
1463 			 (unsigned long)buffer_id);
1464 		spin_unlock_irqrestore(&hmcs[hmc_index].lock, flags);
1465 		ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_INVALID_BUFFER_ID,
1466 					    hmc_session, hmc_index, buffer_id);
1467 		return -1;
1468 	}
1469 
1470 	buffer->real_addr_local = alloc_dma_buffer(to_vio_dev(adapter->dev),
1471 						   ibmvmc.max_mtu,
1472 						   &buffer->dma_addr_local);
1473 
1474 	if (!buffer->real_addr_local) {
1475 		dev_err(adapter->dev, "add_buffer: alloc_dma_buffer failed.\n");
1476 		spin_unlock_irqrestore(&hmcs[hmc_index].lock, flags);
1477 		ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_INTERFACE_FAILURE,
1478 					    hmc_session, hmc_index, buffer_id);
1479 		return -1;
1480 	}
1481 
1482 	buffer->dma_addr_remote = be32_to_cpu(crq->var3.lioba);
1483 	buffer->size = ibmvmc.max_mtu;
1484 	buffer->owner = crq->var1.owner;
1485 	buffer->free = 1;
1486 	/* Must ensure valid==1 is observable only after all other fields are */
1487 	dma_wmb();
1488 	buffer->valid = 1;
1489 	buffer->id = buffer_id;
1490 
1491 	dev_dbg(adapter->dev, "add_buffer: successfully added a buffer:\n");
1492 	dev_dbg(adapter->dev, "   index: %d, session: %d, buffer: 0x%x, owner: %d\n",
1493 		hmc_index, hmc_session, buffer_id, buffer->owner);
1494 	dev_dbg(adapter->dev, "   local: 0x%x, remote: 0x%x\n",
1495 		(u32)buffer->dma_addr_local,
1496 		(u32)buffer->dma_addr_remote);
1497 	spin_unlock_irqrestore(&hmcs[hmc_index].lock, flags);
1498 
1499 	ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_SUCCESS, hmc_session,
1500 				    hmc_index, buffer_id);
1501 
1502 	return rc;
1503 }
1504 
1505 /**
1506  * ibmvmc_rem_buffer - Remove Buffer
1507  *
1508  * @adapter: crq_server_adapter struct
1509  * @crq:	ibmvmc_crq_msg struct
1510  *
1511  * This message requests an HMC buffer to be transferred from management
1512  * partition ownership to hypervisor ownership. The management partition may
1513  * not be able to satisfy the request at a particular point in time if all its
1514  * buffers are in use. The management partition requires a depth of at least
1515  * one inbound buffer to allow management application commands to flow to the
1516  * hypervisor. It is, therefore, an interface error for the hypervisor to
1517  * attempt to remove the management partition's last buffer.
1518  *
1519  * The hypervisor is expected to manage buffer usage with the management
1520  * application directly and inform the management partition when buffers may be
1521  * removed. The typical flow for removing buffers:
1522  *
1523  * 1. The management application no longer needs a communication path to a
1524  *	particular hypervisor function. That function is closed.
1525  * 2. The hypervisor and the management application quiesce all traffic to that
1526  *	function. The hypervisor requests a reduction in buffer pool size.
1527  * 3. The management application acknowledges the reduction in buffer pool size.
1528  * 4. The hypervisor sends a Remove Buffer message to the management partition,
1529  *	informing it of the reduction in buffers.
1530  * 5. The management partition verifies it can remove the buffer. This is
1531  *	possible if buffers have been quiesced.
1532  *
1533  * Return:
1534  *	0 - Success
1535  *	Non-zero - Failure
1536  */
1537 /*
1538  * The hypervisor requested that we pick an unused buffer, and return it.
1539  * Before sending the buffer back, we free any storage associated with the
1540  * buffer.
1541  */
ibmvmc_rem_buffer(struct crq_server_adapter * adapter,struct ibmvmc_crq_msg * crq)1542 static int ibmvmc_rem_buffer(struct crq_server_adapter *adapter,
1543 			     struct ibmvmc_crq_msg *crq)
1544 {
1545 	struct ibmvmc_buffer *buffer;
1546 	u8 hmc_index;
1547 	u8 hmc_session;
1548 	u16 buffer_id = 0;
1549 	unsigned long flags;
1550 	int rc = 0;
1551 
1552 	if (!crq)
1553 		return -1;
1554 
1555 	hmc_session = crq->hmc_session;
1556 	hmc_index = crq->hmc_index;
1557 
1558 	if (hmc_index > ibmvmc.max_hmc_index) {
1559 		dev_warn(adapter->dev, "rem_buffer: invalid hmc_index = 0x%x\n",
1560 			 hmc_index);
1561 		ibmvmc_send_rem_buffer_resp(adapter, VMC_MSG_INVALID_HMC_INDEX,
1562 					    hmc_session, hmc_index, buffer_id);
1563 		return -1;
1564 	}
1565 
1566 	spin_lock_irqsave(&hmcs[hmc_index].lock, flags);
1567 	buffer = ibmvmc_get_free_hmc_buffer(adapter, hmc_index);
1568 	if (!buffer) {
1569 		dev_info(adapter->dev, "rem_buffer: no buffer to remove\n");
1570 		spin_unlock_irqrestore(&hmcs[hmc_index].lock, flags);
1571 		ibmvmc_send_rem_buffer_resp(adapter, VMC_MSG_NO_BUFFER,
1572 					    hmc_session, hmc_index,
1573 					    VMC_INVALID_BUFFER_ID);
1574 		return -1;
1575 	}
1576 
1577 	buffer_id = buffer->id;
1578 
1579 	if (buffer->valid)
1580 		free_dma_buffer(to_vio_dev(adapter->dev),
1581 				ibmvmc.max_mtu,
1582 				buffer->real_addr_local,
1583 				buffer->dma_addr_local);
1584 
1585 	memset(buffer, 0, sizeof(struct ibmvmc_buffer));
1586 	spin_unlock_irqrestore(&hmcs[hmc_index].lock, flags);
1587 
1588 	dev_dbg(adapter->dev, "rem_buffer: removed buffer 0x%x.\n", buffer_id);
1589 	ibmvmc_send_rem_buffer_resp(adapter, VMC_MSG_SUCCESS, hmc_session,
1590 				    hmc_index, buffer_id);
1591 
1592 	return rc;
1593 }
1594 
ibmvmc_recv_msg(struct crq_server_adapter * adapter,struct ibmvmc_crq_msg * crq)1595 static int ibmvmc_recv_msg(struct crq_server_adapter *adapter,
1596 			   struct ibmvmc_crq_msg *crq)
1597 {
1598 	struct ibmvmc_buffer *buffer;
1599 	struct ibmvmc_hmc *hmc;
1600 	unsigned long msg_len;
1601 	u8 hmc_index;
1602 	u8 hmc_session;
1603 	u16 buffer_id;
1604 	unsigned long flags;
1605 	int rc = 0;
1606 
1607 	if (!crq)
1608 		return -1;
1609 
1610 	/* Hypervisor writes CRQs directly into our memory in big endian */
1611 	dev_dbg(adapter->dev, "Recv_msg: msg from HV 0x%016llx 0x%016llx\n",
1612 		be64_to_cpu(*((unsigned long *)crq)),
1613 		be64_to_cpu(*(((unsigned long *)crq) + 1)));
1614 
1615 	hmc_session = crq->hmc_session;
1616 	hmc_index = crq->hmc_index;
1617 	buffer_id = be16_to_cpu(crq->var2.buffer_id);
1618 	msg_len = be32_to_cpu(crq->var3.msg_len);
1619 
1620 	if (hmc_index > ibmvmc.max_hmc_index) {
1621 		dev_err(adapter->dev, "Recv_msg: invalid hmc_index = 0x%x\n",
1622 			hmc_index);
1623 		ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_INVALID_HMC_INDEX,
1624 					    hmc_session, hmc_index, buffer_id);
1625 		return -1;
1626 	}
1627 
1628 	if (buffer_id >= ibmvmc.max_buffer_pool_size) {
1629 		dev_err(adapter->dev, "Recv_msg: invalid buffer_id = 0x%x\n",
1630 			buffer_id);
1631 		ibmvmc_send_add_buffer_resp(adapter, VMC_MSG_INVALID_BUFFER_ID,
1632 					    hmc_session, hmc_index, buffer_id);
1633 		return -1;
1634 	}
1635 
1636 	hmc = &hmcs[hmc_index];
1637 	spin_lock_irqsave(&hmc->lock, flags);
1638 
1639 	if (hmc->state == ibmhmc_state_free) {
1640 		dev_err(adapter->dev, "Recv_msg: invalid hmc state = 0x%x\n",
1641 			hmc->state);
1642 		/* HMC connection is not valid (possibly was reset under us). */
1643 		spin_unlock_irqrestore(&hmc->lock, flags);
1644 		return -1;
1645 	}
1646 
1647 	buffer = &hmc->buffer[buffer_id];
1648 
1649 	if (buffer->valid == 0 || buffer->owner == VMC_BUF_OWNER_ALPHA) {
1650 		dev_err(adapter->dev, "Recv_msg: not valid, or not HV.  0x%x 0x%x\n",
1651 			buffer->valid, buffer->owner);
1652 		spin_unlock_irqrestore(&hmc->lock, flags);
1653 		return -1;
1654 	}
1655 
1656 	/* RDMA the data into the partition. */
1657 	rc = h_copy_rdma(msg_len,
1658 			 adapter->riobn,
1659 			 buffer->dma_addr_remote,
1660 			 adapter->liobn,
1661 			 buffer->dma_addr_local);
1662 
1663 	dev_dbg(adapter->dev, "Recv_msg: msg_len = 0x%x, buffer_id = 0x%x, queue_head = 0x%x, hmc_idx = 0x%x\n",
1664 		(unsigned int)msg_len, (unsigned int)buffer_id,
1665 		(unsigned int)hmc->queue_head, (unsigned int)hmc_index);
1666 	buffer->msg_len = msg_len;
1667 	buffer->free = 0;
1668 	buffer->owner = VMC_BUF_OWNER_ALPHA;
1669 
1670 	if (rc) {
1671 		dev_err(adapter->dev, "Failure in recv_msg: h_copy_rdma = 0x%x\n",
1672 			rc);
1673 		spin_unlock_irqrestore(&hmc->lock, flags);
1674 		return -1;
1675 	}
1676 
1677 	/* Must be locked because read operates on the same data */
1678 	hmc->queue_outbound_msgs[hmc->queue_head] = buffer_id;
1679 	hmc->queue_head++;
1680 	if (hmc->queue_head == ibmvmc_max_buf_pool_size)
1681 		hmc->queue_head = 0;
1682 
1683 	if (hmc->queue_head == hmc->queue_tail)
1684 		dev_err(adapter->dev, "outbound buffer queue wrapped.\n");
1685 
1686 	spin_unlock_irqrestore(&hmc->lock, flags);
1687 
1688 	wake_up_interruptible(&ibmvmc_read_wait);
1689 
1690 	return 0;
1691 }
1692 
1693 /**
1694  * ibmvmc_process_capabilities - Process Capabilities
1695  *
1696  * @adapter:	crq_server_adapter struct
1697  * @crqp:	ibmvmc_crq_msg struct
1698  *
1699  */
ibmvmc_process_capabilities(struct crq_server_adapter * adapter,struct ibmvmc_crq_msg * crqp)1700 static void ibmvmc_process_capabilities(struct crq_server_adapter *adapter,
1701 					struct ibmvmc_crq_msg *crqp)
1702 {
1703 	struct ibmvmc_admin_crq_msg *crq = (struct ibmvmc_admin_crq_msg *)crqp;
1704 
1705 	if ((be16_to_cpu(crq->version) >> 8) !=
1706 			(IBMVMC_PROTOCOL_VERSION >> 8)) {
1707 		dev_err(adapter->dev, "init failed, incompatible versions 0x%x 0x%x\n",
1708 			be16_to_cpu(crq->version),
1709 			IBMVMC_PROTOCOL_VERSION);
1710 		ibmvmc.state = ibmvmc_state_failed;
1711 		return;
1712 	}
1713 
1714 	ibmvmc.max_mtu = min_t(u32, ibmvmc_max_mtu, be32_to_cpu(crq->max_mtu));
1715 	ibmvmc.max_buffer_pool_size = min_t(u16, ibmvmc_max_buf_pool_size,
1716 					    be16_to_cpu(crq->pool_size));
1717 	ibmvmc.max_hmc_index = min_t(u8, ibmvmc_max_hmcs, crq->max_hmc) - 1;
1718 	ibmvmc.state = ibmvmc_state_ready;
1719 
1720 	dev_info(adapter->dev, "Capabilities: mtu=0x%x, pool_size=0x%x, max_hmc=0x%x\n",
1721 		 ibmvmc.max_mtu, ibmvmc.max_buffer_pool_size,
1722 		 ibmvmc.max_hmc_index);
1723 }
1724 
1725 /**
1726  * ibmvmc_validate_hmc_session - Validate HMC Session
1727  *
1728  * @adapter:	crq_server_adapter struct
1729  * @crq:	ibmvmc_crq_msg struct
1730  *
1731  * Return:
1732  *	0 - Success
1733  *	Non-zero - Failure
1734  */
ibmvmc_validate_hmc_session(struct crq_server_adapter * adapter,struct ibmvmc_crq_msg * crq)1735 static int ibmvmc_validate_hmc_session(struct crq_server_adapter *adapter,
1736 				       struct ibmvmc_crq_msg *crq)
1737 {
1738 	unsigned char hmc_index;
1739 
1740 	hmc_index = crq->hmc_index;
1741 
1742 	if (crq->hmc_session == 0)
1743 		return 0;
1744 
1745 	if (hmc_index > ibmvmc.max_hmc_index)
1746 		return -1;
1747 
1748 	if (hmcs[hmc_index].session != crq->hmc_session) {
1749 		dev_warn(adapter->dev, "Drop, bad session: expected 0x%x, recv 0x%x\n",
1750 			 hmcs[hmc_index].session, crq->hmc_session);
1751 		return -1;
1752 	}
1753 
1754 	return 0;
1755 }
1756 
1757 /**
1758  * ibmvmc_reset - Reset
1759  *
1760  * @adapter:	crq_server_adapter struct
1761  * @xport_event:	export_event field
1762  *
1763  * Closes all HMC sessions and conditionally schedules a CRQ reset.
1764  * @xport_event: If true, the partner closed their CRQ; we don't need to reset.
1765  *               If false, we need to schedule a CRQ reset.
1766  */
ibmvmc_reset(struct crq_server_adapter * adapter,bool xport_event)1767 static void ibmvmc_reset(struct crq_server_adapter *adapter, bool xport_event)
1768 {
1769 	int i;
1770 
1771 	if (ibmvmc.state != ibmvmc_state_sched_reset) {
1772 		dev_info(adapter->dev, "*** Reset to initial state.\n");
1773 		for (i = 0; i < ibmvmc_max_hmcs; i++)
1774 			ibmvmc_return_hmc(&hmcs[i], xport_event);
1775 
1776 		if (xport_event) {
1777 			/* CRQ was closed by the partner.  We don't need to do
1778 			 * anything except set ourself to the correct state to
1779 			 * handle init msgs.
1780 			 */
1781 			ibmvmc.state = ibmvmc_state_crqinit;
1782 		} else {
1783 			/* The partner did not close their CRQ - instead, we're
1784 			 * closing the CRQ on our end. Need to schedule this
1785 			 * for process context, because CRQ reset may require a
1786 			 * sleep.
1787 			 *
1788 			 * Setting ibmvmc.state here immediately prevents
1789 			 * ibmvmc_open from completing until the reset
1790 			 * completes in process context.
1791 			 */
1792 			ibmvmc.state = ibmvmc_state_sched_reset;
1793 			dev_dbg(adapter->dev, "Device reset scheduled");
1794 			wake_up_interruptible(&adapter->reset_wait_queue);
1795 		}
1796 	}
1797 }
1798 
1799 /**
1800  * ibmvmc_reset_task - Reset Task
1801  *
1802  * @data:	Data field
1803  *
1804  * Performs a CRQ reset of the VMC device in process context.
1805  * NOTE: This function should not be called directly, use ibmvmc_reset.
1806  */
ibmvmc_reset_task(void * data)1807 static int ibmvmc_reset_task(void *data)
1808 {
1809 	struct crq_server_adapter *adapter = data;
1810 	int rc;
1811 
1812 	set_user_nice(current, -20);
1813 
1814 	while (!kthread_should_stop()) {
1815 		wait_event_interruptible(adapter->reset_wait_queue,
1816 			(ibmvmc.state == ibmvmc_state_sched_reset) ||
1817 			kthread_should_stop());
1818 
1819 		if (kthread_should_stop())
1820 			break;
1821 
1822 		dev_dbg(adapter->dev, "CRQ resetting in process context");
1823 		tasklet_disable(&adapter->work_task);
1824 
1825 		rc = ibmvmc_reset_crq_queue(adapter);
1826 
1827 		if (rc != H_SUCCESS && rc != H_RESOURCE) {
1828 			dev_err(adapter->dev, "Error initializing CRQ.  rc = 0x%x\n",
1829 				rc);
1830 			ibmvmc.state = ibmvmc_state_failed;
1831 		} else {
1832 			ibmvmc.state = ibmvmc_state_crqinit;
1833 
1834 			if (ibmvmc_send_crq(adapter, 0xC001000000000000LL, 0)
1835 			    != 0 && rc != H_RESOURCE)
1836 				dev_warn(adapter->dev, "Failed to send initialize CRQ message\n");
1837 		}
1838 
1839 		vio_enable_interrupts(to_vio_dev(adapter->dev));
1840 		tasklet_enable(&adapter->work_task);
1841 	}
1842 
1843 	return 0;
1844 }
1845 
1846 /**
1847  * ibmvmc_process_open_resp - Process Open Response
1848  *
1849  * @crq: ibmvmc_crq_msg struct
1850  * @adapter:    crq_server_adapter struct
1851  *
1852  * This command is sent by the hypervisor in response to the Interface
1853  * Open message. When this message is received, the indicated buffer is
1854  * again available for management partition use.
1855  */
ibmvmc_process_open_resp(struct ibmvmc_crq_msg * crq,struct crq_server_adapter * adapter)1856 static void ibmvmc_process_open_resp(struct ibmvmc_crq_msg *crq,
1857 				     struct crq_server_adapter *adapter)
1858 {
1859 	unsigned char hmc_index;
1860 	unsigned short buffer_id;
1861 
1862 	hmc_index = crq->hmc_index;
1863 	if (hmc_index > ibmvmc.max_hmc_index) {
1864 		/* Why would PHYP give an index > max negotiated? */
1865 		ibmvmc_reset(adapter, false);
1866 		return;
1867 	}
1868 
1869 	if (crq->status) {
1870 		dev_warn(adapter->dev, "open_resp: failed - status 0x%x\n",
1871 			 crq->status);
1872 		ibmvmc_return_hmc(&hmcs[hmc_index], false);
1873 		return;
1874 	}
1875 
1876 	if (hmcs[hmc_index].state == ibmhmc_state_opening) {
1877 		buffer_id = be16_to_cpu(crq->var2.buffer_id);
1878 		if (buffer_id >= ibmvmc.max_buffer_pool_size) {
1879 			dev_err(adapter->dev, "open_resp: invalid buffer_id = 0x%x\n",
1880 				buffer_id);
1881 			hmcs[hmc_index].state = ibmhmc_state_failed;
1882 		} else {
1883 			ibmvmc_free_hmc_buffer(&hmcs[hmc_index],
1884 					       &hmcs[hmc_index].buffer[buffer_id]);
1885 			hmcs[hmc_index].state = ibmhmc_state_ready;
1886 			dev_dbg(adapter->dev, "open_resp: set hmc state = ready\n");
1887 		}
1888 	} else {
1889 		dev_warn(adapter->dev, "open_resp: invalid hmc state (0x%x)\n",
1890 			 hmcs[hmc_index].state);
1891 	}
1892 }
1893 
1894 /**
1895  * ibmvmc_process_close_resp - Process Close Response
1896  *
1897  * @crq: ibmvmc_crq_msg struct
1898  * @adapter:    crq_server_adapter struct
1899  *
1900  * This command is sent by the hypervisor in response to the managemant
1901  * application Interface Close message.
1902  *
1903  * If the close fails, simply reset the entire driver as the state of the VMC
1904  * must be in tough shape.
1905  */
ibmvmc_process_close_resp(struct ibmvmc_crq_msg * crq,struct crq_server_adapter * adapter)1906 static void ibmvmc_process_close_resp(struct ibmvmc_crq_msg *crq,
1907 				      struct crq_server_adapter *adapter)
1908 {
1909 	unsigned char hmc_index;
1910 
1911 	hmc_index = crq->hmc_index;
1912 	if (hmc_index > ibmvmc.max_hmc_index) {
1913 		ibmvmc_reset(adapter, false);
1914 		return;
1915 	}
1916 
1917 	if (crq->status) {
1918 		dev_warn(adapter->dev, "close_resp: failed - status 0x%x\n",
1919 			 crq->status);
1920 		ibmvmc_reset(adapter, false);
1921 		return;
1922 	}
1923 
1924 	ibmvmc_return_hmc(&hmcs[hmc_index], false);
1925 }
1926 
1927 /**
1928  * ibmvmc_crq_process - Process CRQ
1929  *
1930  * @adapter:    crq_server_adapter struct
1931  * @crq:	ibmvmc_crq_msg struct
1932  *
1933  * Process the CRQ message based upon the type of message received.
1934  *
1935  */
ibmvmc_crq_process(struct crq_server_adapter * adapter,struct ibmvmc_crq_msg * crq)1936 static void ibmvmc_crq_process(struct crq_server_adapter *adapter,
1937 			       struct ibmvmc_crq_msg *crq)
1938 {
1939 	switch (crq->type) {
1940 	case VMC_MSG_CAP_RESP:
1941 		dev_dbg(adapter->dev, "CRQ recv: capabilities resp (0x%x)\n",
1942 			crq->type);
1943 		if (ibmvmc.state == ibmvmc_state_capabilities)
1944 			ibmvmc_process_capabilities(adapter, crq);
1945 		else
1946 			dev_warn(adapter->dev, "caps msg invalid in state 0x%x\n",
1947 				 ibmvmc.state);
1948 		break;
1949 	case VMC_MSG_OPEN_RESP:
1950 		dev_dbg(adapter->dev, "CRQ recv: open resp (0x%x)\n",
1951 			crq->type);
1952 		if (ibmvmc_validate_hmc_session(adapter, crq) == 0)
1953 			ibmvmc_process_open_resp(crq, adapter);
1954 		break;
1955 	case VMC_MSG_ADD_BUF:
1956 		dev_dbg(adapter->dev, "CRQ recv: add buf (0x%x)\n",
1957 			crq->type);
1958 		if (ibmvmc_validate_hmc_session(adapter, crq) == 0)
1959 			ibmvmc_add_buffer(adapter, crq);
1960 		break;
1961 	case VMC_MSG_REM_BUF:
1962 		dev_dbg(adapter->dev, "CRQ recv: rem buf (0x%x)\n",
1963 			crq->type);
1964 		if (ibmvmc_validate_hmc_session(adapter, crq) == 0)
1965 			ibmvmc_rem_buffer(adapter, crq);
1966 		break;
1967 	case VMC_MSG_SIGNAL:
1968 		dev_dbg(adapter->dev, "CRQ recv: signal msg (0x%x)\n",
1969 			crq->type);
1970 		if (ibmvmc_validate_hmc_session(adapter, crq) == 0)
1971 			ibmvmc_recv_msg(adapter, crq);
1972 		break;
1973 	case VMC_MSG_CLOSE_RESP:
1974 		dev_dbg(adapter->dev, "CRQ recv: close resp (0x%x)\n",
1975 			crq->type);
1976 		if (ibmvmc_validate_hmc_session(adapter, crq) == 0)
1977 			ibmvmc_process_close_resp(crq, adapter);
1978 		break;
1979 	case VMC_MSG_CAP:
1980 	case VMC_MSG_OPEN:
1981 	case VMC_MSG_CLOSE:
1982 	case VMC_MSG_ADD_BUF_RESP:
1983 	case VMC_MSG_REM_BUF_RESP:
1984 		dev_warn(adapter->dev, "CRQ recv: unexpected msg (0x%x)\n",
1985 			 crq->type);
1986 		break;
1987 	default:
1988 		dev_warn(adapter->dev, "CRQ recv: unknown msg (0x%x)\n",
1989 			 crq->type);
1990 		break;
1991 	}
1992 }
1993 
1994 /**
1995  * ibmvmc_handle_crq_init - Handle CRQ Init
1996  *
1997  * @crq:	ibmvmc_crq_msg struct
1998  * @adapter:	crq_server_adapter struct
1999  *
2000  * Handle the type of crq initialization based on whether
2001  * it is a message or a response.
2002  *
2003  */
ibmvmc_handle_crq_init(struct ibmvmc_crq_msg * crq,struct crq_server_adapter * adapter)2004 static void ibmvmc_handle_crq_init(struct ibmvmc_crq_msg *crq,
2005 				   struct crq_server_adapter *adapter)
2006 {
2007 	switch (crq->type) {
2008 	case 0x01:	/* Initialization message */
2009 		dev_dbg(adapter->dev, "CRQ recv: CRQ init msg - state 0x%x\n",
2010 			ibmvmc.state);
2011 		if (ibmvmc.state == ibmvmc_state_crqinit) {
2012 			/* Send back a response */
2013 			if (ibmvmc_send_crq(adapter, 0xC002000000000000,
2014 					    0) == 0)
2015 				ibmvmc_send_capabilities(adapter);
2016 			else
2017 				dev_err(adapter->dev, " Unable to send init rsp\n");
2018 		} else {
2019 			dev_err(adapter->dev, "Invalid state 0x%x mtu = 0x%x\n",
2020 				ibmvmc.state, ibmvmc.max_mtu);
2021 		}
2022 
2023 		break;
2024 	case 0x02:	/* Initialization response */
2025 		dev_dbg(adapter->dev, "CRQ recv: initialization resp msg - state 0x%x\n",
2026 			ibmvmc.state);
2027 		if (ibmvmc.state == ibmvmc_state_crqinit)
2028 			ibmvmc_send_capabilities(adapter);
2029 		break;
2030 	default:
2031 		dev_warn(adapter->dev, "Unknown crq message type 0x%lx\n",
2032 			 (unsigned long)crq->type);
2033 	}
2034 }
2035 
2036 /**
2037  * ibmvmc_handle_crq - Handle CRQ
2038  *
2039  * @crq:	ibmvmc_crq_msg struct
2040  * @adapter:	crq_server_adapter struct
2041  *
2042  * Read the command elements from the command queue and execute the
2043  * requests based upon the type of crq message.
2044  *
2045  */
ibmvmc_handle_crq(struct ibmvmc_crq_msg * crq,struct crq_server_adapter * adapter)2046 static void ibmvmc_handle_crq(struct ibmvmc_crq_msg *crq,
2047 			      struct crq_server_adapter *adapter)
2048 {
2049 	switch (crq->valid) {
2050 	case 0xC0:		/* initialization */
2051 		ibmvmc_handle_crq_init(crq, adapter);
2052 		break;
2053 	case 0xFF:	/* Hypervisor telling us the connection is closed */
2054 		dev_warn(adapter->dev, "CRQ recv: virtual adapter failed - resetting.\n");
2055 		ibmvmc_reset(adapter, true);
2056 		break;
2057 	case 0x80:	/* real payload */
2058 		ibmvmc_crq_process(adapter, crq);
2059 		break;
2060 	default:
2061 		dev_warn(adapter->dev, "CRQ recv: unknown msg 0x%02x.\n",
2062 			 crq->valid);
2063 		break;
2064 	}
2065 }
2066 
ibmvmc_task(unsigned long data)2067 static void ibmvmc_task(unsigned long data)
2068 {
2069 	struct crq_server_adapter *adapter =
2070 		(struct crq_server_adapter *)data;
2071 	struct vio_dev *vdev = to_vio_dev(adapter->dev);
2072 	struct ibmvmc_crq_msg *crq;
2073 	int done = 0;
2074 
2075 	while (!done) {
2076 		/* Pull all the valid messages off the CRQ */
2077 		while ((crq = crq_queue_next_crq(&adapter->queue)) != NULL) {
2078 			ibmvmc_handle_crq(crq, adapter);
2079 			crq->valid = 0x00;
2080 			/* CRQ reset was requested, stop processing CRQs.
2081 			 * Interrupts will be re-enabled by the reset task.
2082 			 */
2083 			if (ibmvmc.state == ibmvmc_state_sched_reset)
2084 				return;
2085 		}
2086 
2087 		vio_enable_interrupts(vdev);
2088 		crq = crq_queue_next_crq(&adapter->queue);
2089 		if (crq) {
2090 			vio_disable_interrupts(vdev);
2091 			ibmvmc_handle_crq(crq, adapter);
2092 			crq->valid = 0x00;
2093 			/* CRQ reset was requested, stop processing CRQs.
2094 			 * Interrupts will be re-enabled by the reset task.
2095 			 */
2096 			if (ibmvmc.state == ibmvmc_state_sched_reset)
2097 				return;
2098 		} else {
2099 			done = 1;
2100 		}
2101 	}
2102 }
2103 
2104 /**
2105  * ibmvmc_init_crq_queue - Init CRQ Queue
2106  *
2107  * @adapter:	crq_server_adapter struct
2108  *
2109  * Return:
2110  *	0 - Success
2111  *	Non-zero - Failure
2112  */
ibmvmc_init_crq_queue(struct crq_server_adapter * adapter)2113 static int ibmvmc_init_crq_queue(struct crq_server_adapter *adapter)
2114 {
2115 	struct vio_dev *vdev = to_vio_dev(adapter->dev);
2116 	struct crq_queue *queue = &adapter->queue;
2117 	int rc = 0;
2118 	int retrc = 0;
2119 
2120 	queue->msgs = (struct ibmvmc_crq_msg *)get_zeroed_page(GFP_KERNEL);
2121 
2122 	if (!queue->msgs)
2123 		goto malloc_failed;
2124 
2125 	queue->size = PAGE_SIZE / sizeof(*queue->msgs);
2126 
2127 	queue->msg_token = dma_map_single(adapter->dev, queue->msgs,
2128 					  queue->size * sizeof(*queue->msgs),
2129 					  DMA_BIDIRECTIONAL);
2130 
2131 	if (dma_mapping_error(adapter->dev, queue->msg_token))
2132 		goto map_failed;
2133 
2134 	retrc = plpar_hcall_norets(H_REG_CRQ,
2135 				   vdev->unit_address,
2136 				   queue->msg_token, PAGE_SIZE);
2137 	rc = retrc;
2138 
2139 	if (rc == H_RESOURCE)
2140 		rc = ibmvmc_reset_crq_queue(adapter);
2141 
2142 	if (rc == 2) {
2143 		dev_warn(adapter->dev, "Partner adapter not ready\n");
2144 		retrc = 0;
2145 	} else if (rc != 0) {
2146 		dev_err(adapter->dev, "Error %d opening adapter\n", rc);
2147 		goto reg_crq_failed;
2148 	}
2149 
2150 	queue->cur = 0;
2151 	spin_lock_init(&queue->lock);
2152 
2153 	tasklet_init(&adapter->work_task, ibmvmc_task, (unsigned long)adapter);
2154 
2155 	if (request_irq(vdev->irq,
2156 			ibmvmc_handle_event,
2157 			0, "ibmvmc", (void *)adapter) != 0) {
2158 		dev_err(adapter->dev, "couldn't register irq 0x%x\n",
2159 			vdev->irq);
2160 		goto req_irq_failed;
2161 	}
2162 
2163 	rc = vio_enable_interrupts(vdev);
2164 	if (rc != 0) {
2165 		dev_err(adapter->dev, "Error %d enabling interrupts!!!\n", rc);
2166 		goto req_irq_failed;
2167 	}
2168 
2169 	return retrc;
2170 
2171 req_irq_failed:
2172 	/* Cannot have any work since we either never got our IRQ registered,
2173 	 * or never got interrupts enabled
2174 	 */
2175 	tasklet_kill(&adapter->work_task);
2176 	h_free_crq(vdev->unit_address);
2177 reg_crq_failed:
2178 	dma_unmap_single(adapter->dev,
2179 			 queue->msg_token,
2180 			 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
2181 map_failed:
2182 	free_page((unsigned long)queue->msgs);
2183 malloc_failed:
2184 	return -ENOMEM;
2185 }
2186 
2187 /* Fill in the liobn and riobn fields on the adapter */
read_dma_window(struct vio_dev * vdev,struct crq_server_adapter * adapter)2188 static int read_dma_window(struct vio_dev *vdev,
2189 			   struct crq_server_adapter *adapter)
2190 {
2191 	const __be32 *dma_window;
2192 	const __be32 *prop;
2193 
2194 	/* TODO Using of_parse_dma_window would be better, but it doesn't give
2195 	 * a way to read multiple windows without already knowing the size of
2196 	 * a window or the number of windows
2197 	 */
2198 	dma_window =
2199 		(const __be32 *)vio_get_attribute(vdev, "ibm,my-dma-window",
2200 						NULL);
2201 	if (!dma_window) {
2202 		dev_warn(adapter->dev, "Couldn't find ibm,my-dma-window property\n");
2203 		return -1;
2204 	}
2205 
2206 	adapter->liobn = be32_to_cpu(*dma_window);
2207 	dma_window++;
2208 
2209 	prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-address-cells",
2210 						NULL);
2211 	if (!prop) {
2212 		dev_warn(adapter->dev, "Couldn't find ibm,#dma-address-cells property\n");
2213 		dma_window++;
2214 	} else {
2215 		dma_window += be32_to_cpu(*prop);
2216 	}
2217 
2218 	prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-size-cells",
2219 						NULL);
2220 	if (!prop) {
2221 		dev_warn(adapter->dev, "Couldn't find ibm,#dma-size-cells property\n");
2222 		dma_window++;
2223 	} else {
2224 		dma_window += be32_to_cpu(*prop);
2225 	}
2226 
2227 	/* dma_window should point to the second window now */
2228 	adapter->riobn = be32_to_cpu(*dma_window);
2229 
2230 	return 0;
2231 }
2232 
ibmvmc_probe(struct vio_dev * vdev,const struct vio_device_id * id)2233 static int ibmvmc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
2234 {
2235 	struct crq_server_adapter *adapter = &ibmvmc_adapter;
2236 	int rc;
2237 
2238 	dev_set_drvdata(&vdev->dev, NULL);
2239 	memset(adapter, 0, sizeof(*adapter));
2240 	adapter->dev = &vdev->dev;
2241 
2242 	dev_info(adapter->dev, "Probe for UA 0x%x\n", vdev->unit_address);
2243 
2244 	rc = read_dma_window(vdev, adapter);
2245 	if (rc != 0) {
2246 		ibmvmc.state = ibmvmc_state_failed;
2247 		return -1;
2248 	}
2249 
2250 	dev_dbg(adapter->dev, "Probe: liobn 0x%x, riobn 0x%x\n",
2251 		adapter->liobn, adapter->riobn);
2252 
2253 	init_waitqueue_head(&adapter->reset_wait_queue);
2254 	adapter->reset_task = kthread_run(ibmvmc_reset_task, adapter, "ibmvmc");
2255 	if (IS_ERR(adapter->reset_task)) {
2256 		dev_err(adapter->dev, "Failed to start reset thread\n");
2257 		ibmvmc.state = ibmvmc_state_failed;
2258 		rc = PTR_ERR(adapter->reset_task);
2259 		adapter->reset_task = NULL;
2260 		return rc;
2261 	}
2262 
2263 	rc = ibmvmc_init_crq_queue(adapter);
2264 	if (rc != 0 && rc != H_RESOURCE) {
2265 		dev_err(adapter->dev, "Error initializing CRQ.  rc = 0x%x\n",
2266 			rc);
2267 		ibmvmc.state = ibmvmc_state_failed;
2268 		goto crq_failed;
2269 	}
2270 
2271 	ibmvmc.state = ibmvmc_state_crqinit;
2272 
2273 	/* Try to send an initialization message.  Note that this is allowed
2274 	 * to fail if the other end is not acive.  In that case we just wait
2275 	 * for the other side to initialize.
2276 	 */
2277 	if (ibmvmc_send_crq(adapter, 0xC001000000000000LL, 0) != 0 &&
2278 	    rc != H_RESOURCE)
2279 		dev_warn(adapter->dev, "Failed to send initialize CRQ message\n");
2280 
2281 	dev_set_drvdata(&vdev->dev, adapter);
2282 
2283 	return 0;
2284 
2285 crq_failed:
2286 	kthread_stop(adapter->reset_task);
2287 	adapter->reset_task = NULL;
2288 	return -EPERM;
2289 }
2290 
ibmvmc_remove(struct vio_dev * vdev)2291 static int ibmvmc_remove(struct vio_dev *vdev)
2292 {
2293 	struct crq_server_adapter *adapter = dev_get_drvdata(&vdev->dev);
2294 
2295 	dev_info(adapter->dev, "Entering remove for UA 0x%x\n",
2296 		 vdev->unit_address);
2297 	ibmvmc_release_crq_queue(adapter);
2298 
2299 	return 0;
2300 }
2301 
2302 static struct vio_device_id ibmvmc_device_table[] = {
2303 	{ "ibm,vmc", "IBM,vmc" },
2304 	{ "", "" }
2305 };
2306 MODULE_DEVICE_TABLE(vio, ibmvmc_device_table);
2307 
2308 static struct vio_driver ibmvmc_driver = {
2309 	.name        = ibmvmc_driver_name,
2310 	.id_table    = ibmvmc_device_table,
2311 	.probe       = ibmvmc_probe,
2312 	.remove      = ibmvmc_remove,
2313 };
2314 
ibmvmc_scrub_module_parms(void)2315 static void __init ibmvmc_scrub_module_parms(void)
2316 {
2317 	if (ibmvmc_max_mtu > MAX_MTU) {
2318 		pr_warn("ibmvmc: Max MTU reduced to %d\n", MAX_MTU);
2319 		ibmvmc_max_mtu = MAX_MTU;
2320 	} else if (ibmvmc_max_mtu < MIN_MTU) {
2321 		pr_warn("ibmvmc: Max MTU increased to %d\n", MIN_MTU);
2322 		ibmvmc_max_mtu = MIN_MTU;
2323 	}
2324 
2325 	if (ibmvmc_max_buf_pool_size > MAX_BUF_POOL_SIZE) {
2326 		pr_warn("ibmvmc: Max buffer pool size reduced to %d\n",
2327 			MAX_BUF_POOL_SIZE);
2328 		ibmvmc_max_buf_pool_size = MAX_BUF_POOL_SIZE;
2329 	} else if (ibmvmc_max_buf_pool_size < MIN_BUF_POOL_SIZE) {
2330 		pr_warn("ibmvmc: Max buffer pool size increased to %d\n",
2331 			MIN_BUF_POOL_SIZE);
2332 		ibmvmc_max_buf_pool_size = MIN_BUF_POOL_SIZE;
2333 	}
2334 
2335 	if (ibmvmc_max_hmcs > MAX_HMCS) {
2336 		pr_warn("ibmvmc: Max HMCs reduced to %d\n", MAX_HMCS);
2337 		ibmvmc_max_hmcs = MAX_HMCS;
2338 	} else if (ibmvmc_max_hmcs < MIN_HMCS) {
2339 		pr_warn("ibmvmc: Max HMCs increased to %d\n", MIN_HMCS);
2340 		ibmvmc_max_hmcs = MIN_HMCS;
2341 	}
2342 }
2343 
2344 static struct miscdevice ibmvmc_miscdev = {
2345 	.name = ibmvmc_driver_name,
2346 	.minor = MISC_DYNAMIC_MINOR,
2347 	.fops = &ibmvmc_fops,
2348 };
2349 
ibmvmc_module_init(void)2350 static int __init ibmvmc_module_init(void)
2351 {
2352 	int rc, i, j;
2353 
2354 	ibmvmc.state = ibmvmc_state_initial;
2355 	pr_info("ibmvmc: version %s\n", IBMVMC_DRIVER_VERSION);
2356 
2357 	rc = misc_register(&ibmvmc_miscdev);
2358 	if (rc) {
2359 		pr_err("ibmvmc: misc registration failed\n");
2360 		goto misc_register_failed;
2361 	}
2362 	pr_info("ibmvmc: node %d:%d\n", MISC_MAJOR,
2363 		ibmvmc_miscdev.minor);
2364 
2365 	/* Initialize data structures */
2366 	memset(hmcs, 0, sizeof(struct ibmvmc_hmc) * MAX_HMCS);
2367 	for (i = 0; i < MAX_HMCS; i++) {
2368 		spin_lock_init(&hmcs[i].lock);
2369 		hmcs[i].state = ibmhmc_state_free;
2370 		for (j = 0; j < MAX_BUF_POOL_SIZE; j++)
2371 			hmcs[i].queue_outbound_msgs[j] = VMC_INVALID_BUFFER_ID;
2372 	}
2373 
2374 	/* Sanity check module parms */
2375 	ibmvmc_scrub_module_parms();
2376 
2377 	/*
2378 	 * Initialize some reasonable values.  Might be negotiated smaller
2379 	 * values during the capabilities exchange.
2380 	 */
2381 	ibmvmc.max_mtu = ibmvmc_max_mtu;
2382 	ibmvmc.max_buffer_pool_size = ibmvmc_max_buf_pool_size;
2383 	ibmvmc.max_hmc_index = ibmvmc_max_hmcs - 1;
2384 
2385 	rc = vio_register_driver(&ibmvmc_driver);
2386 
2387 	if (rc) {
2388 		pr_err("ibmvmc: rc %d from vio_register_driver\n", rc);
2389 		goto vio_reg_failed;
2390 	}
2391 
2392 	return 0;
2393 
2394 vio_reg_failed:
2395 	misc_deregister(&ibmvmc_miscdev);
2396 misc_register_failed:
2397 	return rc;
2398 }
2399 
ibmvmc_module_exit(void)2400 static void __exit ibmvmc_module_exit(void)
2401 {
2402 	pr_info("ibmvmc: module exit\n");
2403 	vio_unregister_driver(&ibmvmc_driver);
2404 	misc_deregister(&ibmvmc_miscdev);
2405 }
2406 
2407 module_init(ibmvmc_module_init);
2408 module_exit(ibmvmc_module_exit);
2409 
2410 module_param_named(buf_pool_size, ibmvmc_max_buf_pool_size,
2411 		   int, 0644);
2412 MODULE_PARM_DESC(buf_pool_size, "Buffer pool size");
2413 module_param_named(max_hmcs, ibmvmc_max_hmcs, int, 0644);
2414 MODULE_PARM_DESC(max_hmcs, "Max HMCs");
2415 module_param_named(max_mtu, ibmvmc_max_mtu, int, 0644);
2416 MODULE_PARM_DESC(max_mtu, "Max MTU");
2417 
2418 MODULE_AUTHOR("Steven Royer <seroyer@linux.vnet.ibm.com>");
2419 MODULE_DESCRIPTION("IBM VMC");
2420 MODULE_VERSION(IBMVMC_DRIVER_VERSION);
2421 MODULE_LICENSE("GPL v2");
2422