1 /* 2 * Copyright (c) 2013, Cisco Systems, Inc. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 * 32 */ 33 #include <linux/netdevice.h> 34 #include <linux/pci.h> 35 36 #include "enic_api.h" 37 #include "usnic_common_pkt_hdr.h" 38 #include "usnic_fwd.h" 39 #include "usnic_log.h" 40 41 static int usnic_fwd_devcmd_locked(struct usnic_fwd_dev *ufdev, int vnic_idx, 42 enum vnic_devcmd_cmd cmd, u64 *a0, 43 u64 *a1) 44 { 45 int status; 46 struct net_device *netdev = ufdev->netdev; 47 48 lockdep_assert_held(&ufdev->lock); 49 50 status = enic_api_devcmd_proxy_by_index(netdev, 51 vnic_idx, 52 cmd, 53 a0, a1, 54 1000); 55 if (status) { 56 if (status == ERR_EINVAL && cmd == CMD_DEL_FILTER) { 57 usnic_dbg("Dev %s vnic idx %u cmd %u already deleted", 58 ufdev->name, vnic_idx, cmd); 59 } else { 60 usnic_err("Dev %s vnic idx %u cmd %u failed with status %d\n", 61 ufdev->name, vnic_idx, cmd, 62 status); 63 } 64 } else { 65 usnic_dbg("Dev %s vnic idx %u cmd %u success", 66 ufdev->name, vnic_idx, cmd); 67 } 68 69 return status; 70 } 71 72 static int usnic_fwd_devcmd(struct usnic_fwd_dev *ufdev, int vnic_idx, 73 enum vnic_devcmd_cmd cmd, u64 *a0, u64 *a1) 74 { 75 int status; 76 77 spin_lock(&ufdev->lock); 78 status = usnic_fwd_devcmd_locked(ufdev, vnic_idx, cmd, a0, a1); 79 spin_unlock(&ufdev->lock); 80 81 return status; 82 } 83 84 struct usnic_fwd_dev *usnic_fwd_dev_alloc(struct pci_dev *pdev) 85 { 86 struct usnic_fwd_dev *ufdev; 87 88 ufdev = kzalloc(sizeof(*ufdev), GFP_KERNEL); 89 if (!ufdev) 90 return NULL; 91 92 ufdev->pdev = pdev; 93 ufdev->netdev = pci_get_drvdata(pdev); 94 spin_lock_init(&ufdev->lock); 95 BUILD_BUG_ON(sizeof(ufdev->name) != sizeof(ufdev->netdev->name)); 96 strcpy(ufdev->name, ufdev->netdev->name); 97 98 return ufdev; 99 } 100 101 void usnic_fwd_dev_free(struct usnic_fwd_dev *ufdev) 102 { 103 kfree(ufdev); 104 } 105 106 void usnic_fwd_set_mac(struct usnic_fwd_dev *ufdev, const char mac[ETH_ALEN]) 107 { 108 spin_lock(&ufdev->lock); 109 memcpy(&ufdev->mac, mac, sizeof(ufdev->mac)); 110 spin_unlock(&ufdev->lock); 111 } 112 113 void usnic_fwd_add_ipaddr(struct usnic_fwd_dev *ufdev, __be32 inaddr) 114 { 115 spin_lock(&ufdev->lock); 116 if (!ufdev->inaddr) 117 ufdev->inaddr = inaddr; 118 spin_unlock(&ufdev->lock); 119 } 120 121 void usnic_fwd_del_ipaddr(struct usnic_fwd_dev *ufdev) 122 { 123 spin_lock(&ufdev->lock); 124 ufdev->inaddr = 0; 125 spin_unlock(&ufdev->lock); 126 } 127 128 void usnic_fwd_carrier_up(struct usnic_fwd_dev *ufdev) 129 { 130 spin_lock(&ufdev->lock); 131 ufdev->link_up = 1; 132 spin_unlock(&ufdev->lock); 133 } 134 135 void usnic_fwd_carrier_down(struct usnic_fwd_dev *ufdev) 136 { 137 spin_lock(&ufdev->lock); 138 ufdev->link_up = 0; 139 spin_unlock(&ufdev->lock); 140 } 141 142 void usnic_fwd_set_mtu(struct usnic_fwd_dev *ufdev, unsigned int mtu) 143 { 144 spin_lock(&ufdev->lock); 145 ufdev->mtu = mtu; 146 spin_unlock(&ufdev->lock); 147 } 148 149 static int usnic_fwd_dev_ready_locked(struct usnic_fwd_dev *ufdev) 150 { 151 lockdep_assert_held(&ufdev->lock); 152 153 if (!ufdev->link_up) 154 return -EPERM; 155 156 return 0; 157 } 158 159 static int validate_filter_locked(struct usnic_fwd_dev *ufdev, 160 struct filter *filter) 161 { 162 163 lockdep_assert_held(&ufdev->lock); 164 165 if (filter->type == FILTER_IPV4_5TUPLE) { 166 if (!(filter->u.ipv4.flags & FILTER_FIELD_5TUP_DST_AD)) 167 return -EACCES; 168 if (!(filter->u.ipv4.flags & FILTER_FIELD_5TUP_DST_PT)) 169 return -EBUSY; 170 else if (ufdev->inaddr == 0) 171 return -EINVAL; 172 else if (filter->u.ipv4.dst_port == 0) 173 return -ERANGE; 174 else if (ntohl(ufdev->inaddr) != filter->u.ipv4.dst_addr) 175 return -EFAULT; 176 else 177 return 0; 178 } 179 180 return 0; 181 } 182 183 static void fill_tlv(struct filter_tlv *tlv, struct filter *filter, 184 struct filter_action *action) 185 { 186 tlv->type = CLSF_TLV_FILTER; 187 tlv->length = sizeof(struct filter); 188 *((struct filter *)&tlv->val) = *filter; 189 190 tlv = (struct filter_tlv *)((char *)tlv + sizeof(struct filter_tlv) + 191 sizeof(struct filter)); 192 tlv->type = CLSF_TLV_ACTION; 193 tlv->length = sizeof(struct filter_action); 194 *((struct filter_action *)&tlv->val) = *action; 195 } 196 197 struct usnic_fwd_flow* 198 usnic_fwd_alloc_flow(struct usnic_fwd_dev *ufdev, struct filter *filter, 199 struct usnic_filter_action *uaction) 200 { 201 struct filter_tlv *tlv; 202 struct pci_dev *pdev; 203 struct usnic_fwd_flow *flow; 204 uint64_t a0, a1; 205 uint64_t tlv_size; 206 dma_addr_t tlv_pa; 207 int status; 208 209 pdev = ufdev->pdev; 210 tlv_size = (2*sizeof(struct filter_tlv) + sizeof(struct filter) + 211 sizeof(struct filter_action)); 212 213 flow = kzalloc(sizeof(*flow), GFP_ATOMIC); 214 if (!flow) 215 return ERR_PTR(-ENOMEM); 216 217 tlv = dma_alloc_coherent(&pdev->dev, tlv_size, &tlv_pa, GFP_ATOMIC); 218 if (!tlv) { 219 usnic_err("Failed to allocate memory\n"); 220 status = -ENOMEM; 221 goto out_free_flow; 222 } 223 224 fill_tlv(tlv, filter, &uaction->action); 225 226 spin_lock(&ufdev->lock); 227 status = usnic_fwd_dev_ready_locked(ufdev); 228 if (status) { 229 usnic_err("Forwarding dev %s not ready with status %d\n", 230 ufdev->name, status); 231 goto out_free_tlv; 232 } 233 234 status = validate_filter_locked(ufdev, filter); 235 if (status) { 236 usnic_err("Failed to validate filter with status %d\n", 237 status); 238 goto out_free_tlv; 239 } 240 241 /* Issue Devcmd */ 242 a0 = tlv_pa; 243 a1 = tlv_size; 244 status = usnic_fwd_devcmd_locked(ufdev, uaction->vnic_idx, 245 CMD_ADD_FILTER, &a0, &a1); 246 if (status) { 247 usnic_err("VF %s Filter add failed with status:%d", 248 ufdev->name, status); 249 status = -EFAULT; 250 goto out_free_tlv; 251 } else { 252 usnic_dbg("VF %s FILTER ID:%llu", ufdev->name, a0); 253 } 254 255 flow->flow_id = (uint32_t) a0; 256 flow->vnic_idx = uaction->vnic_idx; 257 flow->ufdev = ufdev; 258 259 out_free_tlv: 260 spin_unlock(&ufdev->lock); 261 dma_free_coherent(&pdev->dev, tlv_size, tlv, tlv_pa); 262 if (!status) 263 return flow; 264 out_free_flow: 265 kfree(flow); 266 return ERR_PTR(status); 267 } 268 269 int usnic_fwd_dealloc_flow(struct usnic_fwd_flow *flow) 270 { 271 int status; 272 u64 a0, a1; 273 274 a0 = flow->flow_id; 275 276 status = usnic_fwd_devcmd(flow->ufdev, flow->vnic_idx, 277 CMD_DEL_FILTER, &a0, &a1); 278 if (status) { 279 if (status == ERR_EINVAL) { 280 usnic_dbg("Filter %u already deleted for VF Idx %u pf: %s status: %d", 281 flow->flow_id, flow->vnic_idx, 282 flow->ufdev->name, status); 283 } else { 284 usnic_err("PF %s VF Idx %u Filter: %u FILTER DELETE failed with status %d", 285 flow->ufdev->name, flow->vnic_idx, 286 flow->flow_id, status); 287 } 288 status = 0; 289 /* 290 * Log the error and fake success to the caller because if 291 * a flow fails to be deleted in the firmware, it is an 292 * unrecoverable error. 293 */ 294 } else { 295 usnic_dbg("PF %s VF Idx %u Filter: %u FILTER DELETED", 296 flow->ufdev->name, flow->vnic_idx, 297 flow->flow_id); 298 } 299 300 kfree(flow); 301 return status; 302 } 303 304 int usnic_fwd_enable_qp(struct usnic_fwd_dev *ufdev, int vnic_idx, int qp_idx) 305 { 306 int status; 307 struct net_device *pf_netdev; 308 u64 a0, a1; 309 310 pf_netdev = ufdev->netdev; 311 a0 = qp_idx; 312 a1 = CMD_QP_RQWQ; 313 314 status = usnic_fwd_devcmd(ufdev, vnic_idx, CMD_QP_ENABLE, 315 &a0, &a1); 316 if (status) { 317 usnic_err("PF %s VNIC Index %u RQ Index: %u ENABLE Failed with status %d", 318 netdev_name(pf_netdev), 319 vnic_idx, 320 qp_idx, 321 status); 322 } else { 323 usnic_dbg("PF %s VNIC Index %u RQ Index: %u ENABLED", 324 netdev_name(pf_netdev), 325 vnic_idx, qp_idx); 326 } 327 328 return status; 329 } 330 331 int usnic_fwd_disable_qp(struct usnic_fwd_dev *ufdev, int vnic_idx, int qp_idx) 332 { 333 int status; 334 u64 a0, a1; 335 struct net_device *pf_netdev; 336 337 pf_netdev = ufdev->netdev; 338 a0 = qp_idx; 339 a1 = CMD_QP_RQWQ; 340 341 status = usnic_fwd_devcmd(ufdev, vnic_idx, CMD_QP_DISABLE, 342 &a0, &a1); 343 if (status) { 344 usnic_err("PF %s VNIC Index %u RQ Index: %u DISABLE Failed with status %d", 345 netdev_name(pf_netdev), 346 vnic_idx, 347 qp_idx, 348 status); 349 } else { 350 usnic_dbg("PF %s VNIC Index %u RQ Index: %u DISABLED", 351 netdev_name(pf_netdev), 352 vnic_idx, 353 qp_idx); 354 } 355 356 return status; 357 } 358