1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // rcpm.c - Freescale QorIQ RCPM driver 4 // 5 // Copyright 2019-2020 NXP 6 // 7 // Author: Ran Wang <ran.wang_1@nxp.com> 8 9 #include <linux/init.h> 10 #include <linux/module.h> 11 #include <linux/platform_device.h> 12 #include <linux/of_address.h> 13 #include <linux/slab.h> 14 #include <linux/suspend.h> 15 #include <linux/kernel.h> 16 #include <linux/acpi.h> 17 18 #define RCPM_WAKEUP_CELL_MAX_SIZE 7 19 20 struct rcpm { 21 unsigned int wakeup_cells; 22 void __iomem *ippdexpcr_base; 23 bool little_endian; 24 }; 25 26 #define SCFG_SPARECR8 0x051c 27 28 static void copy_ippdexpcr1_setting(u32 val) 29 { 30 struct device_node *np; 31 void __iomem *regs; 32 u32 reg_val; 33 34 np = of_find_compatible_node(NULL, NULL, "fsl,ls1021a-scfg"); 35 if (!np) 36 return; 37 38 regs = of_iomap(np, 0); 39 of_node_put(np); 40 if (!regs) 41 return; 42 43 reg_val = ioread32be(regs + SCFG_SPARECR8); 44 iowrite32be(val | reg_val, regs + SCFG_SPARECR8); 45 46 iounmap(regs); 47 } 48 49 /** 50 * rcpm_pm_prepare - performs device-level tasks associated with power 51 * management, such as programming related to the wakeup source control. 52 * @dev: Device to handle. 53 * 54 */ 55 static int rcpm_pm_prepare(struct device *dev) 56 { 57 int i, ret, idx; 58 void __iomem *base; 59 struct wakeup_source *ws; 60 struct rcpm *rcpm; 61 struct device_node *np = dev->of_node; 62 u32 value[RCPM_WAKEUP_CELL_MAX_SIZE + 1]; 63 u32 setting[RCPM_WAKEUP_CELL_MAX_SIZE] = {0}; 64 65 rcpm = dev_get_drvdata(dev); 66 if (!rcpm) 67 return -EINVAL; 68 69 base = rcpm->ippdexpcr_base; 70 idx = wakeup_sources_read_lock(); 71 72 /* Begin with first registered wakeup source */ 73 for_each_wakeup_source(ws) { 74 75 /* skip object which is not attached to device */ 76 if (!ws->dev || !ws->dev->parent) 77 continue; 78 79 ret = device_property_read_u32_array(ws->dev->parent, 80 "fsl,rcpm-wakeup", value, 81 rcpm->wakeup_cells + 1); 82 83 if (ret) 84 continue; 85 86 /* 87 * For DT mode, would handle devices with "fsl,rcpm-wakeup" 88 * pointing to the current RCPM node. 89 * 90 * For ACPI mode, currently we assume there is only one 91 * RCPM controller existing. 92 */ 93 if (is_of_node(dev->fwnode)) 94 if (np->phandle != value[0]) 95 continue; 96 97 /* Property "#fsl,rcpm-wakeup-cells" of rcpm node defines the 98 * number of IPPDEXPCR register cells, and "fsl,rcpm-wakeup" 99 * of wakeup source IP contains an integer array: <phandle to 100 * RCPM node, IPPDEXPCR0 setting, IPPDEXPCR1 setting, 101 * IPPDEXPCR2 setting, etc>. 102 * 103 * So we will go thought them to collect setting data. 104 */ 105 for (i = 0; i < rcpm->wakeup_cells; i++) 106 setting[i] |= value[i + 1]; 107 } 108 109 wakeup_sources_read_unlock(idx); 110 111 /* Program all IPPDEXPCRn once */ 112 for (i = 0; i < rcpm->wakeup_cells; i++) { 113 u32 tmp = setting[i]; 114 void __iomem *address = base + i * 4; 115 116 if (!tmp) 117 continue; 118 119 /* We can only OR related bits */ 120 if (rcpm->little_endian) { 121 tmp |= ioread32(address); 122 iowrite32(tmp, address); 123 } else { 124 tmp |= ioread32be(address); 125 iowrite32be(tmp, address); 126 } 127 /* 128 * Workaround of errata A-008646 on SoC LS1021A: 129 * There is a bug of register ippdexpcr1. 130 * Reading configuration register RCPM_IPPDEXPCR1 131 * always return zero. So save ippdexpcr1's value 132 * to register SCFG_SPARECR8.And the value of 133 * ippdexpcr1 will be read from SCFG_SPARECR8. 134 */ 135 if (dev_of_node(dev) && (i == 1)) 136 if (of_device_is_compatible(np, "fsl,ls1021a-rcpm")) 137 copy_ippdexpcr1_setting(tmp); 138 } 139 140 return 0; 141 } 142 143 static const struct dev_pm_ops rcpm_pm_ops = { 144 .prepare = rcpm_pm_prepare, 145 }; 146 147 static int rcpm_probe(struct platform_device *pdev) 148 { 149 struct device *dev = &pdev->dev; 150 struct rcpm *rcpm; 151 int ret; 152 153 rcpm = devm_kzalloc(dev, sizeof(*rcpm), GFP_KERNEL); 154 if (!rcpm) 155 return -ENOMEM; 156 157 rcpm->ippdexpcr_base = devm_platform_ioremap_resource(pdev, 0); 158 if (IS_ERR(rcpm->ippdexpcr_base)) { 159 ret = PTR_ERR(rcpm->ippdexpcr_base); 160 return ret; 161 } 162 163 rcpm->little_endian = device_property_read_bool( 164 &pdev->dev, "little-endian"); 165 166 ret = device_property_read_u32(&pdev->dev, 167 "#fsl,rcpm-wakeup-cells", &rcpm->wakeup_cells); 168 if (ret) 169 return ret; 170 171 dev_set_drvdata(&pdev->dev, rcpm); 172 173 return 0; 174 } 175 176 static const struct of_device_id rcpm_of_match[] = { 177 { .compatible = "fsl,qoriq-rcpm-2.1+", }, 178 {} 179 }; 180 MODULE_DEVICE_TABLE(of, rcpm_of_match); 181 182 #ifdef CONFIG_ACPI 183 static const struct acpi_device_id rcpm_acpi_ids[] = { 184 {"NXP0015",}, 185 { } 186 }; 187 MODULE_DEVICE_TABLE(acpi, rcpm_acpi_ids); 188 #endif 189 190 static struct platform_driver rcpm_driver = { 191 .driver = { 192 .name = "rcpm", 193 .of_match_table = rcpm_of_match, 194 .acpi_match_table = ACPI_PTR(rcpm_acpi_ids), 195 .pm = &rcpm_pm_ops, 196 }, 197 .probe = rcpm_probe, 198 }; 199 200 module_platform_driver(rcpm_driver); 201