drivers/platform/x86/pmc_atom.c

   1 /*
   2  * Intel Atom SOC Power Management Controller Driver
   3  * Copyright (c) 2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  */
  15
  16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  17
  18 #include <linux/debugfs.h>
  19 #include <linux/device.h>
  20 #include <linux/init.h>
  21 #include <linux/io.h>
  22 #include <linux/platform_data/x86/clk-pmc-atom.h>
  23 #include <linux/platform_data/x86/pmc_atom.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/pci.h>
  26 #include <linux/seq_file.h>
  27
  28 struct pmc_bit_map {
  29         const char *name;
  30         u32 bit_mask;
  31 };
  32
  33 struct pmc_reg_map {
  34         const struct pmc_bit_map *d3_sts_0;
  35         const struct pmc_bit_map *d3_sts_1;
  36         const struct pmc_bit_map *func_dis;
  37         const struct pmc_bit_map *func_dis_2;
  38         const struct pmc_bit_map *pss;
  39 };
  40
  41 struct pmc_data {
  42         const struct pmc_reg_map *map;
  43         const struct pmc_clk *clks;
  44 };
  45
  46 struct pmc_dev {
  47         u32 base_addr;
  48         void __iomem *regmap;
  49         const struct pmc_reg_map *map;
  50 #ifdef CONFIG_DEBUG_FS
  51         struct dentry *dbgfs_dir;
  52 #endif /* CONFIG_DEBUG_FS */
  53         bool init;
  54 };
  55
  56 static struct pmc_dev pmc_device;
  57 static u32 acpi_base_addr;
  58
  59 static const struct pmc_clk byt_clks[] = {
  60         {
  61                 .name = "xtal",
  62                 .freq = 25000000,
  63                 .parent_name = NULL,
  64         },
  65         {
  66                 .name = "pll",
  67                 .freq = 19200000,
  68                 .parent_name = "xtal",
  69         },
  70         {},
  71 };
  72
  73 static const struct pmc_clk cht_clks[] = {
  74         {
  75                 .name = "xtal",
  76                 .freq = 19200000,
  77                 .parent_name = NULL,
  78         },
  79         {},
  80 };
  81
  82 static const struct pmc_bit_map d3_sts_0_map[] = {
  83         {"LPSS1_F0_DMA",        BIT_LPSS1_F0_DMA},
  84         {"LPSS1_F1_PWM1",       BIT_LPSS1_F1_PWM1},
  85         {"LPSS1_F2_PWM2",       BIT_LPSS1_F2_PWM2},
  86         {"LPSS1_F3_HSUART1",    BIT_LPSS1_F3_HSUART1},
  87         {"LPSS1_F4_HSUART2",    BIT_LPSS1_F4_HSUART2},
  88         {"LPSS1_F5_SPI",        BIT_LPSS1_F5_SPI},
  89         {"LPSS1_F6_Reserved",   BIT_LPSS1_F6_XXX},
  90         {"LPSS1_F7_Reserved",   BIT_LPSS1_F7_XXX},
  91         {"SCC_EMMC",            BIT_SCC_EMMC},
  92         {"SCC_SDIO",            BIT_SCC_SDIO},
  93         {"SCC_SDCARD",          BIT_SCC_SDCARD},
  94         {"SCC_MIPI",            BIT_SCC_MIPI},
  95         {"HDA",                 BIT_HDA},
  96         {"LPE",                 BIT_LPE},
  97         {"OTG",                 BIT_OTG},
  98         {"USH",                 BIT_USH},
  99         {"GBE",                 BIT_GBE},
 100         {"SATA",                BIT_SATA},
 101         {"USB_EHCI",            BIT_USB_EHCI},
 102         {"SEC",                 BIT_SEC},
 103         {"PCIE_PORT0",          BIT_PCIE_PORT0},
 104         {"PCIE_PORT1",          BIT_PCIE_PORT1},
 105         {"PCIE_PORT2",          BIT_PCIE_PORT2},
 106         {"PCIE_PORT3",          BIT_PCIE_PORT3},
 107         {"LPSS2_F0_DMA",        BIT_LPSS2_F0_DMA},
 108         {"LPSS2_F1_I2C1",       BIT_LPSS2_F1_I2C1},
 109         {"LPSS2_F2_I2C2",       BIT_LPSS2_F2_I2C2},
 110         {"LPSS2_F3_I2C3",       BIT_LPSS2_F3_I2C3},
 111         {"LPSS2_F3_I2C4",       BIT_LPSS2_F4_I2C4},
 112         {"LPSS2_F5_I2C5",       BIT_LPSS2_F5_I2C5},
 113         {"LPSS2_F6_I2C6",       BIT_LPSS2_F6_I2C6},
 114         {"LPSS2_F7_I2C7",       BIT_LPSS2_F7_I2C7},
 115         {},
 116 };
 117
 118 static struct pmc_bit_map byt_d3_sts_1_map[] = {
 119         {"SMB",                 BIT_SMB},
 120         {"OTG_SS_PHY",          BIT_OTG_SS_PHY},
 121         {"USH_SS_PHY",          BIT_USH_SS_PHY},
 122         {"DFX",                 BIT_DFX},
 123         {},
 124 };
 125
 126 static struct pmc_bit_map cht_d3_sts_1_map[] = {
 127         {"SMB",                 BIT_SMB},
 128         {"GMM",                 BIT_STS_GMM},
 129         {"ISH",                 BIT_STS_ISH},
 130         {},
 131 };
 132
 133 static struct pmc_bit_map cht_func_dis_2_map[] = {
 134         {"SMB",                 BIT_SMB},
 135         {"GMM",                 BIT_FD_GMM},
 136         {"ISH",                 BIT_FD_ISH},
 137         {},
 138 };
 139
 140 static const struct pmc_bit_map byt_pss_map[] = {
 141         {"GBE",                 PMC_PSS_BIT_GBE},
 142         {"SATA",                PMC_PSS_BIT_SATA},
 143         {"HDA",                 PMC_PSS_BIT_HDA},
 144         {"SEC",                 PMC_PSS_BIT_SEC},
 145         {"PCIE",                PMC_PSS_BIT_PCIE},
 146         {"LPSS",                PMC_PSS_BIT_LPSS},
 147         {"LPE",                 PMC_PSS_BIT_LPE},
 148         {"DFX",                 PMC_PSS_BIT_DFX},
 149         {"USH_CTRL",            PMC_PSS_BIT_USH_CTRL},
 150         {"USH_SUS",             PMC_PSS_BIT_USH_SUS},
 151         {"USH_VCCS",            PMC_PSS_BIT_USH_VCCS},
 152         {"USH_VCCA",            PMC_PSS_BIT_USH_VCCA},
 153         {"OTG_CTRL",            PMC_PSS_BIT_OTG_CTRL},
 154         {"OTG_VCCS",            PMC_PSS_BIT_OTG_VCCS},
 155         {"OTG_VCCA_CLK",        PMC_PSS_BIT_OTG_VCCA_CLK},
 156         {"OTG_VCCA",            PMC_PSS_BIT_OTG_VCCA},
 157         {"USB",                 PMC_PSS_BIT_USB},
 158         {"USB_SUS",             PMC_PSS_BIT_USB_SUS},
 159         {},
 160 };
 161
 162 static const struct pmc_bit_map cht_pss_map[] = {
 163         {"SATA",                PMC_PSS_BIT_SATA},
 164         {"HDA",                 PMC_PSS_BIT_HDA},
 165         {"SEC",                 PMC_PSS_BIT_SEC},
 166         {"PCIE",                PMC_PSS_BIT_PCIE},
 167         {"LPSS",                PMC_PSS_BIT_LPSS},
 168         {"LPE",                 PMC_PSS_BIT_LPE},
 169         {"UFS",                 PMC_PSS_BIT_CHT_UFS},
 170         {"UXD",                 PMC_PSS_BIT_CHT_UXD},
 171         {"UXD_FD",              PMC_PSS_BIT_CHT_UXD_FD},
 172         {"UX_ENG",              PMC_PSS_BIT_CHT_UX_ENG},
 173         {"USB_SUS",             PMC_PSS_BIT_CHT_USB_SUS},
 174         {"GMM",                 PMC_PSS_BIT_CHT_GMM},
 175         {"ISH",                 PMC_PSS_BIT_CHT_ISH},
 176         {"DFX_MASTER",          PMC_PSS_BIT_CHT_DFX_MASTER},
 177         {"DFX_CLUSTER1",        PMC_PSS_BIT_CHT_DFX_CLUSTER1},
 178         {"DFX_CLUSTER2",        PMC_PSS_BIT_CHT_DFX_CLUSTER2},
 179         {"DFX_CLUSTER3",        PMC_PSS_BIT_CHT_DFX_CLUSTER3},
 180         {"DFX_CLUSTER4",        PMC_PSS_BIT_CHT_DFX_CLUSTER4},
 181         {"DFX_CLUSTER5",        PMC_PSS_BIT_CHT_DFX_CLUSTER5},
 182         {},
 183 };
 184
 185 static const struct pmc_reg_map byt_reg_map = {
 186         .d3_sts_0       = d3_sts_0_map,
 187         .d3_sts_1       = byt_d3_sts_1_map,
 188         .func_dis       = d3_sts_0_map,
 189         .func_dis_2     = byt_d3_sts_1_map,
 190         .pss            = byt_pss_map,
 191 };
 192
 193 static const struct pmc_reg_map cht_reg_map = {
 194         .d3_sts_0       = d3_sts_0_map,
 195         .d3_sts_1       = cht_d3_sts_1_map,
 196         .func_dis       = d3_sts_0_map,
 197         .func_dis_2     = cht_func_dis_2_map,
 198         .pss            = cht_pss_map,
 199 };
 200
 201 static const struct pmc_data byt_data = {
 202         .map = &byt_reg_map,
 203         .clks = byt_clks,
 204 };
 205
 206 static const struct pmc_data cht_data = {
 207         .map = &cht_reg_map,
 208         .clks = cht_clks,
 209 };
 210
 211 static inline u32 pmc_reg_read(struct pmc_dev *pmc, int reg_offset)
 212 {
 213         return readl(pmc->regmap + reg_offset);
 214 }
 215
 216 static inline void pmc_reg_write(struct pmc_dev *pmc, int reg_offset, u32 val)
 217 {
 218         writel(val, pmc->regmap + reg_offset);
 219 }
 220
 221 int pmc_atom_read(int offset, u32 *value)
 222 {
 223         struct pmc_dev *pmc = &pmc_device;
 224
 225         if (!pmc->init)
 226                 return -ENODEV;
 227
 228         *value = pmc_reg_read(pmc, offset);
 229         return 0;
 230 }
 231 EXPORT_SYMBOL_GPL(pmc_atom_read);
 232
 233 int pmc_atom_write(int offset, u32 value)
 234 {
 235         struct pmc_dev *pmc = &pmc_device;
 236
 237         if (!pmc->init)
 238                 return -ENODEV;
 239
 240         pmc_reg_write(pmc, offset, value);
 241         return 0;
 242 }
 243 EXPORT_SYMBOL_GPL(pmc_atom_write);
 244
 245 static void pmc_power_off(void)
 246 {
 247         u16     pm1_cnt_port;
 248         u32     pm1_cnt_value;
 249
 250         pr_info("Preparing to enter system sleep state S5\n");
 251
 252         pm1_cnt_port = acpi_base_addr + PM1_CNT;
 253
 254         pm1_cnt_value = inl(pm1_cnt_port);
 255         pm1_cnt_value &= SLEEP_TYPE_MASK;
 256         pm1_cnt_value |= SLEEP_TYPE_S5;
 257         pm1_cnt_value |= SLEEP_ENABLE;
 258
 259         outl(pm1_cnt_value, pm1_cnt_port);
 260 }
 261
 262 static void pmc_hw_reg_setup(struct pmc_dev *pmc)
 263 {
 264         /*
 265          * Disable PMC S0IX_WAKE_EN events coming from:
 266          * - LPC clock run
 267          * - GPIO_SUS ored dedicated IRQs
 268          * - GPIO_SCORE ored dedicated IRQs
 269          * - GPIO_SUS shared IRQ
 270          * - GPIO_SCORE shared IRQ
 271          */
 272         pmc_reg_write(pmc, PMC_S0IX_WAKE_EN, (u32)PMC_WAKE_EN_SETTING);
 273 }
 274
 275 #ifdef CONFIG_DEBUG_FS
 276 static void pmc_dev_state_print(struct seq_file *s, int reg_index,
 277                                 u32 sts, const struct pmc_bit_map *sts_map,
 278                                 u32 fd, const struct pmc_bit_map *fd_map)
 279 {
 280         int offset = PMC_REG_BIT_WIDTH * reg_index;
 281         int index;
 282
 283         for (index = 0; sts_map[index].name; index++) {
 284                 seq_printf(s, "Dev: %-2d - %-32s\tState: %s [%s]\n",
 285                         offset + index, sts_map[index].name,
 286                         fd_map[index].bit_mask & fd ?  "Disabled" : "Enabled ",
 287                         sts_map[index].bit_mask & sts ?  "D3" : "D0");
 288         }
 289 }
 290
 291 static int pmc_dev_state_show(struct seq_file *s, void *unused)
 292 {
 293         struct pmc_dev *pmc = s->private;
 294         const struct pmc_reg_map *m = pmc->map;
 295         u32 func_dis, func_dis_2;
 296         u32 d3_sts_0, d3_sts_1;
 297
 298         func_dis = pmc_reg_read(pmc, PMC_FUNC_DIS);
 299         func_dis_2 = pmc_reg_read(pmc, PMC_FUNC_DIS_2);
 300         d3_sts_0 = pmc_reg_read(pmc, PMC_D3_STS_0);
 301         d3_sts_1 = pmc_reg_read(pmc, PMC_D3_STS_1);
 302
 303         /* Low part */
 304         pmc_dev_state_print(s, 0, d3_sts_0, m->d3_sts_0, func_dis, m->func_dis);
 305
 306         /* High part */
 307         pmc_dev_state_print(s, 1, d3_sts_1, m->d3_sts_1, func_dis_2, m->func_dis_2);
 308
 309         return 0;
 310 }
 311
 312 static int pmc_dev_state_open(struct inode *inode, struct file *file)
 313 {
 314         return single_open(file, pmc_dev_state_show, inode->i_private);
 315 }
 316
 317 static const struct file_operations pmc_dev_state_ops = {
 318         .open           = pmc_dev_state_open,
 319         .read           = seq_read,
 320         .llseek         = seq_lseek,
 321         .release        = single_release,
 322 };
 323
 324 static int pmc_pss_state_show(struct seq_file *s, void *unused)
 325 {
 326         struct pmc_dev *pmc = s->private;
 327         const struct pmc_bit_map *map = pmc->map->pss;
 328         u32 pss = pmc_reg_read(pmc, PMC_PSS);
 329         int index;
 330
 331         for (index = 0; map[index].name; index++) {
 332                 seq_printf(s, "Island: %-2d - %-32s\tState: %s\n",
 333                         index, map[index].name,
 334                         map[index].bit_mask & pss ? "Off" : "On");
 335         }
 336         return 0;
 337 }
 338
 339 static int pmc_pss_state_open(struct inode *inode, struct file *file)
 340 {
 341         return single_open(file, pmc_pss_state_show, inode->i_private);
 342 }
 343
 344 static const struct file_operations pmc_pss_state_ops = {
 345         .open           = pmc_pss_state_open,
 346         .read           = seq_read,
 347         .llseek         = seq_lseek,
 348         .release        = single_release,
 349 };
 350
 351 static int pmc_sleep_tmr_show(struct seq_file *s, void *unused)
 352 {
 353         struct pmc_dev *pmc = s->private;
 354         u64 s0ir_tmr, s0i1_tmr, s0i2_tmr, s0i3_tmr, s0_tmr;
 355
 356         s0ir_tmr = (u64)pmc_reg_read(pmc, PMC_S0IR_TMR) << PMC_TMR_SHIFT;
 357         s0i1_tmr = (u64)pmc_reg_read(pmc, PMC_S0I1_TMR) << PMC_TMR_SHIFT;
 358         s0i2_tmr = (u64)pmc_reg_read(pmc, PMC_S0I2_TMR) << PMC_TMR_SHIFT;
 359         s0i3_tmr = (u64)pmc_reg_read(pmc, PMC_S0I3_TMR) << PMC_TMR_SHIFT;
 360         s0_tmr = (u64)pmc_reg_read(pmc, PMC_S0_TMR) << PMC_TMR_SHIFT;
 361
 362         seq_printf(s, "S0IR Residency:\t%lldus\n", s0ir_tmr);
 363         seq_printf(s, "S0I1 Residency:\t%lldus\n", s0i1_tmr);
 364         seq_printf(s, "S0I2 Residency:\t%lldus\n", s0i2_tmr);
 365         seq_printf(s, "S0I3 Residency:\t%lldus\n", s0i3_tmr);
 366         seq_printf(s, "S0   Residency:\t%lldus\n", s0_tmr);
 367         return 0;
 368 }
 369
 370 static int pmc_sleep_tmr_open(struct inode *inode, struct file *file)
 371 {
 372         return single_open(file, pmc_sleep_tmr_show, inode->i_private);
 373 }
 374
 375 static const struct file_operations pmc_sleep_tmr_ops = {
 376         .open           = pmc_sleep_tmr_open,
 377         .read           = seq_read,
 378         .llseek         = seq_lseek,
 379         .release        = single_release,
 380 };
 381
 382 static void pmc_dbgfs_unregister(struct pmc_dev *pmc)
 383 {
 384         debugfs_remove_recursive(pmc->dbgfs_dir);
 385 }
 386
 387 static int pmc_dbgfs_register(struct pmc_dev *pmc)
 388 {
 389         struct dentry *dir, *f;
 390
 391         dir = debugfs_create_dir("pmc_atom", NULL);
 392         if (!dir)
 393                 return -ENOMEM;
 394
 395         pmc->dbgfs_dir = dir;
 396
 397         f = debugfs_create_file("dev_state", S_IFREG | S_IRUGO,
 398                                 dir, pmc, &pmc_dev_state_ops);
 399         if (!f)
 400                 goto err;
 401
 402         f = debugfs_create_file("pss_state", S_IFREG | S_IRUGO,
 403                                 dir, pmc, &pmc_pss_state_ops);
 404         if (!f)
 405                 goto err;
 406
 407         f = debugfs_create_file("sleep_state", S_IFREG | S_IRUGO,
 408                                 dir, pmc, &pmc_sleep_tmr_ops);
 409         if (!f)
 410                 goto err;
 411
 412         return 0;
 413 err:
 414         pmc_dbgfs_unregister(pmc);
 415         return -ENODEV;
 416 }
 417 #else
 418 static int pmc_dbgfs_register(struct pmc_dev *pmc)
 419 {
 420         return 0;
 421 }
 422 #endif /* CONFIG_DEBUG_FS */
 423
 424 static int pmc_setup_clks(struct pci_dev *pdev, void __iomem *pmc_regmap,
 425                           const struct pmc_data *pmc_data)
 426 {
 427         struct platform_device *clkdev;
 428         struct pmc_clk_data *clk_data;
 429
 430         clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL);
 431         if (!clk_data)
 432                 return -ENOMEM;
 433
 434         clk_data->base = pmc_regmap; /* offset is added by client */
 435         clk_data->clks = pmc_data->clks;
 436
 437         clkdev = platform_device_register_data(&pdev->dev, "clk-pmc-atom",
 438                                                PLATFORM_DEVID_NONE,
 439                                                clk_data, sizeof(*clk_data));
 440         if (IS_ERR(clkdev)) {
 441                 kfree(clk_data);
 442                 return PTR_ERR(clkdev);
 443         }
 444
 445         kfree(clk_data);
 446
 447         return 0;
 448 }
 449
 450 static int pmc_setup_dev(struct pci_dev *pdev, const struct pci_device_id *ent)
 451 {
 452         struct pmc_dev *pmc = &pmc_device;
 453         const struct pmc_data *data = (struct pmc_data *)ent->driver_data;
 454         const struct pmc_reg_map *map = data->map;
 455         int ret;
 456
 457         /* Obtain ACPI base address */
 458         pci_read_config_dword(pdev, ACPI_BASE_ADDR_OFFSET, &acpi_base_addr);
 459         acpi_base_addr &= ACPI_BASE_ADDR_MASK;
 460
 461         /* Install power off function */
 462         if (acpi_base_addr != 0 && pm_power_off == NULL)
 463                 pm_power_off = pmc_power_off;
 464
 465         pci_read_config_dword(pdev, PMC_BASE_ADDR_OFFSET, &pmc->base_addr);
 466         pmc->base_addr &= PMC_BASE_ADDR_MASK;
 467
 468         pmc->regmap = ioremap_nocache(pmc->base_addr, PMC_MMIO_REG_LEN);
 469         if (!pmc->regmap) {
 470                 dev_err(&pdev->dev, "error: ioremap failed\n");
 471                 return -ENOMEM;
 472         }
 473
 474         pmc->map = map;
 475
 476         /* PMC hardware registers setup */
 477         pmc_hw_reg_setup(pmc);
 478
 479         ret = pmc_dbgfs_register(pmc);
 480         if (ret)
 481                 dev_warn(&pdev->dev, "debugfs register failed\n");
 482
 483         /* Register platform clocks - PMC_PLT_CLK [0..5] */
 484         ret = pmc_setup_clks(pdev, pmc->regmap, data);
 485         if (ret)
 486                 dev_warn(&pdev->dev, "platform clocks register failed: %d\n",
 487                          ret);
 488
 489         pmc->init = true;
 490         return ret;
 491 }
 492
 493 /*
 494  * Data for PCI driver interface
 495  *
 496  * used by pci_match_id() call below.
 497  */
 498 static const struct pci_device_id pmc_pci_ids[] = {
 499         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_VLV_PMC), (kernel_ulong_t)&byt_data },
 500         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_CHT_PMC), (kernel_ulong_t)&cht_data },
 501         { 0, },
 502 };
 503
 504 static int __init pmc_atom_init(void)
 505 {
 506         struct pci_dev *pdev = NULL;
 507         const struct pci_device_id *ent;
 508
 509         /* We look for our device - PCU PMC
 510          * we assume that there is max. one device.
 511          *
 512          * We can't use plain pci_driver mechanism,
 513          * as the device is really a multiple function device,
 514          * main driver that binds to the pci_device is lpc_ich
 515          * and have to find & bind to the device this way.
 516          */
 517         for_each_pci_dev(pdev) {
 518                 ent = pci_match_id(pmc_pci_ids, pdev);
 519                 if (ent)
 520                         return pmc_setup_dev(pdev, ent);
 521         }
 522         /* Device not found. */
 523         return -ENODEV;
 524 }
 525
 526 device_initcall(pmc_atom_init);
 527
 528 /*
 529 MODULE_AUTHOR("Aubrey Li <aubrey.li@linux.intel.com>");
 530 MODULE_DESCRIPTION("Intel Atom SOC Power Management Controller Interface");
 531 MODULE_LICENSE("GPL v2");
 532 */