1 /**********************************************************************
4 * Contact: support@cavium.com
5 * Please include "LiquidIO" in the subject.
7 * Copyright (c) 2003-2015 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
19 * This file may also be available under a different license from Cavium.
20 * Contact Cavium, Inc. for more information
21 **********************************************************************/
22 #include <linux/pci.h>
23 #include <linux/netdevice.h>
24 #include "liquidio_common.h"
25 #include "octeon_droq.h"
26 #include "octeon_iq.h"
27 #include "response_manager.h"
28 #include "octeon_device.h"
29 #include "octeon_nic.h"
30 #include "octeon_main.h"
33 octeon_alloc_soft_command_resp(struct octeon_device *oct,
34 union octeon_instr_64B *cmd,
37 struct octeon_soft_command *sc;
38 struct octeon_instr_ih3 *ih3;
39 struct octeon_instr_ih2 *ih2;
40 struct octeon_instr_irh *irh;
41 struct octeon_instr_rdp *rdp;
43 sc = (struct octeon_soft_command *)
44 octeon_alloc_soft_command(oct, 0, rdatasize, 0);
49 /* Copy existing command structure into the soft command */
50 memcpy(&sc->cmd, cmd, sizeof(union octeon_instr_64B));
52 /* Add in the response related fields. Opcode and Param are already
55 if (OCTEON_CN23XX_PF(oct)) {
56 ih3 = (struct octeon_instr_ih3 *)&sc->cmd.cmd3.ih3;
57 rdp = (struct octeon_instr_rdp *)&sc->cmd.cmd3.rdp;
58 irh = (struct octeon_instr_irh *)&sc->cmd.cmd3.irh;
59 /*pkiih3 + irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
60 ih3->fsz = LIO_SOFTCMDRESP_IH3;
62 ih2 = (struct octeon_instr_ih2 *)&sc->cmd.cmd2.ih2;
63 rdp = (struct octeon_instr_rdp *)&sc->cmd.cmd2.rdp;
64 irh = (struct octeon_instr_irh *)&sc->cmd.cmd2.irh;
65 /* irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
66 ih2->fsz = LIO_SOFTCMDRESP_IH2;
69 irh->rflag = 1; /* a response is required */
71 rdp->pcie_port = oct->pcie_port;
72 rdp->rlen = rdatasize;
74 *sc->status_word = COMPLETION_WORD_INIT;
76 if (OCTEON_CN23XX_PF(oct))
77 sc->cmd.cmd3.rptr = sc->dmarptr;
79 sc->cmd.cmd2.rptr = sc->dmarptr;
82 sc->timeout = jiffies + sc->wait_time;
87 int octnet_send_nic_data_pkt(struct octeon_device *oct,
88 struct octnic_data_pkt *ndata)
90 int ring_doorbell = 1;
92 return octeon_send_command(oct, ndata->q_no, ring_doorbell, &ndata->cmd,
93 ndata->buf, ndata->datasize,
97 static void octnet_link_ctrl_callback(struct octeon_device *oct,
101 struct octeon_soft_command *sc = (struct octeon_soft_command *)sc_ptr;
102 struct octnic_ctrl_pkt *nctrl;
104 nctrl = (struct octnic_ctrl_pkt *)sc->ctxptr;
106 /* Call the callback function if status is OK.
107 * Status is OK only if a response was expected and core returned
109 * If no response was expected, status is OK if the command was posted
112 if (!status && nctrl->cb_fn)
115 octeon_free_soft_command(oct, sc);
118 static inline struct octeon_soft_command
119 *octnic_alloc_ctrl_pkt_sc(struct octeon_device *oct,
120 struct octnic_ctrl_pkt *nctrl)
122 struct octeon_soft_command *sc = NULL;
125 u32 uddsize = 0, datasize = 0;
127 uddsize = (u32)(nctrl->ncmd.s.more * 8);
129 datasize = OCTNET_CMD_SIZE + uddsize;
130 rdatasize = (nctrl->wait_time) ? 16 : 0;
132 sc = (struct octeon_soft_command *)
133 octeon_alloc_soft_command(oct, datasize, rdatasize,
134 sizeof(struct octnic_ctrl_pkt));
139 memcpy(sc->ctxptr, nctrl, sizeof(struct octnic_ctrl_pkt));
141 data = (u8 *)sc->virtdptr;
143 memcpy(data, &nctrl->ncmd, OCTNET_CMD_SIZE);
145 octeon_swap_8B_data((u64 *)data, (OCTNET_CMD_SIZE >> 3));
148 /* Endian-Swap for UDD should have been done by caller. */
149 memcpy(data + OCTNET_CMD_SIZE, nctrl->udd, uddsize);
152 sc->iq_no = (u32)nctrl->iq_no;
154 octeon_prepare_soft_command(oct, sc, OPCODE_NIC, OPCODE_NIC_CMD,
157 sc->callback = octnet_link_ctrl_callback;
158 sc->callback_arg = sc;
159 sc->wait_time = nctrl->wait_time;
165 octnet_send_nic_ctrl_pkt(struct octeon_device *oct,
166 struct octnic_ctrl_pkt *nctrl)
169 struct octeon_soft_command *sc = NULL;
171 spin_lock_bh(&oct->cmd_resp_wqlock);
172 /* Allow only rx ctrl command to stop traffic on the chip
173 * during offline operations
175 if ((oct->cmd_resp_state == OCT_DRV_OFFLINE) &&
176 (nctrl->ncmd.s.cmd != OCTNET_CMD_RX_CTL)) {
177 spin_unlock_bh(&oct->cmd_resp_wqlock);
178 dev_err(&oct->pci_dev->dev,
179 "%s cmd:%d not processed since driver offline\n",
180 __func__, nctrl->ncmd.s.cmd);
184 sc = octnic_alloc_ctrl_pkt_sc(oct, nctrl);
186 dev_err(&oct->pci_dev->dev, "%s soft command alloc failed\n",
188 spin_unlock_bh(&oct->cmd_resp_wqlock);
192 retval = octeon_send_soft_command(oct, sc);
193 if (retval == IQ_SEND_FAILED) {
194 octeon_free_soft_command(oct, sc);
195 dev_err(&oct->pci_dev->dev, "%s pf_num:%d soft command:%d send failed status: %x\n",
196 __func__, oct->pf_num, nctrl->ncmd.s.cmd, retval);
197 spin_unlock_bh(&oct->cmd_resp_wqlock);
201 spin_unlock_bh(&oct->cmd_resp_wqlock);