tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Intel MIC Platform Software Stack (MPSS)
3 *
4 * Copyright(c) 2016 Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, version 2, as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * The full GNU General Public License is included in this distribution in
16 * the file called "COPYING".
17 *
18 * Intel Virtio Over PCIe (VOP) Bus driver.
19 */
20#include <linux/slab.h>
21#include <linux/module.h>
22#include <linux/idr.h>
23#include <linux/dma-mapping.h>
24
25#include "vop_bus.h"
26
27static ssize_t device_show(struct device *d,
28 struct device_attribute *attr, char *buf)
29{
30 struct vop_device *dev = dev_to_vop(d);
31
32 return sprintf(buf, "0x%04x\n", dev->id.device);
33}
34static DEVICE_ATTR_RO(device);
35
36static ssize_t vendor_show(struct device *d,
37 struct device_attribute *attr, char *buf)
38{
39 struct vop_device *dev = dev_to_vop(d);
40
41 return sprintf(buf, "0x%04x\n", dev->id.vendor);
42}
43static DEVICE_ATTR_RO(vendor);
44
45static ssize_t modalias_show(struct device *d,
46 struct device_attribute *attr, char *buf)
47{
48 struct vop_device *dev = dev_to_vop(d);
49
50 return sprintf(buf, "vop:d%08Xv%08X\n",
51 dev->id.device, dev->id.vendor);
52}
53static DEVICE_ATTR_RO(modalias);
54
55static struct attribute *vop_dev_attrs[] = {
56 &dev_attr_device.attr,
57 &dev_attr_vendor.attr,
58 &dev_attr_modalias.attr,
59 NULL,
60};
61ATTRIBUTE_GROUPS(vop_dev);
62
63static inline int vop_id_match(const struct vop_device *dev,
64 const struct vop_device_id *id)
65{
66 if (id->device != dev->id.device && id->device != VOP_DEV_ANY_ID)
67 return 0;
68
69 return id->vendor == VOP_DEV_ANY_ID || id->vendor == dev->id.vendor;
70}
71
72/*
73 * This looks through all the IDs a driver claims to support. If any of them
74 * match, we return 1 and the kernel will call vop_dev_probe().
75 */
76static int vop_dev_match(struct device *dv, struct device_driver *dr)
77{
78 unsigned int i;
79 struct vop_device *dev = dev_to_vop(dv);
80 const struct vop_device_id *ids;
81
82 ids = drv_to_vop(dr)->id_table;
83 for (i = 0; ids[i].device; i++)
84 if (vop_id_match(dev, &ids[i]))
85 return 1;
86 return 0;
87}
88
89static int vop_uevent(struct device *dv, struct kobj_uevent_env *env)
90{
91 struct vop_device *dev = dev_to_vop(dv);
92
93 return add_uevent_var(env, "MODALIAS=vop:d%08Xv%08X",
94 dev->id.device, dev->id.vendor);
95}
96
97static int vop_dev_probe(struct device *d)
98{
99 struct vop_device *dev = dev_to_vop(d);
100 struct vop_driver *drv = drv_to_vop(dev->dev.driver);
101
102 return drv->probe(dev);
103}
104
105static int vop_dev_remove(struct device *d)
106{
107 struct vop_device *dev = dev_to_vop(d);
108 struct vop_driver *drv = drv_to_vop(dev->dev.driver);
109
110 drv->remove(dev);
111 return 0;
112}
113
114static struct bus_type vop_bus = {
115 .name = "vop_bus",
116 .match = vop_dev_match,
117 .dev_groups = vop_dev_groups,
118 .uevent = vop_uevent,
119 .probe = vop_dev_probe,
120 .remove = vop_dev_remove,
121};
122
123int vop_register_driver(struct vop_driver *driver)
124{
125 driver->driver.bus = &vop_bus;
126 return driver_register(&driver->driver);
127}
128EXPORT_SYMBOL_GPL(vop_register_driver);
129
130void vop_unregister_driver(struct vop_driver *driver)
131{
132 driver_unregister(&driver->driver);
133}
134EXPORT_SYMBOL_GPL(vop_unregister_driver);
135
136static void vop_release_dev(struct device *d)
137{
138 struct vop_device *dev = dev_to_vop(d);
139
140 kfree(dev);
141}
142
143struct vop_device *
144vop_register_device(struct device *pdev, int id,
145 const struct dma_map_ops *dma_ops,
146 struct vop_hw_ops *hw_ops, u8 dnode, struct mic_mw *aper,
147 struct dma_chan *chan)
148{
149 int ret;
150 struct vop_device *vdev;
151
152 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
153 if (!vdev)
154 return ERR_PTR(-ENOMEM);
155
156 vdev->dev.parent = pdev;
157 vdev->id.device = id;
158 vdev->id.vendor = VOP_DEV_ANY_ID;
159 vdev->dev.dma_ops = dma_ops;
160 vdev->dev.dma_mask = &vdev->dev.coherent_dma_mask;
161 dma_set_mask(&vdev->dev, DMA_BIT_MASK(64));
162 vdev->dev.release = vop_release_dev;
163 vdev->hw_ops = hw_ops;
164 vdev->dev.bus = &vop_bus;
165 vdev->dnode = dnode;
166 vdev->aper = aper;
167 vdev->dma_ch = chan;
168 vdev->index = dnode - 1;
169 dev_set_name(&vdev->dev, "vop-dev%u", vdev->index);
170 /*
171 * device_register() causes the bus infrastructure to look for a
172 * matching driver.
173 */
174 ret = device_register(&vdev->dev);
175 if (ret)
176 goto free_vdev;
177 return vdev;
178free_vdev:
179 put_device(&vdev->dev);
180 return ERR_PTR(ret);
181}
182EXPORT_SYMBOL_GPL(vop_register_device);
183
184void vop_unregister_device(struct vop_device *dev)
185{
186 device_unregister(&dev->dev);
187}
188EXPORT_SYMBOL_GPL(vop_unregister_device);
189
190static int __init vop_init(void)
191{
192 return bus_register(&vop_bus);
193}
194
195static void __exit vop_exit(void)
196{
197 bus_unregister(&vop_bus);
198}
199
200core_initcall(vop_init);
201module_exit(vop_exit);
202
203MODULE_AUTHOR("Intel Corporation");
204MODULE_DESCRIPTION("Intel(R) VOP Bus driver");
205MODULE_LICENSE("GPL v2");