1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /* Copyright © 2003-2011 Emulex. All rights reserved. */
23
24 /*
25 * Source file containing the Receive Path handling
26 * functions
27 */
28 #include <oce_impl.h>
29
30
31 void oce_rx_pool_free(char *arg);
32 static void oce_rqb_dtor(oce_rq_bdesc_t *rqbd);
33 static int oce_rqb_ctor(oce_rq_bdesc_t *rqbd, struct oce_rq *rq,
34 size_t size, int flags);
35
36 static inline mblk_t *oce_rx(struct oce_dev *dev, struct oce_rq *rq,
37 struct oce_nic_rx_cqe *cqe);
38 static inline mblk_t *oce_rx_bcopy(struct oce_dev *dev,
39 struct oce_rq *rq, struct oce_nic_rx_cqe *cqe);
40 static int oce_rq_charge(struct oce_rq *rq, uint32_t nbufs, boolean_t repost);
41 static void oce_rx_insert_tag(mblk_t *mp, uint16_t vtag);
42 static void oce_set_rx_oflags(mblk_t *mp, struct oce_nic_rx_cqe *cqe);
43 static inline void oce_rx_drop_pkt(struct oce_rq *rq,
44 struct oce_nic_rx_cqe *cqe);
45 static oce_rq_bdesc_t *oce_rqb_alloc(struct oce_rq *rq);
46 static void oce_rqb_free(struct oce_rq *rq, oce_rq_bdesc_t *rqbd);
47 static void oce_rq_post_buffer(struct oce_rq *rq, int nbufs);
48
49 #pragma inline(oce_rx)
50 #pragma inline(oce_rx_bcopy)
51 #pragma inline(oce_rq_charge)
52 #pragma inline(oce_rx_insert_tag)
53 #pragma inline(oce_set_rx_oflags)
54 #pragma inline(oce_rx_drop_pkt)
55 #pragma inline(oce_rqb_alloc)
56 #pragma inline(oce_rqb_free)
57 #pragma inline(oce_rq_post_buffer)
58
59 static ddi_dma_attr_t oce_rx_buf_attr = {
60 DMA_ATTR_V0, /* version number */
61 0x0000000000000000ull, /* low address */
62 0xFFFFFFFFFFFFFFFFull, /* high address */
63 0x00000000FFFFFFFFull, /* dma counter max */
64 OCE_DMA_ALIGNMENT, /* alignment */
65 0x000007FF, /* burst sizes */
66 0x00000001, /* minimum transfer size */
67 0x00000000FFFFFFFFull, /* maximum transfer size */
68 0xFFFFFFFFFFFFFFFFull, /* maximum segment size */
69 1, /* scatter/gather list length */
70 0x00000001, /* granularity */
71 DDI_DMA_FLAGERR|DDI_DMA_RELAXED_ORDERING /* DMA flags */
72 };
73
74 /*
75 * function to create a DMA buffer pool for RQ
76 *
77 * dev - software handle to the device
78 * num_items - number of buffers in the pool
79 * item_size - size of each buffer
80 *
81 * return DDI_SUCCESS => success, DDI_FAILURE otherwise
82 */
83 int
84 oce_rqb_cache_create(struct oce_rq *rq, size_t buf_size)
85 {
86 int size;
87 int cnt;
88 int ret;
89 oce_rq_bdesc_t *rqbd;
90
91 _NOTE(ARGUNUSED(buf_size));
92 rqbd = rq->rq_bdesc_array;
93 size = rq->cfg.frag_size + OCE_RQE_BUF_HEADROOM;
94 for (cnt = 0; cnt < rq->cfg.nbufs; cnt++, rqbd++) {
95 rq->rqb_freelist[cnt] = rqbd;
96 ret = oce_rqb_ctor(rqbd, rq,
97 size, (DDI_DMA_RDWR|DDI_DMA_STREAMING));
98 if (ret != DDI_SUCCESS) {
99 goto rqb_fail;
100 }
101 }
102 rq->rqb_free = rq->cfg.nbufs;
103 rq->rqb_rc_head = 0;
104 rq->rqb_next_free = 0;
105 return (DDI_SUCCESS);
106
107 rqb_fail:
108 oce_rqb_cache_destroy(rq);
109 return (DDI_FAILURE);
110 } /* oce_rqb_cache_create */
111
112 /*
113 * function to Destroy RQ DMA buffer cache
114 *
115 * rq - pointer to rq structure
116 *
117 * return none
118 */
119 void
120 oce_rqb_cache_destroy(struct oce_rq *rq)
121 {
122 oce_rq_bdesc_t *rqbd = NULL;
123 int cnt;
124
125 rqbd = rq->rq_bdesc_array;
126 for (cnt = 0; cnt < rq->cfg.nbufs; cnt++, rqbd++) {
127 oce_rqb_dtor(rqbd);
128 }
129 } /* oce_rqb_cache_destroy */
130
131 /*
132 * RQ buffer destructor function
133 *
134 * rqbd - pointer to rq buffer descriptor
135 *
136 * return none
137 */
138 static void
139 oce_rqb_dtor(oce_rq_bdesc_t *rqbd)
140 {
141 if ((rqbd == NULL) || (rqbd->rq == NULL)) {
142 return;
143 }
144 if (rqbd->mp != NULL) {
145 rqbd->fr_rtn.free_arg = NULL;
146 freemsg(rqbd->mp);
147 rqbd->mp = NULL;
148 }
149 oce_free_dma_buffer(rqbd->rq->parent, rqbd->rqb);
150 } /* oce_rqb_dtor */
151
152 /*
153 * RQ buffer constructor function
154 *
155 * rqbd - pointer to rq buffer descriptor
156 * rq - pointer to RQ structure
157 * size - size of the buffer
158 * flags - KM_SLEEP OR KM_NOSLEEP
159 *
160 * return DDI_SUCCESS => success, DDI_FAILURE otherwise
161 */
162 static int
163 oce_rqb_ctor(oce_rq_bdesc_t *rqbd, struct oce_rq *rq, size_t size, int flags)
164 {
165 struct oce_dev *dev;
166 oce_dma_buf_t *dbuf;
167
168 dev = rq->parent;
169
170 dbuf = oce_alloc_dma_buffer(dev, size, &oce_rx_buf_attr, flags);
171 if (dbuf == NULL) {
172 return (DDI_FAILURE);
173 }
174
175 /* Set the call back function parameters */
176 rqbd->fr_rtn.free_func = (void (*)())oce_rx_pool_free;
177 rqbd->fr_rtn.free_arg = (caddr_t)(void *)rqbd;
178 rqbd->mp = desballoc((uchar_t *)(dbuf->base),
179 dbuf->size, 0, &rqbd->fr_rtn);
180 if (rqbd->mp == NULL) {
181 oce_free_dma_buffer(dev, dbuf);
182 return (DDI_FAILURE);
183 }
184 rqbd->rqb = dbuf;
185 rqbd->rq = rq;
186 rqbd->frag_addr.dw.addr_lo = ADDR_LO(dbuf->addr + OCE_RQE_BUF_HEADROOM);
187 rqbd->frag_addr.dw.addr_hi = ADDR_HI(dbuf->addr + OCE_RQE_BUF_HEADROOM);
188 rqbd->mp->b_rptr = (uchar_t *)rqbd->rqb->base + OCE_RQE_BUF_HEADROOM;
189
190 return (DDI_SUCCESS);
191 } /* oce_rqb_ctor */
192
193 /*
194 * RQ buffer allocator function
195 *
196 * rq - pointer to RQ structure
197 *
198 * return pointer to RQ buffer descriptor
199 */
200 static inline oce_rq_bdesc_t *
201 oce_rqb_alloc(struct oce_rq *rq)
202 {
203 oce_rq_bdesc_t *rqbd;
204 uint32_t free_index;
205 free_index = rq->rqb_next_free;
206 rqbd = rq->rqb_freelist[free_index];
207 rq->rqb_freelist[free_index] = NULL;
208 rq->rqb_next_free = GET_Q_NEXT(free_index, 1, rq->cfg.nbufs);
209 return (rqbd);
210 } /* oce_rqb_alloc */
211
212 /*
213 * function to free the RQ buffer
214 *
215 * rq - pointer to RQ structure
216 * rqbd - pointer to recieve buffer descriptor
217 *
218 * return none
219 */
220 static inline void
221 oce_rqb_free(struct oce_rq *rq, oce_rq_bdesc_t *rqbd)
222 {
223 uint32_t free_index;
224 mutex_enter(&rq->rc_lock);
225 free_index = rq->rqb_rc_head;
226 rq->rqb_freelist[free_index] = rqbd;
227 rq->rqb_rc_head = GET_Q_NEXT(free_index, 1, rq->cfg.nbufs);
228 mutex_exit(&rq->rc_lock);
229 atomic_add_32(&rq->rqb_free, 1);
230 } /* oce_rqb_free */
231
232
233
234
235 static void oce_rq_post_buffer(struct oce_rq *rq, int nbufs)
236 {
237 pd_rxulp_db_t rxdb_reg;
238 int count;
239 struct oce_dev *dev = rq->parent;
240
241
242 rxdb_reg.dw0 = 0;
243 rxdb_reg.bits.qid = rq->rq_id & DB_RQ_ID_MASK;
244
245 for (count = nbufs/OCE_MAX_RQ_POSTS; count > 0; count--) {
246 rxdb_reg.bits.num_posted = OCE_MAX_RQ_POSTS;
247 OCE_DB_WRITE32(dev, PD_RXULP_DB, rxdb_reg.dw0);
248 rq->buf_avail += OCE_MAX_RQ_POSTS;
249 nbufs -= OCE_MAX_RQ_POSTS;
250 }
251 if (nbufs > 0) {
252 rxdb_reg.bits.num_posted = nbufs;
253 OCE_DB_WRITE32(dev, PD_RXULP_DB, rxdb_reg.dw0);
254 rq->buf_avail += nbufs;
255 }
256 }
257 /*
258 * function to charge a given rq with buffers from a pool's free list
259 *
260 * dev - software handle to the device
261 * rq - pointer to the RQ to charge
262 * nbufs - numbers of buffers to be charged
263 *
264 * return number of rqe's charges.
265 */
266 static inline int
267 oce_rq_charge(struct oce_rq *rq, uint32_t nbufs, boolean_t repost)
268 {
269 struct oce_nic_rqe *rqe;
270 oce_rq_bdesc_t *rqbd;
271 oce_rq_bdesc_t **shadow_rq;
272 int cnt;
273 int cur_index;
274 oce_ring_buffer_t *ring;
275
276 shadow_rq = rq->shadow_ring;
277 ring = rq->ring;
278 cur_index = ring->cidx;
279
280 for (cnt = 0; cnt < nbufs; cnt++) {
281 if (!repost) {
282 rqbd = oce_rqb_alloc(rq);
283 } else {
284 /* just repost the buffers from shadow ring */
285 rqbd = shadow_rq[cur_index];
286 cur_index = GET_Q_NEXT(cur_index, 1, ring->num_items);
287 }
288 /* fill the rqes */
289 rqe = RING_GET_PRODUCER_ITEM_VA(rq->ring,
290 struct oce_nic_rqe);
291 rqe->u0.s.frag_pa_lo = rqbd->frag_addr.dw.addr_lo;
292 rqe->u0.s.frag_pa_hi = rqbd->frag_addr.dw.addr_hi;
293 shadow_rq[rq->ring->pidx] = rqbd;
294 DW_SWAP(u32ptr(rqe), sizeof (struct oce_nic_rqe));
295 RING_PUT(rq->ring, 1);
296 }
297
298 return (cnt);
299 } /* oce_rq_charge */
300
301 /*
302 * function to release the posted buffers
303 *
304 * rq - pointer to the RQ to charge
305 *
306 * return none
307 */
308 void
309 oce_rq_discharge(struct oce_rq *rq)
310 {
311 oce_rq_bdesc_t *rqbd;
312 oce_rq_bdesc_t **shadow_rq;
313
314 shadow_rq = rq->shadow_ring;
315 /* Free the posted buffer since RQ is destroyed already */
316 while ((int32_t)rq->buf_avail > 0) {
317 rqbd = shadow_rq[rq->ring->cidx];
318 oce_rqb_free(rq, rqbd);
319 RING_GET(rq->ring, 1);
320 rq->buf_avail--;
321 }
322 }
323 /*
324 * function to process a single packet
325 *
326 * dev - software handle to the device
327 * rq - pointer to the RQ to charge
328 * cqe - Pointer to Completion Q entry
329 *
330 * return mblk pointer => success, NULL => error
331 */
332 static inline mblk_t *
333 oce_rx(struct oce_dev *dev, struct oce_rq *rq, struct oce_nic_rx_cqe *cqe)
334 {
335 mblk_t *mp;
336 int pkt_len;
337 int32_t frag_cnt = 0;
338 mblk_t **mblk_tail;
339 mblk_t *mblk_head;
340 int frag_size;
341 oce_rq_bdesc_t *rqbd;
342 uint16_t cur_index;
343 oce_ring_buffer_t *ring;
344 int i;
345
346 frag_cnt = cqe->u0.s.num_fragments & 0x7;
347 mblk_head = NULL;
348 mblk_tail = &mblk_head;
349
350 ring = rq->ring;
351 cur_index = ring->cidx;
352
353 /* Get the relevant Queue pointers */
354 pkt_len = cqe->u0.s.pkt_size;
355 for (i = 0; i < frag_cnt; i++) {
356 rqbd = rq->shadow_ring[cur_index];
357 if (rqbd->mp == NULL) {
358 rqbd->mp = desballoc((uchar_t *)rqbd->rqb->base,
359 rqbd->rqb->size, 0, &rqbd->fr_rtn);
360 if (rqbd->mp == NULL) {
361 return (NULL);
362 }
363
364 rqbd->mp->b_rptr =
365 (uchar_t *)rqbd->rqb->base + OCE_RQE_BUF_HEADROOM;
366 }
367
368 mp = rqbd->mp;
369 frag_size = (pkt_len > rq->cfg.frag_size) ?
370 rq->cfg.frag_size : pkt_len;
371 mp->b_wptr = mp->b_rptr + frag_size;
372 pkt_len -= frag_size;
373 mp->b_next = mp->b_cont = NULL;
374 /* Chain the message mblks */
375 *mblk_tail = mp;
376 mblk_tail = &mp->b_cont;
377 (void) DBUF_SYNC(rqbd->rqb, DDI_DMA_SYNC_FORCPU);
378 cur_index = GET_Q_NEXT(cur_index, 1, ring->num_items);
379 }
380
381 if (mblk_head == NULL) {
382 oce_log(dev, CE_WARN, MOD_RX, "%s", "oce_rx:no frags?");
383 return (NULL);
384 }
385
386 /* replace the buffer with new ones */
387 (void) oce_rq_charge(rq, frag_cnt, B_FALSE);
388 atomic_add_32(&rq->pending, frag_cnt);
389 return (mblk_head);
390 } /* oce_rx */
391
392 static inline mblk_t *
393 oce_rx_bcopy(struct oce_dev *dev, struct oce_rq *rq, struct oce_nic_rx_cqe *cqe)
394 {
395 mblk_t *mp;
396 int pkt_len;
397 int alloc_len;
398 int32_t frag_cnt = 0;
399 int frag_size;
400 oce_rq_bdesc_t *rqbd;
401 unsigned char *rptr;
402 uint32_t cur_index;
403 oce_ring_buffer_t *ring;
404 oce_rq_bdesc_t **shadow_rq;
405 int cnt = 0;
406
407 _NOTE(ARGUNUSED(dev));
408
409 shadow_rq = rq->shadow_ring;
410 pkt_len = cqe->u0.s.pkt_size;
411 alloc_len = pkt_len + OCE_RQE_BUF_HEADROOM;
412 frag_cnt = cqe->u0.s.num_fragments & 0x7;
413
414 mp = allocb(alloc_len, BPRI_HI);
415 if (mp == NULL) {
416 return (NULL);
417 }
418
419 mp->b_rptr += OCE_RQE_BUF_HEADROOM;
420 rptr = mp->b_rptr;
421 mp->b_wptr = mp->b_rptr + pkt_len;
422 ring = rq->ring;
423
424 cur_index = ring->cidx;
425 for (cnt = 0; cnt < frag_cnt; cnt++) {
426 rqbd = shadow_rq[cur_index];
427 frag_size = (pkt_len > rq->cfg.frag_size) ?
428 rq->cfg.frag_size : pkt_len;
429 (void) DBUF_SYNC(rqbd->rqb, DDI_DMA_SYNC_FORCPU);
430 bcopy(rqbd->rqb->base + OCE_RQE_BUF_HEADROOM, rptr, frag_size);
431 rptr += frag_size;
432 pkt_len -= frag_size;
433 cur_index = GET_Q_NEXT(cur_index, 1, ring->num_items);
434 }
435 (void) oce_rq_charge(rq, frag_cnt, B_TRUE);
436 return (mp);
437 }
438
439 static inline void
440 oce_set_rx_oflags(mblk_t *mp, struct oce_nic_rx_cqe *cqe)
441 {
442 int csum_flags = 0;
443
444 /* set flags */
445 if (cqe->u0.s.ip_cksum_pass) {
446 csum_flags |= HCK_IPV4_HDRCKSUM_OK;
447 }
448
449 if (cqe->u0.s.l4_cksum_pass) {
450 csum_flags |= (HCK_FULLCKSUM | HCK_FULLCKSUM_OK);
451 }
452
453 if (csum_flags) {
454 (void) mac_hcksum_set(mp, 0, 0, 0, 0, csum_flags);
455 }
456 }
457
458 static inline void
459 oce_rx_insert_tag(mblk_t *mp, uint16_t vtag)
460 {
461 struct ether_vlan_header *ehp;
462
463 (void) memmove(mp->b_rptr - VTAG_SIZE,
464 mp->b_rptr, 2 * ETHERADDRL);
465 mp->b_rptr -= VTAG_SIZE;
466 ehp = (struct ether_vlan_header *)voidptr(mp->b_rptr);
467 ehp->ether_tpid = htons(ETHERTYPE_VLAN);
468 ehp->ether_tci = LE_16(vtag);
469 }
470
471 static inline void
472 oce_rx_drop_pkt(struct oce_rq *rq, struct oce_nic_rx_cqe *cqe)
473 {
474 int frag_cnt;
475 oce_rq_bdesc_t *rqbd;
476 oce_rq_bdesc_t **shadow_rq;
477 shadow_rq = rq->shadow_ring;
478 for (frag_cnt = 0; frag_cnt < cqe->u0.s.num_fragments; frag_cnt++) {
479 rqbd = shadow_rq[rq->ring->cidx];
480 oce_rqb_free(rq, rqbd);
481 RING_GET(rq->ring, 1);
482 }
483 }
484
485
486 /*
487 * function to process a Recieve queue
488 *
489 * arg - pointer to the RQ to charge
490 *
491 * return number of cqes processed
492 */
493 uint16_t
494 oce_drain_rq_cq(void *arg)
495 {
496 struct oce_nic_rx_cqe *cqe;
497 struct oce_rq *rq;
498 mblk_t *mp = NULL;
499 mblk_t *mblk_head;
500 mblk_t **mblk_tail;
501 uint16_t num_cqe = 0;
502 struct oce_cq *cq;
503 struct oce_dev *dev;
504 int32_t frag_cnt;
505 uint32_t nbufs = 0;
506
507 rq = (struct oce_rq *)arg;
508 dev = rq->parent;
509 cq = rq->cq;
510 mblk_head = NULL;
511 mblk_tail = &mblk_head;
512
513 cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring, struct oce_nic_rx_cqe);
514
515 (void) DBUF_SYNC(cq->ring->dbuf, DDI_DMA_SYNC_FORKERNEL);
516 /* dequeue till you reach an invalid cqe */
517 while (RQ_CQE_VALID(cqe)) {
518 DW_SWAP(u32ptr(cqe), sizeof (struct oce_nic_rx_cqe));
519 frag_cnt = cqe->u0.s.num_fragments & 0x7;
520 /* if insufficient buffers to charge then do copy */
521 if ((cqe->u0.s.pkt_size < dev->rx_bcopy_limit) ||
522 (oce_atomic_reserve(&rq->rqb_free, frag_cnt) < 0)) {
523 mp = oce_rx_bcopy(dev, rq, cqe);
524 } else {
525 mp = oce_rx(dev, rq, cqe);
526 if (mp == NULL) {
527 atomic_add_32(&rq->rqb_free, frag_cnt);
528 mp = oce_rx_bcopy(dev, rq, cqe);
529 }
530 }
531 if (mp != NULL) {
532 if (dev->function_mode & FLEX10_MODE) {
533 if (cqe->u0.s.vlan_tag_present &&
534 cqe->u0.s.qnq) {
535 oce_rx_insert_tag(mp,
536 cqe->u0.s.vlan_tag);
537 }
538 } else if (cqe->u0.s.vlan_tag_present) {
539 oce_rx_insert_tag(mp, cqe->u0.s.vlan_tag);
540 }
541 oce_set_rx_oflags(mp, cqe);
542
543 *mblk_tail = mp;
544 mblk_tail = &mp->b_next;
545 } else {
546 (void) oce_rq_charge(rq, frag_cnt, B_TRUE);
547 }
548 RING_GET(rq->ring, frag_cnt);
549 rq->buf_avail -= frag_cnt;
550 nbufs += frag_cnt;
551
552 oce_rq_post_buffer(rq, frag_cnt);
553 RQ_CQE_INVALIDATE(cqe);
554 RING_GET(cq->ring, 1);
555 cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring,
556 struct oce_nic_rx_cqe);
557 num_cqe++;
558 /* process max ring size */
559 if (num_cqe > dev->rx_pkt_per_intr) {
560 break;
561 }
562 } /* for all valid CQEs */
563
564 if (mblk_head) {
565 mac_rx(dev->mac_handle, NULL, mblk_head);
566 }
567 oce_arm_cq(dev, cq->cq_id, num_cqe, B_TRUE);
568 return (num_cqe);
569 } /* oce_drain_rq_cq */
570
571 /*
572 * function to free mblk databuffer to the RQ pool
573 *
574 * arg - pointer to the receive buffer descriptor
575 *
576 * return none
577 */
578 void
579 oce_rx_pool_free(char *arg)
580 {
581 oce_rq_bdesc_t *rqbd;
582 struct oce_rq *rq;
583
584 /* During destroy, arg will be NULL */
585 if (arg == NULL) {
586 return;
587 }
588
589 /* retrieve the pointers from arg */
590 rqbd = (oce_rq_bdesc_t *)(void *)arg;
591 rq = rqbd->rq;
592 rqbd->mp = desballoc((uchar_t *)rqbd->rqb->base,
593 rqbd->rqb->size, 0, &rqbd->fr_rtn);
594
595 if (rqbd->mp) {
596 rqbd->mp->b_rptr =
597 (uchar_t *)rqbd->rqb->base + OCE_RQE_BUF_HEADROOM;
598 }
599
600 oce_rqb_free(rq, rqbd);
601 (void) atomic_add_32(&rq->pending, -1);
602 } /* rx_pool_free */
603
604 /*
605 * function to stop the RX
606 *
607 * rq - pointer to RQ structure
608 *
609 * return none
610 */
611 void
612 oce_clean_rq(struct oce_rq *rq)
613 {
614 uint16_t num_cqe = 0;
615 struct oce_cq *cq;
616 struct oce_dev *dev;
617 struct oce_nic_rx_cqe *cqe;
618 int32_t ti = 0;
619
620 dev = rq->parent;
621 cq = rq->cq;
622 cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring, struct oce_nic_rx_cqe);
623 /* dequeue till you reach an invalid cqe */
624 for (ti = 0; ti < DEFAULT_DRAIN_TIME; ti++) {
625
626 while (RQ_CQE_VALID(cqe)) {
627 DW_SWAP(u32ptr(cqe), sizeof (struct oce_nic_rx_cqe));
628 oce_rx_drop_pkt(rq, cqe);
629 atomic_add_32(&rq->buf_avail,
630 -(cqe->u0.s.num_fragments & 0x7));
631 oce_arm_cq(dev, cq->cq_id, 1, B_TRUE);
632 RQ_CQE_INVALIDATE(cqe);
633 RING_GET(cq->ring, 1);
634 cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring,
635 struct oce_nic_rx_cqe);
636 num_cqe++;
637 }
638 OCE_MSDELAY(1);
639 }
640 } /* oce_clean_rq */
641
642 /*
643 * function to start the RX
644 *
645 * rq - pointer to RQ structure
646 *
647 * return number of rqe's charges.
648 */
649 int
650 oce_start_rq(struct oce_rq *rq)
651 {
652 int ret = 0;
653 int to_charge = 0;
654 struct oce_dev *dev = rq->parent;
655 to_charge = rq->cfg.q_len - rq->buf_avail;
656 to_charge = min(to_charge, rq->rqb_free);
657 atomic_add_32(&rq->rqb_free, -to_charge);
658 (void) oce_rq_charge(rq, to_charge, B_FALSE);
659 /* ok to do it here since Rx has not even started */
660 oce_rq_post_buffer(rq, to_charge);
661 oce_arm_cq(dev, rq->cq->cq_id, 0, B_TRUE);
662 return (ret);
663 } /* oce_start_rq */
664
665 /* Checks for pending rx buffers with Stack */
666 int
667 oce_rx_pending(struct oce_dev *dev, struct oce_rq *rq, int32_t timeout)
668 {
669 int ti;
670 _NOTE(ARGUNUSED(dev));
671
672 for (ti = 0; ti < timeout; ti++) {
673 if (rq->pending > 0) {
674 OCE_MSDELAY(10);
675 continue;
676 } else {
677 rq->pending = 0;
678 break;
679 }
680 }
681 return (rq->pending);
682 }