kernel/drivers/misc/mic/host/mic_main.c

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