2 * Intel MIC Platform Software Stack (MPSS)
4 * Copyright(c) 2013 Intel Corporation.
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.
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.
15 * The full GNU General Public License is included in this distribution in
16 * the file called "COPYING".
18 * Disclaimer: The codes contained in these modules may be specific to
19 * the Intel Software Development Platform codenamed: Knights Ferry, and
20 * the Intel product codenamed: Knights Corner, and are not backward
21 * compatible with other Intel products. Additionally, Intel will NOT
22 * support the codes or instruction set in future products.
24 * Intel MIC Card driver.
27 #include <linux/module.h>
28 #include <linux/pci.h>
29 #include <linux/interrupt.h>
30 #include <linux/reboot.h>
31 #include <linux/dmaengine.h>
32 #include <linux/kmod.h>
34 #include <linux/mic_common.h>
35 #include "../common/mic_dev.h"
36 #include "mic_device.h"
37 #include "mic_virtio.h"
39 static struct mic_driver *g_drv;
41 static int __init mic_dp_init(void)
43 struct mic_driver *mdrv = g_drv;
44 struct mic_device *mdev = &mdrv->mdev;
45 struct mic_bootparam __iomem *bootparam;
46 u64 lo, hi, dp_dma_addr;
49 lo = mic_read_spad(&mdrv->mdev, MIC_DPLO_SPAD);
50 hi = mic_read_spad(&mdrv->mdev, MIC_DPHI_SPAD);
52 dp_dma_addr = lo | (hi << 32);
53 mdrv->dp = mic_card_map(mdev, dp_dma_addr, MIC_DP_SIZE);
55 dev_err(mdrv->dev, "Cannot remap Aperture BAR\n");
59 magic = ioread32(&bootparam->magic);
60 if (MIC_MAGIC != magic) {
61 dev_err(mdrv->dev, "bootparam magic mismatch 0x%x\n", magic);
67 /* Uninitialize the device page */
68 static void mic_dp_uninit(void)
70 mic_card_unmap(&g_drv->mdev, g_drv->dp);
74 * mic_request_card_irq - request an irq.
76 * @handler: interrupt handler passed to request_threaded_irq.
77 * @thread_fn: thread fn. passed to request_threaded_irq.
78 * @name: The ASCII name of the callee requesting the irq.
79 * @data: private data that is returned back when calling the
81 * @index: The doorbell index of the requester.
83 * returns: The cookie that is transparent to the caller. Passed
84 * back when calling mic_free_irq. An appropriate error code
85 * is returned on failure. Caller needs to use IS_ERR(return_val)
86 * to check for failure and PTR_ERR(return_val) to obtained the
91 mic_request_card_irq(irq_handler_t handler,
92 irq_handler_t thread_fn, const char *name,
93 void *data, int index)
97 struct mic_driver *mdrv = g_drv;
99 rc = request_threaded_irq(mic_db_to_irq(mdrv, index), handler,
100 thread_fn, 0, name, data);
102 dev_err(mdrv->dev, "request_threaded_irq failed rc = %d\n", rc);
105 mdrv->irq_info.irq_usage_count[index]++;
107 return (struct mic_irq *)cookie;
113 * mic_free_card_irq - free irq.
115 * @cookie: cookie obtained during a successful call to mic_request_threaded_irq
116 * @data: private data specified by the calling function during the
117 * mic_request_threaded_irq
121 void mic_free_card_irq(struct mic_irq *cookie, void *data)
124 struct mic_driver *mdrv = g_drv;
126 index = (unsigned long)cookie & 0xFFFFU;
127 free_irq(mic_db_to_irq(mdrv, index), data);
128 mdrv->irq_info.irq_usage_count[index]--;
132 * mic_next_card_db - Get the doorbell with minimum usage count.
134 * Returns the irq index.
136 int mic_next_card_db(void)
140 struct mic_driver *mdrv = g_drv;
142 for (i = 0; i < mdrv->intr_info.num_intr; i++) {
143 if (mdrv->irq_info.irq_usage_count[i] <
144 mdrv->irq_info.irq_usage_count[index])
152 * mic_init_irq - Initialize irq information.
154 * Returns 0 in success. Appropriate error code on failure.
156 static int mic_init_irq(void)
158 struct mic_driver *mdrv = g_drv;
160 mdrv->irq_info.irq_usage_count = kzalloc((sizeof(u32) *
161 mdrv->intr_info.num_intr),
163 if (!mdrv->irq_info.irq_usage_count)
169 * mic_uninit_irq - Uninitialize irq information.
173 static void mic_uninit_irq(void)
175 struct mic_driver *mdrv = g_drv;
177 kfree(mdrv->irq_info.irq_usage_count);
180 static inline struct mic_driver *scdev_to_mdrv(struct scif_hw_dev *scdev)
182 return dev_get_drvdata(scdev->dev.parent);
185 static struct mic_irq *
186 ___mic_request_irq(struct scif_hw_dev *scdev,
187 irqreturn_t (*func)(int irq, void *data),
188 const char *name, void *data,
191 return mic_request_card_irq(func, NULL, name, data, db);
195 ___mic_free_irq(struct scif_hw_dev *scdev,
196 struct mic_irq *cookie, void *data)
198 return mic_free_card_irq(cookie, data);
201 static void ___mic_ack_interrupt(struct scif_hw_dev *scdev, int num)
203 struct mic_driver *mdrv = scdev_to_mdrv(scdev);
205 mic_ack_interrupt(&mdrv->mdev);
208 static int ___mic_next_db(struct scif_hw_dev *scdev)
210 return mic_next_card_db();
213 static void ___mic_send_intr(struct scif_hw_dev *scdev, int db)
215 struct mic_driver *mdrv = scdev_to_mdrv(scdev);
217 mic_send_intr(&mdrv->mdev, db);
220 static void ___mic_send_p2p_intr(struct scif_hw_dev *scdev, int db,
223 mic_send_p2p_intr(db, mw);
226 static void __iomem *
227 ___mic_ioremap(struct scif_hw_dev *scdev,
228 phys_addr_t pa, size_t len)
230 struct mic_driver *mdrv = scdev_to_mdrv(scdev);
232 return mic_card_map(&mdrv->mdev, pa, len);
235 static void ___mic_iounmap(struct scif_hw_dev *scdev, void __iomem *va)
237 struct mic_driver *mdrv = scdev_to_mdrv(scdev);
239 mic_card_unmap(&mdrv->mdev, va);
242 static struct scif_hw_ops scif_hw_ops = {
243 .request_irq = ___mic_request_irq,
244 .free_irq = ___mic_free_irq,
245 .ack_interrupt = ___mic_ack_interrupt,
246 .next_db = ___mic_next_db,
247 .send_intr = ___mic_send_intr,
248 .send_p2p_intr = ___mic_send_p2p_intr,
249 .ioremap = ___mic_ioremap,
250 .iounmap = ___mic_iounmap,
253 static int mic_request_dma_chans(struct mic_driver *mdrv)
256 struct dma_chan *chan;
258 request_module("mic_x100_dma");
260 dma_cap_set(DMA_MEMCPY, mask);
263 chan = dma_request_channel(mask, NULL, NULL);
265 mdrv->dma_ch[mdrv->num_dma_ch++] = chan;
266 if (mdrv->num_dma_ch >= MIC_MAX_DMA_CHAN)
270 dev_info(mdrv->dev, "DMA channels # %d\n", mdrv->num_dma_ch);
271 return mdrv->num_dma_ch;
274 static void mic_free_dma_chans(struct mic_driver *mdrv)
278 for (i = 0; i < mdrv->num_dma_ch; i++) {
279 dma_release_channel(mdrv->dma_ch[i]);
280 mdrv->dma_ch[i] = NULL;
282 mdrv->num_dma_ch = 0;
286 * mic_driver_init - MIC driver initialization tasks.
288 * Returns 0 in success. Appropriate error code on failure.
290 int __init mic_driver_init(struct mic_driver *mdrv)
293 struct mic_bootparam __iomem *bootparam;
297 /* Unloading the card module is not supported. */
298 if (!try_module_get(mdrv->dev->driver->owner)) {
308 if (!mic_request_dma_chans(mdrv)) {
312 rc = mic_devices_init(mdrv);
315 bootparam = mdrv->dp;
316 node_id = ioread8(&bootparam->node_id);
317 mdrv->scdev = scif_register_device(mdrv->dev, MIC_SCIF_DEV,
319 0, node_id, &mdrv->mdev.mmio, NULL,
320 NULL, mdrv->dp, mdrv->dma_ch,
321 mdrv->num_dma_ch, true);
322 if (IS_ERR(mdrv->scdev)) {
323 rc = PTR_ERR(mdrv->scdev);
326 mic_create_card_debug_dir(mdrv);
330 mic_devices_uninit(mdrv);
332 mic_free_dma_chans(mdrv);
338 module_put(mdrv->dev->driver->owner);
343 * mic_driver_uninit - MIC driver uninitialization tasks.
347 void mic_driver_uninit(struct mic_driver *mdrv)
349 mic_delete_card_debug_dir(mdrv);
350 scif_unregister_device(mdrv->scdev);
351 mic_devices_uninit(mdrv);
352 mic_free_dma_chans(mdrv);
355 module_put(mdrv->dev->driver->owner);