]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - drivers/net/ethernet/cavium/liquidio/request_manager.c
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
18 **********************************************************************/
19 #include <linux/pci.h>
20 #include <linux/netdevice.h>
21 #include <linux/vmalloc.h>
22 #include "liquidio_common.h"
23 #include "octeon_droq.h"
24 #include "octeon_iq.h"
25 #include "response_manager.h"
26 #include "octeon_device.h"
27 #include "octeon_main.h"
28 #include "octeon_network.h"
29 #include "cn66xx_device.h"
30 #include "cn23xx_pf_device.h"
31 #include "cn23xx_vf_device.h"
33 struct iq_post_status
{
38 static void check_db_timeout(struct work_struct
*work
);
39 static void __check_db_timeout(struct octeon_device
*oct
, u64 iq_no
);
41 static void (*reqtype_free_fn
[MAX_OCTEON_DEVICES
][REQTYPE_LAST
+ 1]) (void *);
43 static inline int IQ_INSTR_MODE_64B(struct octeon_device
*oct
, int iq_no
)
45 struct octeon_instr_queue
*iq
=
46 (struct octeon_instr_queue
*)oct
->instr_queue
[iq_no
];
50 #define IQ_INSTR_MODE_32B(oct, iq_no) (!IQ_INSTR_MODE_64B(oct, iq_no))
52 /* Define this to return the request status comaptible to old code */
53 /*#define OCTEON_USE_OLD_REQ_STATUS*/
55 /* Return 0 on success, 1 on failure */
56 int octeon_init_instr_queue(struct octeon_device
*oct
,
57 union oct_txpciq txpciq
,
60 struct octeon_instr_queue
*iq
;
61 struct octeon_iq_config
*conf
= NULL
;
62 u32 iq_no
= (u32
)txpciq
.s
.q_no
;
64 struct cavium_wq
*db_wq
;
65 int numa_node
= dev_to_node(&oct
->pci_dev
->dev
);
67 if (OCTEON_CN6XXX(oct
))
68 conf
= &(CFG_GET_IQ_CFG(CHIP_CONF(oct
, cn6xxx
)));
69 else if (OCTEON_CN23XX_PF(oct
))
70 conf
= &(CFG_GET_IQ_CFG(CHIP_CONF(oct
, cn23xx_pf
)));
71 else if (OCTEON_CN23XX_VF(oct
))
72 conf
= &(CFG_GET_IQ_CFG(CHIP_CONF(oct
, cn23xx_vf
)));
75 dev_err(&oct
->pci_dev
->dev
, "Unsupported Chip %x\n",
80 q_size
= (u32
)conf
->instr_type
* num_descs
;
82 iq
= oct
->instr_queue
[iq_no
];
86 iq
->base_addr
= lio_dma_alloc(oct
, q_size
, &iq
->base_addr_dma
);
88 dev_err(&oct
->pci_dev
->dev
, "Cannot allocate memory for instr queue %d\n",
93 iq
->max_count
= num_descs
;
95 /* Initialize a list to holds requests that have been posted to Octeon
96 * but has yet to be fetched by octeon
98 iq
->request_list
= vmalloc_node((sizeof(*iq
->request_list
) * num_descs
),
100 if (!iq
->request_list
)
101 iq
->request_list
= vmalloc(sizeof(*iq
->request_list
) *
103 if (!iq
->request_list
) {
104 lio_dma_free(oct
, q_size
, iq
->base_addr
, iq
->base_addr_dma
);
105 dev_err(&oct
->pci_dev
->dev
, "Alloc failed for IQ[%d] nr free list\n",
110 memset(iq
->request_list
, 0, sizeof(*iq
->request_list
) * num_descs
);
112 dev_dbg(&oct
->pci_dev
->dev
, "IQ[%d]: base: %p basedma: %llx count: %d\n",
113 iq_no
, iq
->base_addr
, iq
->base_addr_dma
, iq
->max_count
);
115 iq
->txpciq
.u64
= txpciq
.u64
;
116 iq
->fill_threshold
= (u32
)conf
->db_min
;
118 iq
->host_write_index
= 0;
119 iq
->octeon_read_index
= 0;
121 iq
->last_db_time
= 0;
122 iq
->do_auto_flush
= 1;
123 iq
->db_timeout
= (u32
)conf
->db_timeout
;
124 atomic_set(&iq
->instr_pending
, 0);
126 /* Initialize the spinlock for this instruction queue */
127 spin_lock_init(&iq
->lock
);
128 spin_lock_init(&iq
->post_lock
);
130 spin_lock_init(&iq
->iq_flush_running_lock
);
132 oct
->io_qmask
.iq
|= BIT_ULL(iq_no
);
134 /* Set the 32B/64B mode for each input queue */
135 oct
->io_qmask
.iq64B
|= ((conf
->instr_type
== 64) << iq_no
);
136 iq
->iqcmd_64B
= (conf
->instr_type
== 64);
138 oct
->fn_list
.setup_iq_regs(oct
, iq_no
);
140 oct
->check_db_wq
[iq_no
].wq
= alloc_workqueue("check_iq_db",
143 if (!oct
->check_db_wq
[iq_no
].wq
) {
144 vfree(iq
->request_list
);
145 iq
->request_list
= NULL
;
146 lio_dma_free(oct
, q_size
, iq
->base_addr
, iq
->base_addr_dma
);
147 dev_err(&oct
->pci_dev
->dev
, "check db wq create failed for iq %d\n",
152 db_wq
= &oct
->check_db_wq
[iq_no
];
154 INIT_DELAYED_WORK(&db_wq
->wk
.work
, check_db_timeout
);
155 db_wq
->wk
.ctxptr
= oct
;
156 db_wq
->wk
.ctxul
= iq_no
;
157 queue_delayed_work(db_wq
->wq
, &db_wq
->wk
.work
, msecs_to_jiffies(1));
162 int octeon_delete_instr_queue(struct octeon_device
*oct
, u32 iq_no
)
164 u64 desc_size
= 0, q_size
;
165 struct octeon_instr_queue
*iq
= oct
->instr_queue
[iq_no
];
167 cancel_delayed_work_sync(&oct
->check_db_wq
[iq_no
].wk
.work
);
168 destroy_workqueue(oct
->check_db_wq
[iq_no
].wq
);
170 if (OCTEON_CN6XXX(oct
))
172 CFG_GET_IQ_INSTR_TYPE(CHIP_CONF(oct
, cn6xxx
));
173 else if (OCTEON_CN23XX_PF(oct
))
175 CFG_GET_IQ_INSTR_TYPE(CHIP_CONF(oct
, cn23xx_pf
));
176 else if (OCTEON_CN23XX_VF(oct
))
178 CFG_GET_IQ_INSTR_TYPE(CHIP_CONF(oct
, cn23xx_vf
));
180 vfree(iq
->request_list
);
183 q_size
= iq
->max_count
* desc_size
;
184 lio_dma_free(oct
, (u32
)q_size
, iq
->base_addr
,
186 oct
->io_qmask
.iq
&= ~(1ULL << iq_no
);
187 vfree(oct
->instr_queue
[iq_no
]);
188 oct
->instr_queue
[iq_no
] = NULL
;
195 /* Return 0 on success, 1 on failure */
196 int octeon_setup_iq(struct octeon_device
*oct
,
199 union oct_txpciq txpciq
,
203 u32 iq_no
= (u32
)txpciq
.s
.q_no
;
204 int numa_node
= dev_to_node(&oct
->pci_dev
->dev
);
206 if (oct
->instr_queue
[iq_no
]) {
207 dev_dbg(&oct
->pci_dev
->dev
, "IQ is in use. Cannot create the IQ: %d again\n",
209 oct
->instr_queue
[iq_no
]->txpciq
.u64
= txpciq
.u64
;
210 oct
->instr_queue
[iq_no
]->app_ctx
= app_ctx
;
213 oct
->instr_queue
[iq_no
] =
214 vmalloc_node(sizeof(struct octeon_instr_queue
), numa_node
);
215 if (!oct
->instr_queue
[iq_no
])
216 oct
->instr_queue
[iq_no
] =
217 vmalloc(sizeof(struct octeon_instr_queue
));
218 if (!oct
->instr_queue
[iq_no
])
221 memset(oct
->instr_queue
[iq_no
], 0,
222 sizeof(struct octeon_instr_queue
));
224 oct
->instr_queue
[iq_no
]->q_index
= q_index
;
225 oct
->instr_queue
[iq_no
]->app_ctx
= app_ctx
;
226 oct
->instr_queue
[iq_no
]->ifidx
= ifidx
;
228 if (octeon_init_instr_queue(oct
, txpciq
, num_descs
)) {
229 vfree(oct
->instr_queue
[iq_no
]);
230 oct
->instr_queue
[iq_no
] = NULL
;
235 if (oct
->fn_list
.enable_io_queues(oct
))
241 int lio_wait_for_instr_fetch(struct octeon_device
*oct
)
243 int i
, retry
= 1000, pending
, instr_cnt
= 0;
248 for (i
= 0; i
< MAX_OCTEON_INSTR_QUEUES(oct
); i
++) {
249 if (!(oct
->io_qmask
.iq
& BIT_ULL(i
)))
252 atomic_read(&oct
->instr_queue
[i
]->instr_pending
);
254 __check_db_timeout(oct
, i
);
255 instr_cnt
+= pending
;
261 schedule_timeout_uninterruptible(1);
263 } while (retry
-- && instr_cnt
);
269 ring_doorbell(struct octeon_device
*oct
, struct octeon_instr_queue
*iq
)
271 if (atomic_read(&oct
->status
) == OCT_DEV_RUNNING
) {
272 writel(iq
->fill_cnt
, iq
->doorbell_reg
);
273 /* make sure doorbell write goes through */
276 iq
->last_db_time
= jiffies
;
282 octeon_ring_doorbell_locked(struct octeon_device
*oct
, u32 iq_no
)
284 struct octeon_instr_queue
*iq
;
286 iq
= oct
->instr_queue
[iq_no
];
287 spin_lock(&iq
->post_lock
);
289 ring_doorbell(oct
, iq
);
290 spin_unlock(&iq
->post_lock
);
293 static inline void __copy_cmd_into_iq(struct octeon_instr_queue
*iq
,
298 cmdsize
= ((iq
->iqcmd_64B
) ? 64 : 32);
299 iqptr
= iq
->base_addr
+ (cmdsize
* iq
->host_write_index
);
301 memcpy(iqptr
, cmd
, cmdsize
);
304 static inline struct iq_post_status
305 __post_command2(struct octeon_instr_queue
*iq
, u8
*cmd
)
307 struct iq_post_status st
;
309 st
.status
= IQ_SEND_OK
;
311 /* This ensures that the read index does not wrap around to the same
312 * position if queue gets full before Octeon could fetch any instr.
314 if (atomic_read(&iq
->instr_pending
) >= (s32
)(iq
->max_count
- 1)) {
315 st
.status
= IQ_SEND_FAILED
;
320 if (atomic_read(&iq
->instr_pending
) >= (s32
)(iq
->max_count
- 2))
321 st
.status
= IQ_SEND_STOP
;
323 __copy_cmd_into_iq(iq
, cmd
);
325 /* "index" is returned, host_write_index is modified. */
326 st
.index
= iq
->host_write_index
;
327 iq
->host_write_index
= incr_index(iq
->host_write_index
, 1,
331 /* Flush the command into memory. We need to be sure the data is in
332 * memory before indicating that the instruction is pending.
336 atomic_inc(&iq
->instr_pending
);
342 octeon_register_reqtype_free_fn(struct octeon_device
*oct
, int reqtype
,
345 if (reqtype
> REQTYPE_LAST
) {
346 dev_err(&oct
->pci_dev
->dev
, "%s: Invalid reqtype: %d\n",
351 reqtype_free_fn
[oct
->octeon_id
][reqtype
] = fn
;
357 __add_to_request_list(struct octeon_instr_queue
*iq
,
358 int idx
, void *buf
, int reqtype
)
360 iq
->request_list
[idx
].buf
= buf
;
361 iq
->request_list
[idx
].reqtype
= reqtype
;
364 /* Can only run in process context */
366 lio_process_iq_request_list(struct octeon_device
*oct
,
367 struct octeon_instr_queue
*iq
, u32 napi_budget
)
369 struct cavium_wq
*cwq
= &oct
->dma_comp_wq
;
372 u32 old
= iq
->flush_index
;
374 unsigned int pkts_compl
= 0, bytes_compl
= 0;
375 struct octeon_soft_command
*sc
;
376 struct octeon_instr_irh
*irh
;
379 while (old
!= iq
->octeon_read_index
) {
380 reqtype
= iq
->request_list
[old
].reqtype
;
381 buf
= iq
->request_list
[old
].buf
;
383 if (reqtype
== REQTYPE_NONE
)
386 octeon_update_tx_completion_counters(buf
, reqtype
, &pkts_compl
,
390 case REQTYPE_NORESP_NET
:
391 case REQTYPE_NORESP_NET_SG
:
392 case REQTYPE_RESP_NET_SG
:
393 reqtype_free_fn
[oct
->octeon_id
][reqtype
](buf
);
395 case REQTYPE_RESP_NET
:
396 case REQTYPE_SOFT_COMMAND
:
399 if (OCTEON_CN23XX_PF(oct
) || OCTEON_CN23XX_VF(oct
))
400 irh
= (struct octeon_instr_irh
*)
403 irh
= (struct octeon_instr_irh
*)
406 /* We're expecting a response from Octeon.
407 * It's up to lio_process_ordered_list() to
408 * process sc. Add sc to the ordered soft
409 * command response list because we expect
410 * a response from Octeon.
414 [OCTEON_ORDERED_SC_LIST
].lock
,
416 atomic_inc(&oct
->response_list
417 [OCTEON_ORDERED_SC_LIST
].
419 list_add_tail(&sc
->node
, &oct
->response_list
420 [OCTEON_ORDERED_SC_LIST
].head
);
421 spin_unlock_irqrestore
423 [OCTEON_ORDERED_SC_LIST
].lock
,
427 /* This callback must not sleep */
428 sc
->callback(oct
, OCTEON_REQUEST_DONE
,
434 dev_err(&oct
->pci_dev
->dev
,
435 "%s Unknown reqtype: %d buf: %p at idx %d\n",
436 __func__
, reqtype
, buf
, old
);
439 iq
->request_list
[old
].buf
= NULL
;
440 iq
->request_list
[old
].reqtype
= 0;
444 old
= incr_index(old
, 1, iq
->max_count
);
446 if ((napi_budget
) && (inst_count
>= napi_budget
))
450 octeon_report_tx_completion_to_bql(iq
->app_ctx
, pkts_compl
,
452 iq
->flush_index
= old
;
454 if (atomic_read(&oct
->response_list
455 [OCTEON_ORDERED_SC_LIST
].pending_req_count
))
456 queue_delayed_work(cwq
->wq
, &cwq
->wk
.work
, msecs_to_jiffies(1));
461 /* Can only be called from process context */
463 octeon_flush_iq(struct octeon_device
*oct
, struct octeon_instr_queue
*iq
,
466 u32 inst_processed
= 0;
467 u32 tot_inst_processed
= 0;
470 if (!spin_trylock(&iq
->iq_flush_running_lock
))
473 spin_lock_bh(&iq
->lock
);
475 iq
->octeon_read_index
= oct
->fn_list
.update_iq_read_idx(iq
);
478 /* Process any outstanding IQ packets. */
479 if (iq
->flush_index
== iq
->octeon_read_index
)
484 lio_process_iq_request_list(oct
, iq
,
489 lio_process_iq_request_list(oct
, iq
, 0);
491 if (inst_processed
) {
492 atomic_sub(inst_processed
, &iq
->instr_pending
);
493 iq
->stats
.instr_processed
+= inst_processed
;
496 tot_inst_processed
+= inst_processed
;
497 } while (tot_inst_processed
< napi_budget
);
499 if (napi_budget
&& (tot_inst_processed
>= napi_budget
))
502 iq
->last_db_time
= jiffies
;
504 spin_unlock_bh(&iq
->lock
);
506 spin_unlock(&iq
->iq_flush_running_lock
);
511 /* Process instruction queue after timeout.
512 * This routine gets called from a workqueue or when removing the module.
514 static void __check_db_timeout(struct octeon_device
*oct
, u64 iq_no
)
516 struct octeon_instr_queue
*iq
;
522 iq
= oct
->instr_queue
[iq_no
];
526 /* return immediately, if no work pending */
527 if (!atomic_read(&iq
->instr_pending
))
529 /* If jiffies - last_db_time < db_timeout do nothing */
530 next_time
= iq
->last_db_time
+ iq
->db_timeout
;
531 if (!time_after(jiffies
, (unsigned long)next_time
))
533 iq
->last_db_time
= jiffies
;
535 /* Flush the instruction queue */
536 octeon_flush_iq(oct
, iq
, 0);
538 lio_enable_irq(NULL
, iq
);
541 /* Called by the Poll thread at regular intervals to check the instruction
542 * queue for commands to be posted and for commands that were fetched by Octeon.
544 static void check_db_timeout(struct work_struct
*work
)
546 struct cavium_wk
*wk
= (struct cavium_wk
*)work
;
547 struct octeon_device
*oct
= (struct octeon_device
*)wk
->ctxptr
;
548 u64 iq_no
= wk
->ctxul
;
549 struct cavium_wq
*db_wq
= &oct
->check_db_wq
[iq_no
];
552 __check_db_timeout(oct
, iq_no
);
553 queue_delayed_work(db_wq
->wq
, &db_wq
->wk
.work
, msecs_to_jiffies(delay
));
557 octeon_send_command(struct octeon_device
*oct
, u32 iq_no
,
558 u32 force_db
, void *cmd
, void *buf
,
559 u32 datasize
, u32 reqtype
)
562 struct iq_post_status st
;
563 struct octeon_instr_queue
*iq
= oct
->instr_queue
[iq_no
];
565 /* Get the lock and prevent other tasks and tx interrupt handler from
568 spin_lock_bh(&iq
->post_lock
);
570 st
= __post_command2(iq
, cmd
);
572 if (st
.status
!= IQ_SEND_FAILED
) {
573 xmit_stopped
= octeon_report_sent_bytes_to_bql(buf
, reqtype
);
574 __add_to_request_list(iq
, st
.index
, buf
, reqtype
);
575 INCR_INSTRQUEUE_PKT_COUNT(oct
, iq_no
, bytes_sent
, datasize
);
576 INCR_INSTRQUEUE_PKT_COUNT(oct
, iq_no
, instr_posted
, 1);
578 if (iq
->fill_cnt
>= MAX_OCTEON_FILL_COUNT
|| force_db
||
579 xmit_stopped
|| st
.status
== IQ_SEND_STOP
)
580 ring_doorbell(oct
, iq
);
582 INCR_INSTRQUEUE_PKT_COUNT(oct
, iq_no
, instr_dropped
, 1);
585 spin_unlock_bh(&iq
->post_lock
);
587 /* This is only done here to expedite packets being flushed
588 * for cases where there are no IQ completion interrupts.
595 octeon_prepare_soft_command(struct octeon_device
*oct
,
596 struct octeon_soft_command
*sc
,
603 struct octeon_config
*oct_cfg
;
604 struct octeon_instr_ih2
*ih2
;
605 struct octeon_instr_ih3
*ih3
;
606 struct octeon_instr_pki_ih3
*pki_ih3
;
607 struct octeon_instr_irh
*irh
;
608 struct octeon_instr_rdp
*rdp
;
610 WARN_ON(opcode
> 15);
611 WARN_ON(subcode
> 127);
613 oct_cfg
= octeon_get_conf(oct
);
615 if (OCTEON_CN23XX_PF(oct
) || OCTEON_CN23XX_VF(oct
)) {
616 ih3
= (struct octeon_instr_ih3
*)&sc
->cmd
.cmd3
.ih3
;
618 ih3
->pkind
= oct
->instr_queue
[sc
->iq_no
]->txpciq
.s
.pkind
;
620 pki_ih3
= (struct octeon_instr_pki_ih3
*)&sc
->cmd
.cmd3
.pki_ih3
;
626 oct
->instr_queue
[sc
->iq_no
]->txpciq
.s
.use_qpg
;
628 pki_ih3
->tag
= LIO_CONTROL
;
629 pki_ih3
->tagtype
= ATOMIC_TAG
;
631 oct
->instr_queue
[sc
->iq_no
]->txpciq
.s
.ctrl_qpg
;
637 ih3
->dlengsz
= sc
->datasize
;
639 irh
= (struct octeon_instr_irh
*)&sc
->cmd
.cmd3
.irh
;
640 irh
->opcode
= opcode
;
641 irh
->subcode
= subcode
;
643 /* opcode/subcode specific parameters (ossp) */
644 irh
->ossp
= irh_ossp
;
645 sc
->cmd
.cmd3
.ossp
[0] = ossp0
;
646 sc
->cmd
.cmd3
.ossp
[1] = ossp1
;
649 rdp
= (struct octeon_instr_rdp
*)&sc
->cmd
.cmd3
.rdp
;
650 rdp
->pcie_port
= oct
->pcie_port
;
651 rdp
->rlen
= sc
->rdatasize
;
655 /* pki_ih3 irh+ossp[0]+ossp[1]+rdp+rptr = 48 bytes */
656 ih3
->fsz
= LIO_SOFTCMDRESP_IH3
;
660 /* pki_h3 + irh + ossp[0] + ossp[1] = 32 bytes */
661 ih3
->fsz
= LIO_PCICMD_O3
;
665 ih2
= (struct octeon_instr_ih2
*)&sc
->cmd
.cmd2
.ih2
;
666 ih2
->tagtype
= ATOMIC_TAG
;
667 ih2
->tag
= LIO_CONTROL
;
669 ih2
->grp
= CFG_GET_CTRL_Q_GRP(oct_cfg
);
672 ih2
->dlengsz
= sc
->datasize
;
676 irh
= (struct octeon_instr_irh
*)&sc
->cmd
.cmd2
.irh
;
677 irh
->opcode
= opcode
;
678 irh
->subcode
= subcode
;
680 /* opcode/subcode specific parameters (ossp) */
681 irh
->ossp
= irh_ossp
;
682 sc
->cmd
.cmd2
.ossp
[0] = ossp0
;
683 sc
->cmd
.cmd2
.ossp
[1] = ossp1
;
686 rdp
= (struct octeon_instr_rdp
*)&sc
->cmd
.cmd2
.rdp
;
687 rdp
->pcie_port
= oct
->pcie_port
;
688 rdp
->rlen
= sc
->rdatasize
;
691 /* irh+ossp[0]+ossp[1]+rdp+rptr = 40 bytes */
692 ih2
->fsz
= LIO_SOFTCMDRESP_IH2
;
695 /* irh + ossp[0] + ossp[1] = 24 bytes */
696 ih2
->fsz
= LIO_PCICMD_O2
;
701 int octeon_send_soft_command(struct octeon_device
*oct
,
702 struct octeon_soft_command
*sc
)
704 struct octeon_instr_ih2
*ih2
;
705 struct octeon_instr_ih3
*ih3
;
706 struct octeon_instr_irh
*irh
;
709 if (OCTEON_CN23XX_PF(oct
) || OCTEON_CN23XX_VF(oct
)) {
710 ih3
= (struct octeon_instr_ih3
*)&sc
->cmd
.cmd3
.ih3
;
712 WARN_ON(!sc
->dmadptr
);
713 sc
->cmd
.cmd3
.dptr
= sc
->dmadptr
;
715 irh
= (struct octeon_instr_irh
*)&sc
->cmd
.cmd3
.irh
;
717 WARN_ON(!sc
->dmarptr
);
718 WARN_ON(!sc
->status_word
);
719 *sc
->status_word
= COMPLETION_WORD_INIT
;
720 sc
->cmd
.cmd3
.rptr
= sc
->dmarptr
;
722 len
= (u32
)ih3
->dlengsz
;
724 ih2
= (struct octeon_instr_ih2
*)&sc
->cmd
.cmd2
.ih2
;
726 WARN_ON(!sc
->dmadptr
);
727 sc
->cmd
.cmd2
.dptr
= sc
->dmadptr
;
729 irh
= (struct octeon_instr_irh
*)&sc
->cmd
.cmd2
.irh
;
731 WARN_ON(!sc
->dmarptr
);
732 WARN_ON(!sc
->status_word
);
733 *sc
->status_word
= COMPLETION_WORD_INIT
;
734 sc
->cmd
.cmd2
.rptr
= sc
->dmarptr
;
736 len
= (u32
)ih2
->dlengsz
;
740 sc
->timeout
= jiffies
+ sc
->wait_time
;
742 return (octeon_send_command(oct
, sc
->iq_no
, 1, &sc
->cmd
, sc
,
743 len
, REQTYPE_SOFT_COMMAND
));
746 int octeon_setup_sc_buffer_pool(struct octeon_device
*oct
)
750 struct octeon_soft_command
*sc
;
752 INIT_LIST_HEAD(&oct
->sc_buf_pool
.head
);
753 spin_lock_init(&oct
->sc_buf_pool
.lock
);
754 atomic_set(&oct
->sc_buf_pool
.alloc_buf_count
, 0);
756 for (i
= 0; i
< MAX_SOFT_COMMAND_BUFFERS
; i
++) {
757 sc
= (struct octeon_soft_command
*)
759 SOFT_COMMAND_BUFFER_SIZE
,
760 (dma_addr_t
*)&dma_addr
);
762 octeon_free_sc_buffer_pool(oct
);
766 sc
->dma_addr
= dma_addr
;
767 sc
->size
= SOFT_COMMAND_BUFFER_SIZE
;
769 list_add_tail(&sc
->node
, &oct
->sc_buf_pool
.head
);
775 int octeon_free_sc_buffer_pool(struct octeon_device
*oct
)
777 struct list_head
*tmp
, *tmp2
;
778 struct octeon_soft_command
*sc
;
780 spin_lock_bh(&oct
->sc_buf_pool
.lock
);
782 list_for_each_safe(tmp
, tmp2
, &oct
->sc_buf_pool
.head
) {
785 sc
= (struct octeon_soft_command
*)tmp
;
787 lio_dma_free(oct
, sc
->size
, sc
, sc
->dma_addr
);
790 INIT_LIST_HEAD(&oct
->sc_buf_pool
.head
);
792 spin_unlock_bh(&oct
->sc_buf_pool
.lock
);
797 struct octeon_soft_command
*octeon_alloc_soft_command(struct octeon_device
*oct
,
804 u32 offset
= sizeof(struct octeon_soft_command
);
805 struct octeon_soft_command
*sc
= NULL
;
806 struct list_head
*tmp
;
808 WARN_ON((offset
+ datasize
+ rdatasize
+ ctxsize
) >
809 SOFT_COMMAND_BUFFER_SIZE
);
811 spin_lock_bh(&oct
->sc_buf_pool
.lock
);
813 if (list_empty(&oct
->sc_buf_pool
.head
)) {
814 spin_unlock_bh(&oct
->sc_buf_pool
.lock
);
818 list_for_each(tmp
, &oct
->sc_buf_pool
.head
)
823 atomic_inc(&oct
->sc_buf_pool
.alloc_buf_count
);
825 spin_unlock_bh(&oct
->sc_buf_pool
.lock
);
827 sc
= (struct octeon_soft_command
*)tmp
;
829 dma_addr
= sc
->dma_addr
;
832 memset(sc
, 0, sc
->size
);
834 sc
->dma_addr
= dma_addr
;
838 sc
->ctxptr
= (u8
*)sc
+ offset
;
839 sc
->ctxsize
= ctxsize
;
842 /* Start data at 128 byte boundary */
843 offset
= (offset
+ ctxsize
+ 127) & 0xffffff80;
846 sc
->virtdptr
= (u8
*)sc
+ offset
;
847 sc
->dmadptr
= dma_addr
+ offset
;
848 sc
->datasize
= datasize
;
851 /* Start rdata at 128 byte boundary */
852 offset
= (offset
+ datasize
+ 127) & 0xffffff80;
855 WARN_ON(rdatasize
< 16);
856 sc
->virtrptr
= (u8
*)sc
+ offset
;
857 sc
->dmarptr
= dma_addr
+ offset
;
858 sc
->rdatasize
= rdatasize
;
859 sc
->status_word
= (u64
*)((u8
*)(sc
->virtrptr
) + rdatasize
- 8);
865 void octeon_free_soft_command(struct octeon_device
*oct
,
866 struct octeon_soft_command
*sc
)
868 spin_lock_bh(&oct
->sc_buf_pool
.lock
);
870 list_add_tail(&sc
->node
, &oct
->sc_buf_pool
.head
);
872 atomic_dec(&oct
->sc_buf_pool
.alloc_buf_count
);
874 spin_unlock_bh(&oct
->sc_buf_pool
.lock
);