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 * Global TODO's across the driver to be added after initial base 21 * patches are accepted upstream: 22 * 1) Enable DMA support. 23 * 2) Enable per vring interrupt support. 24 */ 25#include <linux/fs.h> 26#include <linux/module.h> 27#include <linux/pci.h> 28#include <linux/poll.h> 29#include <linux/suspend.h> 30 31#include <linux/mic_common.h> 32#include "../common/mic_dev.h" 33#include "mic_device.h" 34#include "mic_x100.h" 35#include "mic_smpt.h" 36#include "mic_fops.h" 37#include "mic_virtio.h" 38 39static const char mic_driver_name[] = "mic"; 40 41static const struct pci_device_id mic_pci_tbl[] = { 42 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2250)}, 43 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2251)}, 44 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2252)}, 45 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2253)}, 46 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2254)}, 47 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2255)}, 48 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2256)}, 49 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2257)}, 50 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2258)}, 51 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2259)}, 52 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225a)}, 53 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225b)}, 54 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225c)}, 55 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225d)}, 56 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225e)}, 57 58 /* required last entry */ 59 { 0, } 60}; 61 62MODULE_DEVICE_TABLE(pci, mic_pci_tbl); 63 64/* ID allocator for MIC devices */ 65static struct ida g_mic_ida; 66/* Class of MIC devices for sysfs accessibility. */ 67static struct class *g_mic_class; 68/* Base device node number for MIC devices */ 69static dev_t g_mic_devno; 70 71static const struct file_operations mic_fops = { 72 .open = mic_open, 73 .release = mic_release, 74 .unlocked_ioctl = mic_ioctl, 75 .poll = mic_poll, 76 .mmap = mic_mmap, 77 .owner = THIS_MODULE, 78}; 79 80/* Initialize the device page */ 81static int mic_dp_init(struct mic_device *mdev) 82{ 83 mdev->dp = kzalloc(MIC_DP_SIZE, GFP_KERNEL); 84 if (!mdev->dp) { 85 dev_err(mdev->sdev->parent, "%s %d err %d\n", 86 __func__, __LINE__, -ENOMEM); 87 return -ENOMEM; 88 } 89 90 mdev->dp_dma_addr = mic_map_single(mdev, 91 mdev->dp, MIC_DP_SIZE); 92 if (mic_map_error(mdev->dp_dma_addr)) { 93 kfree(mdev->dp); 94 dev_err(mdev->sdev->parent, "%s %d err %d\n", 95 __func__, __LINE__, -ENOMEM); 96 return -ENOMEM; 97 } 98 mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr); 99 mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32); 100 return 0; 101} 102 103/* Uninitialize the device page */ 104static void mic_dp_uninit(struct mic_device *mdev) 105{ 106 mic_unmap_single(mdev, mdev->dp_dma_addr, MIC_DP_SIZE); 107 kfree(mdev->dp); 108} 109 110/** 111 * mic_shutdown_db - Shutdown doorbell interrupt handler. 112 */ 113static irqreturn_t mic_shutdown_db(int irq, void *data) 114{ 115 struct mic_device *mdev = data; 116 struct mic_bootparam *bootparam = mdev->dp; 117 118 mdev->ops->intr_workarounds(mdev); 119 120 switch (bootparam->shutdown_status) { 121 case MIC_HALTED: 122 case MIC_POWER_OFF: 123 case MIC_RESTART: 124 /* Fall through */ 125 case MIC_CRASHED: 126 schedule_work(&mdev->shutdown_work); 127 break; 128 default: 129 break; 130 }; 131 return IRQ_HANDLED; 132} 133 134/** 135 * mic_ops_init: Initialize HW specific operation tables. 136 * 137 * @mdev: pointer to mic_device instance 138 * 139 * returns none. 140 */ 141static void mic_ops_init(struct mic_device *mdev) 142{ 143 switch (mdev->family) { 144 case MIC_FAMILY_X100: 145 mdev->ops = &mic_x100_ops; 146 mdev->intr_ops = &mic_x100_intr_ops; 147 mdev->smpt_ops = &mic_x100_smpt_ops; 148 break; 149 default: 150 break; 151 } 152} 153 154/** 155 * mic_get_family - Determine hardware family to which this MIC belongs. 156 * 157 * @pdev: The pci device structure 158 * 159 * returns family. 160 */ 161static enum mic_hw_family mic_get_family(struct pci_dev *pdev) 162{ 163 enum mic_hw_family family; 164 165 switch (pdev->device) { 166 case MIC_X100_PCI_DEVICE_2250: 167 case MIC_X100_PCI_DEVICE_2251: 168 case MIC_X100_PCI_DEVICE_2252: 169 case MIC_X100_PCI_DEVICE_2253: 170 case MIC_X100_PCI_DEVICE_2254: 171 case MIC_X100_PCI_DEVICE_2255: 172 case MIC_X100_PCI_DEVICE_2256: 173 case MIC_X100_PCI_DEVICE_2257: 174 case MIC_X100_PCI_DEVICE_2258: 175 case MIC_X100_PCI_DEVICE_2259: 176 case MIC_X100_PCI_DEVICE_225a: 177 case MIC_X100_PCI_DEVICE_225b: 178 case MIC_X100_PCI_DEVICE_225c: 179 case MIC_X100_PCI_DEVICE_225d: 180 case MIC_X100_PCI_DEVICE_225e: 181 family = MIC_FAMILY_X100; 182 break; 183 default: 184 family = MIC_FAMILY_UNKNOWN; 185 break; 186 } 187 return family; 188} 189 190/** 191* mic_pm_notifier: Notifier callback function that handles 192* PM notifications. 193* 194* @notifier_block: The notifier structure. 195* @pm_event: The event for which the driver was notified. 196* @unused: Meaningless. Always NULL. 197* 198* returns NOTIFY_DONE 199*/ 200static int mic_pm_notifier(struct notifier_block *notifier, 201 unsigned long pm_event, void *unused) 202{ 203 struct mic_device *mdev = container_of(notifier, 204 struct mic_device, pm_notifier); 205 206 switch (pm_event) { 207 case PM_HIBERNATION_PREPARE: 208 /* Fall through */ 209 case PM_SUSPEND_PREPARE: 210 mic_prepare_suspend(mdev); 211 break; 212 case PM_POST_HIBERNATION: 213 /* Fall through */ 214 case PM_POST_SUSPEND: 215 /* Fall through */ 216 case PM_POST_RESTORE: 217 mic_complete_resume(mdev); 218 break; 219 case PM_RESTORE_PREPARE: 220 break; 221 default: 222 break; 223 } 224 return NOTIFY_DONE; 225} 226 227/** 228 * mic_device_init - Allocates and initializes the MIC device structure 229 * 230 * @mdev: pointer to mic_device instance 231 * @pdev: The pci device structure 232 * 233 * returns none. 234 */ 235static int 236mic_device_init(struct mic_device *mdev, struct pci_dev *pdev) 237{ 238 int rc; 239 240 mdev->family = mic_get_family(pdev); 241 mdev->stepping = pdev->revision; 242 mic_ops_init(mdev); 243 mic_sysfs_init(mdev); 244 mutex_init(&mdev->mic_mutex); 245 mdev->irq_info.next_avail_src = 0; 246 INIT_WORK(&mdev->reset_trigger_work, mic_reset_trigger_work); 247 INIT_WORK(&mdev->shutdown_work, mic_shutdown_work); 248 init_completion(&mdev->reset_wait); 249 INIT_LIST_HEAD(&mdev->vdev_list); 250 mdev->pm_notifier.notifier_call = mic_pm_notifier; 251 rc = register_pm_notifier(&mdev->pm_notifier); 252 if (rc) { 253 dev_err(&pdev->dev, "register_pm_notifier failed rc %d\n", 254 rc); 255 goto register_pm_notifier_fail; 256 } 257 return 0; 258register_pm_notifier_fail: 259 flush_work(&mdev->shutdown_work); 260 flush_work(&mdev->reset_trigger_work); 261 return rc; 262} 263 264/** 265 * mic_device_uninit - Frees resources allocated during mic_device_init(..) 266 * 267 * @mdev: pointer to mic_device instance 268 * 269 * returns none 270 */ 271static void mic_device_uninit(struct mic_device *mdev) 272{ 273 /* The cmdline sysfs entry might have allocated cmdline */ 274 kfree(mdev->cmdline); 275 kfree(mdev->firmware); 276 kfree(mdev->ramdisk); 277 kfree(mdev->bootmode); 278 flush_work(&mdev->reset_trigger_work); 279 flush_work(&mdev->shutdown_work); 280 unregister_pm_notifier(&mdev->pm_notifier); 281} 282 283/** 284 * mic_probe - Device Initialization Routine 285 * 286 * @pdev: PCI device structure 287 * @ent: entry in mic_pci_tbl 288 * 289 * returns 0 on success, < 0 on failure. 290 */ 291static int mic_probe(struct pci_dev *pdev, 292 const struct pci_device_id *ent) 293{ 294 int rc; 295 struct mic_device *mdev; 296 297 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL); 298 if (!mdev) { 299 rc = -ENOMEM; 300 dev_err(&pdev->dev, "mdev kmalloc failed rc %d\n", rc); 301 goto mdev_alloc_fail; 302 } 303 mdev->id = ida_simple_get(&g_mic_ida, 0, MIC_MAX_NUM_DEVS, GFP_KERNEL); 304 if (mdev->id < 0) { 305 rc = mdev->id; 306 dev_err(&pdev->dev, "ida_simple_get failed rc %d\n", rc); 307 goto ida_fail; 308 } 309 310 rc = mic_device_init(mdev, pdev); 311 if (rc) { 312 dev_err(&pdev->dev, "mic_device_init failed rc %d\n", rc); 313 goto device_init_fail; 314 } 315 316 rc = pci_enable_device(pdev); 317 if (rc) { 318 dev_err(&pdev->dev, "failed to enable pci device.\n"); 319 goto uninit_device; 320 } 321 322 pci_set_master(pdev); 323 324 rc = pci_request_regions(pdev, mic_driver_name); 325 if (rc) { 326 dev_err(&pdev->dev, "failed to get pci regions.\n"); 327 goto disable_device; 328 } 329 330 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)); 331 if (rc) { 332 dev_err(&pdev->dev, "Cannot set DMA mask\n"); 333 goto release_regions; 334 } 335 336 mdev->mmio.pa = pci_resource_start(pdev, mdev->ops->mmio_bar); 337 mdev->mmio.len = pci_resource_len(pdev, mdev->ops->mmio_bar); 338 mdev->mmio.va = pci_ioremap_bar(pdev, mdev->ops->mmio_bar); 339 if (!mdev->mmio.va) { 340 dev_err(&pdev->dev, "Cannot remap MMIO BAR\n"); 341 rc = -EIO; 342 goto release_regions; 343 } 344 345 mdev->aper.pa = pci_resource_start(pdev, mdev->ops->aper_bar); 346 mdev->aper.len = pci_resource_len(pdev, mdev->ops->aper_bar); 347 mdev->aper.va = ioremap_wc(mdev->aper.pa, mdev->aper.len); 348 if (!mdev->aper.va) { 349 dev_err(&pdev->dev, "Cannot remap Aperture BAR\n"); 350 rc = -EIO; 351 goto unmap_mmio; 352 } 353 354 mdev->intr_ops->intr_init(mdev); 355 rc = mic_setup_interrupts(mdev, pdev); 356 if (rc) { 357 dev_err(&pdev->dev, "mic_setup_interrupts failed %d\n", rc); 358 goto unmap_aper; 359 } 360 rc = mic_smpt_init(mdev); 361 if (rc) { 362 dev_err(&pdev->dev, "smpt_init failed %d\n", rc); 363 goto free_interrupts; 364 } 365 366 pci_set_drvdata(pdev, mdev); 367 368 mdev->sdev = device_create_with_groups(g_mic_class, &pdev->dev, 369 MKDEV(MAJOR(g_mic_devno), mdev->id), NULL, 370 mdev->attr_group, "mic%d", mdev->id); 371 if (IS_ERR(mdev->sdev)) { 372 rc = PTR_ERR(mdev->sdev); 373 dev_err(&pdev->dev, 374 "device_create_with_groups failed rc %d\n", rc); 375 goto smpt_uninit; 376 } 377 mdev->state_sysfs = sysfs_get_dirent(mdev->sdev->kobj.sd, "state"); 378 if (!mdev->state_sysfs) { 379 rc = -ENODEV; 380 dev_err(&pdev->dev, "sysfs_get_dirent failed rc %d\n", rc); 381 goto destroy_device; 382 } 383 384 rc = mic_dp_init(mdev); 385 if (rc) { 386 dev_err(&pdev->dev, "mic_dp_init failed rc %d\n", rc); 387 goto sysfs_put; 388 } 389 mutex_lock(&mdev->mic_mutex); 390 391 mdev->shutdown_db = mic_next_db(mdev); 392 mdev->shutdown_cookie = mic_request_threaded_irq(mdev, mic_shutdown_db, 393 NULL, "shutdown-interrupt", mdev, 394 mdev->shutdown_db, MIC_INTR_DB); 395 if (IS_ERR(mdev->shutdown_cookie)) { 396 rc = PTR_ERR(mdev->shutdown_cookie); 397 mutex_unlock(&mdev->mic_mutex); 398 goto dp_uninit; 399 } 400 mutex_unlock(&mdev->mic_mutex); 401 mic_bootparam_init(mdev); 402 403 mic_create_debug_dir(mdev); 404 cdev_init(&mdev->cdev, &mic_fops); 405 mdev->cdev.owner = THIS_MODULE; 406 rc = cdev_add(&mdev->cdev, MKDEV(MAJOR(g_mic_devno), mdev->id), 1); 407 if (rc) { 408 dev_err(&pdev->dev, "cdev_add err id %d rc %d\n", mdev->id, rc); 409 goto cleanup_debug_dir; 410 } 411 return 0; 412cleanup_debug_dir: 413 mic_delete_debug_dir(mdev); 414 mutex_lock(&mdev->mic_mutex); 415 mic_free_irq(mdev, mdev->shutdown_cookie, mdev); 416 mutex_unlock(&mdev->mic_mutex); 417dp_uninit: 418 mic_dp_uninit(mdev); 419sysfs_put: 420 sysfs_put(mdev->state_sysfs); 421destroy_device: 422 device_destroy(g_mic_class, MKDEV(MAJOR(g_mic_devno), mdev->id)); 423smpt_uninit: 424 mic_smpt_uninit(mdev); 425free_interrupts: 426 mic_free_interrupts(mdev, pdev); 427unmap_aper: 428 iounmap(mdev->aper.va); 429unmap_mmio: 430 iounmap(mdev->mmio.va); 431release_regions: 432 pci_release_regions(pdev); 433disable_device: 434 pci_disable_device(pdev); 435uninit_device: 436 mic_device_uninit(mdev); 437device_init_fail: 438 ida_simple_remove(&g_mic_ida, mdev->id); 439ida_fail: 440 kfree(mdev); 441mdev_alloc_fail: 442 dev_err(&pdev->dev, "Probe failed rc %d\n", rc); 443 return rc; 444} 445 446/** 447 * mic_remove - Device Removal Routine 448 * mic_remove is called by the PCI subsystem to alert the driver 449 * that it should release a PCI device. 450 * 451 * @pdev: PCI device structure 452 */ 453static void mic_remove(struct pci_dev *pdev) 454{ 455 struct mic_device *mdev; 456 457 mdev = pci_get_drvdata(pdev); 458 if (!mdev) 459 return; 460 461 mic_stop(mdev, false); 462 cdev_del(&mdev->cdev); 463 mic_delete_debug_dir(mdev); 464 mutex_lock(&mdev->mic_mutex); 465 mic_free_irq(mdev, mdev->shutdown_cookie, mdev); 466 mutex_unlock(&mdev->mic_mutex); 467 flush_work(&mdev->shutdown_work); 468 mic_dp_uninit(mdev); 469 sysfs_put(mdev->state_sysfs); 470 device_destroy(g_mic_class, MKDEV(MAJOR(g_mic_devno), mdev->id)); 471 mic_smpt_uninit(mdev); 472 mic_free_interrupts(mdev, pdev); 473 iounmap(mdev->mmio.va); 474 iounmap(mdev->aper.va); 475 mic_device_uninit(mdev); 476 pci_release_regions(pdev); 477 pci_disable_device(pdev); 478 ida_simple_remove(&g_mic_ida, mdev->id); 479 kfree(mdev); 480} 481static struct pci_driver mic_driver = { 482 .name = mic_driver_name, 483 .id_table = mic_pci_tbl, 484 .probe = mic_probe, 485 .remove = mic_remove 486}; 487 488static int __init mic_init(void) 489{ 490 int ret; 491 492 ret = alloc_chrdev_region(&g_mic_devno, 0, 493 MIC_MAX_NUM_DEVS, mic_driver_name); 494 if (ret) { 495 pr_err("alloc_chrdev_region failed ret %d\n", ret); 496 goto error; 497 } 498 499 g_mic_class = class_create(THIS_MODULE, mic_driver_name); 500 if (IS_ERR(g_mic_class)) { 501 ret = PTR_ERR(g_mic_class); 502 pr_err("class_create failed ret %d\n", ret); 503 goto cleanup_chrdev; 504 } 505 506 mic_init_debugfs(); 507 ida_init(&g_mic_ida); 508 ret = pci_register_driver(&mic_driver); 509 if (ret) { 510 pr_err("pci_register_driver failed ret %d\n", ret); 511 goto cleanup_debugfs; 512 } 513 return ret; 514cleanup_debugfs: 515 mic_exit_debugfs(); 516 class_destroy(g_mic_class); 517cleanup_chrdev: 518 unregister_chrdev_region(g_mic_devno, MIC_MAX_NUM_DEVS); 519error: 520 return ret; 521} 522 523static void __exit mic_exit(void) 524{ 525 pci_unregister_driver(&mic_driver); 526 ida_destroy(&g_mic_ida); 527 mic_exit_debugfs(); 528 class_destroy(g_mic_class); 529 unregister_chrdev_region(g_mic_devno, MIC_MAX_NUM_DEVS); 530} 531 532module_init(mic_init); 533module_exit(mic_exit); 534 535MODULE_AUTHOR("Intel Corporation"); 536MODULE_DESCRIPTION("Intel(R) MIC X100 Host driver"); 537MODULE_LICENSE("GPL v2"); 538