| /* |
| * Intel MIC Platform Software Stack (MPSS) |
| * |
| * Copyright(c) 2013 Intel Corporation. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License, version 2, as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * The full GNU General Public License is included in this distribution in |
| * the file called "COPYING". |
| * |
| * Intel MIC Host driver. |
| */ |
| #include <linux/fs.h> |
| #include <linux/module.h> |
| #include <linux/pci.h> |
| #include <linux/poll.h> |
| |
| #include <linux/mic_common.h> |
| #include "../common/mic_dev.h" |
| #include "mic_device.h" |
| #include "mic_x100.h" |
| #include "mic_smpt.h" |
| |
| static const char mic_driver_name[] = "mic"; |
| |
| static const struct pci_device_id mic_pci_tbl[] = { |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2250)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2251)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2252)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2253)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2254)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2255)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2256)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2257)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2258)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_2259)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225a)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225b)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225c)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225d)}, |
| {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MIC_X100_PCI_DEVICE_225e)}, |
| |
| /* required last entry */ |
| { 0, } |
| }; |
| |
| MODULE_DEVICE_TABLE(pci, mic_pci_tbl); |
| |
| /* ID allocator for MIC devices */ |
| static struct ida g_mic_ida; |
| |
| /* Initialize the device page */ |
| static int mic_dp_init(struct mic_device *mdev) |
| { |
| mdev->dp = kzalloc(MIC_DP_SIZE, GFP_KERNEL); |
| if (!mdev->dp) |
| return -ENOMEM; |
| |
| mdev->dp_dma_addr = mic_map_single(mdev, |
| mdev->dp, MIC_DP_SIZE); |
| if (mic_map_error(mdev->dp_dma_addr)) { |
| kfree(mdev->dp); |
| dev_err(&mdev->pdev->dev, "%s %d err %d\n", |
| __func__, __LINE__, -ENOMEM); |
| return -ENOMEM; |
| } |
| mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr); |
| mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32); |
| return 0; |
| } |
| |
| /* Uninitialize the device page */ |
| static void mic_dp_uninit(struct mic_device *mdev) |
| { |
| mic_unmap_single(mdev, mdev->dp_dma_addr, MIC_DP_SIZE); |
| kfree(mdev->dp); |
| } |
| |
| /** |
| * mic_ops_init: Initialize HW specific operation tables. |
| * |
| * @mdev: pointer to mic_device instance |
| * |
| * returns none. |
| */ |
| static void mic_ops_init(struct mic_device *mdev) |
| { |
| switch (mdev->family) { |
| case MIC_FAMILY_X100: |
| mdev->ops = &mic_x100_ops; |
| mdev->intr_ops = &mic_x100_intr_ops; |
| mdev->smpt_ops = &mic_x100_smpt_ops; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /** |
| * mic_get_family - Determine hardware family to which this MIC belongs. |
| * |
| * @pdev: The pci device structure |
| * |
| * returns family. |
| */ |
| static enum mic_hw_family mic_get_family(struct pci_dev *pdev) |
| { |
| enum mic_hw_family family; |
| |
| switch (pdev->device) { |
| case MIC_X100_PCI_DEVICE_2250: |
| case MIC_X100_PCI_DEVICE_2251: |
| case MIC_X100_PCI_DEVICE_2252: |
| case MIC_X100_PCI_DEVICE_2253: |
| case MIC_X100_PCI_DEVICE_2254: |
| case MIC_X100_PCI_DEVICE_2255: |
| case MIC_X100_PCI_DEVICE_2256: |
| case MIC_X100_PCI_DEVICE_2257: |
| case MIC_X100_PCI_DEVICE_2258: |
| case MIC_X100_PCI_DEVICE_2259: |
| case MIC_X100_PCI_DEVICE_225a: |
| case MIC_X100_PCI_DEVICE_225b: |
| case MIC_X100_PCI_DEVICE_225c: |
| case MIC_X100_PCI_DEVICE_225d: |
| case MIC_X100_PCI_DEVICE_225e: |
| family = MIC_FAMILY_X100; |
| break; |
| default: |
| family = MIC_FAMILY_UNKNOWN; |
| break; |
| } |
| return family; |
| } |
| |
| /** |
| * mic_device_init - Allocates and initializes the MIC device structure |
| * |
| * @mdev: pointer to mic_device instance |
| * @pdev: The pci device structure |
| * |
| * returns none. |
| */ |
| static void |
| mic_device_init(struct mic_device *mdev, struct pci_dev *pdev) |
| { |
| mdev->pdev = pdev; |
| mdev->family = mic_get_family(pdev); |
| mdev->stepping = pdev->revision; |
| mic_ops_init(mdev); |
| mutex_init(&mdev->mic_mutex); |
| mdev->irq_info.next_avail_src = 0; |
| } |
| |
| /** |
| * mic_probe - Device Initialization Routine |
| * |
| * @pdev: PCI device structure |
| * @ent: entry in mic_pci_tbl |
| * |
| * returns 0 on success, < 0 on failure. |
| */ |
| static int mic_probe(struct pci_dev *pdev, |
| const struct pci_device_id *ent) |
| { |
| int rc; |
| struct mic_device *mdev; |
| |
| mdev = kzalloc(sizeof(*mdev), GFP_KERNEL); |
| if (!mdev) { |
| rc = -ENOMEM; |
| dev_err(&pdev->dev, "mdev kmalloc failed rc %d\n", rc); |
| goto mdev_alloc_fail; |
| } |
| mdev->id = ida_simple_get(&g_mic_ida, 0, MIC_MAX_NUM_DEVS, GFP_KERNEL); |
| if (mdev->id < 0) { |
| rc = mdev->id; |
| dev_err(&pdev->dev, "ida_simple_get failed rc %d\n", rc); |
| goto ida_fail; |
| } |
| |
| mic_device_init(mdev, pdev); |
| |
| rc = pci_enable_device(pdev); |
| if (rc) { |
| dev_err(&pdev->dev, "failed to enable pci device.\n"); |
| goto ida_remove; |
| } |
| |
| pci_set_master(pdev); |
| |
| rc = pci_request_regions(pdev, mic_driver_name); |
| if (rc) { |
| dev_err(&pdev->dev, "failed to get pci regions.\n"); |
| goto disable_device; |
| } |
| |
| rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)); |
| if (rc) { |
| dev_err(&pdev->dev, "Cannot set DMA mask\n"); |
| goto release_regions; |
| } |
| |
| mdev->mmio.pa = pci_resource_start(pdev, mdev->ops->mmio_bar); |
| mdev->mmio.len = pci_resource_len(pdev, mdev->ops->mmio_bar); |
| mdev->mmio.va = pci_ioremap_bar(pdev, mdev->ops->mmio_bar); |
| if (!mdev->mmio.va) { |
| dev_err(&pdev->dev, "Cannot remap MMIO BAR\n"); |
| rc = -EIO; |
| goto release_regions; |
| } |
| |
| mdev->aper.pa = pci_resource_start(pdev, mdev->ops->aper_bar); |
| mdev->aper.len = pci_resource_len(pdev, mdev->ops->aper_bar); |
| mdev->aper.va = ioremap_wc(mdev->aper.pa, mdev->aper.len); |
| if (!mdev->aper.va) { |
| dev_err(&pdev->dev, "Cannot remap Aperture BAR\n"); |
| rc = -EIO; |
| goto unmap_mmio; |
| } |
| |
| mdev->intr_ops->intr_init(mdev); |
| rc = mic_setup_interrupts(mdev, pdev); |
| if (rc) { |
| dev_err(&pdev->dev, "mic_setup_interrupts failed %d\n", rc); |
| goto unmap_aper; |
| } |
| rc = mic_smpt_init(mdev); |
| if (rc) { |
| dev_err(&pdev->dev, "smpt_init failed %d\n", rc); |
| goto free_interrupts; |
| } |
| |
| pci_set_drvdata(pdev, mdev); |
| |
| rc = mic_dp_init(mdev); |
| if (rc) { |
| dev_err(&pdev->dev, "mic_dp_init failed rc %d\n", rc); |
| goto smpt_uninit; |
| } |
| mic_bootparam_init(mdev); |
| mic_create_debug_dir(mdev); |
| |
| mdev->cosm_dev = cosm_register_device(&mdev->pdev->dev, &cosm_hw_ops); |
| if (IS_ERR(mdev->cosm_dev)) { |
| rc = PTR_ERR(mdev->cosm_dev); |
| dev_err(&pdev->dev, "cosm_add_device failed rc %d\n", rc); |
| goto cleanup_debug_dir; |
| } |
| return 0; |
| cleanup_debug_dir: |
| mic_delete_debug_dir(mdev); |
| mic_dp_uninit(mdev); |
| smpt_uninit: |
| mic_smpt_uninit(mdev); |
| free_interrupts: |
| mic_free_interrupts(mdev, pdev); |
| unmap_aper: |
| iounmap(mdev->aper.va); |
| unmap_mmio: |
| iounmap(mdev->mmio.va); |
| release_regions: |
| pci_release_regions(pdev); |
| disable_device: |
| pci_disable_device(pdev); |
| ida_remove: |
| ida_simple_remove(&g_mic_ida, mdev->id); |
| ida_fail: |
| kfree(mdev); |
| mdev_alloc_fail: |
| dev_err(&pdev->dev, "Probe failed rc %d\n", rc); |
| return rc; |
| } |
| |
| /** |
| * mic_remove - Device Removal Routine |
| * mic_remove is called by the PCI subsystem to alert the driver |
| * that it should release a PCI device. |
| * |
| * @pdev: PCI device structure |
| */ |
| static void mic_remove(struct pci_dev *pdev) |
| { |
| struct mic_device *mdev; |
| |
| mdev = pci_get_drvdata(pdev); |
| if (!mdev) |
| return; |
| |
| cosm_unregister_device(mdev->cosm_dev); |
| mic_delete_debug_dir(mdev); |
| mic_dp_uninit(mdev); |
| mic_smpt_uninit(mdev); |
| mic_free_interrupts(mdev, pdev); |
| iounmap(mdev->aper.va); |
| iounmap(mdev->mmio.va); |
| pci_release_regions(pdev); |
| pci_disable_device(pdev); |
| ida_simple_remove(&g_mic_ida, mdev->id); |
| kfree(mdev); |
| } |
| |
| static struct pci_driver mic_driver = { |
| .name = mic_driver_name, |
| .id_table = mic_pci_tbl, |
| .probe = mic_probe, |
| .remove = mic_remove |
| }; |
| |
| static int __init mic_init(void) |
| { |
| int ret; |
| |
| request_module("mic_x100_dma"); |
| mic_init_debugfs(); |
| ida_init(&g_mic_ida); |
| ret = pci_register_driver(&mic_driver); |
| if (ret) { |
| pr_err("pci_register_driver failed ret %d\n", ret); |
| goto cleanup_debugfs; |
| } |
| return 0; |
| cleanup_debugfs: |
| ida_destroy(&g_mic_ida); |
| mic_exit_debugfs(); |
| return ret; |
| } |
| |
| static void __exit mic_exit(void) |
| { |
| pci_unregister_driver(&mic_driver); |
| ida_destroy(&g_mic_ida); |
| mic_exit_debugfs(); |
| } |
| |
| module_init(mic_init); |
| module_exit(mic_exit); |
| |
| MODULE_AUTHOR("Intel Corporation"); |
| MODULE_DESCRIPTION("Intel(R) MIC X100 Host driver"); |
| MODULE_LICENSE("GPL v2"); |