intel/speed_select_if/isst_if_mmio.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Intel Speed Select Interface: MMIO Interface
0004  * Copyright (c) 2019, Intel Corporation.
0005  * All rights reserved.
0006  *
0007  * Author: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
0008  */
0009
0010 #include <linux/module.h>
0011 #include <linux/pci.h>
0012 #include <linux/sched/signal.h>
0013 #include <linux/uaccess.h>
0014 #include <uapi/linux/isst_if.h>
0015
0016 #include "isst_if_common.h"
0017
0018 struct isst_mmio_range {
0019     int beg;
0020     int end;
0021 };
0022
0023 static struct isst_mmio_range mmio_range_devid_0[] = {
0024     {0x04, 0x14},
0025     {0x20, 0xD0},
0026 };
0027
0028 static struct isst_mmio_range mmio_range_devid_1[] = {
0029     {0x04, 0x14},
0030     {0x20, 0x11C},
0031 };
0032
0033 struct isst_if_device {
0034     void __iomem *punit_mmio;
0035     u32 range_0[5];
0036     u32 range_1[64];
0037     struct isst_mmio_range *mmio_range;
0038     struct mutex mutex;
0039 };
0040
0041 static long isst_if_mmio_rd_wr(u8 *cmd_ptr, int *write_only, int resume)
0042 {
0043     struct isst_if_device *punit_dev;
0044     struct isst_if_io_reg *io_reg;
0045     struct pci_dev *pdev;
0046
0047     io_reg = (struct isst_if_io_reg *)cmd_ptr;
0048
0049     if (io_reg->reg % 4)
0050         return -EINVAL;
0051
0052     if (io_reg->read_write && !capable(CAP_SYS_ADMIN))
0053         return -EPERM;
0054
0055     pdev = isst_if_get_pci_dev(io_reg->logical_cpu, 0, 0, 1);
0056     if (!pdev)
0057         return -EINVAL;
0058
0059     punit_dev = pci_get_drvdata(pdev);
0060     if (!punit_dev)
0061         return -EINVAL;
0062
0063     if (io_reg->reg < punit_dev->mmio_range[0].beg ||
0064         io_reg->reg > punit_dev->mmio_range[1].end)
0065         return -EINVAL;
0066
0067     /*
0068      * Ensure that operation is complete on a PCI device to avoid read
0069      * write race by using per PCI device mutex.
0070      */
0071     mutex_lock(&punit_dev->mutex);
0072     if (io_reg->read_write) {
0073         writel(io_reg->value, punit_dev->punit_mmio+io_reg->reg);
0074         *write_only = 1;
0075     } else {
0076         io_reg->value = readl(punit_dev->punit_mmio+io_reg->reg);
0077         *write_only = 0;
0078     }
0079     mutex_unlock(&punit_dev->mutex);
0080
0081     return 0;
0082 }
0083
0084 static const struct pci_device_id isst_if_ids[] = {
0085     { PCI_DEVICE_DATA(INTEL, RAPL_PRIO_DEVID_0, &mmio_range_devid_0)},
0086     { PCI_DEVICE_DATA(INTEL, RAPL_PRIO_DEVID_1, &mmio_range_devid_1)},
0087     { 0 },
0088 };
0089 MODULE_DEVICE_TABLE(pci, isst_if_ids);
0090
0091 static int isst_if_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
0092 {
0093     struct isst_if_device *punit_dev;
0094     struct isst_if_cmd_cb cb;
0095     u32 mmio_base, pcu_base;
0096     u64 base_addr;
0097     int ret;
0098
0099     punit_dev = devm_kzalloc(&pdev->dev, sizeof(*punit_dev), GFP_KERNEL);
0100     if (!punit_dev)
0101         return -ENOMEM;
0102
0103     ret = pcim_enable_device(pdev);
0104     if (ret)
0105         return ret;
0106
0107     ret = pci_read_config_dword(pdev, 0xD0, &mmio_base);
0108     if (ret)
0109         return ret;
0110
0111     ret = pci_read_config_dword(pdev, 0xFC, &pcu_base);
0112     if (ret)
0113         return ret;
0114
0115     pcu_base &= GENMASK(10, 0);
0116     base_addr = (u64)mmio_base << 23 | (u64) pcu_base << 12;
0117     punit_dev->punit_mmio = devm_ioremap(&pdev->dev, base_addr, 256);
0118     if (!punit_dev->punit_mmio)
0119         return -ENOMEM;
0120
0121     mutex_init(&punit_dev->mutex);
0122     pci_set_drvdata(pdev, punit_dev);
0123     punit_dev->mmio_range = (struct isst_mmio_range *) ent->driver_data;
0124
0125     memset(&cb, 0, sizeof(cb));
0126     cb.cmd_size = sizeof(struct isst_if_io_reg);
0127     cb.offset = offsetof(struct isst_if_io_regs, io_reg);
0128     cb.cmd_callback = isst_if_mmio_rd_wr;
0129     cb.owner = THIS_MODULE;
0130     ret = isst_if_cdev_register(ISST_IF_DEV_MMIO, &cb);
0131     if (ret)
0132         mutex_destroy(&punit_dev->mutex);
0133
0134     return ret;
0135 }
0136
0137 static void isst_if_remove(struct pci_dev *pdev)
0138 {
0139     struct isst_if_device *punit_dev;
0140
0141     punit_dev = pci_get_drvdata(pdev);
0142     isst_if_cdev_unregister(ISST_IF_DEV_MMIO);
0143     mutex_destroy(&punit_dev->mutex);
0144 }
0145
0146 static int __maybe_unused isst_if_suspend(struct device *device)
0147 {
0148     struct isst_if_device *punit_dev = dev_get_drvdata(device);
0149     int i;
0150
0151     for (i = 0; i < ARRAY_SIZE(punit_dev->range_0); ++i)
0152         punit_dev->range_0[i] = readl(punit_dev->punit_mmio +
0153                         punit_dev->mmio_range[0].beg + 4 * i);
0154     for (i = 0; i < ARRAY_SIZE(punit_dev->range_1); ++i) {
0155         u32 addr;
0156
0157         addr = punit_dev->mmio_range[1].beg + 4 * i;
0158         if (addr > punit_dev->mmio_range[1].end)
0159             break;
0160         punit_dev->range_1[i] = readl(punit_dev->punit_mmio + addr);
0161     }
0162
0163     return 0;
0164 }
0165
0166 static int __maybe_unused isst_if_resume(struct device *device)
0167 {
0168     struct isst_if_device *punit_dev = dev_get_drvdata(device);
0169     int i;
0170
0171     for (i = 0; i < ARRAY_SIZE(punit_dev->range_0); ++i)
0172         writel(punit_dev->range_0[i], punit_dev->punit_mmio +
0173                         punit_dev->mmio_range[0].beg + 4 * i);
0174     for (i = 0; i < ARRAY_SIZE(punit_dev->range_1); ++i) {
0175         u32 addr;
0176
0177         addr = punit_dev->mmio_range[1].beg + 4 * i;
0178         if (addr > punit_dev->mmio_range[1].end)
0179             break;
0180
0181         writel(punit_dev->range_1[i], punit_dev->punit_mmio + addr);
0182     }
0183
0184     return 0;
0185 }
0186
0187 static SIMPLE_DEV_PM_OPS(isst_if_pm_ops, isst_if_suspend, isst_if_resume);
0188
0189 static struct pci_driver isst_if_pci_driver = {
0190     .name           = "isst_if_pci",
0191     .id_table       = isst_if_ids,
0192     .probe          = isst_if_probe,
0193     .remove         = isst_if_remove,
0194     .driver.pm      = &isst_if_pm_ops,
0195 };
0196
0197 module_pci_driver(isst_if_pci_driver);
0198
0199 MODULE_LICENSE("GPL v2");
0200 MODULE_DESCRIPTION("Intel speed select interface mmio driver");