12849dd8bSTaniya Das // SPDX-License-Identifier: GPL-2.0
22849dd8bSTaniya Das /*
32849dd8bSTaniya Das * Copyright (c) 2018, The Linux Foundation. All rights reserved.
42849dd8bSTaniya Das */
52849dd8bSTaniya Das
62849dd8bSTaniya Das #include <linux/bitfield.h>
74370232cSManivannan Sadhasivam #include <linux/clk-provider.h>
82849dd8bSTaniya Das #include <linux/cpufreq.h>
92849dd8bSTaniya Das #include <linux/init.h>
1051c843cfSSibi Sankar #include <linux/interconnect.h>
11275157b3SThara Gopinath #include <linux/interrupt.h>
122849dd8bSTaniya Das #include <linux/kernel.h>
132849dd8bSTaniya Das #include <linux/module.h>
1421bb32b1SRob Herring #include <linux/of.h>
1521bb32b1SRob Herring #include <linux/platform_device.h>
1655538fbcSTaniya Das #include <linux/pm_opp.h>
172849dd8bSTaniya Das #include <linux/slab.h>
18275157b3SThara Gopinath #include <linux/spinlock.h>
199de0d75bSYicong Yang #include <linux/units.h>
202849dd8bSTaniya Das
212849dd8bSTaniya Das #define LUT_MAX_ENTRIES 40U
222849dd8bSTaniya Das #define LUT_SRC GENMASK(31, 30)
232849dd8bSTaniya Das #define LUT_L_VAL GENMASK(7, 0)
242849dd8bSTaniya Das #define LUT_CORE_COUNT GENMASK(18, 16)
2555538fbcSTaniya Das #define LUT_VOLT GENMASK(11, 0)
262849dd8bSTaniya Das #define CLK_HW_DIV 2
270eae1e37SSibi Sankar #define LUT_TURBO_IND 1
282849dd8bSTaniya Das
29e4e64486SVladimir Zapolskiy #define GT_IRQ_STATUS BIT(2)
30e4e64486SVladimir Zapolskiy
31*5f19d096SNeil Armstrong #define MAX_FREQ_DOMAINS 4
3235527c67SKonrad Dybcio
33dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_soc_data {
34dcd1fd72SManivannan Sadhasivam u32 reg_enable;
35f84ccad5SVladimir Zapolskiy u32 reg_domain_state;
36c377d4baSBjorn Andersson u32 reg_dcvs_ctrl;
37dcd1fd72SManivannan Sadhasivam u32 reg_freq_lut;
38dcd1fd72SManivannan Sadhasivam u32 reg_volt_lut;
39e4e64486SVladimir Zapolskiy u32 reg_intr_clr;
40275157b3SThara Gopinath u32 reg_current_vote;
41dcd1fd72SManivannan Sadhasivam u32 reg_perf_state;
42dcd1fd72SManivannan Sadhasivam u8 lut_row_size;
43dcd1fd72SManivannan Sadhasivam };
44dcd1fd72SManivannan Sadhasivam
45dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_data {
46dcd1fd72SManivannan Sadhasivam void __iomem *base;
47275157b3SThara Gopinath
48275157b3SThara Gopinath /*
49275157b3SThara Gopinath * Mutex to synchronize between de-init sequence and re-starting LMh
50275157b3SThara Gopinath * polling/interrupts
51275157b3SThara Gopinath */
52275157b3SThara Gopinath struct mutex throttle_lock;
53275157b3SThara Gopinath int throttle_irq;
54be6592edSArd Biesheuvel char irq_name[15];
55275157b3SThara Gopinath bool cancel_throttle;
56275157b3SThara Gopinath struct delayed_work throttle_work;
57275157b3SThara Gopinath struct cpufreq_policy *policy;
584370232cSManivannan Sadhasivam struct clk_hw cpu_clk;
59c377d4baSBjorn Andersson
60c377d4baSBjorn Andersson bool per_core_dcvs;
61dcd1fd72SManivannan Sadhasivam };
622849dd8bSTaniya Das
63054a3ef6SManivannan Sadhasivam static struct {
64054a3ef6SManivannan Sadhasivam struct qcom_cpufreq_data *data;
654f796170SManivannan Sadhasivam const struct qcom_cpufreq_soc_data *soc_data;
66054a3ef6SManivannan Sadhasivam } qcom_cpufreq;
67054a3ef6SManivannan Sadhasivam
682849dd8bSTaniya Das static unsigned long cpu_hw_rate, xo_rate;
6951c843cfSSibi Sankar static bool icc_scaling_enabled;
7051c843cfSSibi Sankar
qcom_cpufreq_set_bw(struct cpufreq_policy * policy,unsigned long freq_khz)7151c843cfSSibi Sankar static int qcom_cpufreq_set_bw(struct cpufreq_policy *policy,
7251c843cfSSibi Sankar unsigned long freq_khz)
7351c843cfSSibi Sankar {
7451c843cfSSibi Sankar unsigned long freq_hz = freq_khz * 1000;
7551c843cfSSibi Sankar struct dev_pm_opp *opp;
7651c843cfSSibi Sankar struct device *dev;
7751c843cfSSibi Sankar int ret;
7851c843cfSSibi Sankar
7951c843cfSSibi Sankar dev = get_cpu_device(policy->cpu);
8051c843cfSSibi Sankar if (!dev)
8151c843cfSSibi Sankar return -ENODEV;
8251c843cfSSibi Sankar
8351c843cfSSibi Sankar opp = dev_pm_opp_find_freq_exact(dev, freq_hz, true);
8451c843cfSSibi Sankar if (IS_ERR(opp))
8551c843cfSSibi Sankar return PTR_ERR(opp);
8651c843cfSSibi Sankar
878d25157fSViresh Kumar ret = dev_pm_opp_set_opp(dev, opp);
8851c843cfSSibi Sankar dev_pm_opp_put(opp);
8951c843cfSSibi Sankar return ret;
9051c843cfSSibi Sankar }
9151c843cfSSibi Sankar
qcom_cpufreq_update_opp(struct device * cpu_dev,unsigned long freq_khz,unsigned long volt)9251c843cfSSibi Sankar static int qcom_cpufreq_update_opp(struct device *cpu_dev,
9351c843cfSSibi Sankar unsigned long freq_khz,
9451c843cfSSibi Sankar unsigned long volt)
9551c843cfSSibi Sankar {
9651c843cfSSibi Sankar unsigned long freq_hz = freq_khz * 1000;
9751c843cfSSibi Sankar int ret;
9851c843cfSSibi Sankar
9951c843cfSSibi Sankar /* Skip voltage update if the opp table is not available */
10051c843cfSSibi Sankar if (!icc_scaling_enabled)
10151c843cfSSibi Sankar return dev_pm_opp_add(cpu_dev, freq_hz, volt);
10251c843cfSSibi Sankar
10351c843cfSSibi Sankar ret = dev_pm_opp_adjust_voltage(cpu_dev, freq_hz, volt, volt, volt);
10451c843cfSSibi Sankar if (ret) {
10551c843cfSSibi Sankar dev_err(cpu_dev, "Voltage update failed freq=%ld\n", freq_khz);
10651c843cfSSibi Sankar return ret;
10751c843cfSSibi Sankar }
10851c843cfSSibi Sankar
10951c843cfSSibi Sankar return dev_pm_opp_enable(cpu_dev, freq_hz);
11051c843cfSSibi Sankar }
1112849dd8bSTaniya Das
qcom_cpufreq_hw_target_index(struct cpufreq_policy * policy,unsigned int index)1122849dd8bSTaniya Das static int qcom_cpufreq_hw_target_index(struct cpufreq_policy *policy,
1132849dd8bSTaniya Das unsigned int index)
1142849dd8bSTaniya Das {
115dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_data *data = policy->driver_data;
1164f796170SManivannan Sadhasivam const struct qcom_cpufreq_soc_data *soc_data = qcom_cpufreq.soc_data;
117ada54f35SDouglas RAILLARD unsigned long freq = policy->freq_table[index].frequency;
118c377d4baSBjorn Andersson unsigned int i;
1192849dd8bSTaniya Das
120dcd1fd72SManivannan Sadhasivam writel_relaxed(index, data->base + soc_data->reg_perf_state);
1212849dd8bSTaniya Das
122c377d4baSBjorn Andersson if (data->per_core_dcvs)
123c377d4baSBjorn Andersson for (i = 1; i < cpumask_weight(policy->related_cpus); i++)
124c377d4baSBjorn Andersson writel_relaxed(index, data->base + soc_data->reg_perf_state + i * 4);
125c377d4baSBjorn Andersson
12651c843cfSSibi Sankar if (icc_scaling_enabled)
12751c843cfSSibi Sankar qcom_cpufreq_set_bw(policy, freq);
12851c843cfSSibi Sankar
1292849dd8bSTaniya Das return 0;
1302849dd8bSTaniya Das }
1312849dd8bSTaniya Das
qcom_lmh_get_throttle_freq(struct qcom_cpufreq_data * data)132c72cf0cbSManivannan Sadhasivam static unsigned long qcom_lmh_get_throttle_freq(struct qcom_cpufreq_data *data)
133c72cf0cbSManivannan Sadhasivam {
134c72cf0cbSManivannan Sadhasivam unsigned int lval;
135c72cf0cbSManivannan Sadhasivam
136c72cf0cbSManivannan Sadhasivam if (qcom_cpufreq.soc_data->reg_current_vote)
137c72cf0cbSManivannan Sadhasivam lval = readl_relaxed(data->base + qcom_cpufreq.soc_data->reg_current_vote) & 0x3ff;
138c72cf0cbSManivannan Sadhasivam else
139c72cf0cbSManivannan Sadhasivam lval = readl_relaxed(data->base + qcom_cpufreq.soc_data->reg_domain_state) & 0xff;
140c72cf0cbSManivannan Sadhasivam
141c72cf0cbSManivannan Sadhasivam return lval * xo_rate;
142c72cf0cbSManivannan Sadhasivam }
143c72cf0cbSManivannan Sadhasivam
144c72cf0cbSManivannan Sadhasivam /* Get the frequency requested by the cpufreq core for the CPU */
qcom_cpufreq_get_freq(unsigned int cpu)145c72cf0cbSManivannan Sadhasivam static unsigned int qcom_cpufreq_get_freq(unsigned int cpu)
146c72cf0cbSManivannan Sadhasivam {
147c72cf0cbSManivannan Sadhasivam struct qcom_cpufreq_data *data;
148dcd1fd72SManivannan Sadhasivam const struct qcom_cpufreq_soc_data *soc_data;
1492849dd8bSTaniya Das struct cpufreq_policy *policy;
1502849dd8bSTaniya Das unsigned int index;
1512849dd8bSTaniya Das
1522849dd8bSTaniya Das policy = cpufreq_cpu_get_raw(cpu);
1532849dd8bSTaniya Das if (!policy)
1542849dd8bSTaniya Das return 0;
1552849dd8bSTaniya Das
156dcd1fd72SManivannan Sadhasivam data = policy->driver_data;
1574f796170SManivannan Sadhasivam soc_data = qcom_cpufreq.soc_data;
1582849dd8bSTaniya Das
159dcd1fd72SManivannan Sadhasivam index = readl_relaxed(data->base + soc_data->reg_perf_state);
1602849dd8bSTaniya Das index = min(index, LUT_MAX_ENTRIES - 1);
1612849dd8bSTaniya Das
1622849dd8bSTaniya Das return policy->freq_table[index].frequency;
1632849dd8bSTaniya Das }
1642849dd8bSTaniya Das
qcom_cpufreq_hw_get(unsigned int cpu)16551be2fffSDouglas Anderson static unsigned int qcom_cpufreq_hw_get(unsigned int cpu)
16651be2fffSDouglas Anderson {
16751be2fffSDouglas Anderson struct qcom_cpufreq_data *data;
16851be2fffSDouglas Anderson struct cpufreq_policy *policy;
16951be2fffSDouglas Anderson
17051be2fffSDouglas Anderson policy = cpufreq_cpu_get_raw(cpu);
17151be2fffSDouglas Anderson if (!policy)
17251be2fffSDouglas Anderson return 0;
17351be2fffSDouglas Anderson
17451be2fffSDouglas Anderson data = policy->driver_data;
17551be2fffSDouglas Anderson
17651be2fffSDouglas Anderson if (data->throttle_irq >= 0)
17751be2fffSDouglas Anderson return qcom_lmh_get_throttle_freq(data) / HZ_PER_KHZ;
17851be2fffSDouglas Anderson
17951be2fffSDouglas Anderson return qcom_cpufreq_get_freq(cpu);
18051be2fffSDouglas Anderson }
18151be2fffSDouglas Anderson
qcom_cpufreq_hw_fast_switch(struct cpufreq_policy * policy,unsigned int target_freq)1822849dd8bSTaniya Das static unsigned int qcom_cpufreq_hw_fast_switch(struct cpufreq_policy *policy,
1832849dd8bSTaniya Das unsigned int target_freq)
1842849dd8bSTaniya Das {
185dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_data *data = policy->driver_data;
1864f796170SManivannan Sadhasivam const struct qcom_cpufreq_soc_data *soc_data = qcom_cpufreq.soc_data;
187292072c3SViresh Kumar unsigned int index;
188c377d4baSBjorn Andersson unsigned int i;
1892849dd8bSTaniya Das
1902849dd8bSTaniya Das index = policy->cached_resolved_idx;
191dcd1fd72SManivannan Sadhasivam writel_relaxed(index, data->base + soc_data->reg_perf_state);
1922849dd8bSTaniya Das
193c377d4baSBjorn Andersson if (data->per_core_dcvs)
194c377d4baSBjorn Andersson for (i = 1; i < cpumask_weight(policy->related_cpus); i++)
195c377d4baSBjorn Andersson writel_relaxed(index, data->base + soc_data->reg_perf_state + i * 4);
196c377d4baSBjorn Andersson
1971a0419b0SIonela Voinescu return policy->freq_table[index].frequency;
1982849dd8bSTaniya Das }
1992849dd8bSTaniya Das
qcom_cpufreq_hw_read_lut(struct device * cpu_dev,struct cpufreq_policy * policy)20055538fbcSTaniya Das static int qcom_cpufreq_hw_read_lut(struct device *cpu_dev,
201dcd1fd72SManivannan Sadhasivam struct cpufreq_policy *policy)
2022849dd8bSTaniya Das {
2030eae1e37SSibi Sankar u32 data, src, lval, i, core_count, prev_freq = 0, freq;
20455538fbcSTaniya Das u32 volt;
2052849dd8bSTaniya Das struct cpufreq_frequency_table *table;
20651c843cfSSibi Sankar struct dev_pm_opp *opp;
20751c843cfSSibi Sankar unsigned long rate;
20851c843cfSSibi Sankar int ret;
209dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_data *drv_data = policy->driver_data;
2104f796170SManivannan Sadhasivam const struct qcom_cpufreq_soc_data *soc_data = qcom_cpufreq.soc_data;
2112849dd8bSTaniya Das
2122849dd8bSTaniya Das table = kcalloc(LUT_MAX_ENTRIES + 1, sizeof(*table), GFP_KERNEL);
2132849dd8bSTaniya Das if (!table)
2142849dd8bSTaniya Das return -ENOMEM;
2152849dd8bSTaniya Das
21651c843cfSSibi Sankar ret = dev_pm_opp_of_add_table(cpu_dev);
21751c843cfSSibi Sankar if (!ret) {
21851c843cfSSibi Sankar /* Disable all opps and cross-validate against LUT later */
21951c843cfSSibi Sankar icc_scaling_enabled = true;
22051c843cfSSibi Sankar for (rate = 0; ; rate++) {
22151c843cfSSibi Sankar opp = dev_pm_opp_find_freq_ceil(cpu_dev, &rate);
22251c843cfSSibi Sankar if (IS_ERR(opp))
22351c843cfSSibi Sankar break;
22451c843cfSSibi Sankar
22551c843cfSSibi Sankar dev_pm_opp_put(opp);
22651c843cfSSibi Sankar dev_pm_opp_disable(cpu_dev, rate);
22751c843cfSSibi Sankar }
22851c843cfSSibi Sankar } else if (ret != -ENODEV) {
22951c843cfSSibi Sankar dev_err(cpu_dev, "Invalid opp table in device tree\n");
2309901c21bSChen Hui kfree(table);
23151c843cfSSibi Sankar return ret;
23251c843cfSSibi Sankar } else {
233afdb219bSSibi Sankar policy->fast_switch_possible = true;
23451c843cfSSibi Sankar icc_scaling_enabled = false;
23551c843cfSSibi Sankar }
23651c843cfSSibi Sankar
2372849dd8bSTaniya Das for (i = 0; i < LUT_MAX_ENTRIES; i++) {
238dcd1fd72SManivannan Sadhasivam data = readl_relaxed(drv_data->base + soc_data->reg_freq_lut +
239dcd1fd72SManivannan Sadhasivam i * soc_data->lut_row_size);
2402849dd8bSTaniya Das src = FIELD_GET(LUT_SRC, data);
2412849dd8bSTaniya Das lval = FIELD_GET(LUT_L_VAL, data);
2422849dd8bSTaniya Das core_count = FIELD_GET(LUT_CORE_COUNT, data);
2432849dd8bSTaniya Das
244dcd1fd72SManivannan Sadhasivam data = readl_relaxed(drv_data->base + soc_data->reg_volt_lut +
245dcd1fd72SManivannan Sadhasivam i * soc_data->lut_row_size);
24655538fbcSTaniya Das volt = FIELD_GET(LUT_VOLT, data) * 1000;
24755538fbcSTaniya Das
2482849dd8bSTaniya Das if (src)
2492849dd8bSTaniya Das freq = xo_rate * lval / 1000;
2502849dd8bSTaniya Das else
2512849dd8bSTaniya Das freq = cpu_hw_rate / 1000;
2522849dd8bSTaniya Das
2530eae1e37SSibi Sankar if (freq != prev_freq && core_count != LUT_TURBO_IND) {
254bc9b9c5aSMatthias Kaehlcke if (!qcom_cpufreq_update_opp(cpu_dev, freq, volt)) {
2552849dd8bSTaniya Das table[i].frequency = freq;
25655538fbcSTaniya Das dev_dbg(cpu_dev, "index=%d freq=%d, core_count %d\n", i,
2572849dd8bSTaniya Das freq, core_count);
258bc9b9c5aSMatthias Kaehlcke } else {
259bc9b9c5aSMatthias Kaehlcke dev_warn(cpu_dev, "failed to update OPP for freq=%d\n", freq);
260bc9b9c5aSMatthias Kaehlcke table[i].frequency = CPUFREQ_ENTRY_INVALID;
261bc9b9c5aSMatthias Kaehlcke }
262bc9b9c5aSMatthias Kaehlcke
2630eae1e37SSibi Sankar } else if (core_count == LUT_TURBO_IND) {
26455538fbcSTaniya Das table[i].frequency = CPUFREQ_ENTRY_INVALID;
2652849dd8bSTaniya Das }
2662849dd8bSTaniya Das
2672849dd8bSTaniya Das /*
2682849dd8bSTaniya Das * Two of the same frequencies with the same core counts means
2692849dd8bSTaniya Das * end of table
2702849dd8bSTaniya Das */
2710eae1e37SSibi Sankar if (i > 0 && prev_freq == freq) {
2722849dd8bSTaniya Das struct cpufreq_frequency_table *prev = &table[i - 1];
2732849dd8bSTaniya Das
2742849dd8bSTaniya Das /*
2752849dd8bSTaniya Das * Only treat the last frequency that might be a boost
2762849dd8bSTaniya Das * as the boost frequency
2772849dd8bSTaniya Das */
2780eae1e37SSibi Sankar if (prev->frequency == CPUFREQ_ENTRY_INVALID) {
279bc9b9c5aSMatthias Kaehlcke if (!qcom_cpufreq_update_opp(cpu_dev, prev_freq, volt)) {
2802849dd8bSTaniya Das prev->frequency = prev_freq;
2812849dd8bSTaniya Das prev->flags = CPUFREQ_BOOST_FREQ;
282bc9b9c5aSMatthias Kaehlcke } else {
283bc9b9c5aSMatthias Kaehlcke dev_warn(cpu_dev, "failed to update OPP for freq=%d\n",
284bc9b9c5aSMatthias Kaehlcke freq);
285bc9b9c5aSMatthias Kaehlcke }
2862849dd8bSTaniya Das }
2872849dd8bSTaniya Das
2882849dd8bSTaniya Das break;
2892849dd8bSTaniya Das }
2902849dd8bSTaniya Das
2912849dd8bSTaniya Das prev_freq = freq;
2922849dd8bSTaniya Das }
2932849dd8bSTaniya Das
2942849dd8bSTaniya Das table[i].frequency = CPUFREQ_TABLE_END;
2952849dd8bSTaniya Das policy->freq_table = table;
29655538fbcSTaniya Das dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
2972849dd8bSTaniya Das
2982849dd8bSTaniya Das return 0;
2992849dd8bSTaniya Das }
3002849dd8bSTaniya Das
qcom_get_related_cpus(int index,struct cpumask * m)3012849dd8bSTaniya Das static void qcom_get_related_cpus(int index, struct cpumask *m)
3022849dd8bSTaniya Das {
3032849dd8bSTaniya Das struct device_node *cpu_np;
3042849dd8bSTaniya Das struct of_phandle_args args;
3052849dd8bSTaniya Das int cpu, ret;
3062849dd8bSTaniya Das
3072849dd8bSTaniya Das for_each_possible_cpu(cpu) {
3082849dd8bSTaniya Das cpu_np = of_cpu_device_node_get(cpu);
3092849dd8bSTaniya Das if (!cpu_np)
3102849dd8bSTaniya Das continue;
3112849dd8bSTaniya Das
3122849dd8bSTaniya Das ret = of_parse_phandle_with_args(cpu_np, "qcom,freq-domain",
3132849dd8bSTaniya Das "#freq-domain-cells", 0,
3142849dd8bSTaniya Das &args);
3152849dd8bSTaniya Das of_node_put(cpu_np);
3162849dd8bSTaniya Das if (ret < 0)
3172849dd8bSTaniya Das continue;
3182849dd8bSTaniya Das
3192849dd8bSTaniya Das if (index == args.args[0])
3202849dd8bSTaniya Das cpumask_set_cpu(cpu, m);
3212849dd8bSTaniya Das }
3222849dd8bSTaniya Das }
3232849dd8bSTaniya Das
qcom_lmh_dcvs_notify(struct qcom_cpufreq_data * data)324275157b3SThara Gopinath static void qcom_lmh_dcvs_notify(struct qcom_cpufreq_data *data)
325275157b3SThara Gopinath {
326275157b3SThara Gopinath struct cpufreq_policy *policy = data->policy;
3275e4f009dSDmitry Baryshkov int cpu = cpumask_first(policy->related_cpus);
328275157b3SThara Gopinath struct device *dev = get_cpu_device(cpu);
3290258cb19SLukasz Luba unsigned long freq_hz, throttled_freq;
330275157b3SThara Gopinath struct dev_pm_opp *opp;
331275157b3SThara Gopinath
332275157b3SThara Gopinath /*
333275157b3SThara Gopinath * Get the h/w throttled frequency, normalize it using the
334275157b3SThara Gopinath * registered opp table and use it to calculate thermal pressure.
335275157b3SThara Gopinath */
336f84ccad5SVladimir Zapolskiy freq_hz = qcom_lmh_get_throttle_freq(data);
337275157b3SThara Gopinath
338275157b3SThara Gopinath opp = dev_pm_opp_find_freq_floor(dev, &freq_hz);
339275157b3SThara Gopinath if (IS_ERR(opp) && PTR_ERR(opp) == -ERANGE)
3406240aaadSDmitry Baryshkov opp = dev_pm_opp_find_freq_ceil(dev, &freq_hz);
341275157b3SThara Gopinath
3426240aaadSDmitry Baryshkov if (IS_ERR(opp)) {
3436240aaadSDmitry Baryshkov dev_warn(dev, "Can't find the OPP for throttling: %pe!\n", opp);
3446240aaadSDmitry Baryshkov } else {
34591dc90fdSViresh Kumar dev_pm_opp_put(opp);
34691dc90fdSViresh Kumar }
34791dc90fdSViresh Kumar
348275157b3SThara Gopinath throttled_freq = freq_hz / HZ_PER_KHZ;
349275157b3SThara Gopinath
3500258cb19SLukasz Luba /* Update thermal pressure (the boost frequencies are accepted) */
3510258cb19SLukasz Luba arch_update_thermal_pressure(policy->related_cpus, throttled_freq);
352275157b3SThara Gopinath
353275157b3SThara Gopinath /*
354275157b3SThara Gopinath * In the unlikely case policy is unregistered do not enable
355275157b3SThara Gopinath * polling or h/w interrupt
356275157b3SThara Gopinath */
357275157b3SThara Gopinath mutex_lock(&data->throttle_lock);
358275157b3SThara Gopinath if (data->cancel_throttle)
359275157b3SThara Gopinath goto out;
360275157b3SThara Gopinath
361275157b3SThara Gopinath /*
362275157b3SThara Gopinath * If h/w throttled frequency is higher than what cpufreq has requested
363275157b3SThara Gopinath * for, then stop polling and switch back to interrupt mechanism.
364275157b3SThara Gopinath */
365c72cf0cbSManivannan Sadhasivam if (throttled_freq >= qcom_cpufreq_get_freq(cpu))
366275157b3SThara Gopinath enable_irq(data->throttle_irq);
367275157b3SThara Gopinath else
368275157b3SThara Gopinath mod_delayed_work(system_highpri_wq, &data->throttle_work,
369275157b3SThara Gopinath msecs_to_jiffies(10));
370275157b3SThara Gopinath
371275157b3SThara Gopinath out:
372275157b3SThara Gopinath mutex_unlock(&data->throttle_lock);
373275157b3SThara Gopinath }
374275157b3SThara Gopinath
qcom_lmh_dcvs_poll(struct work_struct * work)375275157b3SThara Gopinath static void qcom_lmh_dcvs_poll(struct work_struct *work)
376275157b3SThara Gopinath {
377275157b3SThara Gopinath struct qcom_cpufreq_data *data;
378275157b3SThara Gopinath
379275157b3SThara Gopinath data = container_of(work, struct qcom_cpufreq_data, throttle_work.work);
380275157b3SThara Gopinath qcom_lmh_dcvs_notify(data);
381275157b3SThara Gopinath }
382275157b3SThara Gopinath
qcom_lmh_dcvs_handle_irq(int irq,void * data)383275157b3SThara Gopinath static irqreturn_t qcom_lmh_dcvs_handle_irq(int irq, void *data)
384275157b3SThara Gopinath {
385275157b3SThara Gopinath struct qcom_cpufreq_data *c_data = data;
386275157b3SThara Gopinath
387275157b3SThara Gopinath /* Disable interrupt and enable polling */
388275157b3SThara Gopinath disable_irq_nosync(c_data->throttle_irq);
389e0e27c3dSVladimir Zapolskiy schedule_delayed_work(&c_data->throttle_work, 0);
390275157b3SThara Gopinath
3914f796170SManivannan Sadhasivam if (qcom_cpufreq.soc_data->reg_intr_clr)
392e4e64486SVladimir Zapolskiy writel_relaxed(GT_IRQ_STATUS,
3934f796170SManivannan Sadhasivam c_data->base + qcom_cpufreq.soc_data->reg_intr_clr);
394e4e64486SVladimir Zapolskiy
395e0e27c3dSVladimir Zapolskiy return IRQ_HANDLED;
396275157b3SThara Gopinath }
397275157b3SThara Gopinath
398dcd1fd72SManivannan Sadhasivam static const struct qcom_cpufreq_soc_data qcom_soc_data = {
399dcd1fd72SManivannan Sadhasivam .reg_enable = 0x0,
400c377d4baSBjorn Andersson .reg_dcvs_ctrl = 0xbc,
401dcd1fd72SManivannan Sadhasivam .reg_freq_lut = 0x110,
402dcd1fd72SManivannan Sadhasivam .reg_volt_lut = 0x114,
403275157b3SThara Gopinath .reg_current_vote = 0x704,
404dcd1fd72SManivannan Sadhasivam .reg_perf_state = 0x920,
405dcd1fd72SManivannan Sadhasivam .lut_row_size = 32,
406dcd1fd72SManivannan Sadhasivam };
407dcd1fd72SManivannan Sadhasivam
40849b59f4cSManivannan Sadhasivam static const struct qcom_cpufreq_soc_data epss_soc_data = {
40949b59f4cSManivannan Sadhasivam .reg_enable = 0x0,
410f84ccad5SVladimir Zapolskiy .reg_domain_state = 0x20,
411c377d4baSBjorn Andersson .reg_dcvs_ctrl = 0xb0,
41249b59f4cSManivannan Sadhasivam .reg_freq_lut = 0x100,
41349b59f4cSManivannan Sadhasivam .reg_volt_lut = 0x200,
414e4e64486SVladimir Zapolskiy .reg_intr_clr = 0x308,
41549b59f4cSManivannan Sadhasivam .reg_perf_state = 0x320,
41649b59f4cSManivannan Sadhasivam .lut_row_size = 4,
41749b59f4cSManivannan Sadhasivam };
41849b59f4cSManivannan Sadhasivam
419dcd1fd72SManivannan Sadhasivam static const struct of_device_id qcom_cpufreq_hw_match[] = {
420dcd1fd72SManivannan Sadhasivam { .compatible = "qcom,cpufreq-hw", .data = &qcom_soc_data },
42149b59f4cSManivannan Sadhasivam { .compatible = "qcom,cpufreq-epss", .data = &epss_soc_data },
422dcd1fd72SManivannan Sadhasivam {}
423dcd1fd72SManivannan Sadhasivam };
424dcd1fd72SManivannan Sadhasivam MODULE_DEVICE_TABLE(of, qcom_cpufreq_hw_match);
425dcd1fd72SManivannan Sadhasivam
qcom_cpufreq_hw_lmh_init(struct cpufreq_policy * policy,int index)426275157b3SThara Gopinath static int qcom_cpufreq_hw_lmh_init(struct cpufreq_policy *policy, int index)
427275157b3SThara Gopinath {
428275157b3SThara Gopinath struct qcom_cpufreq_data *data = policy->driver_data;
429275157b3SThara Gopinath struct platform_device *pdev = cpufreq_get_driver_data();
430275157b3SThara Gopinath int ret;
431275157b3SThara Gopinath
432275157b3SThara Gopinath /*
433275157b3SThara Gopinath * Look for LMh interrupt. If no interrupt line is specified /
434275157b3SThara Gopinath * if there is an error, allow cpufreq to be enabled as usual.
435275157b3SThara Gopinath */
4368f5783adSStephen Boyd data->throttle_irq = platform_get_irq_optional(pdev, index);
4378f5783adSStephen Boyd if (data->throttle_irq == -ENXIO)
4388f5783adSStephen Boyd return 0;
4398f5783adSStephen Boyd if (data->throttle_irq < 0)
4408f5783adSStephen Boyd return data->throttle_irq;
441275157b3SThara Gopinath
442275157b3SThara Gopinath data->cancel_throttle = false;
443275157b3SThara Gopinath data->policy = policy;
444275157b3SThara Gopinath
445275157b3SThara Gopinath mutex_init(&data->throttle_lock);
446275157b3SThara Gopinath INIT_DEFERRABLE_WORK(&data->throttle_work, qcom_lmh_dcvs_poll);
447275157b3SThara Gopinath
448be6592edSArd Biesheuvel snprintf(data->irq_name, sizeof(data->irq_name), "dcvsh-irq-%u", policy->cpu);
449275157b3SThara Gopinath ret = request_threaded_irq(data->throttle_irq, NULL, qcom_lmh_dcvs_handle_irq,
450ef8ee1cbSBjorn Andersson IRQF_ONESHOT | IRQF_NO_AUTOEN, data->irq_name, data);
451275157b3SThara Gopinath if (ret) {
452be6592edSArd Biesheuvel dev_err(&pdev->dev, "Error registering %s: %d\n", data->irq_name, ret);
453275157b3SThara Gopinath return 0;
454275157b3SThara Gopinath }
455275157b3SThara Gopinath
456f2b03dffSPierre Gondois ret = irq_set_affinity_and_hint(data->throttle_irq, policy->cpus);
4573ed6dfbdSVladimir Zapolskiy if (ret)
4583ed6dfbdSVladimir Zapolskiy dev_err(&pdev->dev, "Failed to set CPU affinity of %s[%d]\n",
4593ed6dfbdSVladimir Zapolskiy data->irq_name, data->throttle_irq);
4603ed6dfbdSVladimir Zapolskiy
461275157b3SThara Gopinath return 0;
462275157b3SThara Gopinath }
463275157b3SThara Gopinath
qcom_cpufreq_hw_cpu_online(struct cpufreq_policy * policy)464a1eb080aSDmitry Baryshkov static int qcom_cpufreq_hw_cpu_online(struct cpufreq_policy *policy)
465275157b3SThara Gopinath {
466a1eb080aSDmitry Baryshkov struct qcom_cpufreq_data *data = policy->driver_data;
467a1eb080aSDmitry Baryshkov struct platform_device *pdev = cpufreq_get_driver_data();
468a1eb080aSDmitry Baryshkov int ret;
469a1eb080aSDmitry Baryshkov
470668a7a12SStephen Boyd if (data->throttle_irq <= 0)
471668a7a12SStephen Boyd return 0;
472668a7a12SStephen Boyd
473cdcf8eb3SPierre Gondois mutex_lock(&data->throttle_lock);
474cdcf8eb3SPierre Gondois data->cancel_throttle = false;
475cdcf8eb3SPierre Gondois mutex_unlock(&data->throttle_lock);
476cdcf8eb3SPierre Gondois
477f2b03dffSPierre Gondois ret = irq_set_affinity_and_hint(data->throttle_irq, policy->cpus);
478a1eb080aSDmitry Baryshkov if (ret)
479a1eb080aSDmitry Baryshkov dev_err(&pdev->dev, "Failed to set CPU affinity of %s[%d]\n",
480a1eb080aSDmitry Baryshkov data->irq_name, data->throttle_irq);
481a1eb080aSDmitry Baryshkov
482a1eb080aSDmitry Baryshkov return ret;
483a1eb080aSDmitry Baryshkov }
484a1eb080aSDmitry Baryshkov
qcom_cpufreq_hw_cpu_offline(struct cpufreq_policy * policy)485a1eb080aSDmitry Baryshkov static int qcom_cpufreq_hw_cpu_offline(struct cpufreq_policy *policy)
486a1eb080aSDmitry Baryshkov {
487a1eb080aSDmitry Baryshkov struct qcom_cpufreq_data *data = policy->driver_data;
488a1eb080aSDmitry Baryshkov
489275157b3SThara Gopinath if (data->throttle_irq <= 0)
490a1eb080aSDmitry Baryshkov return 0;
491275157b3SThara Gopinath
492275157b3SThara Gopinath mutex_lock(&data->throttle_lock);
493275157b3SThara Gopinath data->cancel_throttle = true;
494275157b3SThara Gopinath mutex_unlock(&data->throttle_lock);
495275157b3SThara Gopinath
496275157b3SThara Gopinath cancel_delayed_work_sync(&data->throttle_work);
497f2b03dffSPierre Gondois irq_set_affinity_and_hint(data->throttle_irq, NULL);
498f7fca54aSPierre Gondois disable_irq_nosync(data->throttle_irq);
499a1eb080aSDmitry Baryshkov
500a1eb080aSDmitry Baryshkov return 0;
501a1eb080aSDmitry Baryshkov }
502a1eb080aSDmitry Baryshkov
qcom_cpufreq_hw_lmh_exit(struct qcom_cpufreq_data * data)503a1eb080aSDmitry Baryshkov static void qcom_cpufreq_hw_lmh_exit(struct qcom_cpufreq_data *data)
504a1eb080aSDmitry Baryshkov {
505668a7a12SStephen Boyd if (data->throttle_irq <= 0)
506668a7a12SStephen Boyd return;
507668a7a12SStephen Boyd
508275157b3SThara Gopinath free_irq(data->throttle_irq, data);
509275157b3SThara Gopinath }
510275157b3SThara Gopinath
qcom_cpufreq_hw_cpu_init(struct cpufreq_policy * policy)5112849dd8bSTaniya Das static int qcom_cpufreq_hw_cpu_init(struct cpufreq_policy *policy)
5122849dd8bSTaniya Das {
513bd74e286SManivannan Sadhasivam struct platform_device *pdev = cpufreq_get_driver_data();
514bd74e286SManivannan Sadhasivam struct device *dev = &pdev->dev;
5152849dd8bSTaniya Das struct of_phandle_args args;
5162849dd8bSTaniya Das struct device_node *cpu_np;
51755538fbcSTaniya Das struct device *cpu_dev;
518dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_data *data;
5192849dd8bSTaniya Das int ret, index;
5202849dd8bSTaniya Das
52155538fbcSTaniya Das cpu_dev = get_cpu_device(policy->cpu);
52255538fbcSTaniya Das if (!cpu_dev) {
52355538fbcSTaniya Das pr_err("%s: failed to get cpu%d device\n", __func__,
52455538fbcSTaniya Das policy->cpu);
52555538fbcSTaniya Das return -ENODEV;
52655538fbcSTaniya Das }
52755538fbcSTaniya Das
5282849dd8bSTaniya Das cpu_np = of_cpu_device_node_get(policy->cpu);
5292849dd8bSTaniya Das if (!cpu_np)
5302849dd8bSTaniya Das return -EINVAL;
5312849dd8bSTaniya Das
5322849dd8bSTaniya Das ret = of_parse_phandle_with_args(cpu_np, "qcom,freq-domain",
5332849dd8bSTaniya Das "#freq-domain-cells", 0, &args);
5342849dd8bSTaniya Das of_node_put(cpu_np);
5352849dd8bSTaniya Das if (ret)
5362849dd8bSTaniya Das return ret;
5372849dd8bSTaniya Das
5382849dd8bSTaniya Das index = args.args[0];
539054a3ef6SManivannan Sadhasivam data = &qcom_cpufreq.data[index];
5402849dd8bSTaniya Das
541054a3ef6SManivannan Sadhasivam /* HW should be in enabled state to proceed */
5424f796170SManivannan Sadhasivam if (!(readl_relaxed(data->base + qcom_cpufreq.soc_data->reg_enable) & 0x1)) {
543054a3ef6SManivannan Sadhasivam dev_err(dev, "Domain-%d cpufreq hardware not enabled\n", index);
54467fc209bSShawn Guo return -ENODEV;
54567fc209bSShawn Guo }
5462849dd8bSTaniya Das
5474f796170SManivannan Sadhasivam if (readl_relaxed(data->base + qcom_cpufreq.soc_data->reg_dcvs_ctrl) & 0x1)
548c377d4baSBjorn Andersson data->per_core_dcvs = true;
549c377d4baSBjorn Andersson
5502849dd8bSTaniya Das qcom_get_related_cpus(index, policy->cpus);
5512849dd8bSTaniya Das
552dcd1fd72SManivannan Sadhasivam policy->driver_data = data;
553f0712aceSTaniya Das policy->dvfs_possible_from_any_cpu = true;
5542849dd8bSTaniya Das
555dcd1fd72SManivannan Sadhasivam ret = qcom_cpufreq_hw_read_lut(cpu_dev, policy);
5562849dd8bSTaniya Das if (ret) {
5572849dd8bSTaniya Das dev_err(dev, "Domain-%d failed to read LUT\n", index);
558054a3ef6SManivannan Sadhasivam return ret;
5592849dd8bSTaniya Das }
5602849dd8bSTaniya Das
56155538fbcSTaniya Das ret = dev_pm_opp_get_opp_count(cpu_dev);
56255538fbcSTaniya Das if (ret <= 0) {
56355538fbcSTaniya Das dev_err(cpu_dev, "Failed to add OPPs\n");
564054a3ef6SManivannan Sadhasivam return -ENODEV;
56555538fbcSTaniya Das }
56655538fbcSTaniya Das
56726699172SShawn Guo if (policy_has_boost_freq(policy)) {
56826699172SShawn Guo ret = cpufreq_enable_boost_support();
56926699172SShawn Guo if (ret)
57026699172SShawn Guo dev_warn(cpu_dev, "failed to enable boost: %d\n", ret);
57126699172SShawn Guo }
57226699172SShawn Guo
573054a3ef6SManivannan Sadhasivam return qcom_cpufreq_hw_lmh_init(policy, index);
5742849dd8bSTaniya Das }
5752849dd8bSTaniya Das
qcom_cpufreq_hw_cpu_exit(struct cpufreq_policy * policy)5762849dd8bSTaniya Das static int qcom_cpufreq_hw_cpu_exit(struct cpufreq_policy *policy)
5772849dd8bSTaniya Das {
57855538fbcSTaniya Das struct device *cpu_dev = get_cpu_device(policy->cpu);
579dcd1fd72SManivannan Sadhasivam struct qcom_cpufreq_data *data = policy->driver_data;
5802849dd8bSTaniya Das
58155538fbcSTaniya Das dev_pm_opp_remove_all_dynamic(cpu_dev);
58251c843cfSSibi Sankar dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
583275157b3SThara Gopinath qcom_cpufreq_hw_lmh_exit(data);
5842849dd8bSTaniya Das kfree(policy->freq_table);
58567fc209bSShawn Guo kfree(data);
5862849dd8bSTaniya Das
5872849dd8bSTaniya Das return 0;
5882849dd8bSTaniya Das }
5892849dd8bSTaniya Das
qcom_cpufreq_ready(struct cpufreq_policy * policy)590ef8ee1cbSBjorn Andersson static void qcom_cpufreq_ready(struct cpufreq_policy *policy)
591ef8ee1cbSBjorn Andersson {
592ef8ee1cbSBjorn Andersson struct qcom_cpufreq_data *data = policy->driver_data;
593ef8ee1cbSBjorn Andersson
594ef8ee1cbSBjorn Andersson if (data->throttle_irq >= 0)
595ef8ee1cbSBjorn Andersson enable_irq(data->throttle_irq);
596ef8ee1cbSBjorn Andersson }
597ef8ee1cbSBjorn Andersson
5982849dd8bSTaniya Das static struct freq_attr *qcom_cpufreq_hw_attr[] = {
5992849dd8bSTaniya Das &cpufreq_freq_attr_scaling_available_freqs,
6002849dd8bSTaniya Das &cpufreq_freq_attr_scaling_boost_freqs,
6012849dd8bSTaniya Das NULL
6022849dd8bSTaniya Das };
6032849dd8bSTaniya Das
6042849dd8bSTaniya Das static struct cpufreq_driver cpufreq_qcom_hw_driver = {
6055ae4a4b4SViresh Kumar .flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK |
6064c5ff1c8SAmit Kucheria CPUFREQ_HAVE_GOVERNOR_PER_POLICY |
6074c5ff1c8SAmit Kucheria CPUFREQ_IS_COOLING_DEV,
6082849dd8bSTaniya Das .verify = cpufreq_generic_frequency_table_verify,
6092849dd8bSTaniya Das .target_index = qcom_cpufreq_hw_target_index,
6102849dd8bSTaniya Das .get = qcom_cpufreq_hw_get,
6112849dd8bSTaniya Das .init = qcom_cpufreq_hw_cpu_init,
6122849dd8bSTaniya Das .exit = qcom_cpufreq_hw_cpu_exit,
613a1eb080aSDmitry Baryshkov .online = qcom_cpufreq_hw_cpu_online,
614a1eb080aSDmitry Baryshkov .offline = qcom_cpufreq_hw_cpu_offline,
615e96c2153SViresh Kumar .register_em = cpufreq_register_em_with_opp,
6162849dd8bSTaniya Das .fast_switch = qcom_cpufreq_hw_fast_switch,
6172849dd8bSTaniya Das .name = "qcom-cpufreq-hw",
6182849dd8bSTaniya Das .attr = qcom_cpufreq_hw_attr,
619ef8ee1cbSBjorn Andersson .ready = qcom_cpufreq_ready,
6202849dd8bSTaniya Das };
6212849dd8bSTaniya Das
qcom_cpufreq_hw_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)6224370232cSManivannan Sadhasivam static unsigned long qcom_cpufreq_hw_recalc_rate(struct clk_hw *hw, unsigned long parent_rate)
6234370232cSManivannan Sadhasivam {
6244370232cSManivannan Sadhasivam struct qcom_cpufreq_data *data = container_of(hw, struct qcom_cpufreq_data, cpu_clk);
6254370232cSManivannan Sadhasivam
6264370232cSManivannan Sadhasivam return qcom_lmh_get_throttle_freq(data);
6274370232cSManivannan Sadhasivam }
6284370232cSManivannan Sadhasivam
6294370232cSManivannan Sadhasivam static const struct clk_ops qcom_cpufreq_hw_clk_ops = {
6304370232cSManivannan Sadhasivam .recalc_rate = qcom_cpufreq_hw_recalc_rate,
6314370232cSManivannan Sadhasivam };
6324370232cSManivannan Sadhasivam
qcom_cpufreq_hw_driver_probe(struct platform_device * pdev)6332849dd8bSTaniya Das static int qcom_cpufreq_hw_driver_probe(struct platform_device *pdev)
6342849dd8bSTaniya Das {
6354370232cSManivannan Sadhasivam struct clk_hw_onecell_data *clk_data;
6367cfa8553SManivannan Sadhasivam struct device *dev = &pdev->dev;
63751c843cfSSibi Sankar struct device *cpu_dev;
6382849dd8bSTaniya Das struct clk *clk;
63935527c67SKonrad Dybcio int ret, i, num_domains;
6402849dd8bSTaniya Das
6417cfa8553SManivannan Sadhasivam clk = clk_get(dev, "xo");
6422849dd8bSTaniya Das if (IS_ERR(clk))
6432849dd8bSTaniya Das return PTR_ERR(clk);
6442849dd8bSTaniya Das
6452849dd8bSTaniya Das xo_rate = clk_get_rate(clk);
6462849dd8bSTaniya Das clk_put(clk);
6472849dd8bSTaniya Das
6487cfa8553SManivannan Sadhasivam clk = clk_get(dev, "alternate");
6492849dd8bSTaniya Das if (IS_ERR(clk))
6502849dd8bSTaniya Das return PTR_ERR(clk);
6512849dd8bSTaniya Das
6522849dd8bSTaniya Das cpu_hw_rate = clk_get_rate(clk) / CLK_HW_DIV;
6532849dd8bSTaniya Das clk_put(clk);
6542849dd8bSTaniya Das
655bd74e286SManivannan Sadhasivam cpufreq_qcom_hw_driver.driver_data = pdev;
6562849dd8bSTaniya Das
65751c843cfSSibi Sankar /* Check for optional interconnect paths on CPU0 */
65851c843cfSSibi Sankar cpu_dev = get_cpu_device(0);
65951c843cfSSibi Sankar if (!cpu_dev)
66051c843cfSSibi Sankar return -EPROBE_DEFER;
66151c843cfSSibi Sankar
66251c843cfSSibi Sankar ret = dev_pm_opp_of_find_icc_paths(cpu_dev, NULL);
66351c843cfSSibi Sankar if (ret)
6645ee64250SAndrew Halaney return dev_err_probe(dev, ret, "Failed to find icc paths\n");
66551c843cfSSibi Sankar
66635527c67SKonrad Dybcio for (num_domains = 0; num_domains < MAX_FREQ_DOMAINS; num_domains++)
66735527c67SKonrad Dybcio if (!platform_get_resource(pdev, IORESOURCE_MEM, num_domains))
66835527c67SKonrad Dybcio break;
669054a3ef6SManivannan Sadhasivam
6707cfa8553SManivannan Sadhasivam qcom_cpufreq.data = devm_kzalloc(dev, sizeof(struct qcom_cpufreq_data) * num_domains,
671054a3ef6SManivannan Sadhasivam GFP_KERNEL);
672054a3ef6SManivannan Sadhasivam if (!qcom_cpufreq.data)
673054a3ef6SManivannan Sadhasivam return -ENOMEM;
674054a3ef6SManivannan Sadhasivam
6754f796170SManivannan Sadhasivam qcom_cpufreq.soc_data = of_device_get_match_data(dev);
6766f098cdeSManivannan Sadhasivam if (!qcom_cpufreq.soc_data)
6776f098cdeSManivannan Sadhasivam return -ENODEV;
6784f796170SManivannan Sadhasivam
6794370232cSManivannan Sadhasivam clk_data = devm_kzalloc(dev, struct_size(clk_data, hws, num_domains), GFP_KERNEL);
6804370232cSManivannan Sadhasivam if (!clk_data)
6814370232cSManivannan Sadhasivam return -ENOMEM;
6824370232cSManivannan Sadhasivam
6834370232cSManivannan Sadhasivam clk_data->num = num_domains;
6844370232cSManivannan Sadhasivam
685054a3ef6SManivannan Sadhasivam for (i = 0; i < num_domains; i++) {
686054a3ef6SManivannan Sadhasivam struct qcom_cpufreq_data *data = &qcom_cpufreq.data[i];
6874370232cSManivannan Sadhasivam struct clk_init_data clk_init = {};
688054a3ef6SManivannan Sadhasivam void __iomem *base;
689054a3ef6SManivannan Sadhasivam
690ba5e770cSKrzysztof Kozlowski base = devm_platform_ioremap_resource(pdev, i);
691054a3ef6SManivannan Sadhasivam if (IS_ERR(base)) {
692ba5e770cSKrzysztof Kozlowski dev_err(dev, "Failed to map resource index %d\n", i);
693054a3ef6SManivannan Sadhasivam return PTR_ERR(base);
694054a3ef6SManivannan Sadhasivam }
695054a3ef6SManivannan Sadhasivam
696054a3ef6SManivannan Sadhasivam data->base = base;
6974370232cSManivannan Sadhasivam
6984370232cSManivannan Sadhasivam /* Register CPU clock for each frequency domain */
6994370232cSManivannan Sadhasivam clk_init.name = kasprintf(GFP_KERNEL, "qcom_cpufreq%d", i);
7004370232cSManivannan Sadhasivam if (!clk_init.name)
7014370232cSManivannan Sadhasivam return -ENOMEM;
7024370232cSManivannan Sadhasivam
7034370232cSManivannan Sadhasivam clk_init.flags = CLK_GET_RATE_NOCACHE;
7044370232cSManivannan Sadhasivam clk_init.ops = &qcom_cpufreq_hw_clk_ops;
7054370232cSManivannan Sadhasivam data->cpu_clk.init = &clk_init;
7064370232cSManivannan Sadhasivam
7074370232cSManivannan Sadhasivam ret = devm_clk_hw_register(dev, &data->cpu_clk);
7084370232cSManivannan Sadhasivam if (ret < 0) {
7094370232cSManivannan Sadhasivam dev_err(dev, "Failed to register clock %d: %d\n", i, ret);
7104370232cSManivannan Sadhasivam kfree(clk_init.name);
7114370232cSManivannan Sadhasivam return ret;
7124370232cSManivannan Sadhasivam }
7134370232cSManivannan Sadhasivam
7144370232cSManivannan Sadhasivam clk_data->hws[i] = &data->cpu_clk;
7154370232cSManivannan Sadhasivam kfree(clk_init.name);
7164370232cSManivannan Sadhasivam }
7174370232cSManivannan Sadhasivam
7184370232cSManivannan Sadhasivam ret = devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, clk_data);
7194370232cSManivannan Sadhasivam if (ret < 0) {
7204370232cSManivannan Sadhasivam dev_err(dev, "Failed to add clock provider\n");
7214370232cSManivannan Sadhasivam return ret;
722054a3ef6SManivannan Sadhasivam }
723054a3ef6SManivannan Sadhasivam
7242849dd8bSTaniya Das ret = cpufreq_register_driver(&cpufreq_qcom_hw_driver);
7252849dd8bSTaniya Das if (ret)
7267cfa8553SManivannan Sadhasivam dev_err(dev, "CPUFreq HW driver failed to register\n");
7272849dd8bSTaniya Das else
7287cfa8553SManivannan Sadhasivam dev_dbg(dev, "QCOM CPUFreq HW driver initialized\n");
7292849dd8bSTaniya Das
7302849dd8bSTaniya Das return ret;
7312849dd8bSTaniya Das }
7322849dd8bSTaniya Das
qcom_cpufreq_hw_driver_remove(struct platform_device * pdev)733573d54dbSYangtao Li static void qcom_cpufreq_hw_driver_remove(struct platform_device *pdev)
7342849dd8bSTaniya Das {
735dd329e1eSUwe Kleine-König cpufreq_unregister_driver(&cpufreq_qcom_hw_driver);
7362849dd8bSTaniya Das }
7372849dd8bSTaniya Das
7382849dd8bSTaniya Das static struct platform_driver qcom_cpufreq_hw_driver = {
7392849dd8bSTaniya Das .probe = qcom_cpufreq_hw_driver_probe,
740573d54dbSYangtao Li .remove_new = qcom_cpufreq_hw_driver_remove,
7412849dd8bSTaniya Das .driver = {
7422849dd8bSTaniya Das .name = "qcom-cpufreq-hw",
7432849dd8bSTaniya Das .of_match_table = qcom_cpufreq_hw_match,
7442849dd8bSTaniya Das },
7452849dd8bSTaniya Das };
7462849dd8bSTaniya Das
qcom_cpufreq_hw_init(void)7472849dd8bSTaniya Das static int __init qcom_cpufreq_hw_init(void)
7482849dd8bSTaniya Das {
7492849dd8bSTaniya Das return platform_driver_register(&qcom_cpufreq_hw_driver);
7502849dd8bSTaniya Das }
75111ff4bddSAmit Kucheria postcore_initcall(qcom_cpufreq_hw_init);
7522849dd8bSTaniya Das
qcom_cpufreq_hw_exit(void)7532849dd8bSTaniya Das static void __exit qcom_cpufreq_hw_exit(void)
7542849dd8bSTaniya Das {
7552849dd8bSTaniya Das platform_driver_unregister(&qcom_cpufreq_hw_driver);
7562849dd8bSTaniya Das }
7572849dd8bSTaniya Das module_exit(qcom_cpufreq_hw_exit);
7582849dd8bSTaniya Das
7592849dd8bSTaniya Das MODULE_DESCRIPTION("QCOM CPUFREQ HW Driver");
7602849dd8bSTaniya Das MODULE_LICENSE("GPL v2");
761