octeon_nic.c

  1/**********************************************************************
  2 * Author: Cavium, Inc.
  3 *
  4 * Contact: support@cavium.com
  5 *          Please include "LiquidIO" in the subject.
  6 *
  7 * Copyright (c) 2003-2016 Cavium, Inc.
  8 *
  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.
 12 *
 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
 17 * details.
 18 **********************************************************************/
 19#include <linux/pci.h>
 20#include <linux/netdevice.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_nic.h"
 27#include "octeon_main.h"
 28
 29void *
 30octeon_alloc_soft_command_resp(struct octeon_device    *oct,
 31			       union octeon_instr_64B *cmd,
 32			       u32		       rdatasize)
 33{
 34	struct octeon_soft_command *sc;
 35	struct octeon_instr_ih3  *ih3;
 36	struct octeon_instr_ih2  *ih2;
 37	struct octeon_instr_irh *irh;
 38	struct octeon_instr_rdp *rdp;
 39
 40	sc = (struct octeon_soft_command *)
 41		octeon_alloc_soft_command(oct, 0, rdatasize, 0);
 42
 43	if (!sc)
 44		return NULL;
 45
 46	/* Copy existing command structure into the soft command */
 47	memcpy(&sc->cmd, cmd, sizeof(union octeon_instr_64B));
 48
 49	/* Add in the response related fields. Opcode and Param are already
 50	 * there.
 51	 */
 52	if (OCTEON_CN23XX_PF(oct) || OCTEON_CN23XX_VF(oct)) {
 53		ih3      = (struct octeon_instr_ih3 *)&sc->cmd.cmd3.ih3;
 54		rdp     = (struct octeon_instr_rdp *)&sc->cmd.cmd3.rdp;
 55		irh     = (struct octeon_instr_irh *)&sc->cmd.cmd3.irh;
 56		/*pkiih3 + irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
 57		ih3->fsz = LIO_SOFTCMDRESP_IH3;
 58	} else {
 59		ih2      = (struct octeon_instr_ih2 *)&sc->cmd.cmd2.ih2;
 60		rdp     = (struct octeon_instr_rdp *)&sc->cmd.cmd2.rdp;
 61		irh     = (struct octeon_instr_irh *)&sc->cmd.cmd2.irh;
 62		/* irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
 63		ih2->fsz = LIO_SOFTCMDRESP_IH2;
 64	}
 65
 66	irh->rflag = 1; /* a response is required */
 67
 68	rdp->pcie_port = oct->pcie_port;
 69	rdp->rlen      = rdatasize;
 70
 71	*sc->status_word = COMPLETION_WORD_INIT;
 72
 73	if (OCTEON_CN23XX_PF(oct) || OCTEON_CN23XX_VF(oct))
 74		sc->cmd.cmd3.rptr =  sc->dmarptr;
 75	else
 76		sc->cmd.cmd2.rptr =  sc->dmarptr;
 77
 78	sc->expiry_time = jiffies + msecs_to_jiffies(LIO_SC_MAX_TMO_MS);
 79
 80	return sc;
 81}
 82EXPORT_SYMBOL_GPL(octeon_alloc_soft_command_resp);
 83
 84int octnet_send_nic_data_pkt(struct octeon_device *oct,
 85			     struct octnic_data_pkt *ndata,
 86			     int xmit_more)
 87{
 88	int ring_doorbell = !xmit_more;
 89
 90	return octeon_send_command(oct, ndata->q_no, ring_doorbell, &ndata->cmd,
 91				   ndata->buf, ndata->datasize,
 92				   ndata->reqtype);
 93}
 94EXPORT_SYMBOL_GPL(octnet_send_nic_data_pkt);
 95
 96static inline struct octeon_soft_command
 97*octnic_alloc_ctrl_pkt_sc(struct octeon_device *oct,
 98			  struct octnic_ctrl_pkt *nctrl)
 99{
100	struct octeon_soft_command *sc = NULL;
101	u8 *data;
102	u32 rdatasize;
103	u32 uddsize = 0, datasize = 0;
104
105	uddsize = (u32)(nctrl->ncmd.s.more * 8);
106
107	datasize = OCTNET_CMD_SIZE + uddsize;
108	rdatasize = 16;
109
110	sc = (struct octeon_soft_command *)
111		octeon_alloc_soft_command(oct, datasize, rdatasize, 0);
112
113	if (!sc)
114		return NULL;
115
116	data = (u8 *)sc->virtdptr;
117
118	memcpy(data, &nctrl->ncmd, OCTNET_CMD_SIZE);
119
120	octeon_swap_8B_data((u64 *)data, (OCTNET_CMD_SIZE >> 3));
121
122	if (uddsize) {
123		/* Endian-Swap for UDD should have been done by caller. */
124		memcpy(data + OCTNET_CMD_SIZE, nctrl->udd, uddsize);
125	}
126
127	sc->iq_no = (u32)nctrl->iq_no;
128
129	octeon_prepare_soft_command(oct, sc, OPCODE_NIC, OPCODE_NIC_CMD,
130				    0, 0, 0);
131
132	init_completion(&sc->complete);
133	sc->sc_status = OCTEON_REQUEST_PENDING;
134
135	return sc;
136}
137
138int
139octnet_send_nic_ctrl_pkt(struct octeon_device *oct,
140			 struct octnic_ctrl_pkt *nctrl)
141{
142	int retval;
143	struct octeon_soft_command *sc = NULL;
144
145	spin_lock_bh(&oct->cmd_resp_wqlock);
146	/* Allow only rx ctrl command to stop traffic on the chip
147	 * during offline operations
148	 */
149	if ((oct->cmd_resp_state == OCT_DRV_OFFLINE) &&
150	    (nctrl->ncmd.s.cmd != OCTNET_CMD_RX_CTL)) {
151		spin_unlock_bh(&oct->cmd_resp_wqlock);
152		dev_err(&oct->pci_dev->dev,
153			"%s cmd:%d not processed since driver offline\n",
154			__func__, nctrl->ncmd.s.cmd);
155		return -1;
156	}
157
158	sc = octnic_alloc_ctrl_pkt_sc(oct, nctrl);
159	if (!sc) {
160		dev_err(&oct->pci_dev->dev, "%s soft command alloc failed\n",
161			__func__);
162		spin_unlock_bh(&oct->cmd_resp_wqlock);
163		return -1;
164	}
165
166	retval = octeon_send_soft_command(oct, sc);
167	if (retval == IQ_SEND_FAILED) {
168		octeon_free_soft_command(oct, sc);
169		dev_err(&oct->pci_dev->dev, "%s pf_num:%d soft command:%d send failed status: %x\n",
170			__func__, oct->pf_num, nctrl->ncmd.s.cmd, retval);
171		spin_unlock_bh(&oct->cmd_resp_wqlock);
172		return -1;
173	}
174
175	spin_unlock_bh(&oct->cmd_resp_wqlock);
176
177	if (nctrl->ncmd.s.cmdgroup == 0) {
178		switch (nctrl->ncmd.s.cmd) {
179			/* caller holds lock, can not sleep */
180		case OCTNET_CMD_CHANGE_DEVFLAGS:
181		case OCTNET_CMD_SET_MULTI_LIST:
182		case OCTNET_CMD_SET_UC_LIST:
183			WRITE_ONCE(sc->caller_is_done, true);
184			return retval;
185		}
186	}
187
188	retval = wait_for_sc_completion_timeout(oct, sc, 0);
189	if (retval)
190		return (retval);
191
192	nctrl->sc_status = sc->sc_status;
193	retval = nctrl->sc_status;
194	if (nctrl->cb_fn)
195		nctrl->cb_fn(nctrl);
196
197	WRITE_ONCE(sc->caller_is_done, true);
198
199	return retval;
200}
201EXPORT_SYMBOL_GPL(octnet_send_nic_ctrl_pkt);