[GFS2] Fix up merge of Linus' kernel into GFS2
[linux-2.6] / drivers / infiniband / hw / ehca / ipz_pt_fn.c
1 /*
2  *  IBM eServer eHCA Infiniband device driver for Linux on POWER
3  *
4  *  internal queue handling
5  *
6  *  Authors: Waleri Fomin <fomin@de.ibm.com>
7  *           Reinhard Ernst <rernst@de.ibm.com>
8  *           Christoph Raisch <raisch@de.ibm.com>
9  *
10  *  Copyright (c) 2005 IBM Corporation
11  *
12  *  This source code is distributed under a dual license of GPL v2.0 and OpenIB
13  *  BSD.
14  *
15  * OpenIB BSD License
16  *
17  * Redistribution and use in source and binary forms, with or without
18  * modification, are permitted provided that the following conditions are met:
19  *
20  * Redistributions of source code must retain the above copyright notice, this
21  * list of conditions and the following disclaimer.
22  *
23  * Redistributions in binary form must reproduce the above copyright notice,
24  * this list of conditions and the following disclaimer in the documentation
25  * and/or other materials
26  * provided with the distribution.
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
35  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
36  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38  * POSSIBILITY OF SUCH DAMAGE.
39  */
40
41 #include "ehca_tools.h"
42 #include "ipz_pt_fn.h"
43
44 void *ipz_qpageit_get_inc(struct ipz_queue *queue)
45 {
46         void *ret = ipz_qeit_get(queue);
47         queue->current_q_offset += queue->pagesize;
48         if (queue->current_q_offset > queue->queue_length) {
49                 queue->current_q_offset -= queue->pagesize;
50                 ret = NULL;
51         }
52         if (((u64)ret) % EHCA_PAGESIZE) {
53                 ehca_gen_err("ERROR!! not at PAGE-Boundary");
54                 return NULL;
55         }
56         return ret;
57 }
58
59 void *ipz_qeit_eq_get_inc(struct ipz_queue *queue)
60 {
61         void *ret = ipz_qeit_get(queue);
62         u64 last_entry_in_q = queue->queue_length - queue->qe_size;
63
64         queue->current_q_offset += queue->qe_size;
65         if (queue->current_q_offset > last_entry_in_q) {
66                 queue->current_q_offset = 0;
67                 queue->toggle_state = (~queue->toggle_state) & 1;
68         }
69
70         return ret;
71 }
72
73 int ipz_queue_ctor(struct ipz_queue *queue,
74                    const u32 nr_of_pages,
75                    const u32 pagesize, const u32 qe_size, const u32 nr_of_sg)
76 {
77         int pages_per_kpage = PAGE_SIZE >> EHCA_PAGESHIFT;
78         int f;
79
80         if (pagesize > PAGE_SIZE) {
81                 ehca_gen_err("FATAL ERROR: pagesize=%x is greater "
82                              "than kernel page size", pagesize);
83                 return 0;
84         }
85         if (!pages_per_kpage) {
86                 ehca_gen_err("FATAL ERROR: invalid kernel page size. "
87                              "pages_per_kpage=%x", pages_per_kpage);
88                 return 0;
89         }
90         queue->queue_length = nr_of_pages * pagesize;
91         queue->queue_pages = vmalloc(nr_of_pages * sizeof(void *));
92         if (!queue->queue_pages) {
93                 ehca_gen_err("ERROR!! didn't get the memory");
94                 return 0;
95         }
96         memset(queue->queue_pages, 0, nr_of_pages * sizeof(void *));
97         /*
98          * allocate pages for queue:
99          * outer loop allocates whole kernel pages (page aligned) and
100          * inner loop divides a kernel page into smaller hca queue pages
101          */
102         f = 0;
103         while (f < nr_of_pages) {
104                 u8 *kpage = (u8*)get_zeroed_page(GFP_KERNEL);
105                 int k;
106                 if (!kpage)
107                         goto ipz_queue_ctor_exit0; /*NOMEM*/
108                 for (k = 0; k < pages_per_kpage && f < nr_of_pages; k++) {
109                         (queue->queue_pages)[f] = (struct ipz_page *)kpage;
110                         kpage += EHCA_PAGESIZE;
111                         f++;
112                 }
113         }
114
115         queue->current_q_offset = 0;
116         queue->qe_size = qe_size;
117         queue->act_nr_of_sg = nr_of_sg;
118         queue->pagesize = pagesize;
119         queue->toggle_state = 1;
120         return 1;
121
122  ipz_queue_ctor_exit0:
123         ehca_gen_err("Couldn't get alloc pages queue=%p f=%x nr_of_pages=%x",
124                      queue, f, nr_of_pages);
125         for (f = 0; f < nr_of_pages; f += pages_per_kpage) {
126                 if (!(queue->queue_pages)[f])
127                         break;
128                 free_page((unsigned long)(queue->queue_pages)[f]);
129         }
130         return 0;
131 }
132
133 int ipz_queue_dtor(struct ipz_queue *queue)
134 {
135         int pages_per_kpage = PAGE_SIZE >> EHCA_PAGESHIFT;
136         int g;
137         int nr_pages;
138
139         if (!queue || !queue->queue_pages) {
140                 ehca_gen_dbg("queue or queue_pages is NULL");
141                 return 0;
142         }
143         nr_pages = queue->queue_length / queue->pagesize;
144         for (g = 0; g < nr_pages; g += pages_per_kpage)
145                 free_page((unsigned long)(queue->queue_pages)[g]);
146         vfree(queue->queue_pages);
147
148         return 1;
149 }