Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | /*
* Intel MIC Platform Software Stack (MPSS)
*
* Copyright(c) 2014 Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2, as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* Intel SCIF driver.
*/
#include "scif_main.h"
#include "../bus/scif_bus.h"
#include "scif_peer_bus.h"
static inline struct scif_peer_dev *
dev_to_scif_peer(struct device *dev)
{
return container_of(dev, struct scif_peer_dev, dev);
}
struct bus_type scif_peer_bus = {
.name = "scif_peer_bus",
};
static void scif_peer_release_dev(struct device *d)
{
struct scif_peer_dev *sdev = dev_to_scif_peer(d);
struct scif_dev *scifdev = &scif_dev[sdev->dnode];
scif_cleanup_scifdev(scifdev);
kfree(sdev);
}
static int scif_peer_initialize_device(struct scif_dev *scifdev)
{
struct scif_peer_dev *spdev;
int ret;
spdev = kzalloc(sizeof(*spdev), GFP_KERNEL);
if (!spdev) {
ret = -ENOMEM;
goto err;
}
spdev->dev.parent = scifdev->sdev->dev.parent;
spdev->dev.release = scif_peer_release_dev;
spdev->dnode = scifdev->node;
spdev->dev.bus = &scif_peer_bus;
dev_set_name(&spdev->dev, "scif_peer-dev%u", spdev->dnode);
device_initialize(&spdev->dev);
get_device(&spdev->dev);
rcu_assign_pointer(scifdev->spdev, spdev);
mutex_lock(&scif_info.conflock);
scif_info.total++;
scif_info.maxid = max_t(u32, spdev->dnode, scif_info.maxid);
mutex_unlock(&scif_info.conflock);
return 0;
err:
dev_err(&scifdev->sdev->dev,
"dnode %d: initialize_device rc %d\n", scifdev->node, ret);
return ret;
}
static int scif_peer_add_device(struct scif_dev *scifdev)
{
struct scif_peer_dev *spdev = rcu_dereference(scifdev->spdev);
char pool_name[16];
int ret;
ret = device_add(&spdev->dev);
put_device(&spdev->dev);
if (ret) {
dev_err(&scifdev->sdev->dev,
"dnode %d: peer device_add failed\n", scifdev->node);
goto put_spdev;
}
scnprintf(pool_name, sizeof(pool_name), "scif-%d", spdev->dnode);
scifdev->signal_pool = dmam_pool_create(pool_name, &scifdev->sdev->dev,
sizeof(struct scif_status), 1,
0);
if (!scifdev->signal_pool) {
dev_err(&scifdev->sdev->dev,
"dnode %d: dmam_pool_create failed\n", scifdev->node);
ret = -ENOMEM;
goto del_spdev;
}
dev_dbg(&spdev->dev, "Added peer dnode %d\n", spdev->dnode);
return 0;
del_spdev:
device_del(&spdev->dev);
put_spdev:
RCU_INIT_POINTER(scifdev->spdev, NULL);
synchronize_rcu();
put_device(&spdev->dev);
mutex_lock(&scif_info.conflock);
scif_info.total--;
mutex_unlock(&scif_info.conflock);
return ret;
}
void scif_add_peer_device(struct work_struct *work)
{
struct scif_dev *scifdev = container_of(work, struct scif_dev,
peer_add_work);
scif_peer_add_device(scifdev);
}
/*
* Peer device registration is split into a device_initialize and a device_add.
* The reason for doing this is as follows: First, peer device registration
* itself cannot be done in the message processing thread and must be delegated
* to another workqueue, otherwise if SCIF client probe, called during peer
* device registration, calls scif_connect(..), it will block the message
* processing thread causing a deadlock. Next, device_initialize is done in the
* "top-half" message processing thread and device_add in the "bottom-half"
* workqueue. If this is not done, SCIF_CNCT_REQ message processing executing
* concurrently with SCIF_INIT message processing is unable to get a reference
* on the peer device, thereby failing the connect request.
*/
void scif_peer_register_device(struct scif_dev *scifdev)
{
int ret;
mutex_lock(&scifdev->lock);
ret = scif_peer_initialize_device(scifdev);
if (ret)
goto exit;
schedule_work(&scifdev->peer_add_work);
exit:
mutex_unlock(&scifdev->lock);
}
int scif_peer_unregister_device(struct scif_dev *scifdev)
{
struct scif_peer_dev *spdev;
mutex_lock(&scifdev->lock);
/* Flush work to ensure device register is complete */
flush_work(&scifdev->peer_add_work);
/*
* Continue holding scifdev->lock since theoretically unregister_device
* can be called simultaneously from multiple threads
*/
spdev = rcu_dereference(scifdev->spdev);
if (!spdev) {
mutex_unlock(&scifdev->lock);
return -ENODEV;
}
RCU_INIT_POINTER(scifdev->spdev, NULL);
synchronize_rcu();
mutex_unlock(&scifdev->lock);
dev_dbg(&spdev->dev, "Removing peer dnode %d\n", spdev->dnode);
device_unregister(&spdev->dev);
mutex_lock(&scif_info.conflock);
scif_info.total--;
mutex_unlock(&scif_info.conflock);
return 0;
}
int scif_peer_bus_init(void)
{
return bus_register(&scif_peer_bus);
}
void scif_peer_bus_exit(void)
{
bus_unregister(&scif_peer_bus);
}
|