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/platform_device.h>
31 #include "../common/mic_dev.h"
32 #include "mic_device.h"
35 static const char mic_driver_name[] = "mic";
37 static struct mic_driver g_drv;
40 * mic_read_spad - read from the scratchpad register
41 * @mdev: pointer to mic_device instance
42 * @idx: index to scratchpad register, 0 based
44 * This function allows reading of the 32bit scratchpad register.
46 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
48 u32 mic_read_spad(struct mic_device *mdev, unsigned int idx)
50 return mic_mmio_read(&mdev->mmio,
51 MIC_X100_SBOX_BASE_ADDRESS +
52 MIC_X100_SBOX_SPAD0 + idx * 4);
56 * __mic_send_intr - Send interrupt to Host.
57 * @mdev: pointer to mic_device instance
58 * @doorbell: Doorbell number.
60 void mic_send_intr(struct mic_device *mdev, int doorbell)
62 struct mic_mw *mw = &mdev->mmio;
64 if (doorbell > MIC_X100_MAX_DOORBELL_IDX)
66 /* Ensure that the interrupt is ordered w.r.t previous stores. */
68 mic_mmio_write(mw, MIC_X100_SBOX_SDBIC0_DBREQ_BIT,
69 MIC_X100_SBOX_BASE_ADDRESS +
70 (MIC_X100_SBOX_SDBIC0 + (4 * doorbell)));
74 * mic_x100_send_sbox_intr - Send an MIC_X100_SBOX interrupt to MIC.
76 static void mic_x100_send_sbox_intr(struct mic_mw *mw, int doorbell)
78 u64 apic_icr_offset = MIC_X100_SBOX_APICICR0 + doorbell * 8;
79 u32 apicicr_low = mic_mmio_read(mw, MIC_X100_SBOX_BASE_ADDRESS +
82 /* for MIC we need to make sure we "hit" the send_icr bit (13) */
83 apicicr_low = (apicicr_low | (1 << 13));
85 * Ensure that the interrupt is ordered w.r.t. previous stores
86 * to main memory. Fence instructions are not implemented in X100
87 * since execution is in order but a compiler barrier is still
91 mic_mmio_write(mw, apicicr_low,
92 MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset);
95 static void mic_x100_send_rdmasr_intr(struct mic_mw *mw, int doorbell)
97 int rdmasr_offset = MIC_X100_SBOX_RDMASR0 + (doorbell << 2);
99 * Ensure that the interrupt is ordered w.r.t. previous stores
100 * to main memory. Fence instructions are not implemented in X100
101 * since execution is in order but a compiler barrier is still
105 mic_mmio_write(mw, 0, MIC_X100_SBOX_BASE_ADDRESS + rdmasr_offset);
109 * mic_ack_interrupt - Device specific interrupt handling.
110 * @mdev: pointer to mic_device instance
112 * Returns: bitmask of doorbell events triggered.
114 u32 mic_ack_interrupt(struct mic_device *mdev)
119 static inline int mic_get_sbox_irq(int db)
121 return MIC_X100_IRQ_BASE + db;
124 static inline int mic_get_rdmasr_irq(int index)
126 return MIC_X100_RDMASR_IRQ_BASE + index;
129 void mic_send_p2p_intr(int db, struct mic_mw *mw)
133 if (db < MIC_X100_NUM_SBOX_IRQ) {
134 mic_x100_send_sbox_intr(mw, db);
136 rdmasr_index = db - MIC_X100_NUM_SBOX_IRQ;
137 mic_x100_send_rdmasr_intr(mw, rdmasr_index);
142 * mic_hw_intr_init - Initialize h/w specific interrupt
144 * @mdrv: pointer to mic_driver
146 void mic_hw_intr_init(struct mic_driver *mdrv)
148 mdrv->intr_info.num_intr = MIC_X100_NUM_SBOX_IRQ +
149 MIC_X100_NUM_RDMASR_IRQ;
153 * mic_db_to_irq - Retrieve irq number corresponding to a doorbell.
154 * @mdrv: pointer to mic_driver
155 * @db: The doorbell obtained for which the irq is needed. Doorbell
156 * may correspond to an sbox doorbell or an rdmasr index.
158 * Returns the irq corresponding to the doorbell.
160 int mic_db_to_irq(struct mic_driver *mdrv, int db)
165 * The total number of doorbell interrupts on the card are 16. Indices
166 * 0-8 falls in the SBOX category and 8-15 fall in the RDMASR category.
168 if (db < MIC_X100_NUM_SBOX_IRQ) {
169 return mic_get_sbox_irq(db);
171 rdmasr_index = db - MIC_X100_NUM_SBOX_IRQ;
172 return mic_get_rdmasr_irq(rdmasr_index);
177 * mic_card_map - Allocate virtual address for a remote memory region.
178 * @mdev: pointer to mic_device instance.
179 * @addr: Remote DMA address.
180 * @size: Size of the region.
182 * Returns: Virtual address backing the remote memory region.
185 mic_card_map(struct mic_device *mdev, dma_addr_t addr, size_t size)
187 return ioremap(addr, size);
191 * mic_card_unmap - Unmap the virtual address for a remote memory region.
192 * @mdev: pointer to mic_device instance.
193 * @addr: Virtual address for remote memory region.
197 void mic_card_unmap(struct mic_device *mdev, void __iomem *addr)
202 static inline struct mic_driver *mbdev_to_mdrv(struct mbus_device *mbdev)
204 return dev_get_drvdata(mbdev->dev.parent);
207 static struct mic_irq *
208 _mic_request_threaded_irq(struct mbus_device *mbdev,
209 irq_handler_t handler, irq_handler_t thread_fn,
210 const char *name, void *data, int intr_src)
213 unsigned int irq = intr_src;
214 unsigned long cookie = irq;
216 rc = request_threaded_irq(irq, handler, thread_fn, 0, name, data);
218 dev_err(mbdev_to_mdrv(mbdev)->dev,
219 "request_threaded_irq failed rc = %d\n", rc);
222 return (struct mic_irq *)cookie;
225 static void _mic_free_irq(struct mbus_device *mbdev,
226 struct mic_irq *cookie, void *data)
228 unsigned long irq = (unsigned long)cookie;
232 static void _mic_ack_interrupt(struct mbus_device *mbdev, int num)
234 mic_ack_interrupt(&mbdev_to_mdrv(mbdev)->mdev);
237 static struct mbus_hw_ops mbus_hw_ops = {
238 .request_threaded_irq = _mic_request_threaded_irq,
239 .free_irq = _mic_free_irq,
240 .ack_interrupt = _mic_ack_interrupt,
243 static int __init mic_probe(struct platform_device *pdev)
245 struct mic_driver *mdrv = &g_drv;
246 struct mic_device *mdev = &mdrv->mdev;
249 mdrv->dev = &pdev->dev;
250 snprintf(mdrv->name, sizeof(mic_driver_name), mic_driver_name);
252 /* FIXME: use dma_set_mask_and_coherent() and check result */
253 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
255 mdev->mmio.pa = MIC_X100_MMIO_BASE;
256 mdev->mmio.len = MIC_X100_MMIO_LEN;
257 mdev->mmio.va = devm_ioremap(&pdev->dev, MIC_X100_MMIO_BASE,
259 if (!mdev->mmio.va) {
260 dev_err(&pdev->dev, "Cannot remap MMIO BAR\n");
264 mic_hw_intr_init(mdrv);
265 platform_set_drvdata(pdev, mdrv);
266 mdrv->dma_mbdev = mbus_register_device(mdrv->dev, MBUS_DEV_DMA_MIC,
267 NULL, &mbus_hw_ops, 0,
269 if (IS_ERR(mdrv->dma_mbdev)) {
270 rc = PTR_ERR(mdrv->dma_mbdev);
271 dev_err(&pdev->dev, "mbus_add_device failed rc %d\n", rc);
274 rc = mic_driver_init(mdrv);
276 dev_err(&pdev->dev, "mic_driver_init failed rc %d\n", rc);
282 mbus_unregister_device(mdrv->dma_mbdev);
286 static int mic_remove(struct platform_device *pdev)
288 struct mic_driver *mdrv = &g_drv;
290 mic_driver_uninit(mdrv);
291 mbus_unregister_device(mdrv->dma_mbdev);
295 static void mic_platform_shutdown(struct platform_device *pdev)
300 static struct platform_driver __refdata mic_platform_driver = {
302 .remove = mic_remove,
303 .shutdown = mic_platform_shutdown,
305 .name = mic_driver_name,
309 static struct platform_device *mic_platform_dev;
311 static int __init mic_init(void)
314 struct cpuinfo_x86 *c = &cpu_data(0);
316 if (!(c->x86 == 11 && c->x86_model == 1)) {
318 pr_err("%s not running on X100 ret %d\n", __func__, ret);
322 request_module("mic_x100_dma");
323 mic_init_card_debugfs();
325 mic_platform_dev = platform_device_register_simple(mic_driver_name,
327 ret = PTR_ERR_OR_ZERO(mic_platform_dev);
329 pr_err("platform_device_register_full ret %d\n", ret);
330 goto cleanup_debugfs;
332 ret = platform_driver_register(&mic_platform_driver);
334 pr_err("platform_driver_register ret %d\n", ret);
335 goto device_unregister;
340 platform_device_unregister(mic_platform_dev);
342 mic_exit_card_debugfs();
347 static void __exit mic_exit(void)
349 platform_driver_unregister(&mic_platform_driver);
350 platform_device_unregister(mic_platform_dev);
351 mic_exit_card_debugfs();
354 module_init(mic_init);
355 module_exit(mic_exit);
357 MODULE_AUTHOR("Intel Corporation");
358 MODULE_DESCRIPTION("Intel(R) MIC X100 Card driver");
359 MODULE_LICENSE("GPL v2");