Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Intel MIC Platform Software Stack (MPSS)
4 *
5 * Copyright(c) 2013 Intel Corporation.
6 *
7 * Intel MIC Host driver.
8 */
9#include <linux/fs.h>
10#include <linux/module.h>
11#include <linux/pci.h>
12#include <linux/poll.h>
13
14#include <linux/mic_common.h>
15#include "../common/mic_dev.h"
16#include "mic_device.h"
17#include "mic_x100.h"
18#include "mic_smpt.h"
19
20static const char mic_driver_name[] = "mic";
21
22static const struct pci_device_id mic_pci_tbl[] = {
23 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2250)},
24 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2251)},
25 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2252)},
26 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2253)},
27 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2254)},
28 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2255)},
29 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2256)},
30 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2257)},
31 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2258)},
32 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2259)},
33 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225a)},
34 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225b)},
35 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225c)},
36 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225d)},
37 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225e)},
38
39 /* required last entry */
40 { 0, }
41};
42
43MODULE_DEVICE_TABLE(pci, mic_pci_tbl);
44
45/* ID allocator for MIC devices */
46static struct ida g_mic_ida;
47
48/* Initialize the device page */
49static int mic_dp_init(struct mic_device *mdev)
50{
51 mdev->dp = kzalloc(MIC_DP_SIZE, GFP_KERNEL);
52 if (!mdev->dp)
53 return -ENOMEM;
54
55 mdev->dp_dma_addr = mic_map_single(mdev,
56 mdev->dp, MIC_DP_SIZE);
57 if (mic_map_error(mdev->dp_dma_addr)) {
58 kfree(mdev->dp);
59 dev_err(&mdev->pdev->dev, "%s %d err %d\n",
60 __func__, __LINE__, -ENOMEM);
61 return -ENOMEM;
62 }
63 mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr);
64 mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32);
65 return 0;
66}
67
68/* Uninitialize the device page */
69static void mic_dp_uninit(struct mic_device *mdev)
70{
71 mic_unmap_single(mdev, mdev->dp_dma_addr, MIC_DP_SIZE);
72 kfree(mdev->dp);
73}
74
75/**
76 * mic_ops_init: Initialize HW specific operation tables.
77 *
78 * @mdev: pointer to mic_device instance
79 *
80 * returns none.
81 */
82static void mic_ops_init(struct mic_device *mdev)
83{
84 switch (mdev->family) {
85 case MIC_FAMILY_X100:
86 mdev->ops = &mic_x100_ops;
87 mdev->intr_ops = &mic_x100_intr_ops;
88 mdev->smpt_ops = &mic_x100_smpt_ops;
89 break;
90 default:
91 break;
92 }
93}
94
95/**
96 * mic_get_family - Determine hardware family to which this MIC belongs.
97 *
98 * @pdev: The pci device structure
99 *
100 * returns family.
101 */
102static enum mic_hw_family mic_get_family(struct pci_dev *pdev)
103{
104 enum mic_hw_family family;
105
106 switch (pdev->device) {
107 case MIC_X100_PCI_DEVICE_2250:
108 case MIC_X100_PCI_DEVICE_2251:
109 case MIC_X100_PCI_DEVICE_2252:
110 case MIC_X100_PCI_DEVICE_2253:
111 case MIC_X100_PCI_DEVICE_2254:
112 case MIC_X100_PCI_DEVICE_2255:
113 case MIC_X100_PCI_DEVICE_2256:
114 case MIC_X100_PCI_DEVICE_2257:
115 case MIC_X100_PCI_DEVICE_2258:
116 case MIC_X100_PCI_DEVICE_2259:
117 case MIC_X100_PCI_DEVICE_225a:
118 case MIC_X100_PCI_DEVICE_225b:
119 case MIC_X100_PCI_DEVICE_225c:
120 case MIC_X100_PCI_DEVICE_225d:
121 case MIC_X100_PCI_DEVICE_225e:
122 family = MIC_FAMILY_X100;
123 break;
124 default:
125 family = MIC_FAMILY_UNKNOWN;
126 break;
127 }
128 return family;
129}
130
131/**
132 * mic_device_init - Allocates and initializes the MIC device structure
133 *
134 * @mdev: pointer to mic_device instance
135 * @pdev: The pci device structure
136 *
137 * returns none.
138 */
139static void
140mic_device_init(struct mic_device *mdev, struct pci_dev *pdev)
141{
142 mdev->pdev = pdev;
143 mdev->family = mic_get_family(pdev);
144 mdev->stepping = pdev->revision;
145 mic_ops_init(mdev);
146 mutex_init(&mdev->mic_mutex);
147 mdev->irq_info.next_avail_src = 0;
148}
149
150/**
151 * mic_probe - Device Initialization Routine
152 *
153 * @pdev: PCI device structure
154 * @ent: entry in mic_pci_tbl
155 *
156 * returns 0 on success, < 0 on failure.
157 */
158static int mic_probe(struct pci_dev *pdev,
159 const struct pci_device_id *ent)
160{
161 int rc;
162 struct mic_device *mdev;
163
164 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
165 if (!mdev) {
166 rc = -ENOMEM;
167 dev_err(&pdev->dev, "mdev kmalloc failed rc %d\n", rc);
168 goto mdev_alloc_fail;
169 }
170 mdev->id = ida_simple_get(&g_mic_ida, 0, MIC_MAX_NUM_DEVS, GFP_KERNEL);
171 if (mdev->id < 0) {
172 rc = mdev->id;
173 dev_err(&pdev->dev, "ida_simple_get failed rc %d\n", rc);
174 goto ida_fail;
175 }
176
177 mic_device_init(mdev, pdev);
178
179 rc = pci_enable_device(pdev);
180 if (rc) {
181 dev_err(&pdev->dev, "failed to enable pci device.\n");
182 goto ida_remove;
183 }
184
185 pci_set_master(pdev);
186
187 rc = pci_request_regions(pdev, mic_driver_name);
188 if (rc) {
189 dev_err(&pdev->dev, "failed to get pci regions.\n");
190 goto disable_device;
191 }
192
193 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
194 if (rc) {
195 dev_err(&pdev->dev, "Cannot set DMA mask\n");
196 goto release_regions;
197 }
198
199 mdev->mmio.pa = pci_resource_start(pdev, mdev->ops->mmio_bar);
200 mdev->mmio.len = pci_resource_len(pdev, mdev->ops->mmio_bar);
201 mdev->mmio.va = pci_ioremap_bar(pdev, mdev->ops->mmio_bar);
202 if (!mdev->mmio.va) {
203 dev_err(&pdev->dev, "Cannot remap MMIO BAR\n");
204 rc = -EIO;
205 goto release_regions;
206 }
207
208 mdev->aper.pa = pci_resource_start(pdev, mdev->ops->aper_bar);
209 mdev->aper.len = pci_resource_len(pdev, mdev->ops->aper_bar);
210 mdev->aper.va = ioremap_wc(mdev->aper.pa, mdev->aper.len);
211 if (!mdev->aper.va) {
212 dev_err(&pdev->dev, "Cannot remap Aperture BAR\n");
213 rc = -EIO;
214 goto unmap_mmio;
215 }
216
217 mdev->intr_ops->intr_init(mdev);
218 rc = mic_setup_interrupts(mdev, pdev);
219 if (rc) {
220 dev_err(&pdev->dev, "mic_setup_interrupts failed %d\n", rc);
221 goto unmap_aper;
222 }
223 rc = mic_smpt_init(mdev);
224 if (rc) {
225 dev_err(&pdev->dev, "smpt_init failed %d\n", rc);
226 goto free_interrupts;
227 }
228
229 pci_set_drvdata(pdev, mdev);
230
231 rc = mic_dp_init(mdev);
232 if (rc) {
233 dev_err(&pdev->dev, "mic_dp_init failed rc %d\n", rc);
234 goto smpt_uninit;
235 }
236 mic_bootparam_init(mdev);
237 mic_create_debug_dir(mdev);
238
239 mdev->cosm_dev = cosm_register_device(&mdev->pdev->dev, &cosm_hw_ops);
240 if (IS_ERR(mdev->cosm_dev)) {
241 rc = PTR_ERR(mdev->cosm_dev);
242 dev_err(&pdev->dev, "cosm_add_device failed rc %d\n", rc);
243 goto cleanup_debug_dir;
244 }
245 return 0;
246cleanup_debug_dir:
247 mic_delete_debug_dir(mdev);
248 mic_dp_uninit(mdev);
249smpt_uninit:
250 mic_smpt_uninit(mdev);
251free_interrupts:
252 mic_free_interrupts(mdev, pdev);
253unmap_aper:
254 iounmap(mdev->aper.va);
255unmap_mmio:
256 iounmap(mdev->mmio.va);
257release_regions:
258 pci_release_regions(pdev);
259disable_device:
260 pci_disable_device(pdev);
261ida_remove:
262 ida_simple_remove(&g_mic_ida, mdev->id);
263ida_fail:
264 kfree(mdev);
265mdev_alloc_fail:
266 dev_err(&pdev->dev, "Probe failed rc %d\n", rc);
267 return rc;
268}
269
270/**
271 * mic_remove - Device Removal Routine
272 * mic_remove is called by the PCI subsystem to alert the driver
273 * that it should release a PCI device.
274 *
275 * @pdev: PCI device structure
276 */
277static void mic_remove(struct pci_dev *pdev)
278{
279 struct mic_device *mdev;
280
281 mdev = pci_get_drvdata(pdev);
282 if (!mdev)
283 return;
284
285 cosm_unregister_device(mdev->cosm_dev);
286 mic_delete_debug_dir(mdev);
287 mic_dp_uninit(mdev);
288 mic_smpt_uninit(mdev);
289 mic_free_interrupts(mdev, pdev);
290 iounmap(mdev->aper.va);
291 iounmap(mdev->mmio.va);
292 pci_release_regions(pdev);
293 pci_disable_device(pdev);
294 ida_simple_remove(&g_mic_ida, mdev->id);
295 kfree(mdev);
296}
297
298static struct pci_driver mic_driver = {
299 .name = mic_driver_name,
300 .id_table = mic_pci_tbl,
301 .probe = mic_probe,
302 .remove = mic_remove
303};
304
305static int __init mic_init(void)
306{
307 int ret;
308
309 request_module("mic_x100_dma");
310 mic_init_debugfs();
311 ida_init(&g_mic_ida);
312 ret = pci_register_driver(&mic_driver);
313 if (ret) {
314 pr_err("pci_register_driver failed ret %d\n", ret);
315 goto cleanup_debugfs;
316 }
317 return 0;
318cleanup_debugfs:
319 ida_destroy(&g_mic_ida);
320 mic_exit_debugfs();
321 return ret;
322}
323
324static void __exit mic_exit(void)
325{
326 pci_unregister_driver(&mic_driver);
327 ida_destroy(&g_mic_ida);
328 mic_exit_debugfs();
329}
330
331module_init(mic_init);
332module_exit(mic_exit);
333
334MODULE_AUTHOR("Intel Corporation");
335MODULE_DESCRIPTION("Intel(R) MIC X100 Host driver");
336MODULE_LICENSE("GPL v2");
1/*
2 * Intel MIC Platform Software Stack (MPSS)
3 *
4 * Copyright(c) 2013 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 MIC Host driver.
19 */
20#include <linux/fs.h>
21#include <linux/module.h>
22#include <linux/pci.h>
23#include <linux/poll.h>
24
25#include <linux/mic_common.h>
26#include "../common/mic_dev.h"
27#include "mic_device.h"
28#include "mic_x100.h"
29#include "mic_smpt.h"
30
31static const char mic_driver_name[] = "mic";
32
33static const struct pci_device_id mic_pci_tbl[] = {
34 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2250)},
35 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2251)},
36 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2252)},
37 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2253)},
38 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2254)},
39 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2255)},
40 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2256)},
41 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2257)},
42 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2258)},
43 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2259)},
44 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225a)},
45 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225b)},
46 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225c)},
47 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225d)},
48 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225e)},
49
50 /* required last entry */
51 { 0, }
52};
53
54MODULE_DEVICE_TABLE(pci, mic_pci_tbl);
55
56/* ID allocator for MIC devices */
57static struct ida g_mic_ida;
58
59/* Initialize the device page */
60static int mic_dp_init(struct mic_device *mdev)
61{
62 mdev->dp = kzalloc(MIC_DP_SIZE, GFP_KERNEL);
63 if (!mdev->dp)
64 return -ENOMEM;
65
66 mdev->dp_dma_addr = mic_map_single(mdev,
67 mdev->dp, MIC_DP_SIZE);
68 if (mic_map_error(mdev->dp_dma_addr)) {
69 kfree(mdev->dp);
70 dev_err(&mdev->pdev->dev, "%s %d err %d\n",
71 __func__, __LINE__, -ENOMEM);
72 return -ENOMEM;
73 }
74 mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr);
75 mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32);
76 return 0;
77}
78
79/* Uninitialize the device page */
80static void mic_dp_uninit(struct mic_device *mdev)
81{
82 mic_unmap_single(mdev, mdev->dp_dma_addr, MIC_DP_SIZE);
83 kfree(mdev->dp);
84}
85
86/**
87 * mic_ops_init: Initialize HW specific operation tables.
88 *
89 * @mdev: pointer to mic_device instance
90 *
91 * returns none.
92 */
93static void mic_ops_init(struct mic_device *mdev)
94{
95 switch (mdev->family) {
96 case MIC_FAMILY_X100:
97 mdev->ops = &mic_x100_ops;
98 mdev->intr_ops = &mic_x100_intr_ops;
99 mdev->smpt_ops = &mic_x100_smpt_ops;
100 break;
101 default:
102 break;
103 }
104}
105
106/**
107 * mic_get_family - Determine hardware family to which this MIC belongs.
108 *
109 * @pdev: The pci device structure
110 *
111 * returns family.
112 */
113static enum mic_hw_family mic_get_family(struct pci_dev *pdev)
114{
115 enum mic_hw_family family;
116
117 switch (pdev->device) {
118 case MIC_X100_PCI_DEVICE_2250:
119 case MIC_X100_PCI_DEVICE_2251:
120 case MIC_X100_PCI_DEVICE_2252:
121 case MIC_X100_PCI_DEVICE_2253:
122 case MIC_X100_PCI_DEVICE_2254:
123 case MIC_X100_PCI_DEVICE_2255:
124 case MIC_X100_PCI_DEVICE_2256:
125 case MIC_X100_PCI_DEVICE_2257:
126 case MIC_X100_PCI_DEVICE_2258:
127 case MIC_X100_PCI_DEVICE_2259:
128 case MIC_X100_PCI_DEVICE_225a:
129 case MIC_X100_PCI_DEVICE_225b:
130 case MIC_X100_PCI_DEVICE_225c:
131 case MIC_X100_PCI_DEVICE_225d:
132 case MIC_X100_PCI_DEVICE_225e:
133 family = MIC_FAMILY_X100;
134 break;
135 default:
136 family = MIC_FAMILY_UNKNOWN;
137 break;
138 }
139 return family;
140}
141
142/**
143 * mic_device_init - Allocates and initializes the MIC device structure
144 *
145 * @mdev: pointer to mic_device instance
146 * @pdev: The pci device structure
147 *
148 * returns none.
149 */
150static void
151mic_device_init(struct mic_device *mdev, struct pci_dev *pdev)
152{
153 mdev->pdev = pdev;
154 mdev->family = mic_get_family(pdev);
155 mdev->stepping = pdev->revision;
156 mic_ops_init(mdev);
157 mutex_init(&mdev->mic_mutex);
158 mdev->irq_info.next_avail_src = 0;
159}
160
161/**
162 * mic_probe - Device Initialization Routine
163 *
164 * @pdev: PCI device structure
165 * @ent: entry in mic_pci_tbl
166 *
167 * returns 0 on success, < 0 on failure.
168 */
169static int mic_probe(struct pci_dev *pdev,
170 const struct pci_device_id *ent)
171{
172 int rc;
173 struct mic_device *mdev;
174
175 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
176 if (!mdev) {
177 rc = -ENOMEM;
178 dev_err(&pdev->dev, "mdev kmalloc failed rc %d\n", rc);
179 goto mdev_alloc_fail;
180 }
181 mdev->id = ida_simple_get(&g_mic_ida, 0, MIC_MAX_NUM_DEVS, GFP_KERNEL);
182 if (mdev->id < 0) {
183 rc = mdev->id;
184 dev_err(&pdev->dev, "ida_simple_get failed rc %d\n", rc);
185 goto ida_fail;
186 }
187
188 mic_device_init(mdev, pdev);
189
190 rc = pci_enable_device(pdev);
191 if (rc) {
192 dev_err(&pdev->dev, "failed to enable pci device.\n");
193 goto ida_remove;
194 }
195
196 pci_set_master(pdev);
197
198 rc = pci_request_regions(pdev, mic_driver_name);
199 if (rc) {
200 dev_err(&pdev->dev, "failed to get pci regions.\n");
201 goto disable_device;
202 }
203
204 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
205 if (rc) {
206 dev_err(&pdev->dev, "Cannot set DMA mask\n");
207 goto release_regions;
208 }
209
210 mdev->mmio.pa = pci_resource_start(pdev, mdev->ops->mmio_bar);
211 mdev->mmio.len = pci_resource_len(pdev, mdev->ops->mmio_bar);
212 mdev->mmio.va = pci_ioremap_bar(pdev, mdev->ops->mmio_bar);
213 if (!mdev->mmio.va) {
214 dev_err(&pdev->dev, "Cannot remap MMIO BAR\n");
215 rc = -EIO;
216 goto release_regions;
217 }
218
219 mdev->aper.pa = pci_resource_start(pdev, mdev->ops->aper_bar);
220 mdev->aper.len = pci_resource_len(pdev, mdev->ops->aper_bar);
221 mdev->aper.va = ioremap_wc(mdev->aper.pa, mdev->aper.len);
222 if (!mdev->aper.va) {
223 dev_err(&pdev->dev, "Cannot remap Aperture BAR\n");
224 rc = -EIO;
225 goto unmap_mmio;
226 }
227
228 mdev->intr_ops->intr_init(mdev);
229 rc = mic_setup_interrupts(mdev, pdev);
230 if (rc) {
231 dev_err(&pdev->dev, "mic_setup_interrupts failed %d\n", rc);
232 goto unmap_aper;
233 }
234 rc = mic_smpt_init(mdev);
235 if (rc) {
236 dev_err(&pdev->dev, "smpt_init failed %d\n", rc);
237 goto free_interrupts;
238 }
239
240 pci_set_drvdata(pdev, mdev);
241
242 rc = mic_dp_init(mdev);
243 if (rc) {
244 dev_err(&pdev->dev, "mic_dp_init failed rc %d\n", rc);
245 goto smpt_uninit;
246 }
247 mic_bootparam_init(mdev);
248 mic_create_debug_dir(mdev);
249
250 mdev->cosm_dev = cosm_register_device(&mdev->pdev->dev, &cosm_hw_ops);
251 if (IS_ERR(mdev->cosm_dev)) {
252 rc = PTR_ERR(mdev->cosm_dev);
253 dev_err(&pdev->dev, "cosm_add_device failed rc %d\n", rc);
254 goto cleanup_debug_dir;
255 }
256 return 0;
257cleanup_debug_dir:
258 mic_delete_debug_dir(mdev);
259 mic_dp_uninit(mdev);
260smpt_uninit:
261 mic_smpt_uninit(mdev);
262free_interrupts:
263 mic_free_interrupts(mdev, pdev);
264unmap_aper:
265 iounmap(mdev->aper.va);
266unmap_mmio:
267 iounmap(mdev->mmio.va);
268release_regions:
269 pci_release_regions(pdev);
270disable_device:
271 pci_disable_device(pdev);
272ida_remove:
273 ida_simple_remove(&g_mic_ida, mdev->id);
274ida_fail:
275 kfree(mdev);
276mdev_alloc_fail:
277 dev_err(&pdev->dev, "Probe failed rc %d\n", rc);
278 return rc;
279}
280
281/**
282 * mic_remove - Device Removal Routine
283 * mic_remove is called by the PCI subsystem to alert the driver
284 * that it should release a PCI device.
285 *
286 * @pdev: PCI device structure
287 */
288static void mic_remove(struct pci_dev *pdev)
289{
290 struct mic_device *mdev;
291
292 mdev = pci_get_drvdata(pdev);
293 if (!mdev)
294 return;
295
296 cosm_unregister_device(mdev->cosm_dev);
297 mic_delete_debug_dir(mdev);
298 mic_dp_uninit(mdev);
299 mic_smpt_uninit(mdev);
300 mic_free_interrupts(mdev, pdev);
301 iounmap(mdev->aper.va);
302 iounmap(mdev->mmio.va);
303 pci_release_regions(pdev);
304 pci_disable_device(pdev);
305 ida_simple_remove(&g_mic_ida, mdev->id);
306 kfree(mdev);
307}
308
309static struct pci_driver mic_driver = {
310 .name = mic_driver_name,
311 .id_table = mic_pci_tbl,
312 .probe = mic_probe,
313 .remove = mic_remove
314};
315
316static int __init mic_init(void)
317{
318 int ret;
319
320 request_module("mic_x100_dma");
321 mic_init_debugfs();
322 ida_init(&g_mic_ida);
323 ret = pci_register_driver(&mic_driver);
324 if (ret) {
325 pr_err("pci_register_driver failed ret %d\n", ret);
326 goto cleanup_debugfs;
327 }
328 return 0;
329cleanup_debugfs:
330 ida_destroy(&g_mic_ida);
331 mic_exit_debugfs();
332 return ret;
333}
334
335static void __exit mic_exit(void)
336{
337 pci_unregister_driver(&mic_driver);
338 ida_destroy(&g_mic_ida);
339 mic_exit_debugfs();
340}
341
342module_init(mic_init);
343module_exit(mic_exit);
344
345MODULE_AUTHOR("Intel Corporation");
346MODULE_DESCRIPTION("Intel(R) MIC X100 Host driver");
347MODULE_LICENSE("GPL v2");