1 /* 2 * This file is provided under a dual BSD/GPLv2 license. When using or 3 * redistributing this file, you may do so under either license. 4 * 5 * GPL LICENSE SUMMARY 6 * 7 * Copyright (C) 2015 EMC Corporation. All Rights Reserved. 8 * Copyright (C) 2016 T-Platforms. All Rights Reserved. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of version 2 of the GNU General Public License as 12 * published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * BSD LICENSE 20 * 21 * Copyright (C) 2015 EMC Corporation. All Rights Reserved. 22 * Copyright (C) 2016 T-Platforms. All Rights Reserved. 23 * 24 * Redistribution and use in source and binary forms, with or without 25 * modification, are permitted provided that the following conditions 26 * are met: 27 * 28 * * Redistributions of source code must retain the above copyright 29 * notice, this list of conditions and the following disclaimer. 30 * * Redistributions in binary form must reproduce the above copy 31 * notice, this list of conditions and the following disclaimer in 32 * the documentation and/or other materials provided with the 33 * distribution. 34 * * Neither the name of Intel Corporation nor the names of its 35 * contributors may be used to endorse or promote products derived 36 * from this software without specific prior written permission. 37 * 38 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 39 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 40 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 41 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 42 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 43 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 44 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 45 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 46 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 47 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 48 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 49 * 50 * PCIe NTB Linux driver 51 * 52 * Contact Information: 53 * Allen Hubbe <Allen.Hubbe@emc.com> 54 */ 55 56 #include <linux/device.h> 57 #include <linux/kernel.h> 58 #include <linux/module.h> 59 60 #include <linux/ntb.h> 61 #include <linux/pci.h> 62 63 #define DRIVER_NAME "ntb" 64 #define DRIVER_DESCRIPTION "PCIe NTB Driver Framework" 65 66 #define DRIVER_VERSION "1.0" 67 #define DRIVER_RELDATE "24 March 2015" 68 #define DRIVER_AUTHOR "Allen Hubbe <Allen.Hubbe@emc.com>" 69 70 MODULE_LICENSE("Dual BSD/GPL"); 71 MODULE_VERSION(DRIVER_VERSION); 72 MODULE_AUTHOR(DRIVER_AUTHOR); 73 MODULE_DESCRIPTION(DRIVER_DESCRIPTION); 74 75 static struct bus_type ntb_bus; 76 static void ntb_dev_release(struct device *dev); 77 78 int __ntb_register_client(struct ntb_client *client, struct module *mod, 79 const char *mod_name) 80 { 81 if (!client) 82 return -EINVAL; 83 if (!ntb_client_ops_is_valid(&client->ops)) 84 return -EINVAL; 85 86 memset(&client->drv, 0, sizeof(client->drv)); 87 client->drv.bus = &ntb_bus; 88 client->drv.name = mod_name; 89 client->drv.owner = mod; 90 91 return driver_register(&client->drv); 92 } 93 EXPORT_SYMBOL(__ntb_register_client); 94 95 void ntb_unregister_client(struct ntb_client *client) 96 { 97 driver_unregister(&client->drv); 98 } 99 EXPORT_SYMBOL(ntb_unregister_client); 100 101 int ntb_register_device(struct ntb_dev *ntb) 102 { 103 if (!ntb) 104 return -EINVAL; 105 if (!ntb->pdev) 106 return -EINVAL; 107 if (!ntb->ops) 108 return -EINVAL; 109 if (!ntb_dev_ops_is_valid(ntb->ops)) 110 return -EINVAL; 111 112 init_completion(&ntb->released); 113 114 ntb->dev.bus = &ntb_bus; 115 ntb->dev.parent = &ntb->pdev->dev; 116 ntb->dev.release = ntb_dev_release; 117 dev_set_name(&ntb->dev, "%s", pci_name(ntb->pdev)); 118 119 ntb->ctx = NULL; 120 ntb->ctx_ops = NULL; 121 spin_lock_init(&ntb->ctx_lock); 122 123 return device_register(&ntb->dev); 124 } 125 EXPORT_SYMBOL(ntb_register_device); 126 127 void ntb_unregister_device(struct ntb_dev *ntb) 128 { 129 device_unregister(&ntb->dev); 130 wait_for_completion(&ntb->released); 131 } 132 EXPORT_SYMBOL(ntb_unregister_device); 133 134 int ntb_set_ctx(struct ntb_dev *ntb, void *ctx, 135 const struct ntb_ctx_ops *ctx_ops) 136 { 137 unsigned long irqflags; 138 139 if (!ntb_ctx_ops_is_valid(ctx_ops)) 140 return -EINVAL; 141 if (ntb->ctx_ops) 142 return -EINVAL; 143 144 spin_lock_irqsave(&ntb->ctx_lock, irqflags); 145 { 146 ntb->ctx = ctx; 147 ntb->ctx_ops = ctx_ops; 148 } 149 spin_unlock_irqrestore(&ntb->ctx_lock, irqflags); 150 151 return 0; 152 } 153 EXPORT_SYMBOL(ntb_set_ctx); 154 155 void ntb_clear_ctx(struct ntb_dev *ntb) 156 { 157 unsigned long irqflags; 158 159 spin_lock_irqsave(&ntb->ctx_lock, irqflags); 160 { 161 ntb->ctx_ops = NULL; 162 ntb->ctx = NULL; 163 } 164 spin_unlock_irqrestore(&ntb->ctx_lock, irqflags); 165 } 166 EXPORT_SYMBOL(ntb_clear_ctx); 167 168 void ntb_link_event(struct ntb_dev *ntb) 169 { 170 unsigned long irqflags; 171 172 spin_lock_irqsave(&ntb->ctx_lock, irqflags); 173 { 174 if (ntb->ctx_ops && ntb->ctx_ops->link_event) 175 ntb->ctx_ops->link_event(ntb->ctx); 176 } 177 spin_unlock_irqrestore(&ntb->ctx_lock, irqflags); 178 } 179 EXPORT_SYMBOL(ntb_link_event); 180 181 void ntb_db_event(struct ntb_dev *ntb, int vector) 182 { 183 unsigned long irqflags; 184 185 spin_lock_irqsave(&ntb->ctx_lock, irqflags); 186 { 187 if (ntb->ctx_ops && ntb->ctx_ops->db_event) 188 ntb->ctx_ops->db_event(ntb->ctx, vector); 189 } 190 spin_unlock_irqrestore(&ntb->ctx_lock, irqflags); 191 } 192 EXPORT_SYMBOL(ntb_db_event); 193 194 void ntb_msg_event(struct ntb_dev *ntb) 195 { 196 unsigned long irqflags; 197 198 spin_lock_irqsave(&ntb->ctx_lock, irqflags); 199 { 200 if (ntb->ctx_ops && ntb->ctx_ops->msg_event) 201 ntb->ctx_ops->msg_event(ntb->ctx); 202 } 203 spin_unlock_irqrestore(&ntb->ctx_lock, irqflags); 204 } 205 EXPORT_SYMBOL(ntb_msg_event); 206 207 int ntb_default_port_number(struct ntb_dev *ntb) 208 { 209 switch (ntb->topo) { 210 case NTB_TOPO_PRI: 211 case NTB_TOPO_B2B_USD: 212 return NTB_PORT_PRI_USD; 213 case NTB_TOPO_SEC: 214 case NTB_TOPO_B2B_DSD: 215 return NTB_PORT_SEC_DSD; 216 default: 217 break; 218 } 219 220 return -EINVAL; 221 } 222 EXPORT_SYMBOL(ntb_default_port_number); 223 224 int ntb_default_peer_port_count(struct ntb_dev *ntb) 225 { 226 return NTB_DEF_PEER_CNT; 227 } 228 EXPORT_SYMBOL(ntb_default_peer_port_count); 229 230 int ntb_default_peer_port_number(struct ntb_dev *ntb, int pidx) 231 { 232 if (pidx != NTB_DEF_PEER_IDX) 233 return -EINVAL; 234 235 switch (ntb->topo) { 236 case NTB_TOPO_PRI: 237 case NTB_TOPO_B2B_USD: 238 return NTB_PORT_SEC_DSD; 239 case NTB_TOPO_SEC: 240 case NTB_TOPO_B2B_DSD: 241 return NTB_PORT_PRI_USD; 242 default: 243 break; 244 } 245 246 return -EINVAL; 247 } 248 EXPORT_SYMBOL(ntb_default_peer_port_number); 249 250 int ntb_default_peer_port_idx(struct ntb_dev *ntb, int port) 251 { 252 int peer_port = ntb_default_peer_port_number(ntb, NTB_DEF_PEER_IDX); 253 254 if (peer_port == -EINVAL || port != peer_port) 255 return -EINVAL; 256 257 return 0; 258 } 259 EXPORT_SYMBOL(ntb_default_peer_port_idx); 260 261 static int ntb_probe(struct device *dev) 262 { 263 struct ntb_dev *ntb; 264 struct ntb_client *client; 265 int rc; 266 267 get_device(dev); 268 ntb = dev_ntb(dev); 269 client = drv_ntb_client(dev->driver); 270 271 rc = client->ops.probe(client, ntb); 272 if (rc) 273 put_device(dev); 274 275 return rc; 276 } 277 278 static int ntb_remove(struct device *dev) 279 { 280 struct ntb_dev *ntb; 281 struct ntb_client *client; 282 283 if (dev->driver) { 284 ntb = dev_ntb(dev); 285 client = drv_ntb_client(dev->driver); 286 287 client->ops.remove(client, ntb); 288 put_device(dev); 289 } 290 291 return 0; 292 } 293 294 static void ntb_dev_release(struct device *dev) 295 { 296 struct ntb_dev *ntb = dev_ntb(dev); 297 298 complete(&ntb->released); 299 } 300 301 static struct bus_type ntb_bus = { 302 .name = "ntb", 303 .probe = ntb_probe, 304 .remove = ntb_remove, 305 }; 306 307 static int __init ntb_driver_init(void) 308 { 309 return bus_register(&ntb_bus); 310 } 311 module_init(ntb_driver_init); 312 313 static void __exit ntb_driver_exit(void) 314 { 315 bus_unregister(&ntb_bus); 316 } 317 module_exit(ntb_driver_exit); 318 319