1 /**********************************************************************
4 * Contact: support@cavium.com
5 * Please include "LiquidIO" in the subject.
7 * Copyright (c) 2003-2016 Cavium, Inc.
9 * This file is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License, Version 2, as
11 * published by the Free Software Foundation.
13 * This file is distributed in the hope that it will be useful, but
14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
16 * NONINFRINGEMENT. See the GNU General Public License for more details.
17 ***********************************************************************/
18 #include <linux/pci.h>
19 #include <linux/netdevice.h>
20 #include <linux/vmalloc.h>
21 #include "liquidio_common.h"
22 #include "octeon_droq.h"
23 #include "octeon_iq.h"
24 #include "response_manager.h"
25 #include "octeon_device.h"
26 #include "octeon_main.h"
27 #include "octeon_network.h"
28 #include "cn66xx_regs.h"
29 #include "cn66xx_device.h"
30 #include "cn23xx_pf_device.h"
31 #include "cn23xx_vf_device.h"
34 struct list_head list;
39 struct list_head list;
40 struct octeon_recv_info *rinfo;
41 octeon_dispatch_fn_t disp_fn;
44 /** Get the argument that the user set when registering dispatch
45 * function for a given opcode/subcode.
46 * @param octeon_dev - the octeon device pointer.
47 * @param opcode - the opcode for which the dispatch argument
49 * @param subcode - the subcode for which the dispatch argument
51 * @return Success: void * (argument to the dispatch function)
52 * @return Failure: NULL
55 void *octeon_get_dispatch_arg(struct octeon_device *octeon_dev,
56 u16 opcode, u16 subcode)
59 struct list_head *dispatch;
61 u16 combined_opcode = OPCODE_SUBCODE(opcode, subcode);
63 idx = combined_opcode & OCTEON_OPCODE_MASK;
65 spin_lock_bh(&octeon_dev->dispatch.lock);
67 if (octeon_dev->dispatch.count == 0) {
68 spin_unlock_bh(&octeon_dev->dispatch.lock);
72 if (octeon_dev->dispatch.dlist[idx].opcode == combined_opcode) {
73 fn_arg = octeon_dev->dispatch.dlist[idx].arg;
75 list_for_each(dispatch,
76 &octeon_dev->dispatch.dlist[idx].list) {
77 if (((struct octeon_dispatch *)dispatch)->opcode ==
79 fn_arg = ((struct octeon_dispatch *)
86 spin_unlock_bh(&octeon_dev->dispatch.lock);
90 /** Check for packets on Droq. This function should be called with lock held.
91 * @param droq - Droq on which count is checked.
92 * @return Returns packet count.
94 u32 octeon_droq_check_hw_for_pkts(struct octeon_droq *droq)
99 pkt_count = readl(droq->pkts_sent_reg);
101 last_count = pkt_count - droq->pkt_count;
102 droq->pkt_count = pkt_count;
104 /* we shall write to cnts at napi irq enable or end of droq tasklet */
106 atomic_add(last_count, &droq->pkts_pending);
111 static void octeon_droq_compute_max_packet_bufs(struct octeon_droq *droq)
115 /* max_empty_descs is the max. no. of descs that can have no buffers.
116 * If the empty desc count goes beyond this value, we cannot safely
117 * read in a 64K packet sent by Octeon
118 * (64K is max pkt size from Octeon)
120 droq->max_empty_descs = 0;
123 droq->max_empty_descs++;
124 count += droq->buffer_size;
125 } while (count < (64 * 1024));
127 droq->max_empty_descs = droq->max_count - droq->max_empty_descs;
130 static void octeon_droq_reset_indices(struct octeon_droq *droq)
134 droq->refill_idx = 0;
135 droq->refill_count = 0;
136 atomic_set(&droq->pkts_pending, 0);
140 octeon_droq_destroy_ring_buffers(struct octeon_device *oct,
141 struct octeon_droq *droq)
144 struct octeon_skb_page_info *pg_info;
146 for (i = 0; i < droq->max_count; i++) {
147 pg_info = &droq->recv_buf_list[i].pg_info;
152 lio_unmap_ring(oct->pci_dev,
157 recv_buffer_destroy(droq->recv_buf_list[i].buffer,
160 droq->recv_buf_list[i].buffer = NULL;
163 octeon_droq_reset_indices(droq);
167 octeon_droq_setup_ring_buffers(struct octeon_device *oct,
168 struct octeon_droq *droq)
172 struct octeon_droq_desc *desc_ring = droq->desc_ring;
174 for (i = 0; i < droq->max_count; i++) {
175 buf = recv_buffer_alloc(oct, &droq->recv_buf_list[i].pg_info);
178 dev_err(&oct->pci_dev->dev, "%s buffer alloc failed\n",
180 droq->stats.rx_alloc_failure++;
184 droq->recv_buf_list[i].buffer = buf;
185 droq->recv_buf_list[i].data = get_rbd(buf);
186 desc_ring[i].info_ptr = 0;
187 desc_ring[i].buffer_ptr =
188 lio_map_ring(droq->recv_buf_list[i].buffer);
191 octeon_droq_reset_indices(droq);
193 octeon_droq_compute_max_packet_bufs(droq);
198 int octeon_delete_droq(struct octeon_device *oct, u32 q_no)
200 struct octeon_droq *droq = oct->droq[q_no];
202 dev_dbg(&oct->pci_dev->dev, "%s[%d]\n", __func__, q_no);
204 octeon_droq_destroy_ring_buffers(oct, droq);
205 vfree(droq->recv_buf_list);
208 lio_dma_free(oct, (droq->max_count * OCT_DROQ_DESC_SIZE),
209 droq->desc_ring, droq->desc_ring_dma);
211 memset(droq, 0, OCT_DROQ_SIZE);
212 oct->io_qmask.oq &= ~(1ULL << q_no);
213 vfree(oct->droq[q_no]);
214 oct->droq[q_no] = NULL;
220 int octeon_init_droq(struct octeon_device *oct,
226 struct octeon_droq *droq;
227 u32 desc_ring_size = 0, c_num_descs = 0, c_buf_size = 0;
228 u32 c_pkts_per_intr = 0, c_refill_threshold = 0;
229 int numa_node = dev_to_node(&oct->pci_dev->dev);
231 dev_dbg(&oct->pci_dev->dev, "%s[%d]\n", __func__, q_no);
233 droq = oct->droq[q_no];
234 memset(droq, 0, OCT_DROQ_SIZE);
239 droq->app_ctx = app_ctx;
241 droq->app_ctx = (void *)(size_t)q_no;
243 c_num_descs = num_descs;
244 c_buf_size = desc_size;
245 if (OCTEON_CN6XXX(oct)) {
246 struct octeon_config *conf6x = CHIP_CONF(oct, cn6xxx);
248 c_pkts_per_intr = (u32)CFG_GET_OQ_PKTS_PER_INTR(conf6x);
250 (u32)CFG_GET_OQ_REFILL_THRESHOLD(conf6x);
251 } else if (OCTEON_CN23XX_PF(oct)) {
252 struct octeon_config *conf23 = CHIP_CONF(oct, cn23xx_pf);
254 c_pkts_per_intr = (u32)CFG_GET_OQ_PKTS_PER_INTR(conf23);
255 c_refill_threshold = (u32)CFG_GET_OQ_REFILL_THRESHOLD(conf23);
256 } else if (OCTEON_CN23XX_VF(oct)) {
257 struct octeon_config *conf23 = CHIP_CONF(oct, cn23xx_vf);
259 c_pkts_per_intr = (u32)CFG_GET_OQ_PKTS_PER_INTR(conf23);
260 c_refill_threshold = (u32)CFG_GET_OQ_REFILL_THRESHOLD(conf23);
265 droq->max_count = c_num_descs;
266 droq->buffer_size = c_buf_size;
268 desc_ring_size = droq->max_count * OCT_DROQ_DESC_SIZE;
269 droq->desc_ring = lio_dma_alloc(oct, desc_ring_size,
270 (dma_addr_t *)&droq->desc_ring_dma);
272 if (!droq->desc_ring) {
273 dev_err(&oct->pci_dev->dev,
274 "Output queue %d ring alloc failed\n", q_no);
278 dev_dbg(&oct->pci_dev->dev, "droq[%d]: desc_ring: virt: 0x%p, dma: %lx\n",
279 q_no, droq->desc_ring, droq->desc_ring_dma);
280 dev_dbg(&oct->pci_dev->dev, "droq[%d]: num_desc: %d\n", q_no,
283 droq->recv_buf_list = (struct octeon_recv_buffer *)
284 vzalloc_node(droq->max_count *
285 OCT_DROQ_RECVBUF_SIZE,
287 if (!droq->recv_buf_list)
288 droq->recv_buf_list = (struct octeon_recv_buffer *)
289 vzalloc(array_size(droq->max_count,
290 OCT_DROQ_RECVBUF_SIZE));
291 if (!droq->recv_buf_list) {
292 dev_err(&oct->pci_dev->dev, "Output queue recv buf list alloc failed\n");
296 if (octeon_droq_setup_ring_buffers(oct, droq))
299 droq->pkts_per_intr = c_pkts_per_intr;
300 droq->refill_threshold = c_refill_threshold;
302 dev_dbg(&oct->pci_dev->dev, "DROQ INIT: max_empty_descs: %d\n",
303 droq->max_empty_descs);
305 spin_lock_init(&droq->lock);
307 INIT_LIST_HEAD(&droq->dispatch_list);
309 /* For 56xx Pass1, this function won't be called, so no checks. */
310 oct->fn_list.setup_oq_regs(oct, q_no);
312 oct->io_qmask.oq |= BIT_ULL(q_no);
317 octeon_delete_droq(oct, q_no);
321 /* octeon_create_recv_info
323 * octeon_dev - pointer to the octeon device structure
324 * droq - droq in which the packet arrived.
325 * buf_cnt - no. of buffers used by the packet.
326 * idx - index in the descriptor for the first buffer in the packet.
328 * Allocates a recv_info_t and copies the buffer addresses for packet data
329 * into the recv_pkt space which starts at an 8B offset from recv_info_t.
330 * Flags the descriptors for refill later. If available descriptors go
331 * below the threshold to receive a 64K pkt, new buffers are first allocated
332 * before the recv_pkt_t is created.
333 * This routine will be called in interrupt context.
335 * Success: Pointer to recv_info_t
338 * The droq->lock is held when this routine is called.
340 static inline struct octeon_recv_info *octeon_create_recv_info(
341 struct octeon_device *octeon_dev,
342 struct octeon_droq *droq,
346 struct octeon_droq_info *info;
347 struct octeon_recv_pkt *recv_pkt;
348 struct octeon_recv_info *recv_info;
350 struct octeon_skb_page_info *pg_info;
352 info = (struct octeon_droq_info *)droq->recv_buf_list[idx].data;
354 recv_info = octeon_alloc_recv_info(sizeof(struct __dispatch));
358 recv_pkt = recv_info->recv_pkt;
359 recv_pkt->rh = info->rh;
360 recv_pkt->length = (u32)info->length;
361 recv_pkt->buffer_count = (u16)buf_cnt;
362 recv_pkt->octeon_id = (u16)octeon_dev->octeon_id;
365 bytes_left = (u32)info->length;
369 pg_info = &droq->recv_buf_list[idx].pg_info;
371 lio_unmap_ring(octeon_dev->pci_dev,
373 pg_info->page = NULL;
377 recv_pkt->buffer_size[i] =
379 droq->buffer_size) ? droq->buffer_size : bytes_left;
381 recv_pkt->buffer_ptr[i] = droq->recv_buf_list[idx].buffer;
382 droq->recv_buf_list[idx].buffer = NULL;
384 idx = incr_index(idx, 1, droq->max_count);
385 bytes_left -= droq->buffer_size;
393 /* If we were not able to refill all buffers, try to move around
394 * the buffers that were not dispatched.
397 octeon_droq_refill_pullup_descs(struct octeon_droq *droq,
398 struct octeon_droq_desc *desc_ring)
400 u32 desc_refilled = 0;
402 u32 refill_index = droq->refill_idx;
404 while (refill_index != droq->read_idx) {
405 if (droq->recv_buf_list[refill_index].buffer) {
406 droq->recv_buf_list[droq->refill_idx].buffer =
407 droq->recv_buf_list[refill_index].buffer;
408 droq->recv_buf_list[droq->refill_idx].data =
409 droq->recv_buf_list[refill_index].data;
410 desc_ring[droq->refill_idx].buffer_ptr =
411 desc_ring[refill_index].buffer_ptr;
412 droq->recv_buf_list[refill_index].buffer = NULL;
413 desc_ring[refill_index].buffer_ptr = 0;
415 droq->refill_idx = incr_index(droq->refill_idx,
419 droq->refill_count--;
420 } while (droq->recv_buf_list[droq->refill_idx].buffer);
422 refill_index = incr_index(refill_index, 1, droq->max_count);
424 return desc_refilled;
427 /* octeon_droq_refill
429 * droq - droq in which descriptors require new buffers.
431 * Called during normal DROQ processing in interrupt mode or by the poll
432 * thread to refill the descriptors from which buffers were dispatched
433 * to upper layers. Attempts to allocate new buffers. If that fails, moves
434 * up buffers (that were not dispatched) to form a contiguous ring.
436 * No of descriptors refilled.
438 * This routine is called with droq->lock held.
441 octeon_droq_refill(struct octeon_device *octeon_dev, struct octeon_droq *droq)
443 struct octeon_droq_desc *desc_ring;
446 u32 desc_refilled = 0;
447 struct octeon_skb_page_info *pg_info;
449 desc_ring = droq->desc_ring;
451 while (droq->refill_count && (desc_refilled < droq->max_count)) {
452 /* If a valid buffer exists (happens if there is no dispatch),
454 * the buffer, else allocate.
456 if (!droq->recv_buf_list[droq->refill_idx].buffer) {
458 &droq->recv_buf_list[droq->refill_idx].pg_info;
459 /* Either recycle the existing pages or go for
463 buf = recv_buffer_reuse(octeon_dev, pg_info);
465 buf = recv_buffer_alloc(octeon_dev, pg_info);
466 /* If a buffer could not be allocated, no point in
470 droq->stats.rx_alloc_failure++;
473 droq->recv_buf_list[droq->refill_idx].buffer =
477 data = get_rbd(droq->recv_buf_list
478 [droq->refill_idx].buffer);
481 droq->recv_buf_list[droq->refill_idx].data = data;
483 desc_ring[droq->refill_idx].buffer_ptr =
484 lio_map_ring(droq->recv_buf_list[
485 droq->refill_idx].buffer);
487 droq->refill_idx = incr_index(droq->refill_idx, 1,
490 droq->refill_count--;
493 if (droq->refill_count)
495 octeon_droq_refill_pullup_descs(droq, desc_ring);
497 /* if droq->refill_count
498 * The refill count would not change in pass two. We only moved buffers
499 * to close the gap in the ring, but we would still have the same no. of
502 return desc_refilled;
505 /** check if we can allocate packets to get out of oom.
506 * @param droq - Droq being checked.
507 * @return does not return anything
509 void octeon_droq_check_oom(struct octeon_droq *droq)
512 struct octeon_device *oct = droq->oct_dev;
514 if (readl(droq->pkts_credit_reg) <= CN23XX_SLI_DEF_BP) {
515 spin_lock_bh(&droq->lock);
516 desc_refilled = octeon_droq_refill(oct, droq);
518 /* Flush the droq descriptor data to memory to be sure
519 * that when we update the credits the data in memory
523 writel(desc_refilled, droq->pkts_credit_reg);
524 /* make sure mmio write completes */
527 spin_unlock_bh(&droq->lock);
532 octeon_droq_get_bufcount(u32 buf_size, u32 total_len)
534 return ((total_len + buf_size - 1) / buf_size);
538 octeon_droq_dispatch_pkt(struct octeon_device *oct,
539 struct octeon_droq *droq,
541 struct octeon_droq_info *info)
544 octeon_dispatch_fn_t disp_fn;
545 struct octeon_recv_info *rinfo;
547 cnt = octeon_droq_get_bufcount(droq->buffer_size, (u32)info->length);
549 disp_fn = octeon_get_dispatch(oct, (u16)rh->r.opcode,
552 rinfo = octeon_create_recv_info(oct, droq, cnt, droq->read_idx);
554 struct __dispatch *rdisp = rinfo->rsvd;
556 rdisp->rinfo = rinfo;
557 rdisp->disp_fn = disp_fn;
558 rinfo->recv_pkt->rh = *rh;
559 list_add_tail(&rdisp->list,
560 &droq->dispatch_list);
562 droq->stats.dropped_nomem++;
565 dev_err(&oct->pci_dev->dev, "DROQ: No dispatch function (opcode %u/%u)\n",
566 (unsigned int)rh->r.opcode,
567 (unsigned int)rh->r.subcode);
568 droq->stats.dropped_nodispatch++;
574 static inline void octeon_droq_drop_packets(struct octeon_device *oct,
575 struct octeon_droq *droq,
579 struct octeon_droq_info *info;
581 for (i = 0; i < cnt; i++) {
582 info = (struct octeon_droq_info *)
583 droq->recv_buf_list[droq->read_idx].data;
584 octeon_swap_8B_data((u64 *)info, 2);
587 info->length += OCTNET_FRM_LENGTH_SIZE;
588 droq->stats.bytes_received += info->length;
589 buf_cnt = octeon_droq_get_bufcount(droq->buffer_size,
592 dev_err(&oct->pci_dev->dev, "DROQ: In drop: pkt with len 0\n");
596 droq->read_idx = incr_index(droq->read_idx, buf_cnt,
598 droq->refill_count += buf_cnt;
603 octeon_droq_fast_process_packets(struct octeon_device *oct,
604 struct octeon_droq *droq,
607 struct octeon_droq_info *info;
609 u32 pkt, total_len = 0, pkt_count;
611 pkt_count = pkts_to_process;
613 for (pkt = 0; pkt < pkt_count; pkt++) {
615 struct sk_buff *nicbuf = NULL;
616 struct octeon_skb_page_info *pg_info;
619 info = (struct octeon_droq_info *)
620 droq->recv_buf_list[droq->read_idx].data;
621 octeon_swap_8B_data((u64 *)info, 2);
624 dev_err(&oct->pci_dev->dev,
625 "DROQ[%d] idx: %d len:0, pkt_cnt: %d\n",
626 droq->q_no, droq->read_idx, pkt_count);
627 print_hex_dump_bytes("", DUMP_PREFIX_ADDRESS,
633 /* Len of resp hdr in included in the received data len. */
636 info->length += OCTNET_FRM_LENGTH_SIZE;
637 rh->r_dh.len += (ROUNDUP8(OCT_DROQ_INFO_SIZE) / sizeof(u64));
638 total_len += (u32)info->length;
639 if (opcode_slow_path(rh)) {
642 buf_cnt = octeon_droq_dispatch_pkt(oct, droq, rh, info);
643 droq->read_idx = incr_index(droq->read_idx,
644 buf_cnt, droq->max_count);
645 droq->refill_count += buf_cnt;
647 if (info->length <= droq->buffer_size) {
648 pkt_len = (u32)info->length;
649 nicbuf = droq->recv_buf_list[
650 droq->read_idx].buffer;
651 pg_info = &droq->recv_buf_list[
652 droq->read_idx].pg_info;
653 if (recv_buffer_recycle(oct, pg_info))
654 pg_info->page = NULL;
655 droq->recv_buf_list[droq->read_idx].buffer =
658 droq->read_idx = incr_index(droq->read_idx, 1,
660 droq->refill_count++;
662 nicbuf = octeon_fast_packet_alloc((u32)
665 /* nicbuf allocation can fail. We'll handle it
668 while (pkt_len < info->length) {
669 int cpy_len, idx = droq->read_idx;
671 cpy_len = ((pkt_len + droq->buffer_size)
673 ((u32)info->length - pkt_len) :
677 octeon_fast_packet_next(droq,
681 buf = droq->recv_buf_list[
683 recv_buffer_fast_free(buf);
684 droq->recv_buf_list[idx].buffer
687 droq->stats.rx_alloc_failure++;
692 incr_index(droq->read_idx, 1,
694 droq->refill_count++;
699 if (droq->ops.fptr) {
700 droq->ops.fptr(oct->octeon_id,
705 recv_buffer_free(nicbuf);
710 if (droq->refill_count >= droq->refill_threshold) {
711 int desc_refilled = octeon_droq_refill(oct, droq);
713 /* Flush the droq descriptor data to memory to be sure
714 * that when we update the credits the data in memory
718 writel((desc_refilled), droq->pkts_credit_reg);
719 /* make sure mmio write completes */
723 } /* for (each packet)... */
725 /* Increment refill_count by the number of buffers processed. */
726 droq->stats.pkts_received += pkt;
727 droq->stats.bytes_received += total_len;
729 if ((droq->ops.drop_on_max) && (pkts_to_process - pkt)) {
730 octeon_droq_drop_packets(oct, droq, (pkts_to_process - pkt));
732 droq->stats.dropped_toomany += (pkts_to_process - pkt);
733 return pkts_to_process;
740 octeon_droq_process_packets(struct octeon_device *oct,
741 struct octeon_droq *droq,
744 u32 pkt_count = 0, pkts_processed = 0;
745 struct list_head *tmp, *tmp2;
747 /* Grab the droq lock */
748 spin_lock(&droq->lock);
750 octeon_droq_check_hw_for_pkts(droq);
751 pkt_count = atomic_read(&droq->pkts_pending);
754 spin_unlock(&droq->lock);
758 if (pkt_count > budget)
761 pkts_processed = octeon_droq_fast_process_packets(oct, droq, pkt_count);
763 atomic_sub(pkts_processed, &droq->pkts_pending);
765 /* Release the spin lock */
766 spin_unlock(&droq->lock);
768 list_for_each_safe(tmp, tmp2, &droq->dispatch_list) {
769 struct __dispatch *rdisp = (struct __dispatch *)tmp;
772 rdisp->disp_fn(rdisp->rinfo,
773 octeon_get_dispatch_arg
775 (u16)rdisp->rinfo->recv_pkt->rh.r.opcode,
776 (u16)rdisp->rinfo->recv_pkt->rh.r.subcode));
779 /* If there are packets pending. schedule tasklet again */
780 if (atomic_read(&droq->pkts_pending))
787 * Utility function to poll for packets. check_hw_for_packets must be
788 * called before calling this routine.
792 octeon_droq_process_poll_pkts(struct octeon_device *oct,
793 struct octeon_droq *droq, u32 budget)
795 struct list_head *tmp, *tmp2;
796 u32 pkts_available = 0, pkts_processed = 0;
797 u32 total_pkts_processed = 0;
799 if (budget > droq->max_count)
800 budget = droq->max_count;
802 spin_lock(&droq->lock);
804 while (total_pkts_processed < budget) {
805 octeon_droq_check_hw_for_pkts(droq);
807 pkts_available = min((budget - total_pkts_processed),
808 (u32)(atomic_read(&droq->pkts_pending)));
810 if (pkts_available == 0)
814 octeon_droq_fast_process_packets(oct, droq,
817 atomic_sub(pkts_processed, &droq->pkts_pending);
819 total_pkts_processed += pkts_processed;
822 spin_unlock(&droq->lock);
824 list_for_each_safe(tmp, tmp2, &droq->dispatch_list) {
825 struct __dispatch *rdisp = (struct __dispatch *)tmp;
828 rdisp->disp_fn(rdisp->rinfo,
829 octeon_get_dispatch_arg
831 (u16)rdisp->rinfo->recv_pkt->rh.r.opcode,
832 (u16)rdisp->rinfo->recv_pkt->rh.r.subcode));
835 return total_pkts_processed;
838 /* Enable Pkt Interrupt */
840 octeon_enable_irq(struct octeon_device *oct, u32 q_no)
842 switch (oct->chip_id) {
844 case OCTEON_CN68XX: {
845 struct octeon_cn6xxx *cn6xxx =
846 (struct octeon_cn6xxx *)oct->chip;
851 (&cn6xxx->lock_for_droq_int_enb_reg, flags);
852 value = octeon_read_csr(oct, CN6XXX_SLI_PKT_TIME_INT_ENB);
853 value |= (1 << q_no);
854 octeon_write_csr(oct, CN6XXX_SLI_PKT_TIME_INT_ENB, value);
855 value = octeon_read_csr(oct, CN6XXX_SLI_PKT_CNT_INT_ENB);
856 value |= (1 << q_no);
857 octeon_write_csr(oct, CN6XXX_SLI_PKT_CNT_INT_ENB, value);
859 /* don't bother flushing the enables */
861 spin_unlock_irqrestore
862 (&cn6xxx->lock_for_droq_int_enb_reg, flags);
865 case OCTEON_CN23XX_PF_VID:
866 lio_enable_irq(oct->droq[q_no], oct->instr_queue[q_no]);
869 case OCTEON_CN23XX_VF_VID:
870 lio_enable_irq(oct->droq[q_no], oct->instr_queue[q_no]);
873 dev_err(&oct->pci_dev->dev, "%s Unknown Chip\n", __func__);
880 int octeon_register_droq_ops(struct octeon_device *oct, u32 q_no,
881 struct octeon_droq_ops *ops)
883 struct octeon_droq *droq;
885 struct octeon_config *oct_cfg = NULL;
887 oct_cfg = octeon_get_conf(oct);
893 dev_err(&oct->pci_dev->dev, "%s: droq_ops pointer is NULL\n",
898 if (q_no >= CFG_GET_OQ_MAX_Q(oct_cfg)) {
899 dev_err(&oct->pci_dev->dev, "%s: droq id (%d) exceeds MAX (%d)\n",
900 __func__, q_no, (oct->num_oqs - 1));
904 droq = oct->droq[q_no];
906 spin_lock_irqsave(&droq->lock, flags);
908 memcpy(&droq->ops, ops, sizeof(struct octeon_droq_ops));
910 spin_unlock_irqrestore(&droq->lock, flags);
915 int octeon_unregister_droq_ops(struct octeon_device *oct, u32 q_no)
918 struct octeon_droq *droq;
919 struct octeon_config *oct_cfg = NULL;
921 oct_cfg = octeon_get_conf(oct);
926 if (q_no >= CFG_GET_OQ_MAX_Q(oct_cfg)) {
927 dev_err(&oct->pci_dev->dev, "%s: droq id (%d) exceeds MAX (%d)\n",
928 __func__, q_no, oct->num_oqs - 1);
932 droq = oct->droq[q_no];
935 dev_info(&oct->pci_dev->dev,
936 "Droq id (%d) not available.\n", q_no);
940 spin_lock_irqsave(&droq->lock, flags);
942 droq->ops.fptr = NULL;
943 droq->ops.farg = NULL;
944 droq->ops.drop_on_max = 0;
946 spin_unlock_irqrestore(&droq->lock, flags);
951 int octeon_create_droq(struct octeon_device *oct,
952 u32 q_no, u32 num_descs,
953 u32 desc_size, void *app_ctx)
955 struct octeon_droq *droq;
956 int numa_node = dev_to_node(&oct->pci_dev->dev);
958 if (oct->droq[q_no]) {
959 dev_dbg(&oct->pci_dev->dev, "Droq already in use. Cannot create droq %d again\n",
964 /* Allocate the DS for the new droq. */
965 droq = vmalloc_node(sizeof(*droq), numa_node);
967 droq = vmalloc(sizeof(*droq));
971 memset(droq, 0, sizeof(struct octeon_droq));
973 /*Disable the pkt o/p for this Q */
974 octeon_set_droq_pkt_op(oct, q_no, 0);
975 oct->droq[q_no] = droq;
977 /* Initialize the Droq */
978 if (octeon_init_droq(oct, q_no, num_descs, desc_size, app_ctx)) {
979 vfree(oct->droq[q_no]);
980 oct->droq[q_no] = NULL;
986 dev_dbg(&oct->pci_dev->dev, "%s: Total number of OQ: %d\n", __func__,
989 /* Global Droq register settings */
991 /* As of now not required, as setting are done for all 32 Droqs at