static irqreturn_t exynos4x12_tmu_irq_handler(int irq, void *id)
{
struct s5p_tmu_info *info = id;
unsigned int status;
disable_irq_nosync(irq);
status = __raw_readl(info->tmu_base + EXYNOS4_TMU_INTSTAT) & 0x1FFFF;
pr_info("EXYNOS4x12_tmu interrupt: INTSTAT = 0x%08x\n", status);
/* To handle multiple interrupt pending,
* interrupt by high temperature are serviced with priority.
*/
#if defined(CONFIG_TC_VOLTAGE)
if (status & INTSTAT_FALL0) {
info->tmu_state = TMU_STATUS_TC;
__raw_writel(INTCLEARALL, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
exynos_interrupt_enable(info, 0);
} else if (status & INTSTAT_RISE2) {
info->tmu_state = TMU_STATUS_TRIPPED;
__raw_writel(INTCLEAR_RISE2, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
#else
if (status & INTSTAT_RISE2) {
info->tmu_state = TMU_STATUS_TRIPPED;
__raw_writel(INTCLEAR_RISE2, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
#endif
} else if (status & INTSTAT_RISE1) {
info->tmu_state = TMU_STATUS_WARNING;
__raw_writel(INTCLEAR_RISE1, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
} else if (status & INTSTAT_RISE0) {
info->tmu_state = TMU_STATUS_THROTTLED;
__raw_writel(INTCLEAR_RISE0, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
} else {
pr_err("%s: interrupt error\n", __func__);
__raw_writel(INTCLEARALL, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
queue_delayed_work_on(0, tmu_monitor_wq,
&info->polling, info->sampling_rate / 2);
return -ENODEV;
}
/* read current temperature & save */
info->last_temperature = get_curr_temp(info);
queue_delayed_work_on(0, tmu_monitor_wq, &info->polling,
info->sampling_rate);
return IRQ_HANDLED;
}
static irqreturn_t exynos4210_tmu_irq_handler(int irq, void *id)
{
struct s5p_tmu_info *info = id;
unsigned int status;
disable_irq_nosync(irq);
status = __raw_readl(info->tmu_base + EXYNOS4_TMU_INTSTAT);
pr_info("EXYNOS4212_tmu interrupt: INTSTAT = 0x%08x\n", status);
/* To handle multiple interrupt pending,
* interrupt by high temperature are serviced with priority.
*/
if (status & TMU_INTSTAT2) {
info->tmu_state = TMU_STATUS_TRIPPED;
__raw_writel(INTCLEAR2, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
} else if (status & TMU_INTSTAT1) {
info->tmu_state = TMU_STATUS_WARNING;
__raw_writel(INTCLEAR1, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
} else if (status & TMU_INTSTAT0) {
info->tmu_state = TMU_STATUS_THROTTLED;
__raw_writel(INTCLEAR0, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
} else {
pr_err("%s: interrupt error\n", __func__);
__raw_writel(INTCLEARALL, info->tmu_base + EXYNOS4_TMU_INTCLEAR);
queue_delayed_work_on(0, tmu_monitor_wq,
&info->polling, info->sampling_rate / 2);
return -ENODEV;
}
/* read current temperature & save */
info->last_temperature = get_curr_temp(info);
queue_delayed_work_on(0, tmu_monitor_wq, &info->polling,
info->sampling_rate);
return IRQ_HANDLED;
}
#ifdef CONFIG_TMU_SYSFS
static ssize_t s5p_tmu_show_curr_temp(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct s5p_tmu_info *info = dev_get_drvdata(dev);
unsigned int curr_temp;
curr_temp = get_curr_temp(info);
curr_temp *= 10;
pr_info("curr temp = %d\n", curr_temp);
return sprintf(buf, "%d\n", curr_temp);
}
static DEVICE_ATTR(curr_temp, S_IRUGO, s5p_tmu_show_curr_temp, NULL);
#endif
static int __devinit s5p_tmu_probe(struct platform_device *pdev)
{
struct s5p_tmu_info *info;
struct s5p_platform_tmu *pdata;
struct resource *res;
unsigned int mask = (enable_mask & ENABLE_DBGMASK);
int ret = 0;
pr_debug("%s: probe=%p\n", __func__, pdev);
info = kzalloc(sizeof(struct s5p_tmu_info), GFP_KERNEL);
if (!info) {
dev_err(&pdev->dev, "failed to alloc memory!\n");
ret = -ENOMEM;
goto err_nomem;
}
platform_set_drvdata(pdev, info);
info->dev = &pdev->dev;
info->tmu_state = TMU_STATUS_INIT;
/* set cpufreq limit level at 1st_throttle & 2nd throttle */
pdata = info->dev->platform_data;
if (pdata->cpufreq.limit_1st_throttle)
exynos_cpufreq_get_level(pdata->cpufreq.limit_1st_throttle,
&info->cpufreq_level_1st_throttle);
if (pdata->cpufreq.limit_2nd_throttle)
exynos_cpufreq_get_level(pdata->cpufreq.limit_2nd_throttle,
&info->cpufreq_level_2nd_throttle);
pr_info("@@@ %s: cpufreq_limit: 1st_throttle: %u, 2nd_throttle = %u\n",
__func__, info->cpufreq_level_1st_throttle,
info->cpufreq_level_2nd_throttle);
#if defined(CONFIG_TC_VOLTAGE) /* Temperature compensated voltage */
if (exynos_find_cpufreq_level_by_volt(pdata->temp_compensate.arm_volt,
&info->cpulevel_tc) < 0) {
dev_err(&pdev->dev, "cpufreq_get_level error\n");
ret = -EINVAL;
goto err_nores;
}
#ifdef CONFIG_BUSFREQ_OPP
/* To lock bus frequency in OPP mode */
info->bus_dev = dev_get("exynos-busfreq");
if (info->bus_dev < 0) {
dev_err(&pdev->dev, "Failed to get_dev\n");
ret = -EINVAL;
goto err_nores;
}
if (exynos4x12_find_busfreq_by_volt(pdata->temp_compensate.bus_volt,
&info->busfreq_tc)) {
dev_err(&pdev->dev, "get_busfreq_value error\n");
ret = -EINVAL;
goto err_nores;
}
#endif
pr_info("%s: cpufreq_level[%u], busfreq_value[%u]\n",
__func__, info->cpulevel_tc, info->busfreq_tc);
#endif
/* Map auto_refresh_rate of normal & tq0 mode */
info->auto_refresh_tq0 =
get_refresh_interval(FREQ_IN_PLL, AUTO_REFRESH_PERIOD_TQ0);
info->auto_refresh_normal =
get_refresh_interval(FREQ_IN_PLL, AUTO_REFRESH_PERIOD_NORMAL);
/* To poll current temp, set sampling rate to ONE second sampling */
info->sampling_rate = usecs_to_jiffies(1000 * 1000);
/* 10sec monitroing */
info->monitor_period = usecs_to_jiffies(10000 * 1000);
/* support test mode */
if (mask & ENABLE_TEST_MODE)
set_temperature_params(info);
else
print_temperature_params(info);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "failed to get memory region resource\n");
ret = -ENODEV;
goto err_nores;
}
info->ioarea = request_mem_region(res->start,
res->end-res->start + 1, pdev->name);
if (!(info->ioarea)) {
dev_err(&pdev->dev, "failed to reserve memory region\n");
ret = -EBUSY;
goto err_nores;
}
info->tmu_base = ioremap(res->start, (res->end - res->start) + 1);
if (!(info->tmu_base)) {
dev_err(&pdev->dev, "failed ioremap()\n");
ret = -ENOMEM;
goto err_nomap;
}
tmu_monitor_wq = create_freezable_workqueue(dev_name(&pdev->dev));
if (!tmu_monitor_wq) {
pr_info("Creation of tmu_monitor_wq failed\n");
ret = -ENOMEM;
goto err_wq;
}
/* To support periodic temprature monitoring */
if (mask & ENABLE_TEMP_MON) {
INIT_DELAYED_WORK_DEFERRABLE(&info->monitor,
exynos4_poll_cur_temp);
queue_delayed_work_on(0, tmu_monitor_wq, &info->monitor,
info->monitor_period);
}
INIT_DELAYED_WORK_DEFERRABLE(&info->polling, exynos4_handler_tmu_state);
info->irq = platform_get_irq(pdev, 0);
if (info->irq < 0) {
dev_err(&pdev->dev, "no irq for thermal %d\n", info->irq);
ret = -EINVAL;
goto err_irq;
}
if (soc_is_exynos4210())
ret = request_irq(info->irq, exynos4210_tmu_irq_handler,
IRQF_DISABLED, "s5p-tmu interrupt", info);
else
ret = request_irq(info->irq, exynos4x12_tmu_irq_handler,
IRQF_DISABLED, "s5p-tmu interrupt", info);
if (ret) {
dev_err(&pdev->dev, "request_irq is failed. %d\n", ret);
goto err_irq;
}
ret = device_create_file(&pdev->dev, &dev_attr_temperature);
if (ret != 0) {
pr_err("Failed to create temperatue file: %d\n", ret);
goto err_sysfs_file1;
}
ret = device_create_file(&pdev->dev, &dev_attr_tmu_state);
if (ret != 0) {
pr_err("Failed to create tmu_state file: %d\n", ret);
goto err_sysfs_file2;
}
ret = device_create_file(&pdev->dev, &dev_attr_lot_id);
if (ret != 0) {
pr_err("Failed to create lot id file: %d\n", ret);
goto err_sysfs_file3;
}
ret = tmu_initialize(pdev);
if (ret)
goto err_init;
#ifdef CONFIG_TMU_SYSFS
ret = device_create_file(&pdev->dev, &dev_attr_curr_temp);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to create sysfs group\n");
goto err_init;
}
#endif
#ifdef CONFIG_TMU_DEBUG
ret = device_create_file(&pdev->dev, &dev_attr_print_state);
if (ret) {
dev_err(&pdev->dev, "Failed to create tmu sysfs group\n\n");
return ret;
}
#endif
#if defined(CONFIG_TC_VOLTAGE)
/* s/w workaround for fast service when interrupt is not occured,
* such as current temp is lower than tc interrupt temperature
* or current temp is continuosly increased.
*/
if (get_curr_temp(info) <= pdata->ts.start_tc) {
if (exynos_tc_volt(info, 1) < 0)
pr_err("TMU: lock error!\n");
}
#if defined(CONFIG_VIDEO_MALI400MP)
if (mali_voltage_lock_init())
pr_err("Failed to initialize mail voltage lock.\n");
#endif
#endif
/* initialize tmu_state */
queue_delayed_work_on(0, tmu_monitor_wq, &info->polling,
info->sampling_rate);
return ret;
err_init:
device_remove_file(&pdev->dev, &dev_attr_lot_id);
err_sysfs_file3:
device_remove_file(&pdev->dev, &dev_attr_tmu_state);
err_sysfs_file2:
device_remove_file(&pdev->dev, &dev_attr_temperature);
err_sysfs_file1:
if (info->irq >= 0)
free_irq(info->irq, info);
err_irq:
destroy_workqueue(tmu_monitor_wq);
err_wq:
iounmap(info->tmu_base);
err_nomap:
release_resource(info->ioarea);
kfree(info->ioarea);
err_nores:
kfree(info);
info = NULL;
err_nomem:
dev_err(&pdev->dev, "initialization failed.\n");
return ret;
}
static int __devinit s5p_tmu_remove(struct platform_device *pdev)
{
struct s5p_tmu_info *info = platform_get_drvdata(pdev);
cancel_delayed_work(&info->polling);
destroy_workqueue(tmu_monitor_wq);
device_remove_file(&pdev->dev, &dev_attr_temperature);
device_remove_file(&pdev->dev, &dev_attr_tmu_state);
if (info->irq >= 0)
free_irq(info->irq, info);
iounmap(info->tmu_base);
release_resource(info->ioarea);
kfree(info->ioarea);
kfree(info);
info = NULL;
pr_info("%s is removed\n", dev_name(&pdev->dev));
return 0;
}
#ifdef CONFIG_PM
static int s5p_tmu_suspend(struct platform_device *pdev, pm_message_t state)
{
struct s5p_tmu_info *info = platform_get_drvdata(pdev);
if (!info)
return -EAGAIN;
/* save register value */
info->reg_save[0] = __raw_readl(info->tmu_base + EXYNOS4_TMU_CONTROL);
info->reg_save[1] = __raw_readl(info->tmu_base + EXYNOS4_TMU_SAMPLING_INTERNAL);
info->reg_save[2] = __raw_readl(info->tmu_base + EXYNOS4_TMU_COUNTER_VALUE0);
info->reg_save[3] = __raw_readl(info->tmu_base + EXYNOS4_TMU_COUNTER_VALUE1);
info->reg_save[4] = __raw_readl(info->tmu_base + EXYNOS4_TMU_INTEN);
if (soc_is_exynos4210()) {
info->reg_save[5] =
__raw_readl(info->tmu_base + EXYNOS4210_TMU_THRESHOLD_TEMP);
info->reg_save[6] =
__raw_readl(info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL0);
info->reg_save[7] =
__raw_readl(info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL1);
info->reg_save[8] =
__raw_readl(info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL2);
info->reg_save[9] =
__raw_readl(info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL3);
} else {
info->reg_save[5] =
__raw_readl(info->tmu_base + EXYNOS4x12_TMU_TRESHOLD_TEMP_RISE);
#if defined(CONFIG_TC_VOLTAGE)
info->reg_save[6] = __raw_readl(info->tmu_base
+ EXYNOS4x12_TMU_TRESHOLD_TEMP_FALL);
#endif
}
disable_irq(info->irq);
return 0;
}
static int s5p_tmu_resume(struct platform_device *pdev)
{
struct s5p_tmu_info *info = platform_get_drvdata(pdev);
struct s5p_platform_tmu *data;
if (!info || !(info->dev))
return -EAGAIN;
data = info->dev->platform_data;
/* restore tmu register value */
__raw_writel(info->reg_save[0], info->tmu_base + EXYNOS4_TMU_CONTROL);
__raw_writel(info->reg_save[1],
info->tmu_base + EXYNOS4_TMU_SAMPLING_INTERNAL);
__raw_writel(info->reg_save[2],
info->tmu_base + EXYNOS4_TMU_COUNTER_VALUE0);
__raw_writel(info->reg_save[3],
info->tmu_base + EXYNOS4_TMU_COUNTER_VALUE1);
if (soc_is_exynos4210()) {
__raw_writel(info->reg_save[5],
info->tmu_base + EXYNOS4210_TMU_THRESHOLD_TEMP);
__raw_writel(info->reg_save[6],
info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL0);
__raw_writel(info->reg_save[7],
info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL1);
__raw_writel(info->reg_save[8],
info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL2);
__raw_writel(info->reg_save[9],
info->tmu_base + EXYNOS4210_TMU_TRIG_LEVEL3);
} else {
__raw_writel(info->reg_save[5],
info->tmu_base + EXYNOS4x12_TMU_TRESHOLD_TEMP_RISE);
#if defined(CONFIG_TC_VOLTAGE)
__raw_writel(info->reg_save[6],
info->tmu_base + EXYNOS4x12_TMU_TRESHOLD_TEMP_FALL);
#endif
}
__raw_writel(info->reg_save[4],
info->tmu_base + EXYNOS4_TMU_INTEN);
#if defined(CONFIG_TC_VOLTAGE)
/* s/w workaround for fast service when interrupt is not occured,
* such as current temp is lower than tc interrupt temperature
* or current temp is continuosly increased..
*/
mdelay(1);
if (get_curr_temp(info) <= data->ts.start_tc) {
if (exynos_tc_volt(info, 1) < 0)
pr_err("TMU: lock error!\n");
}
#endif
/* Find out tmu_state after wakeup */
queue_delayed_work_on(0, tmu_monitor_wq, &info->polling, 0);
return 0;
}
#else
#define s5p_tmu_suspend NULL
#define s5p_tmu_resume NULL
#endif
static struct platform_driver s5p_tmu_driver = {
.probe = s5p_tmu_probe,
.remove = s5p_tmu_remove,
.suspend = s5p_tmu_suspend,
.resume = s5p_tmu_resume,
.driver = {
.name = "s5p-tmu",
.owner = THIS_MODULE,
},
};
static int __init s5p_tmu_driver_init(void)
{
return platform_driver_register(&s5p_tmu_driver);
}
static void __exit s5p_tmu_driver_exit(void)
{
platform_driver_unregister(&s5p_tmu_driver);
}
static int exynos_tmu_init(struct tmu_info *info)
{
struct tmu_data *data = info->dev->platform_data;
unsigned int te_temp, con;
unsigned int temp_throttle, temp_warning, temp_trip;
unsigned int hw_temp_trip;
unsigned int rising_thr = 0, cooling_thr = 0;
/* must reload for using efuse value at EXYNOS4212 */
__raw_writel(TRIMINFO_RELOAD, info->tmu_base + TRIMINFO_CON);
/* get the compensation parameter */
te_temp = __raw_readl(info->tmu_base + TRIMINFO);
info->te1 = te_temp & TRIM_INFO_MASK;
info->te2 = ((te_temp >> 8) & TRIM_INFO_MASK);
if ((EFUSE_MIN_VALUE > info->te1) || (info->te1 > EFUSE_MAX_VALUE)
|| (info->te2 != 0))
info->te1 = data->efuse_value;
/*Get rising Threshold and Set interrupt level*/
temp_throttle = data->ts.start_throttle
+ info->te1 - TMU_DC_VALUE;
temp_warning = data->ts.start_warning
+ info->te1 - TMU_DC_VALUE;
temp_trip = data->ts.start_tripping
+ info->te1 - TMU_DC_VALUE;
hw_temp_trip = data->ts.start_hw_tripping
+ info->te1 - TMU_DC_VALUE;
rising_thr = (temp_throttle | (temp_warning<<8) | \
(temp_trip<<16) | (hw_temp_trip<<24));
__raw_writel(rising_thr, info->tmu_base + THD_TEMP_RISE);
#if defined(CONFIG_TC_VOLTAGE)
/* Get set temperature for tc_voltage and set falling interrupt
* trigger level
*/
cooling_thr = data->ts.start_tc
+ info->te1 - TMU_DC_VALUE;
#endif
__raw_writel(cooling_thr, info->tmu_base + THD_TEMP_FALL);
/* Set TMU status */
info->tmu_state = TMU_STATUS_INIT;
/* Set frequecny level */
exynos_cpufreq_get_level(data->cpulimit.throttle_freq,
&info->throttle_freq);
exynos_cpufreq_get_level(data->cpulimit.warning_freq,
&info->warning_freq);
/* Map auto_refresh_rate of normal & tq0 mode */
info->auto_refresh_tq0 =
get_refresh_interval(FREQ_IN_PLL, AUTO_REFRESH_PERIOD_TQ0);
info->auto_refresh_normal =
get_refresh_interval(FREQ_IN_PLL, AUTO_REFRESH_PERIOD_NORMAL);
/* To poll current temp, set sampling rate */
info->sampling_rate = usecs_to_jiffies(200 * 1000);
#if defined(CONFIG_TC_VOLTAGE) /* Temperature compensated voltage */
if (exynos_find_cpufreq_level_by_volt(data->temp_compensate.arm_volt,
&info->cpulevel_tc) < 0) {
pr_err("cpufreq_get_level error\n");
return -EINVAL;
}
#ifdef CONFIG_BUSFREQ_OPP
/* To lock bus frequency in OPP mode */
info->bus_dev = dev_get("exynos-busfreq");
if (info->bus_dev < 0) {
pr_err("Failed to get_dev\n");
return -EINVAL;
}
if (exynos4x12_find_busfreq_by_volt(data->temp_compensate.bus_volt,
&info->busfreq_tc)) {
pr_err("get_busfreq_value error\n");
}
#endif
if (mali_voltage_lock_init()) {
pr_err("Failed to initialize mail voltage lock.\n");
return -EINVAL;
}
pr_info("%s: cpufreq_level[%d], busfreq_value[%d]\n",
__func__, info->cpulevel_tc, info->busfreq_tc);
#endif
/* Need to initail regsiter setting after getting parameter info */
/* [28:23] vref [11:8] slope - Tunning parameter */
__raw_writel(data->slope, info->tmu_base + TMU_CON);
__raw_writel((CLEAR_RISE_INT | CLEAR_FALL_INT), \
info->tmu_base + INTCLEAR);
/* TMU core enable and HW trpping enable */
con = __raw_readl(info->tmu_base + TMU_CON);
con &= ~(HW_TRIP_MODE);
con |= (HW_TRIPPING_EN | MUX_ADDR_VALUE<<20 | CORE_EN);
__raw_writel(con, info->tmu_base + TMU_CON);
/* Because temperature sensing time is appro 940us,
* tmu is enabled and 1st valid sample can get 1ms after.
*/
mdelay(1);
te_temp = __raw_readl(S5P_PMU_PS_HOLD_CONTROL);
te_temp |= S5P_PS_HOLD_EN;
__raw_writel(te_temp, S5P_PMU_PS_HOLD_CONTROL);
/*LEV0 LEV1 LEV2 interrupt enable */
__raw_writel(INTEN_RISE0 | INTEN_RISE1 | INTEN_RISE2, \
info->tmu_base + INTEN);
#if defined(CONFIG_TC_VOLTAGE)
te_temp = __raw_readl(info->tmu_base + INTEN);
te_temp |= INTEN_FALL0;
__raw_writel(te_temp, info->tmu_base + INTEN);
/* s/w workaround for fast service when interrupt is not occured,
* such as current temp is lower than tc interrupt temperature
* or current temp is continuosly increased.
*/
if (get_cur_temp(info) <= data->ts.start_tc) {
disable_irq_nosync(info->irq);
if (exynos_tc_volt(info, 1) < 0)
pr_err("%s\n", __func__);
info->tmu_state = TMU_STATUS_TC;
already_limit = 1;
queue_delayed_work_on(0, tmu_monitor_wq,
&info->polling, usecs_to_jiffies(1000));
}
#endif
return 0;
}
static int __devinit s5p_tmu_probe(struct platform_device *pdev)
{
struct s5p_tmu_info *info;
struct s5p_platform_tmu *pdata;
struct resource *res;
int ret = 0;
pr_debug("%s: probe=%p\n", __func__, pdev);
info = kzalloc(sizeof(struct s5p_tmu_info), GFP_KERNEL);
if (!info) {
dev_err(&pdev->dev, "failed to alloc memory!\n");
ret = -ENOMEM;
goto err_nomem;
}
platform_set_drvdata(pdev, info);
info->dev = &pdev->dev;
info->tmu_state = TMU_STATUS_INIT;
/* set cpufreq limit level at 1st_throttle & 2nd throttle */
pdata = info->dev->platform_data;
if (pdata->cpufreq.limit_1st_throttle)
exynos_cpufreq_get_level(pdata->cpufreq.limit_1st_throttle,
&info->cpufreq_level_1st_throttle);
if (pdata->cpufreq.limit_2nd_throttle)
exynos_cpufreq_get_level(pdata->cpufreq.limit_2nd_throttle,
&info->cpufreq_level_2nd_throttle);
pr_info("@@@ %s: cpufreq_limit: 1st_throttle: %d, 2nd_throttle = %d\n",
__func__, info->cpufreq_level_1st_throttle,
info->cpufreq_level_2nd_throttle);
/* Map auto_refresh_rate of normal & tq0 mode */
info->auto_refresh_tq0 =
get_refresh_interval(FREQ_IN_PLL, AUTO_REFRESH_PERIOD_TQ0);
info->auto_refresh_normal =
get_refresh_interval(FREQ_IN_PLL, AUTO_REFRESH_PERIOD_NORMAL);
/* To poll current temp, set sampling rate to ONE second sampling */
info->sampling_rate = usecs_to_jiffies(1000 * 1000);
/* 10sec monitroing */
info->monitor_period = usecs_to_jiffies(10000 * 1000);
set_temperature_params(info);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "failed to get memory region resource\n");
ret = -ENODEV;
goto err_nores;
}
info->ioarea = request_mem_region(res->start,
res->end-res->start + 1, pdev->name);
if (!(info->ioarea)) {
dev_err(&pdev->dev, "failed to reserve memory region\n");
ret = -EBUSY;
goto err_nores;
}
info->tmu_base = ioremap(res->start, (res->end - res->start) + 1);
if (!(info->tmu_base)) {
dev_err(&pdev->dev, "failed ioremap()\n");
ret = -EINVAL;
goto err_nomap;
}
tmu_monitor_wq = create_freezable_workqueue(dev_name(&pdev->dev));
if (!tmu_monitor_wq) {
pr_info("Creation of tmu_monitor_wq failed\n");
return -EFAULT;
}
#ifdef CONFIG_TMU_DEBUG
INIT_DELAYED_WORK_DEFERRABLE(&info->monitor, exynos4_poll_cur_temp);
queue_delayed_work_on(0, tmu_monitor_wq, &info->monitor,
info->monitor_period);
#endif
INIT_DELAYED_WORK_DEFERRABLE(&info->polling, exynos4_handler_tmu_state);
info->irq = platform_get_irq(pdev, 0);
if (info->irq < 0) {
dev_err(&pdev->dev, "no irq for thermal %d\n", info->irq);
ret = -EINVAL;
goto err_irq;
}
if (soc_is_exynos4210())
ret = request_irq(info->irq, exynos4210_tmu_irq_handler,
IRQF_DISABLED, "s5p-tmu interrupt", info);
else
ret = request_irq(info->irq, exynos4x12_tmu_irq_handler,
IRQF_DISABLED, "s5p-tmu interrupt", info);
if (ret) {
dev_err(&pdev->dev, "request_irq is failed. %d\n", ret);
goto err_irq;
}
ret = tmu_initialize(pdev);
if (ret)
goto err_init;
#ifdef CONFIG_TMU_SYSFS
ret = device_create_file(&pdev->dev, &dev_attr_curr_temp);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to create sysfs group\n");
goto err_init;
}
#endif
#ifdef CONFIG_TMU_DEBUG
ret = device_create_file(&pdev->dev, &dev_attr_print_state);
if (ret) {
dev_err(&pdev->dev, "Failed to create tmu sysfs group\n\n");
return ret;
}
#endif
return ret;
err_init:
if (info->irq >= 0)
free_irq(info->irq, info);
err_irq:
iounmap(info->tmu_base);
err_nomap:
release_resource(info->ioarea);
kfree(info->ioarea);
err_nores:
kfree(info);
info = NULL;
err_nomem:
dev_err(&pdev->dev, "initialization failed.\n");
return ret;
}
