diff --git a/Makefile b/Makefile index 1065154..03373bb 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ VERSION = 2 PATCHLEVEL = 6 SUBLEVEL = 30 -EXTRAVERSION = -rc8 +EXTRAVERSION = NAME = Man-Eating Seals of Antiquity # *DOCUMENTATION* diff --git a/arch/arm/mach-mx3/cpufreq.c b/arch/arm/mach-mx3/cpufreq.c new file mode 100644 index 0000000..8cebe92 --- /dev/null +++ b/arch/arm/mach-mx3/cpufreq.c @@ -0,0 +1,236 @@ +/* + * cpufreq.c -- i.MX3x CPUfreq driver. + * + * Copyright (C) 2007 Wolfson Microelectronics PLC. + * + * Author: Liam Girdwood + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static struct clk *cpu_clk; +static struct regulator *regulator; + +struct mx3_freq_volts { + int freq; + int uV; +}; + +/* + * These voltage and frequency settings could be further refined. + */ +static const struct mx3_freq_volts freq_uV[] = { + {133000 * 1000, 1275 * 1000}, + {266000 * 1000, 1400 * 1000}, + {399000 * 1000, 1500 * 1000}, + {532000 * 1000, 1600 * 1000}, +}; + +/* does need to be in ascending order for calc_frequency() below */ +static struct cpufreq_frequency_table imx31_freq_table[] = { + {0x01, 133000}, + {0x02, 266000}, + {0x03, 399000}, + {0x04, 532000}, + {0, CPUFREQ_TABLE_END}, +}; + +static int mx3_verify_speed(struct cpufreq_policy *policy) +{ + if (policy->cpu != 0) + return -EINVAL; + + return cpufreq_frequency_table_verify(policy, imx31_freq_table); +} + +static unsigned int mx3_get_speed(unsigned int cpu) +{ + if (cpu) + return 0; + return clk_get_rate(cpu_clk) / 1000; +} + +static int calc_frequency(int target, unsigned int relation) +{ + int i; + + if (relation == CPUFREQ_RELATION_H) { + for (i = ARRAY_SIZE(imx31_freq_table) - 1; i > 0; i--) { + if (imx31_freq_table[i].frequency <= target) + return imx31_freq_table[i].frequency; + } + } else if (relation == CPUFREQ_RELATION_L) { + for (i = 0; i < ARRAY_SIZE(imx31_freq_table) - 1; i++) { + if (imx31_freq_table[i].frequency >= target) + return imx31_freq_table[i].frequency; + } + } + printk(KERN_ERR "error no valid cpufreq relation\n"); + return 532000; +} + +static int mx3_cpu_voltage(struct cpufreq_policy *policy, int freq) +{ + int i, ret = -EINVAL, mV_delta; + + for (i = 0; i < ARRAY_SIZE(freq_uV); i++) { + if (freq_uV[i].freq == freq) + goto found; + } + printk(KERN_ERR "%s: could not find voltage for freq %d kHz\n", + __func__, freq); + return ret; + +found: + mV_delta = (freq_uV[i].uV - regulator_get_voltage(regulator)) / 1000; + ret = regulator_set_voltage(regulator, freq_uV[i].uV, freq_uV[i].uV); + if (mV_delta < 0) + mV_delta *= -1; + udelay(mV_delta * 2); /* wait for voltage change - TODO: tune */ + return ret; +} + +static int mx3_set_target(struct cpufreq_policy *policy, + unsigned int target_freq, unsigned int relation) +{ + struct cpufreq_freqs freqs; + long freq; + int ret = 0; + + /* + * Some governors do not respects CPU and policy lower limits + * which leads to bad things (division by zero etc), ensure + * that such things do not happen. + */ + if (target_freq < policy->cpuinfo.min_freq) + target_freq = policy->cpuinfo.min_freq; + + if (target_freq < policy->min) + target_freq = policy->min; + + freq = calc_frequency(target_freq, relation) * 1000; + freqs.old = clk_get_rate(cpu_clk) / 1000; + freqs.new = (freq + 500) / 1000; + freqs.cpu = 0; + freqs.flags = 0; + + if (freqs.old < freqs.new) + ret = mx3_cpu_voltage(policy, freq); + + if (ret < 0) { + printk(KERN_ERR "cant raise voltage for CPU frequency %ld\n", + freq); + return -EIO; + } + + cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); + clk_set_rate(cpu_clk, freq); + + if (freqs.old > freqs.new) + ret = mx3_cpu_voltage(policy, freq); + if (ret < 0) { + printk(KERN_ERR "cant lower voltage for CPU frequency %ld\n", + freq); + } + + cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); + return 0; +} + +static int __init mx3_cpufreq_driver_init(struct cpufreq_policy *policy) +{ + int ret; + + printk(KERN_INFO "i.MX3x CPU frequency driver\n"); + + if (policy->cpu != 0) + return -EINVAL; + + cpu_clk = clk_get(NULL, "cpu_clk"); + if (IS_ERR(cpu_clk)) { + printk(KERN_ERR "%s: failed to get clock\n", __func__); + return PTR_ERR(cpu_clk); + } + + regulator = regulator_get(NULL, "cpu_vcc"); + if (IS_ERR(regulator)) { + clk_put(cpu_clk); + printk(KERN_ERR "%s: failed to get regulator\n", __func__); + return PTR_ERR(regulator); + } + + policy->cur = policy->min = policy->max = clk_get_rate(cpu_clk) / 1000; + policy->governor = CPUFREQ_DEFAULT_GOVERNOR; + policy->cpuinfo.min_freq = 133000; + policy->cpuinfo.max_freq = 532000; + + /* Manual states, that PLL stabilizes in two CLK32 periods */ + policy->cpuinfo.transition_latency = 10; + + ret = cpufreq_frequency_table_cpuinfo(policy, imx31_freq_table); + if (ret < 0) { + clk_put(cpu_clk); + regulator_put(regulator); + printk(KERN_ERR "%s: failed to register i.MX3x CPUfreq\n", + __func__); + return ret; + } + cpufreq_frequency_table_get_attr(imx31_freq_table, policy->cpu); + return 0; +} + +static int mx3_cpufreq_driver_exit(struct cpufreq_policy *policy) +{ + cpufreq_frequency_table_put_attr(policy->cpu); + + /* reset CPU to 532MHz */ + if (regulator_set_voltage(regulator, 1600 * 1000, 1600 * 1000) == 0) + clk_set_rate(cpu_clk, 532000 * 1000); + + clk_put(cpu_clk); + regulator_put(regulator); + return 0; +} + +static struct cpufreq_driver mx3_driver = { + .flags = CPUFREQ_STICKY, + .verify = mx3_verify_speed, + .target = mx3_set_target, + .get = mx3_get_speed, + .init = mx3_cpufreq_driver_init, + .exit = mx3_cpufreq_driver_exit, + .name = "imx3x", +}; + +static int __devinit mx3_cpufreq_init(void) +{ + return cpufreq_register_driver(&mx3_driver); +} + +static void mx3_cpufreq_exit(void) +{ + cpufreq_unregister_driver(&mx3_driver); +} + +module_init(mx3_cpufreq_init); +module_exit(mx3_cpufreq_exit); + +MODULE_AUTHOR("Liam Girdwood "); +MODULE_DESCRIPTION("CPUfreq driver for i.mx3x"); +MODULE_LICENSE("GPL"); diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index ee3927a..8ad8a32 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -152,7 +152,7 @@ config MFD_WM8400 depends on I2C help Support for the Wolfson Microelecronics WM8400 PMIC and audio - CODEC. This driver adds provides common support for accessing + CODEC. This driver provides common support for accessing the device, additional drivers must be enabled in order to use the functionality of the device. diff --git a/drivers/mfd/htc-pasic3.c b/drivers/mfd/htc-pasic3.c index 386da15..cb73051 100644 --- a/drivers/mfd/htc-pasic3.c +++ b/drivers/mfd/htc-pasic3.c @@ -35,7 +35,7 @@ struct pasic3_data { */ void pasic3_write_register(struct device *dev, u32 reg, u8 val) { - struct pasic3_data *asic = dev->driver_data; + struct pasic3_data *asic = dev_get_drvdata(dev); int bus_shift = asic->bus_shift; void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift); void __iomem *data = asic->mapping + (REG_DATA << bus_shift); @@ -50,7 +50,7 @@ EXPORT_SYMBOL(pasic3_write_register); /* for leds-pasic3 */ */ u8 pasic3_read_register(struct device *dev, u32 reg) { - struct pasic3_data *asic = dev->driver_data; + struct pasic3_data *asic = dev_get_drvdata(dev); int bus_shift = asic->bus_shift; void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift); void __iomem *data = asic->mapping + (REG_DATA << bus_shift); diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c index 11a6248..082c197 100644 --- a/drivers/mfd/pcf50633-core.c +++ b/drivers/mfd/pcf50633-core.c @@ -618,7 +618,7 @@ static int __devinit pcf50633_probe(struct i2c_client *client, pdev->dev.parent = pcf->dev; pdev->dev.platform_data = &pdata->reg_init_data[i]; - pdev->dev.driver_data = pcf; + dev_set_drvdata(&pdev->dev, pcf); pcf->regulator_pdev[i] = pdev; platform_device_add(pdev); diff --git a/drivers/mfd/wm8350-regmap.c b/drivers/mfd/wm8350-regmap.c index 9a4cc95..7ccc1ea 100644 --- a/drivers/mfd/wm8350-regmap.c +++ b/drivers/mfd/wm8350-regmap.c @@ -3186,7 +3186,7 @@ const struct wm8350_reg_access wm8350_reg_io_map[] = { /* read write volatile */ { 0xFFFF, 0xFFFF, 0xFFFF }, /* R0 - Reset/ID */ { 0x7CFF, 0x0C00, 0x7FFF }, /* R1 - ID */ - { 0x0000, 0x0000, 0x0000 }, /* R2 */ + { 0x007F, 0x0000, 0x0000 }, /* R2 - ROM Mask ID */ { 0xBE3B, 0xBE3B, 0x8000 }, /* R3 - System Control 1 */ { 0xFEF7, 0xFEF7, 0xF800 }, /* R4 - System Control 2 */ { 0x80FF, 0x80FF, 0x8000 }, /* R5 - System Hibernate */ @@ -3411,7 +3411,7 @@ const struct wm8350_reg_access wm8350_reg_io_map[] = { { 0x0000, 0x0000, 0x0000 }, /* R224 */ { 0x8F3F, 0x0000, 0xFFFF }, /* R225 - DCDC/LDO status */ { 0x0000, 0x0000, 0xFFFF }, /* R226 - Charger status */ - { 0x0000, 0x0000, 0xFFFF }, /* R227 */ + { 0x34FE, 0x0000, 0xFFFF }, /* R227 */ { 0x0000, 0x0000, 0x0000 }, /* R228 */ { 0x0000, 0x0000, 0x0000 }, /* R229 */ { 0xFFFF, 0x1FFF, 0xFFFF }, /* R230 - GPIO Pin Status */ diff --git a/drivers/mfd/wm8400-core.c b/drivers/mfd/wm8400-core.c index cf30d06..7c21bf7 100644 --- a/drivers/mfd/wm8400-core.c +++ b/drivers/mfd/wm8400-core.c @@ -265,7 +265,7 @@ static int wm8400_init(struct wm8400 *wm8400, mutex_init(&wm8400->io_lock); - wm8400->dev->driver_data = wm8400; + dev_set_drvdata(wm8400->dev, wm8400); /* Check that this is actually a WM8400 */ ret = wm8400->read_dev(wm8400->io_data, WM8400_RESET_ID, 1, ®); diff --git a/sound/soc/codecs/wm8350.h b/sound/soc/codecs/wm8350.h index d11bd92..d088eb4 100644 --- a/sound/soc/codecs/wm8350.h +++ b/sound/soc/codecs/wm8350.h @@ -13,6 +13,7 @@ #define _WM8350_H #include +#include extern struct snd_soc_dai wm8350_dai; extern struct snd_soc_codec_device soc_codec_dev_wm8350; diff --git a/sound/soc/codecs/wm8400-codec.h b/sound/soc/codecs/wm8400-codec.h new file mode 100644 index 0000000..cadddbe --- /dev/null +++ b/sound/soc/codecs/wm8400-codec.h @@ -0,0 +1,62 @@ +/* + * wm8400.h -- audio driver for WM8400 + * + * Copyright 2008 Wolfson Microelectronics PLC. + * Author: Mark Brown + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + */ + +#ifndef _WM8400_CODEC_H +#define _WM8400_CODEC_H + +#define WM8400_MCLK_DIV 0 +#define WM8400_DACCLK_DIV 1 +#define WM8400_ADCCLK_DIV 2 +#define WM8400_BCLK_DIV 3 + +#define WM8400_MCLK_DIV_1 0x400 +#define WM8400_MCLK_DIV_2 0x800 + +#define WM8400_DAC_CLKDIV_1 0x00 +#define WM8400_DAC_CLKDIV_1_5 0x04 +#define WM8400_DAC_CLKDIV_2 0x08 +#define WM8400_DAC_CLKDIV_3 0x0c +#define WM8400_DAC_CLKDIV_4 0x10 +#define WM8400_DAC_CLKDIV_5_5 0x14 +#define WM8400_DAC_CLKDIV_6 0x18 + +#define WM8400_ADC_CLKDIV_1 0x00 +#define WM8400_ADC_CLKDIV_1_5 0x20 +#define WM8400_ADC_CLKDIV_2 0x40 +#define WM8400_ADC_CLKDIV_3 0x60 +#define WM8400_ADC_CLKDIV_4 0x80 +#define WM8400_ADC_CLKDIV_5_5 0xa0 +#define WM8400_ADC_CLKDIV_6 0xc0 + + +#define WM8400_BCLK_DIV_1 (0x0 << 1) +#define WM8400_BCLK_DIV_1_5 (0x1 << 1) +#define WM8400_BCLK_DIV_2 (0x2 << 1) +#define WM8400_BCLK_DIV_3 (0x3 << 1) +#define WM8400_BCLK_DIV_4 (0x4 << 1) +#define WM8400_BCLK_DIV_5_5 (0x5 << 1) +#define WM8400_BCLK_DIV_6 (0x6 << 1) +#define WM8400_BCLK_DIV_8 (0x7 << 1) +#define WM8400_BCLK_DIV_11 (0x8 << 1) +#define WM8400_BCLK_DIV_12 (0x9 << 1) +#define WM8400_BCLK_DIV_16 (0xA << 1) +#define WM8400_BCLK_DIV_22 (0xB << 1) +#define WM8400_BCLK_DIV_24 (0xC << 1) +#define WM8400_BCLK_DIV_32 (0xD << 1) +#define WM8400_BCLK_DIV_44 (0xE << 1) +#define WM8400_BCLK_DIV_48 (0xF << 1) + +extern struct snd_soc_codec_dai wm8400_dai; +extern struct snd_soc_codec_device soc_codec_dev_wm8400; + +#endif