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
