| @@ -0,0 +1,254 @@ |
| | 1 | /* QLogic qedr NIC Driver |
| | 2 | * Copyright (c) 2015-2016 QLogic Corporation |
| | 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 | * OpenIB.org 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 | #include <linux/module.h> |
| | 33 | #include <rdma/ib_verbs.h> |
| | 34 | #include <rdma/ib_addr.h> |
| | 35 | #include <linux/netdevice.h> |
| | 36 | #include <linux/iommu.h> |
| | 37 | #include <net/addrconf.h> |
| | 38 | #include <linux/qed/qede_roce.h> |
| | 39 | #include "qedr.h" |
| | 40 | |
| | 41 | MODULE_DESCRIPTION("QLogic 40G/100G ROCE Driver"); |
| | 42 | MODULE_AUTHOR("QLogic Corporation"); |
| | 43 | MODULE_LICENSE("Dual BSD/GPL"); |
| | 44 | MODULE_VERSION(QEDR_MODULE_VERSION); |
| | 45 | |
| | 46 | void qedr_ib_dispatch_event(struct qedr_dev *dev, u8 port_num, |
| | 47 | enum ib_event_type type) |
| | 48 | { |
| | 49 | struct ib_event ibev; |
| | 50 | |
| | 51 | ibev.device = &dev->ibdev; |
| | 52 | ibev.element.port_num = port_num; |
| | 53 | ibev.event = type; |
| | 54 | |
| | 55 | ib_dispatch_event(&ibev); |
| | 56 | } |
| | 57 | |
| | 58 | static enum rdma_link_layer qedr_link_layer(struct ib_device *device, |
| | 59 | u8 port_num) |
| | 60 | { |
| | 61 | return IB_LINK_LAYER_ETHERNET; |
| | 62 | } |
| | 63 | |
| | 64 | static int qedr_register_device(struct qedr_dev *dev) |
| | 65 | { |
| | 66 | strlcpy(dev->ibdev.name, "qedr%d", IB_DEVICE_NAME_MAX); |
| | 67 | |
| | 68 | memcpy(dev->ibdev.node_desc, QEDR_NODE_DESC, sizeof(QEDR_NODE_DESC)); |
| | 69 | dev->ibdev.owner = THIS_MODULE; |
| | 70 | |
| | 71 | dev->ibdev.get_link_layer = qedr_link_layer; |
| | 72 | |
| | 73 | return 0; |
| | 74 | } |
| | 75 | |
| | 76 | /* QEDR sysfs interface */ |
| | 77 | static ssize_t show_rev(struct device *device, struct device_attribute *attr, |
| | 78 | char *buf) |
| | 79 | { |
| | 80 | struct qedr_dev *dev = dev_get_drvdata(device); |
| | 81 | |
| | 82 | return scnprintf(buf, PAGE_SIZE, "0x%x\n", dev->pdev->vendor); |
| | 83 | } |
| | 84 | |
| | 85 | static ssize_t show_hca_type(struct device *device, |
| | 86 | struct device_attribute *attr, char *buf) |
| | 87 | { |
| | 88 | return scnprintf(buf, PAGE_SIZE, "%s\n", "HCA_TYPE_TO_SET"); |
| | 89 | } |
| | 90 | |
| | 91 | static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); |
| | 92 | static DEVICE_ATTR(hca_type, S_IRUGO, show_hca_type, NULL); |
| | 93 | |
| | 94 | static struct device_attribute *qedr_attributes[] = { |
| | 95 | &dev_attr_hw_rev, |
| | 96 | &dev_attr_hca_type |
| | 97 | }; |
| | 98 | |
| | 99 | static void qedr_remove_sysfiles(struct qedr_dev *dev) |
| | 100 | { |
| | 101 | int i; |
| | 102 | |
| | 103 | for (i = 0; i < ARRAY_SIZE(qedr_attributes); i++) |
| | 104 | device_remove_file(&dev->ibdev.dev, qedr_attributes[i]); |
| | 105 | } |
| | 106 | |
| | 107 | static void qedr_pci_set_atomic(struct qedr_dev *dev, struct pci_dev *pdev) |
| | 108 | { |
| | 109 | struct pci_dev *bridge; |
| | 110 | u32 val; |
| | 111 | |
| | 112 | dev->atomic_cap = IB_ATOMIC_NONE; |
| | 113 | |
| | 114 | bridge = pdev->bus->self; |
| | 115 | if (!bridge) |
| | 116 | return; |
| | 117 | |
| | 118 | /* Check whether we are connected directly or via a switch */ |
| | 119 | while (bridge && bridge->bus->parent) { |
| | 120 | DP_DEBUG(dev, QEDR_MSG_INIT, |
| | 121 | "Device is not connected directly to root. bridge->bus->number=%d primary=%d\n", |
| | 122 | bridge->bus->number, bridge->bus->primary); |
| | 123 | /* Need to check Atomic Op Routing Supported all the way to |
| | 124 | * root complex. |
| | 125 | */ |
| | 126 | pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &val); |
| | 127 | if (!(val & PCI_EXP_DEVCAP2_ATOMIC_ROUTE)) { |
| | 128 | pcie_capability_clear_word(pdev, |
| | 129 | PCI_EXP_DEVCTL2, |
| | 130 | PCI_EXP_DEVCTL2_ATOMIC_REQ); |
| | 131 | return; |
| | 132 | } |
| | 133 | bridge = bridge->bus->parent->self; |
| | 134 | } |
| | 135 | bridge = pdev->bus->self; |
| | 136 | |
| | 137 | /* according to bridge capability */ |
| | 138 | pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &val); |
| | 139 | if (val & PCI_EXP_DEVCAP2_ATOMIC_COMP64) { |
| | 140 | pcie_capability_set_word(pdev, PCI_EXP_DEVCTL2, |
| | 141 | PCI_EXP_DEVCTL2_ATOMIC_REQ); |
| | 142 | dev->atomic_cap = IB_ATOMIC_GLOB; |
| | 143 | } else { |
| | 144 | pcie_capability_clear_word(pdev, PCI_EXP_DEVCTL2, |
| | 145 | PCI_EXP_DEVCTL2_ATOMIC_REQ); |
| | 146 | } |
| | 147 | } |
| | 148 | |
| | 149 | static struct qedr_dev *qedr_add(struct qed_dev *cdev, struct pci_dev *pdev, |
| | 150 | struct net_device *ndev) |
| | 151 | { |
| | 152 | struct qedr_dev *dev; |
| | 153 | int rc = 0, i; |
| | 154 | |
| | 155 | dev = (struct qedr_dev *)ib_alloc_device(sizeof(*dev)); |
| | 156 | if (!dev) { |
| | 157 | pr_err("Unable to allocate ib device\n"); |
| | 158 | return NULL; |
| | 159 | } |
| | 160 | |
| | 161 | DP_DEBUG(dev, QEDR_MSG_INIT, "qedr add device called\n"); |
| | 162 | |
| | 163 | dev->pdev = pdev; |
| | 164 | dev->ndev = ndev; |
| | 165 | dev->cdev = cdev; |
| | 166 | |
| | 167 | qedr_pci_set_atomic(dev, pdev); |
| | 168 | |
| | 169 | rc = qedr_register_device(dev); |
| | 170 | if (rc) { |
| | 171 | DP_ERR(dev, "Unable to allocate register device\n"); |
| | 172 | goto init_err; |
| | 173 | } |
| | 174 | |
| | 175 | for (i = 0; i < ARRAY_SIZE(qedr_attributes); i++) |
| | 176 | if (device_create_file(&dev->ibdev.dev, qedr_attributes[i])) |
| | 177 | goto init_err; |
| | 178 | |
| | 179 | DP_DEBUG(dev, QEDR_MSG_INIT, "qedr driver loaded successfully\n"); |
| | 180 | return dev; |
| | 181 | |
| | 182 | init_err: |
| | 183 | ib_dealloc_device(&dev->ibdev); |
| | 184 | DP_ERR(dev, "qedr driver load failed rc=%d\n", rc); |
| | 185 | |
| | 186 | return NULL; |
| | 187 | } |
| | 188 | |
| | 189 | static void qedr_remove(struct qedr_dev *dev) |
| | 190 | { |
| | 191 | /* First unregister with stack to stop all the active traffic |
| | 192 | * of the registered clients. |
| | 193 | */ |
| | 194 | qedr_remove_sysfiles(dev); |
| | 195 | |
| | 196 | ib_dealloc_device(&dev->ibdev); |
| | 197 | } |
| | 198 | |
| | 199 | static int qedr_close(struct qedr_dev *dev) |
| | 200 | { |
| | 201 | qedr_ib_dispatch_event(dev, 1, IB_EVENT_PORT_ERR); |
| | 202 | |
| | 203 | return 0; |
| | 204 | } |
| | 205 | |
| | 206 | static void qedr_shutdown(struct qedr_dev *dev) |
| | 207 | { |
| | 208 | qedr_close(dev); |
| | 209 | qedr_remove(dev); |
| | 210 | } |
| | 211 | |
| | 212 | /* event handling via NIC driver ensures that all the NIC specific |
| | 213 | * initialization done before RoCE driver notifies |
| | 214 | * event to stack. |
| | 215 | */ |
| | 216 | static void qedr_notify(struct qedr_dev *dev, enum qede_roce_event event) |
| | 217 | { |
| | 218 | switch (event) { |
| | 219 | case QEDE_UP: |
| | 220 | qedr_ib_dispatch_event(dev, 1, IB_EVENT_PORT_ACTIVE); |
| | 221 | break; |
| | 222 | case QEDE_DOWN: |
| | 223 | qedr_close(dev); |
| | 224 | break; |
| | 225 | case QEDE_CLOSE: |
| | 226 | qedr_shutdown(dev); |
| | 227 | break; |
| | 228 | case QEDE_CHANGE_ADDR: |
| | 229 | qedr_ib_dispatch_event(dev, 1, IB_EVENT_GID_CHANGE); |
| | 230 | break; |
| | 231 | default: |
| | 232 | pr_err("Event not supported\n"); |
| | 233 | } |
| | 234 | } |
| | 235 | |
| | 236 | static struct qedr_driver qedr_drv = { |
| | 237 | .name = "qedr_driver", |
| | 238 | .add = qedr_add, |
| | 239 | .remove = qedr_remove, |
| | 240 | .notify = qedr_notify, |
| | 241 | }; |
| | 242 | |
| | 243 | static int __init qedr_init_module(void) |
| | 244 | { |
| | 245 | return qede_roce_register_driver(&qedr_drv); |
| | 246 | } |
| | 247 | |
| | 248 | static void __exit qedr_exit_module(void) |
| | 249 | { |
| | 250 | qede_roce_unregister_driver(&qedr_drv); |
| | 251 | } |
| | 252 | |
| | 253 | module_init(qedr_init_module); |
| | 254 | module_exit(qedr_exit_module); |