/** * hinic_port_set_mtu - set mtu * @nic_dev: nic device * @new_mtu: new mtu * * Return 0 - Success, negative - Failure **/ int hinic_port_set_mtu(struct hinic_dev *nic_dev, int new_mtu) { struct net_device *netdev = nic_dev->netdev; struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_port_mtu_cmd port_mtu_cmd; struct hinic_hwif *hwif = hwdev->hwif; struct pci_dev *pdev = hwif->pdev; int err, max_frame; u16 out_size; if (new_mtu < HINIC_MIN_MTU_SIZE) { netif_err(nic_dev, drv, netdev, "mtu < MIN MTU size"); return -EINVAL; } max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN; if (max_frame > HINIC_MAX_JUMBO_FRAME_SIZE) { netif_err(nic_dev, drv, netdev, "mtu > MAX MTU size"); return -EINVAL; } port_mtu_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif); port_mtu_cmd.mtu = new_mtu; err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_CHANGE_MTU, &port_mtu_cmd, sizeof(port_mtu_cmd), &port_mtu_cmd, &out_size); if (err || (out_size != sizeof(port_mtu_cmd)) || port_mtu_cmd.status) { dev_err(&pdev->dev, "Failed to set mtu, ret = %d\n", port_mtu_cmd.status); return -EFAULT; } return 0; }
/** * hinic_port_link_state - get the link state * @nic_dev: nic device * @link_state: the returned link state * * Return 0 - Success, negative - Failure **/ int hinic_port_link_state(struct hinic_dev *nic_dev, enum hinic_port_link_state *link_state) { struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_hwif *hwif = hwdev->hwif; struct hinic_port_link_cmd link_cmd; struct pci_dev *pdev = hwif->pdev; u16 out_size; int err; if (!HINIC_IS_PF(hwif) && !HINIC_IS_PPF(hwif)) { dev_err(&pdev->dev, "unsupported PCI Function type\n"); return -EINVAL; } link_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif); err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_LINK_STATE, &link_cmd, sizeof(link_cmd), &link_cmd, &out_size); if (err || (out_size != sizeof(link_cmd)) || link_cmd.status) { dev_err(&pdev->dev, "Failed to get link state, ret = %d\n", link_cmd.status); return -EINVAL; } *link_state = link_cmd.state; return 0; }
/** * cmdq_init_queue_ctxt - init the queue ctxt of a cmdq * @cmdq_ctxt: cmdq ctxt to initialize * @cmdq: the cmdq * @cmdq_pages: the memory of the queue **/ static void cmdq_init_queue_ctxt(struct hinic_cmdq_ctxt *cmdq_ctxt, struct hinic_cmdq *cmdq, struct hinic_cmdq_pages *cmdq_pages) { struct hinic_cmdq_ctxt_info *ctxt_info = &cmdq_ctxt->ctxt_info; u64 wq_first_page_paddr, cmdq_first_block_paddr, pfn; struct hinic_cmdqs *cmdqs = cmdq_to_cmdqs(cmdq); struct hinic_wq *wq = cmdq->wq; /* The data in the HW is in Big Endian Format */ wq_first_page_paddr = be64_to_cpu(*wq->block_vaddr); pfn = CMDQ_PFN(wq_first_page_paddr, wq->wq_page_size); ctxt_info->curr_wqe_page_pfn = HINIC_CMDQ_CTXT_PAGE_INFO_SET(pfn, CURR_WQE_PAGE_PFN) | HINIC_CMDQ_CTXT_PAGE_INFO_SET(HINIC_CEQ_ID_CMDQ, EQ_ID) | HINIC_CMDQ_CTXT_PAGE_INFO_SET(1, CEQ_ARM) | HINIC_CMDQ_CTXT_PAGE_INFO_SET(1, CEQ_EN) | HINIC_CMDQ_CTXT_PAGE_INFO_SET(cmdq->wrapped, WRAPPED); /* block PFN - Read Modify Write */ cmdq_first_block_paddr = cmdq_pages->page_paddr; pfn = CMDQ_PFN(cmdq_first_block_paddr, wq->wq_page_size); ctxt_info->wq_block_pfn = HINIC_CMDQ_CTXT_BLOCK_INFO_SET(pfn, WQ_BLOCK_PFN) | HINIC_CMDQ_CTXT_BLOCK_INFO_SET(atomic_read(&wq->cons_idx), CI); cmdq_ctxt->func_idx = HINIC_HWIF_FUNC_IDX(cmdqs->hwif); cmdq_ctxt->cmdq_type = cmdq->cmdq_type; }
/** * hinic_port_set_rx_mode - set rx mode in the nic device * @nic_dev: nic device * @rx_mode: the rx mode to set * * Return 0 - Success, negative - Failure **/ int hinic_port_set_rx_mode(struct hinic_dev *nic_dev, u32 rx_mode) { struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_port_rx_mode_cmd rx_mode_cmd; rx_mode_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwdev->hwif); rx_mode_cmd.rx_mode = rx_mode; return hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RX_MODE, &rx_mode_cmd, sizeof(rx_mode_cmd), NULL, NULL); }
/** * hinic_port_del_vlan - delete vlan from the nic device * @nic_dev: nic device * @vlan_id: the vlan number to delete * * Return 0 - Success, negative - Failure **/ int hinic_port_del_vlan(struct hinic_dev *nic_dev, u16 vlan_id) { struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_port_vlan_cmd port_vlan_cmd; port_vlan_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwdev->hwif); port_vlan_cmd.vlan_id = vlan_id; return hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_DEL_VLAN, &port_vlan_cmd, sizeof(port_vlan_cmd), NULL, NULL); }
/** * set_ppf - try to set hwif as ppf and set the type of hwif in this case * @hwif: the HW interface of a pci function device **/ static void set_ppf(struct hinic_hwif *hwif) { struct hinic_func_attr *attr = &hwif->attr; u32 addr, val, ppf_election; /* Read Modify Write */ addr = HINIC_CSR_PPF_ELECTION_ADDR(HINIC_HWIF_PCI_INTF(hwif)); val = hinic_hwif_read_reg(hwif, addr); val = HINIC_PPF_ELECTION_CLEAR(val, IDX); ppf_election = HINIC_PPF_ELECTION_SET(HINIC_HWIF_FUNC_IDX(hwif), IDX); val |= ppf_election; hinic_hwif_write_reg(hwif, addr, val); /* check PPF */ val = hinic_hwif_read_reg(hwif, addr); attr->ppf_idx = HINIC_PPF_ELECTION_GET(val, IDX); if (attr->ppf_idx == HINIC_HWIF_FUNC_IDX(hwif)) attr->func_type = HINIC_PPF; }
/** * hinic_port_get_cap - get port capabilities * @nic_dev: nic device * @port_cap: returned port capabilities * * Return 0 - Success, negative - Failure **/ int hinic_port_get_cap(struct hinic_dev *nic_dev, struct hinic_port_cap *port_cap) { struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_hwif *hwif = hwdev->hwif; struct pci_dev *pdev = hwif->pdev; u16 out_size; int err; port_cap->func_idx = HINIC_HWIF_FUNC_IDX(hwif); err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_CAP, port_cap, sizeof(*port_cap), port_cap, &out_size); if (err || (out_size != sizeof(*port_cap)) || port_cap->status) { dev_err(&pdev->dev, "Failed to get port capabilities, ret = %d\n", port_cap->status); return -EINVAL; } return 0; }
/** * hinic_port_get_mac - get the mac address of the nic device * @nic_dev: nic device * @addr: returned mac address * * Return 0 - Success, negative - Failure **/ int hinic_port_get_mac(struct hinic_dev *nic_dev, u8 *addr) { struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_port_mac_cmd port_mac_cmd; struct hinic_hwif *hwif = hwdev->hwif; struct pci_dev *pdev = hwif->pdev; u16 out_size; int err; port_mac_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif); err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_MAC, &port_mac_cmd, sizeof(port_mac_cmd), &port_mac_cmd, &out_size); if (err || (out_size != sizeof(port_mac_cmd)) || port_mac_cmd.status) { dev_err(&pdev->dev, "Failed to get mac, ret = %d\n", port_mac_cmd.status); return -EFAULT; } memcpy(addr, port_mac_cmd.mac, ETH_ALEN); return 0; }
/** * change_mac - change(add or delete) mac address * @nic_dev: nic device * @addr: mac address * @vlan_id: vlan number to set with the mac * @op: add or delete the mac * * Return 0 - Success, negative - Failure **/ static int change_mac(struct hinic_dev *nic_dev, const u8 *addr, u16 vlan_id, enum mac_op op) { struct net_device *netdev = nic_dev->netdev; struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_port_mac_cmd port_mac_cmd; struct hinic_hwif *hwif = hwdev->hwif; struct pci_dev *pdev = hwif->pdev; enum hinic_port_cmd cmd; u16 out_size; int err; if (vlan_id >= VLAN_N_VID) { netif_err(nic_dev, drv, netdev, "Invalid VLAN number\n"); return -EINVAL; } if (op == MAC_SET) cmd = HINIC_PORT_CMD_SET_MAC; else cmd = HINIC_PORT_CMD_DEL_MAC; port_mac_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif); port_mac_cmd.vlan_id = vlan_id; memcpy(port_mac_cmd.mac, addr, ETH_ALEN); err = hinic_port_msg_cmd(hwdev, cmd, &port_mac_cmd, sizeof(port_mac_cmd), &port_mac_cmd, &out_size); if (err || (out_size != sizeof(port_mac_cmd)) || port_mac_cmd.status) { dev_err(&pdev->dev, "Failed to change MAC, ret = %d\n", port_mac_cmd.status); return -EFAULT; } return 0; }
/** * hinic_port_set_tso - set port tso configuration * @nic_dev: nic device * @state: the tso state to set * * Return 0 - Success, negative - Failure **/ int hinic_port_set_tso(struct hinic_dev *nic_dev, enum hinic_tso_state state) { struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_hwif *hwif = hwdev->hwif; struct hinic_tso_config tso_cfg = {0}; struct pci_dev *pdev = hwif->pdev; u16 out_size; int err; tso_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif); tso_cfg.tso_en = state; err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_TSO, &tso_cfg, sizeof(tso_cfg), &tso_cfg, &out_size); if (err || out_size != sizeof(tso_cfg) || tso_cfg.status) { dev_err(&pdev->dev, "Failed to set port tso, ret = %d\n", tso_cfg.status); return -EINVAL; } return 0; }
/** * hinic_port_set_func_state- set func device state * @nic_dev: nic device * @state: the state to set * * Return 0 - Success, negative - Failure **/ int hinic_port_set_func_state(struct hinic_dev *nic_dev, enum hinic_func_port_state state) { struct hinic_port_func_state_cmd func_state; struct hinic_hwdev *hwdev = nic_dev->hwdev; struct hinic_hwif *hwif = hwdev->hwif; struct pci_dev *pdev = hwif->pdev; u16 out_size; int err; func_state.func_idx = HINIC_HWIF_FUNC_IDX(hwif); func_state.state = state; err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_FUNC_STATE, &func_state, sizeof(func_state), &func_state, &out_size); if (err || (out_size != sizeof(func_state)) || func_state.status) { dev_err(&pdev->dev, "Failed to set port func state, ret = %d\n", func_state.status); return -EFAULT; } return 0; }