2 * Copyright 2008-2010 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
5 * This program is free software; you may redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
9 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/types.h>
23 #include <linux/pci.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
31 static int vnic_rq_alloc_bufs(struct vnic_rq
*rq
)
33 struct vnic_rq_buf
*buf
;
34 unsigned int i
, j
, count
= rq
->ring
.desc_count
;
35 unsigned int blks
= VNIC_RQ_BUF_BLKS_NEEDED(count
);
37 for (i
= 0; i
< blks
; i
++) {
38 rq
->bufs
[i
] = kzalloc(VNIC_RQ_BUF_BLK_SZ(count
), GFP_KERNEL
);
43 for (i
= 0; i
< blks
; i
++) {
45 for (j
= 0; j
< VNIC_RQ_BUF_BLK_ENTRIES(count
); j
++) {
46 buf
->index
= i
* VNIC_RQ_BUF_BLK_ENTRIES(count
) + j
;
47 buf
->desc
= (u8
*)rq
->ring
.descs
+
48 rq
->ring
.desc_size
* buf
->index
;
49 if (buf
->index
+ 1 == count
) {
50 buf
->next
= rq
->bufs
[0];
52 } else if (j
+ 1 == VNIC_RQ_BUF_BLK_ENTRIES(count
)) {
53 buf
->next
= rq
->bufs
[i
+ 1];
61 rq
->to_use
= rq
->to_clean
= rq
->bufs
[0];
66 void vnic_rq_free(struct vnic_rq
*rq
)
68 struct vnic_dev
*vdev
;
73 vnic_dev_free_desc_ring(vdev
, &rq
->ring
);
75 for (i
= 0; i
< VNIC_RQ_BUF_BLKS_MAX
; i
++) {
85 int vnic_rq_alloc(struct vnic_dev
*vdev
, struct vnic_rq
*rq
, unsigned int index
,
86 unsigned int desc_count
, unsigned int desc_size
)
93 rq
->ctrl
= vnic_dev_get_res(vdev
, RES_TYPE_RQ
, index
);
95 vdev_err(vdev
, "Failed to hook RQ[%d] resource\n", index
);
101 err
= vnic_dev_alloc_desc_ring(vdev
, &rq
->ring
, desc_count
, desc_size
);
105 err
= vnic_rq_alloc_bufs(rq
);
114 static void vnic_rq_init_start(struct vnic_rq
*rq
, unsigned int cq_index
,
115 unsigned int fetch_index
, unsigned int posted_index
,
116 unsigned int error_interrupt_enable
,
117 unsigned int error_interrupt_offset
)
120 unsigned int count
= rq
->ring
.desc_count
;
122 paddr
= (u64
)rq
->ring
.base_addr
| VNIC_PADDR_TARGET
;
123 writeq(paddr
, &rq
->ctrl
->ring_base
);
124 iowrite32(count
, &rq
->ctrl
->ring_size
);
125 iowrite32(cq_index
, &rq
->ctrl
->cq_index
);
126 iowrite32(error_interrupt_enable
, &rq
->ctrl
->error_interrupt_enable
);
127 iowrite32(error_interrupt_offset
, &rq
->ctrl
->error_interrupt_offset
);
128 iowrite32(0, &rq
->ctrl
->dropped_packet_count
);
129 iowrite32(0, &rq
->ctrl
->error_status
);
130 iowrite32(fetch_index
, &rq
->ctrl
->fetch_index
);
131 iowrite32(posted_index
, &rq
->ctrl
->posted_index
);
133 rq
->to_use
= rq
->to_clean
=
134 &rq
->bufs
[fetch_index
/ VNIC_RQ_BUF_BLK_ENTRIES(count
)]
135 [fetch_index
% VNIC_RQ_BUF_BLK_ENTRIES(count
)];
138 void vnic_rq_init(struct vnic_rq
*rq
, unsigned int cq_index
,
139 unsigned int error_interrupt_enable
,
140 unsigned int error_interrupt_offset
)
142 vnic_rq_init_start(rq
, cq_index
, 0, 0, error_interrupt_enable
,
143 error_interrupt_offset
);
146 unsigned int vnic_rq_error_status(struct vnic_rq
*rq
)
148 return ioread32(&rq
->ctrl
->error_status
);
151 void vnic_rq_enable(struct vnic_rq
*rq
)
153 iowrite32(1, &rq
->ctrl
->enable
);
156 int vnic_rq_disable(struct vnic_rq
*rq
)
159 struct vnic_dev
*vdev
= rq
->vdev
;
162 /* Due to a race condition with clearing RQ "mini-cache" in hw, we need
163 * to disable the RQ twice to guarantee that stale descriptors are not
164 * used when this RQ is re-enabled.
166 for (i
= 0; i
< 2; i
++) {
167 iowrite32(0, &rq
->ctrl
->enable
);
169 /* Wait for HW to ACK disable request */
170 for (wait
= 20000; wait
> 0; wait
--)
171 if (!ioread32(&rq
->ctrl
->running
))
174 vdev_neterr(vdev
, "Failed to disable RQ[%d]\n",
184 void vnic_rq_clean(struct vnic_rq
*rq
,
185 void (*buf_clean
)(struct vnic_rq
*rq
, struct vnic_rq_buf
*buf
))
187 struct vnic_rq_buf
*buf
;
189 unsigned int count
= rq
->ring
.desc_count
;
194 for (i
= 0; i
< rq
->ring
.desc_count
; i
++) {
195 (*buf_clean
)(rq
, buf
);
198 rq
->ring
.desc_avail
= rq
->ring
.desc_count
- 1;
200 /* Use current fetch_index as the ring starting point */
201 fetch_index
= ioread32(&rq
->ctrl
->fetch_index
);
203 if (fetch_index
== 0xFFFFFFFF) { /* check for hardware gone */
204 /* Hardware surprise removal: reset fetch_index */
207 rq
->to_use
= rq
->to_clean
=
208 &rq
->bufs
[fetch_index
/ VNIC_RQ_BUF_BLK_ENTRIES(count
)]
209 [fetch_index
% VNIC_RQ_BUF_BLK_ENTRIES(count
)];
210 iowrite32(fetch_index
, &rq
->ctrl
->posted_index
);
212 /* Anytime we write fetch_index, we need to re-write 0 to rq->enable
213 * to re-sync internal VIC state.
215 iowrite32(0, &rq
->ctrl
->enable
);
217 vnic_dev_clear_desc_ring(&rq
->ring
);