Commit | Line | Data |
---|---|---|
a19ddd6f SD |
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 | ||
27 | static 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 | } | |
34 | static DEVICE_ATTR_RO(device); | |
35 | ||
36 | static 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 | } | |
43 | static DEVICE_ATTR_RO(vendor); | |
44 | ||
45 | static 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 | } | |
53 | static DEVICE_ATTR_RO(modalias); | |
54 | ||
55 | static struct attribute *vop_dev_attrs[] = { | |
56 | &dev_attr_device.attr, | |
57 | &dev_attr_vendor.attr, | |
58 | &dev_attr_modalias.attr, | |
59 | NULL, | |
60 | }; | |
61 | ATTRIBUTE_GROUPS(vop_dev); | |
62 | ||
63 | static 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 | */ | |
76 | static 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 | ||
89 | static 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 | ||
97 | static 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 | ||
105 | static 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 | ||
114 | static 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 | ||
123 | int vop_register_driver(struct vop_driver *driver) | |
124 | { | |
125 | driver->driver.bus = &vop_bus; | |
126 | return driver_register(&driver->driver); | |
127 | } | |
128 | EXPORT_SYMBOL_GPL(vop_register_driver); | |
129 | ||
130 | void vop_unregister_driver(struct vop_driver *driver) | |
131 | { | |
132 | driver_unregister(&driver->driver); | |
133 | } | |
134 | EXPORT_SYMBOL_GPL(vop_unregister_driver); | |
135 | ||
136 | static void vop_release_dev(struct device *d) | |
137 | { | |
138 | put_device(d); | |
139 | } | |
140 | ||
141 | struct vop_device * | |
142 | vop_register_device(struct device *pdev, int id, | |
143 | const struct dma_map_ops *dma_ops, | |
144 | struct vop_hw_ops *hw_ops, u8 dnode, struct mic_mw *aper, | |
145 | struct dma_chan *chan) | |
146 | { | |
147 | int ret; | |
148 | struct vop_device *vdev; | |
149 | ||
150 | vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); | |
151 | if (!vdev) | |
152 | return ERR_PTR(-ENOMEM); | |
153 | ||
154 | vdev->dev.parent = pdev; | |
155 | vdev->id.device = id; | |
156 | vdev->id.vendor = VOP_DEV_ANY_ID; | |
157 | vdev->dev.archdata.dma_ops = (struct dma_map_ops *)dma_ops; | |
158 | vdev->dev.dma_mask = &vdev->dev.coherent_dma_mask; | |
159 | dma_set_mask(&vdev->dev, DMA_BIT_MASK(64)); | |
160 | vdev->dev.release = vop_release_dev; | |
161 | vdev->hw_ops = hw_ops; | |
162 | vdev->dev.bus = &vop_bus; | |
163 | vdev->dnode = dnode; | |
164 | vdev->aper = aper; | |
165 | vdev->dma_ch = chan; | |
166 | vdev->index = dnode - 1; | |
167 | dev_set_name(&vdev->dev, "vop-dev%u", vdev->index); | |
168 | /* | |
169 | * device_register() causes the bus infrastructure to look for a | |
170 | * matching driver. | |
171 | */ | |
172 | ret = device_register(&vdev->dev); | |
173 | if (ret) | |
174 | goto free_vdev; | |
175 | return vdev; | |
176 | free_vdev: | |
177 | kfree(vdev); | |
178 | return ERR_PTR(ret); | |
179 | } | |
180 | EXPORT_SYMBOL_GPL(vop_register_device); | |
181 | ||
182 | void vop_unregister_device(struct vop_device *dev) | |
183 | { | |
184 | device_unregister(&dev->dev); | |
185 | } | |
186 | EXPORT_SYMBOL_GPL(vop_unregister_device); | |
187 | ||
188 | static int __init vop_init(void) | |
189 | { | |
190 | return bus_register(&vop_bus); | |
191 | } | |
192 | ||
193 | static void __exit vop_exit(void) | |
194 | { | |
195 | bus_unregister(&vop_bus); | |
196 | } | |
197 | ||
198 | core_initcall(vop_init); | |
199 | module_exit(vop_exit); | |
200 | ||
201 | MODULE_AUTHOR("Intel Corporation"); | |
202 | MODULE_DESCRIPTION("Intel(R) VOP Bus driver"); | |
203 | MODULE_LICENSE("GPL v2"); |