Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 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 | * 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. |
| 23 | * |
| 24 | * Intel MIC Card driver. |
| 25 | * |
| 26 | */ |
| 27 | #include <linux/module.h> |
| 28 | #include <linux/pci.h> |
| 29 | #include <linux/interrupt.h> |
| 30 | #include <linux/reboot.h> |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 31 | #include <linux/dmaengine.h> |
| 32 | #include <linux/kmod.h> |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 33 | |
| 34 | #include <linux/mic_common.h> |
Sudeep Dutt | 4aa7996 | 2013-09-27 09:49:42 -0700 | [diff] [blame] | 35 | #include "../common/mic_dev.h" |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 36 | #include "mic_device.h" |
| 37 | |
| 38 | static struct mic_driver *g_drv; |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 39 | |
| 40 | static int __init mic_dp_init(void) |
| 41 | { |
| 42 | struct mic_driver *mdrv = g_drv; |
| 43 | struct mic_device *mdev = &mdrv->mdev; |
| 44 | struct mic_bootparam __iomem *bootparam; |
| 45 | u64 lo, hi, dp_dma_addr; |
| 46 | u32 magic; |
| 47 | |
| 48 | lo = mic_read_spad(&mdrv->mdev, MIC_DPLO_SPAD); |
| 49 | hi = mic_read_spad(&mdrv->mdev, MIC_DPHI_SPAD); |
| 50 | |
| 51 | dp_dma_addr = lo | (hi << 32); |
| 52 | mdrv->dp = mic_card_map(mdev, dp_dma_addr, MIC_DP_SIZE); |
| 53 | if (!mdrv->dp) { |
| 54 | dev_err(mdrv->dev, "Cannot remap Aperture BAR\n"); |
| 55 | return -ENOMEM; |
| 56 | } |
| 57 | bootparam = mdrv->dp; |
| 58 | magic = ioread32(&bootparam->magic); |
| 59 | if (MIC_MAGIC != magic) { |
| 60 | dev_err(mdrv->dev, "bootparam magic mismatch 0x%x\n", magic); |
| 61 | return -EIO; |
| 62 | } |
| 63 | return 0; |
| 64 | } |
| 65 | |
| 66 | /* Uninitialize the device page */ |
| 67 | static void mic_dp_uninit(void) |
| 68 | { |
| 69 | mic_card_unmap(&g_drv->mdev, g_drv->dp); |
| 70 | } |
| 71 | |
| 72 | /** |
| 73 | * mic_request_card_irq - request an irq. |
| 74 | * |
Siva Yerramreddy | 9c3d37c | 2014-07-11 14:04:24 -0700 | [diff] [blame] | 75 | * @handler: interrupt handler passed to request_threaded_irq. |
| 76 | * @thread_fn: thread fn. passed to request_threaded_irq. |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 77 | * @name: The ASCII name of the callee requesting the irq. |
| 78 | * @data: private data that is returned back when calling the |
| 79 | * function handler. |
| 80 | * @index: The doorbell index of the requester. |
| 81 | * |
| 82 | * returns: The cookie that is transparent to the caller. Passed |
| 83 | * back when calling mic_free_irq. An appropriate error code |
| 84 | * is returned on failure. Caller needs to use IS_ERR(return_val) |
| 85 | * to check for failure and PTR_ERR(return_val) to obtained the |
| 86 | * error code. |
| 87 | * |
| 88 | */ |
Siva Yerramreddy | 9c3d37c | 2014-07-11 14:04:24 -0700 | [diff] [blame] | 89 | struct mic_irq * |
| 90 | mic_request_card_irq(irq_handler_t handler, |
| 91 | irq_handler_t thread_fn, const char *name, |
| 92 | void *data, int index) |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 93 | { |
| 94 | int rc = 0; |
| 95 | unsigned long cookie; |
| 96 | struct mic_driver *mdrv = g_drv; |
| 97 | |
Siva Yerramreddy | 9c3d37c | 2014-07-11 14:04:24 -0700 | [diff] [blame] | 98 | rc = request_threaded_irq(mic_db_to_irq(mdrv, index), handler, |
| 99 | thread_fn, 0, name, data); |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 100 | if (rc) { |
Siva Yerramreddy | 9c3d37c | 2014-07-11 14:04:24 -0700 | [diff] [blame] | 101 | dev_err(mdrv->dev, "request_threaded_irq failed rc = %d\n", rc); |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 102 | goto err; |
| 103 | } |
| 104 | mdrv->irq_info.irq_usage_count[index]++; |
| 105 | cookie = index; |
| 106 | return (struct mic_irq *)cookie; |
| 107 | err: |
| 108 | return ERR_PTR(rc); |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | /** |
| 112 | * mic_free_card_irq - free irq. |
| 113 | * |
Siva Yerramreddy | 9c3d37c | 2014-07-11 14:04:24 -0700 | [diff] [blame] | 114 | * @cookie: cookie obtained during a successful call to mic_request_threaded_irq |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 115 | * @data: private data specified by the calling function during the |
Siva Yerramreddy | 9c3d37c | 2014-07-11 14:04:24 -0700 | [diff] [blame] | 116 | * mic_request_threaded_irq |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 117 | * |
| 118 | * returns: none. |
| 119 | */ |
| 120 | void mic_free_card_irq(struct mic_irq *cookie, void *data) |
| 121 | { |
| 122 | int index; |
| 123 | struct mic_driver *mdrv = g_drv; |
| 124 | |
| 125 | index = (unsigned long)cookie & 0xFFFFU; |
| 126 | free_irq(mic_db_to_irq(mdrv, index), data); |
| 127 | mdrv->irq_info.irq_usage_count[index]--; |
| 128 | } |
| 129 | |
| 130 | /** |
| 131 | * mic_next_card_db - Get the doorbell with minimum usage count. |
| 132 | * |
| 133 | * Returns the irq index. |
| 134 | */ |
| 135 | int mic_next_card_db(void) |
| 136 | { |
| 137 | int i; |
| 138 | int index = 0; |
| 139 | struct mic_driver *mdrv = g_drv; |
| 140 | |
| 141 | for (i = 0; i < mdrv->intr_info.num_intr; i++) { |
| 142 | if (mdrv->irq_info.irq_usage_count[i] < |
| 143 | mdrv->irq_info.irq_usage_count[index]) |
| 144 | index = i; |
| 145 | } |
| 146 | |
| 147 | return index; |
| 148 | } |
| 149 | |
| 150 | /** |
| 151 | * mic_init_irq - Initialize irq information. |
| 152 | * |
| 153 | * Returns 0 in success. Appropriate error code on failure. |
| 154 | */ |
| 155 | static int mic_init_irq(void) |
| 156 | { |
| 157 | struct mic_driver *mdrv = g_drv; |
| 158 | |
| 159 | mdrv->irq_info.irq_usage_count = kzalloc((sizeof(u32) * |
| 160 | mdrv->intr_info.num_intr), |
| 161 | GFP_KERNEL); |
| 162 | if (!mdrv->irq_info.irq_usage_count) |
| 163 | return -ENOMEM; |
| 164 | return 0; |
| 165 | } |
| 166 | |
| 167 | /** |
| 168 | * mic_uninit_irq - Uninitialize irq information. |
| 169 | * |
| 170 | * None. |
| 171 | */ |
| 172 | static void mic_uninit_irq(void) |
| 173 | { |
| 174 | struct mic_driver *mdrv = g_drv; |
| 175 | |
| 176 | kfree(mdrv->irq_info.irq_usage_count); |
| 177 | } |
| 178 | |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 179 | static inline struct mic_driver *scdev_to_mdrv(struct scif_hw_dev *scdev) |
| 180 | { |
| 181 | return dev_get_drvdata(scdev->dev.parent); |
| 182 | } |
| 183 | |
| 184 | static struct mic_irq * |
| 185 | ___mic_request_irq(struct scif_hw_dev *scdev, |
| 186 | irqreturn_t (*func)(int irq, void *data), |
| 187 | const char *name, void *data, |
| 188 | int db) |
| 189 | { |
| 190 | return mic_request_card_irq(func, NULL, name, data, db); |
| 191 | } |
| 192 | |
| 193 | static void |
| 194 | ___mic_free_irq(struct scif_hw_dev *scdev, |
| 195 | struct mic_irq *cookie, void *data) |
| 196 | { |
| 197 | return mic_free_card_irq(cookie, data); |
| 198 | } |
| 199 | |
| 200 | static void ___mic_ack_interrupt(struct scif_hw_dev *scdev, int num) |
| 201 | { |
| 202 | struct mic_driver *mdrv = scdev_to_mdrv(scdev); |
| 203 | |
| 204 | mic_ack_interrupt(&mdrv->mdev); |
| 205 | } |
| 206 | |
| 207 | static int ___mic_next_db(struct scif_hw_dev *scdev) |
| 208 | { |
| 209 | return mic_next_card_db(); |
| 210 | } |
| 211 | |
| 212 | static void ___mic_send_intr(struct scif_hw_dev *scdev, int db) |
| 213 | { |
| 214 | struct mic_driver *mdrv = scdev_to_mdrv(scdev); |
| 215 | |
| 216 | mic_send_intr(&mdrv->mdev, db); |
| 217 | } |
| 218 | |
| 219 | static void ___mic_send_p2p_intr(struct scif_hw_dev *scdev, int db, |
| 220 | struct mic_mw *mw) |
| 221 | { |
| 222 | mic_send_p2p_intr(db, mw); |
| 223 | } |
| 224 | |
| 225 | static void __iomem * |
| 226 | ___mic_ioremap(struct scif_hw_dev *scdev, |
| 227 | phys_addr_t pa, size_t len) |
| 228 | { |
| 229 | struct mic_driver *mdrv = scdev_to_mdrv(scdev); |
| 230 | |
| 231 | return mic_card_map(&mdrv->mdev, pa, len); |
| 232 | } |
| 233 | |
| 234 | static void ___mic_iounmap(struct scif_hw_dev *scdev, void __iomem *va) |
| 235 | { |
| 236 | struct mic_driver *mdrv = scdev_to_mdrv(scdev); |
| 237 | |
| 238 | mic_card_unmap(&mdrv->mdev, va); |
| 239 | } |
| 240 | |
| 241 | static struct scif_hw_ops scif_hw_ops = { |
| 242 | .request_irq = ___mic_request_irq, |
| 243 | .free_irq = ___mic_free_irq, |
| 244 | .ack_interrupt = ___mic_ack_interrupt, |
| 245 | .next_db = ___mic_next_db, |
| 246 | .send_intr = ___mic_send_intr, |
| 247 | .send_p2p_intr = ___mic_send_p2p_intr, |
| 248 | .ioremap = ___mic_ioremap, |
| 249 | .iounmap = ___mic_iounmap, |
| 250 | }; |
| 251 | |
Sudeep Dutt | c74c931 | 2016-02-08 15:48:18 -0800 | [diff] [blame] | 252 | static inline struct mic_driver *vpdev_to_mdrv(struct vop_device *vpdev) |
| 253 | { |
| 254 | return dev_get_drvdata(vpdev->dev.parent); |
| 255 | } |
| 256 | |
| 257 | static struct mic_irq * |
| 258 | __mic_request_irq(struct vop_device *vpdev, |
| 259 | irqreturn_t (*func)(int irq, void *data), |
| 260 | const char *name, void *data, int intr_src) |
| 261 | { |
| 262 | return mic_request_card_irq(func, NULL, name, data, intr_src); |
| 263 | } |
| 264 | |
| 265 | static void __mic_free_irq(struct vop_device *vpdev, |
| 266 | struct mic_irq *cookie, void *data) |
| 267 | { |
| 268 | return mic_free_card_irq(cookie, data); |
| 269 | } |
| 270 | |
| 271 | static void __mic_ack_interrupt(struct vop_device *vpdev, int num) |
| 272 | { |
| 273 | struct mic_driver *mdrv = vpdev_to_mdrv(vpdev); |
| 274 | |
| 275 | mic_ack_interrupt(&mdrv->mdev); |
| 276 | } |
| 277 | |
| 278 | static int __mic_next_db(struct vop_device *vpdev) |
| 279 | { |
| 280 | return mic_next_card_db(); |
| 281 | } |
| 282 | |
| 283 | static void __iomem *__mic_get_remote_dp(struct vop_device *vpdev) |
| 284 | { |
| 285 | struct mic_driver *mdrv = vpdev_to_mdrv(vpdev); |
| 286 | |
| 287 | return mdrv->dp; |
| 288 | } |
| 289 | |
| 290 | static void __mic_send_intr(struct vop_device *vpdev, int db) |
| 291 | { |
| 292 | struct mic_driver *mdrv = vpdev_to_mdrv(vpdev); |
| 293 | |
| 294 | mic_send_intr(&mdrv->mdev, db); |
| 295 | } |
| 296 | |
| 297 | static void __iomem *__mic_ioremap(struct vop_device *vpdev, |
| 298 | dma_addr_t pa, size_t len) |
| 299 | { |
| 300 | struct mic_driver *mdrv = vpdev_to_mdrv(vpdev); |
| 301 | |
| 302 | return mic_card_map(&mdrv->mdev, pa, len); |
| 303 | } |
| 304 | |
| 305 | static void __mic_iounmap(struct vop_device *vpdev, void __iomem *va) |
| 306 | { |
| 307 | struct mic_driver *mdrv = vpdev_to_mdrv(vpdev); |
| 308 | |
| 309 | mic_card_unmap(&mdrv->mdev, va); |
| 310 | } |
| 311 | |
| 312 | static struct vop_hw_ops vop_hw_ops = { |
| 313 | .request_irq = __mic_request_irq, |
| 314 | .free_irq = __mic_free_irq, |
| 315 | .ack_interrupt = __mic_ack_interrupt, |
| 316 | .next_db = __mic_next_db, |
| 317 | .get_remote_dp = __mic_get_remote_dp, |
| 318 | .send_intr = __mic_send_intr, |
| 319 | .ioremap = __mic_ioremap, |
| 320 | .iounmap = __mic_iounmap, |
| 321 | }; |
| 322 | |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 323 | static int mic_request_dma_chans(struct mic_driver *mdrv) |
| 324 | { |
| 325 | dma_cap_mask_t mask; |
| 326 | struct dma_chan *chan; |
| 327 | |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 328 | dma_cap_zero(mask); |
| 329 | dma_cap_set(DMA_MEMCPY, mask); |
| 330 | |
| 331 | do { |
| 332 | chan = dma_request_channel(mask, NULL, NULL); |
| 333 | if (chan) { |
| 334 | mdrv->dma_ch[mdrv->num_dma_ch++] = chan; |
| 335 | if (mdrv->num_dma_ch >= MIC_MAX_DMA_CHAN) |
| 336 | break; |
| 337 | } |
| 338 | } while (chan); |
| 339 | dev_info(mdrv->dev, "DMA channels # %d\n", mdrv->num_dma_ch); |
| 340 | return mdrv->num_dma_ch; |
| 341 | } |
| 342 | |
| 343 | static void mic_free_dma_chans(struct mic_driver *mdrv) |
| 344 | { |
| 345 | int i = 0; |
| 346 | |
| 347 | for (i = 0; i < mdrv->num_dma_ch; i++) { |
| 348 | dma_release_channel(mdrv->dma_ch[i]); |
| 349 | mdrv->dma_ch[i] = NULL; |
| 350 | } |
| 351 | mdrv->num_dma_ch = 0; |
| 352 | } |
| 353 | |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 354 | /* |
| 355 | * mic_driver_init - MIC driver initialization tasks. |
| 356 | * |
| 357 | * Returns 0 in success. Appropriate error code on failure. |
| 358 | */ |
| 359 | int __init mic_driver_init(struct mic_driver *mdrv) |
| 360 | { |
| 361 | int rc; |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 362 | struct mic_bootparam __iomem *bootparam; |
| 363 | u8 node_id; |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 364 | |
| 365 | g_drv = mdrv; |
Ashutosh Dixit | d411e79 | 2015-09-29 18:13:54 -0700 | [diff] [blame] | 366 | /* Unloading the card module is not supported. */ |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 367 | if (!try_module_get(mdrv->dev->driver->owner)) { |
| 368 | rc = -ENODEV; |
| 369 | goto done; |
| 370 | } |
| 371 | rc = mic_dp_init(); |
| 372 | if (rc) |
| 373 | goto put; |
| 374 | rc = mic_init_irq(); |
| 375 | if (rc) |
| 376 | goto dp_uninit; |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 377 | if (!mic_request_dma_chans(mdrv)) { |
| 378 | rc = -ENODEV; |
Ashutosh Dixit | d411e79 | 2015-09-29 18:13:54 -0700 | [diff] [blame] | 379 | goto irq_uninit; |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 380 | } |
Sudeep Dutt | c74c931 | 2016-02-08 15:48:18 -0800 | [diff] [blame] | 381 | mdrv->vpdev = vop_register_device(mdrv->dev, VOP_DEV_TRNSP, |
| 382 | NULL, &vop_hw_ops, 0, |
| 383 | NULL, mdrv->dma_ch[0]); |
| 384 | if (IS_ERR(mdrv->vpdev)) { |
| 385 | rc = PTR_ERR(mdrv->vpdev); |
| 386 | goto dma_free; |
| 387 | } |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 388 | bootparam = mdrv->dp; |
| 389 | node_id = ioread8(&bootparam->node_id); |
| 390 | mdrv->scdev = scif_register_device(mdrv->dev, MIC_SCIF_DEV, |
| 391 | NULL, &scif_hw_ops, |
| 392 | 0, node_id, &mdrv->mdev.mmio, NULL, |
| 393 | NULL, mdrv->dp, mdrv->dma_ch, |
Ashutosh Dixit | d411e79 | 2015-09-29 18:13:54 -0700 | [diff] [blame] | 394 | mdrv->num_dma_ch, true); |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 395 | if (IS_ERR(mdrv->scdev)) { |
| 396 | rc = PTR_ERR(mdrv->scdev); |
Sudeep Dutt | c74c931 | 2016-02-08 15:48:18 -0800 | [diff] [blame] | 397 | goto vop_remove; |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 398 | } |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 399 | mic_create_card_debug_dir(mdrv); |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 400 | done: |
| 401 | return rc; |
Sudeep Dutt | c74c931 | 2016-02-08 15:48:18 -0800 | [diff] [blame] | 402 | vop_remove: |
| 403 | vop_unregister_device(mdrv->vpdev); |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 404 | dma_free: |
| 405 | mic_free_dma_chans(mdrv); |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 406 | irq_uninit: |
| 407 | mic_uninit_irq(); |
| 408 | dp_uninit: |
| 409 | mic_dp_uninit(); |
| 410 | put: |
| 411 | module_put(mdrv->dev->driver->owner); |
| 412 | return rc; |
| 413 | } |
| 414 | |
| 415 | /* |
| 416 | * mic_driver_uninit - MIC driver uninitialization tasks. |
| 417 | * |
| 418 | * Returns None |
| 419 | */ |
| 420 | void mic_driver_uninit(struct mic_driver *mdrv) |
| 421 | { |
| 422 | mic_delete_card_debug_dir(mdrv); |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 423 | scif_unregister_device(mdrv->scdev); |
Sudeep Dutt | c74c931 | 2016-02-08 15:48:18 -0800 | [diff] [blame] | 424 | vop_unregister_device(mdrv->vpdev); |
Sudeep Dutt | dd8d8d4 | 2015-04-29 05:32:39 -0700 | [diff] [blame] | 425 | mic_free_dma_chans(mdrv); |
Sudeep Dutt | aa27bad | 2013-09-05 16:42:06 -0700 | [diff] [blame] | 426 | mic_uninit_irq(); |
| 427 | mic_dp_uninit(); |
| 428 | module_put(mdrv->dev->driver->owner); |
| 429 | } |