Merge tag 'backlight-next-5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/lee...
[sfrench/cifs-2.6.git] / drivers / misc / ibmvmc.c
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
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
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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
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  */
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 */
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
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
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
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
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
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");