| /* | |
| * Copyright (c) 2006-2009 Simtec Electronics | |
| * http://armlinux.simtec.co.uk/ | |
| * Ben Dooks <ben@simtec.co.uk> | |
| * Vincent Sanders <vince@simtec.co.uk> | |
| * | |
| * S3C2440/S3C2442 CPU Frequency scaling | |
| * | |
| * 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. | |
| */ | |
| #include <linux/init.h> | |
| #include <linux/module.h> | |
| #include <linux/interrupt.h> | |
| #include <linux/ioport.h> | |
| #include <linux/cpufreq.h> | |
| #include <linux/device.h> | |
| #include <linux/delay.h> | |
| #include <linux/clk.h> | |
| #include <linux/err.h> | |
| #include <linux/io.h> | |
| #include <asm/mach/arch.h> | |
| #include <asm/mach/map.h> | |
| #include <mach/regs-clock.h> | |
| #include <plat/cpu.h> | |
| #include <plat/cpu-freq-core.h> | |
| static struct clk *xtal; | |
| static struct clk *fclk; | |
| static struct clk *hclk; | |
| static struct clk *armclk; | |
| /* HDIV: 1, 2, 3, 4, 6, 8 */ | |
| static inline int within_khz(unsigned long a, unsigned long b) | |
| { | |
| long diff = a - b; | |
| return (diff >= -1000 && diff <= 1000); | |
| } | |
| /** | |
| * s3c2440_cpufreq_calcdivs - calculate divider settings | |
| * @cfg: The cpu frequency settings. | |
| * | |
| * Calcualte the divider values for the given frequency settings | |
| * specified in @cfg. The values are stored in @cfg for later use | |
| * by the relevant set routine if the request settings can be reached. | |
| */ | |
| static int s3c2440_cpufreq_calcdivs(struct s3c_cpufreq_config *cfg) | |
| { | |
| unsigned int hdiv, pdiv; | |
| unsigned long hclk, fclk, armclk; | |
| unsigned long hclk_max; | |
| fclk = cfg->freq.fclk; | |
| armclk = cfg->freq.armclk; | |
| hclk_max = cfg->max.hclk; | |
| s3c_freq_dbg("%s: fclk is %lu, armclk %lu, max hclk %lu\n", | |
| __func__, fclk, armclk, hclk_max); | |
| if (armclk > fclk) { | |
| printk(KERN_WARNING "%s: armclk > fclk\n", __func__); | |
| armclk = fclk; | |
| } | |
| /* if we are in DVS, we need HCLK to be <= ARMCLK */ | |
| if (armclk < fclk && armclk < hclk_max) | |
| hclk_max = armclk; | |
| for (hdiv = 1; hdiv < 9; hdiv++) { | |
| if (hdiv == 5 || hdiv == 7) | |
| hdiv++; | |
| hclk = (fclk / hdiv); | |
| if (hclk <= hclk_max || within_khz(hclk, hclk_max)) | |
| break; | |
| } | |
| s3c_freq_dbg("%s: hclk %lu, div %d\n", __func__, hclk, hdiv); | |
| if (hdiv > 8) | |
| goto invalid; | |
| pdiv = (hclk > cfg->max.pclk) ? 2 : 1; | |
| if ((hclk / pdiv) > cfg->max.pclk) | |
| pdiv++; | |
| s3c_freq_dbg("%s: pdiv %d\n", __func__, pdiv); | |
| if (pdiv > 2) | |
| goto invalid; | |
| pdiv *= hdiv; | |
| /* calculate a valid armclk */ | |
| if (armclk < hclk) | |
| armclk = hclk; | |
| /* if we're running armclk lower than fclk, this really means | |
| * that the system should go into dvs mode, which means that | |
| * armclk is connected to hclk. */ | |
| if (armclk < fclk) { | |
| cfg->divs.dvs = 1; | |
| armclk = hclk; | |
| } else | |
| cfg->divs.dvs = 0; | |
| cfg->freq.armclk = armclk; | |
| /* store the result, and then return */ | |
| cfg->divs.h_divisor = hdiv; | |
| cfg->divs.p_divisor = pdiv; | |
| return 0; | |
| invalid: | |
| return -EINVAL; | |
| } | |
| #define CAMDIVN_HCLK_HALF (S3C2440_CAMDIVN_HCLK3_HALF | \ | |
| S3C2440_CAMDIVN_HCLK4_HALF) | |
| /** | |
| * s3c2440_cpufreq_setdivs - set the cpu frequency divider settings | |
| * @cfg: The cpu frequency settings. | |
| * | |
| * Set the divisors from the settings in @cfg, which where generated | |
| * during the calculation phase by s3c2440_cpufreq_calcdivs(). | |
| */ | |
| static void s3c2440_cpufreq_setdivs(struct s3c_cpufreq_config *cfg) | |
| { | |
| unsigned long clkdiv, camdiv; | |
| s3c_freq_dbg("%s: divsiors: h=%d, p=%d\n", __func__, | |
| cfg->divs.h_divisor, cfg->divs.p_divisor); | |
| clkdiv = __raw_readl(S3C2410_CLKDIVN); | |
| camdiv = __raw_readl(S3C2440_CAMDIVN); | |
| clkdiv &= ~(S3C2440_CLKDIVN_HDIVN_MASK | S3C2440_CLKDIVN_PDIVN); | |
| camdiv &= ~CAMDIVN_HCLK_HALF; | |
| switch (cfg->divs.h_divisor) { | |
| case 1: | |
| clkdiv |= S3C2440_CLKDIVN_HDIVN_1; | |
| break; | |
| case 2: | |
| clkdiv |= S3C2440_CLKDIVN_HDIVN_2; | |
| break; | |
| case 6: | |
| camdiv |= S3C2440_CAMDIVN_HCLK3_HALF; | |
| case 3: | |
| clkdiv |= S3C2440_CLKDIVN_HDIVN_3_6; | |
| break; | |
| case 8: | |
| camdiv |= S3C2440_CAMDIVN_HCLK4_HALF; | |
| case 4: | |
| clkdiv |= S3C2440_CLKDIVN_HDIVN_4_8; | |
| break; | |
| default: | |
| BUG(); /* we don't expect to get here. */ | |
| } | |
| if (cfg->divs.p_divisor != cfg->divs.h_divisor) | |
| clkdiv |= S3C2440_CLKDIVN_PDIVN; | |
| /* todo - set pclk. */ | |
| /* Write the divisors first with hclk intentionally halved so that | |
| * when we write clkdiv we will under-frequency instead of over. We | |
| * then make a short delay and remove the hclk halving if necessary. | |
| */ | |
| __raw_writel(camdiv | CAMDIVN_HCLK_HALF, S3C2440_CAMDIVN); | |
| __raw_writel(clkdiv, S3C2410_CLKDIVN); | |
| ndelay(20); | |
| __raw_writel(camdiv, S3C2440_CAMDIVN); | |
| clk_set_parent(armclk, cfg->divs.dvs ? hclk : fclk); | |
| } | |
| static int run_freq_for(unsigned long max_hclk, unsigned long fclk, | |
| int *divs, | |
| struct cpufreq_frequency_table *table, | |
| size_t table_size) | |
| { | |
| unsigned long freq; | |
| int index = 0; | |
| int div; | |
| for (div = *divs; div > 0; div = *divs++) { | |
| freq = fclk / div; | |
| if (freq > max_hclk && div != 1) | |
| continue; | |
| freq /= 1000; /* table is in kHz */ | |
| index = s3c_cpufreq_addfreq(table, index, table_size, freq); | |
| if (index < 0) | |
| break; | |
| } | |
| return index; | |
| } | |
| static int hclk_divs[] = { 1, 2, 3, 4, 6, 8, -1 }; | |
| static int s3c2440_cpufreq_calctable(struct s3c_cpufreq_config *cfg, | |
| struct cpufreq_frequency_table *table, | |
| size_t table_size) | |
| { | |
| int ret; | |
| WARN_ON(cfg->info == NULL); | |
| WARN_ON(cfg->board == NULL); | |
| ret = run_freq_for(cfg->info->max.hclk, | |
| cfg->info->max.fclk, | |
| hclk_divs, | |
| table, table_size); | |
| s3c_freq_dbg("%s: returning %d\n", __func__, ret); | |
| return ret; | |
| } | |
| static struct s3c_cpufreq_info s3c2440_cpufreq_info = { | |
| .max = { | |
| .fclk = 400000000, | |
| .hclk = 133333333, | |
| .pclk = 66666666, | |
| }, | |
| .locktime_m = 300, | |
| .locktime_u = 300, | |
| .locktime_bits = 16, | |
| .name = "s3c244x", | |
| .calc_iotiming = s3c2410_iotiming_calc, | |
| .set_iotiming = s3c2410_iotiming_set, | |
| .get_iotiming = s3c2410_iotiming_get, | |
| .set_fvco = s3c2410_set_fvco, | |
| .set_refresh = s3c2410_cpufreq_setrefresh, | |
| .set_divs = s3c2440_cpufreq_setdivs, | |
| .calc_divs = s3c2440_cpufreq_calcdivs, | |
| .calc_freqtable = s3c2440_cpufreq_calctable, | |
| .debug_io_show = s3c_cpufreq_debugfs_call(s3c2410_iotiming_debugfs), | |
| }; | |
| static int s3c2440_cpufreq_add(struct device *dev, | |
| struct subsys_interface *sif) | |
| { | |
| xtal = s3c_cpufreq_clk_get(NULL, "xtal"); | |
| hclk = s3c_cpufreq_clk_get(NULL, "hclk"); | |
| fclk = s3c_cpufreq_clk_get(NULL, "fclk"); | |
| armclk = s3c_cpufreq_clk_get(NULL, "armclk"); | |
| if (IS_ERR(xtal) || IS_ERR(hclk) || IS_ERR(fclk) || IS_ERR(armclk)) { | |
| printk(KERN_ERR "%s: failed to get clocks\n", __func__); | |
| return -ENOENT; | |
| } | |
| return s3c_cpufreq_register(&s3c2440_cpufreq_info); | |
| } | |
| static struct subsys_interface s3c2440_cpufreq_interface = { | |
| .name = "s3c2440_cpufreq", | |
| .subsys = &s3c2440_subsys, | |
| .add_dev = s3c2440_cpufreq_add, | |
| }; | |
| static int s3c2440_cpufreq_init(void) | |
| { | |
| return subsys_interface_register(&s3c2440_cpufreq_interface); | |
| } | |
| /* arch_initcall adds the clocks we need, so use subsys_initcall. */ | |
| subsys_initcall(s3c2440_cpufreq_init); | |
| static struct subsys_interface s3c2442_cpufreq_interface = { | |
| .name = "s3c2442_cpufreq", | |
| .subsys = &s3c2442_subsys, | |
| .add_dev = s3c2440_cpufreq_add, | |
| }; | |
| static int s3c2442_cpufreq_init(void) | |
| { | |
| return subsys_interface_register(&s3c2442_cpufreq_interface); | |
| } | |
| subsys_initcall(s3c2442_cpufreq_init); |