drivers/thermal/msm_popmem-tm.c - kernel/msm - Gitiles

 /* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  */

 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <linux/thermal.h>
 #include <linux/slab.h>
 #include <linux/io.h>
 #include <mach/msm_memtypes.h>

 #define POP_MEM_LPDDR1_REFRESH_MASK	0x00000700
 #define POP_MEM_LPDDR1_REFRESH_SHIFT	0x8

 #define POP_MEM_LPDDR2_REFRESH_MASK	0x00000007
 #define POP_MEM_LPDDR2_REFRESH_SHIFT	0x0

 #define POP_MEM_REFRESH_REG		0x3C

 #define POP_MEM_LOW_TEMPERATURE		25000
 #define POP_MEM_NORMAL_TEMPERATURE	50000
 #define POP_MEM_HIGH_TEMPERATURE	85000

 #define POP_MEM_TRIP_OUT_OF_SPEC	0
 #define POP_MEM_TRIP_NUM		1

 struct pop_mem_tm_device {
 	unsigned long			baseaddr;
 	struct thermal_zone_device	*tz_dev;
 	unsigned long			refresh_mask;
 	unsigned int			refresh_shift;
 };


 static int pop_mem_tm_read_refresh(struct pop_mem_tm_device *tm,
 				   unsigned int *ref_rate){
 	unsigned int ref;

 	ref = __raw_readl(tm->baseaddr + POP_MEM_REFRESH_REG);
 	*ref_rate = (ref & tm->refresh_mask) >> tm->refresh_shift;

 	return 0;
 }


 static int pop_mem_tm_get_temperature(struct thermal_zone_device *thermal,
 			       unsigned long *temperature)
 {
 	struct pop_mem_tm_device *tm = thermal->devdata;
 	unsigned int ref_rate;
 	int rc;

 	if (!tm || !temperature)
 		return -EINVAL;

 	rc = pop_mem_tm_read_refresh(tm, &ref_rate);
 	if (rc < 0)
 		return rc;

 	switch (ref_rate) {
 	case 0:
 	case 1:
 	case 2:
 		*temperature = POP_MEM_LOW_TEMPERATURE;
 		break;
 	case 3:
 	case 4:
 		*temperature = POP_MEM_NORMAL_TEMPERATURE;
 		break;
 	case 5:
 	case 6:
 	case 7:
 		*temperature = POP_MEM_HIGH_TEMPERATURE;
 		break;
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static int pop_mem_tm_get_trip_type(struct thermal_zone_device *thermal,
 				    int trip, enum thermal_trip_type *type)
 {
 	struct pop_mem_tm_device *tm = thermal->devdata;

 	if (!tm || trip < 0 || !type)
 		return -EINVAL;

 	if (trip == POP_MEM_TRIP_OUT_OF_SPEC)
 		*type = THERMAL_TRIP_CRITICAL;
 	else
 		return -EINVAL;

 	return 0;
 }

 static int pop_mem_tm_get_trip_temperature(struct thermal_zone_device *thermal,
 				    int trip, unsigned long *temperature)
 {
 	struct pop_mem_tm_device *tm = thermal->devdata;

 	if (!tm || trip < 0 || !temperature)
 		return -EINVAL;

 	if (trip == POP_MEM_TRIP_OUT_OF_SPEC)
 		*temperature = POP_MEM_HIGH_TEMPERATURE;
 	else
 		return -EINVAL;

 	return 0;
 }


 static int pop_mem_tm_get_crit_temperature(struct thermal_zone_device *thermal,
 				    unsigned long *temperature)
 {
 	struct pop_mem_tm_device *tm = thermal->devdata;

 	if (!tm || !temperature)
 		return -EINVAL;

 	*temperature = POP_MEM_HIGH_TEMPERATURE;

 	return 0;
 }


 static struct thermal_zone_device_ops pop_mem_thermal_zone_ops = {
 	.get_temp = pop_mem_tm_get_temperature,
 	.get_trip_type = pop_mem_tm_get_trip_type,
 	.get_trip_temp = pop_mem_tm_get_trip_temperature,
 	.get_crit_temp = pop_mem_tm_get_crit_temperature,
 };


 static int __devinit pop_mem_tm_probe(struct platform_device *pdev)
 {
 	int rc, len, numcontrollers;
 	struct resource *controller_mem = NULL;
 	struct resource *res_mem = NULL;
 	struct pop_mem_tm_device *tmdev = NULL;
 	void __iomem *base = NULL;

 	rc = len = 0;
 	numcontrollers = get_num_populated_chipselects();

 	if (pdev->id >= numcontrollers) {
 		pr_err("%s: memory controller %d does not exist", __func__,
 			pdev->id);
 		rc = -ENODEV;
 		goto fail;
 	}

 	controller_mem = platform_get_resource_byname(pdev,
 						  IORESOURCE_MEM, "physbase");
 	if (!controller_mem) {
 		pr_err("%s: could not get resources for controller %d",
 			__func__, pdev->id);
 		rc = -EFAULT;
 		goto fail;
 	}

 	len = controller_mem->end - controller_mem->start + 1;

 	res_mem = request_mem_region(controller_mem->start, len,
 				     controller_mem->name);
 	if (!res_mem) {
 		pr_err("%s: Could not request memory region: "
 			"start=%p, len=%d\n", __func__,
 			(void *) controller_mem->start, len);
 		rc = -EBUSY;
 		goto fail;

 	}

 	base = ioremap(res_mem->start, len);
 	if (!base) {
 		pr_err("%s: Could not ioremap: start=%p, len=%d\n",
 			 __func__, (void *) controller_mem->start, len);
 		rc = -EBUSY;
 		goto fail;

 	}

 	tmdev = kzalloc(sizeof(*tmdev), GFP_KERNEL);
 	if (tmdev == NULL) {
 		pr_err("%s: kzalloc() failed.\n", __func__);
 		rc = -ENOMEM;
 		goto fail;
 	}

 	if (numcontrollers == 1) {
 		tmdev->refresh_mask = POP_MEM_LPDDR1_REFRESH_MASK;
 		tmdev->refresh_shift = POP_MEM_LPDDR1_REFRESH_SHIFT;
 	} else {
 		tmdev->refresh_mask = POP_MEM_LPDDR2_REFRESH_MASK;
 		tmdev->refresh_shift = POP_MEM_LPDDR2_REFRESH_SHIFT;
 	}
 	tmdev->baseaddr = (unsigned long) base;
 	tmdev->tz_dev = thermal_zone_device_register("msm_popmem_tz",
 						     POP_MEM_TRIP_NUM, tmdev,
 						     &pop_mem_thermal_zone_ops,
 						     0, 0, 0, 0);

 	if (tmdev->tz_dev == NULL) {
 		pr_err("%s: thermal_zone_device_register() failed.\n",
 			__func__);
 		goto fail;
 	}

 	platform_set_drvdata(pdev, tmdev);

 	pr_notice("%s: device %d probed successfully\n", __func__, pdev->id);

 	return rc;

 fail:
 	if (base)
 		iounmap(base);
 	if (res_mem)
 		release_mem_region(controller_mem->start, len);
 	kfree(tmdev);

 	return rc;
 }

 static int __devexit pop_mem_tm_remove(struct platform_device *pdev)
 {

 	int len;
 	struct pop_mem_tm_device *tmdev = platform_get_drvdata(pdev);
 	struct resource *controller_mem;

 	iounmap((void __iomem *)tmdev->baseaddr);

 	controller_mem = platform_get_resource_byname(pdev,
 						  IORESOURCE_MEM, "physbase");
 	len = controller_mem->end - controller_mem->start + 1;
 	release_mem_region(controller_mem->start, len);

 	thermal_zone_device_unregister(tmdev->tz_dev);
 	platform_set_drvdata(pdev, NULL);
 	kfree(tmdev);

 	return 0;
 }

 static struct platform_driver pop_mem_tm_driver = {
 	.probe          = pop_mem_tm_probe,
 	.remove         = pop_mem_tm_remove,
 	.driver         = {
 		.name = "msm_popmem-tm",
 		.owner = THIS_MODULE
 	},
 };

 static int __init pop_mem_tm_init(void)
 {
 	return platform_driver_register(&pop_mem_tm_driver);
 }

 static void __exit pop_mem_tm_exit(void)
 {
 	platform_driver_unregister(&pop_mem_tm_driver);
 }

 module_init(pop_mem_tm_init);
 module_exit(pop_mem_tm_exit);

 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("Pop memory thermal manager driver");
 MODULE_VERSION("1.0");
 MODULE_ALIAS("platform:popmem-tm");
	/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	*/

	#include <linux/module.h>
	#include <linux/platform_device.h>
	#include <linux/err.h>
	#include <linux/thermal.h>
	#include <linux/slab.h>
	#include <linux/io.h>
	#include <mach/msm_memtypes.h>

	#define POP_MEM_LPDDR1_REFRESH_MASK 0x00000700
	#define POP_MEM_LPDDR1_REFRESH_SHIFT 0x8

	#define POP_MEM_LPDDR2_REFRESH_MASK 0x00000007
	#define POP_MEM_LPDDR2_REFRESH_SHIFT 0x0

	#define POP_MEM_REFRESH_REG 0x3C

	#define POP_MEM_LOW_TEMPERATURE 25000
	#define POP_MEM_NORMAL_TEMPERATURE 50000
	#define POP_MEM_HIGH_TEMPERATURE 85000

	#define POP_MEM_TRIP_OUT_OF_SPEC 0
	#define POP_MEM_TRIP_NUM 1

	struct pop_mem_tm_device {
	unsigned long baseaddr;
	struct thermal_zone_device *tz_dev;
	unsigned long refresh_mask;
	unsigned int refresh_shift;
	};


	static int pop_mem_tm_read_refresh(struct pop_mem_tm_device *tm,
	unsigned int *ref_rate){
	unsigned int ref;

	ref = __raw_readl(tm->baseaddr + POP_MEM_REFRESH_REG);
	*ref_rate = (ref & tm->refresh_mask) >> tm->refresh_shift;

	return 0;
	}


	static int pop_mem_tm_get_temperature(struct thermal_zone_device *thermal,
	unsigned long *temperature)
	{
	struct pop_mem_tm_device *tm = thermal->devdata;
	unsigned int ref_rate;
	int rc;

	if (!tm \|\| !temperature)
	return -EINVAL;

	rc = pop_mem_tm_read_refresh(tm, &ref_rate);
	if (rc < 0)
	return rc;

	switch (ref_rate) {
	case 0:
	case 1:
	case 2:
	*temperature = POP_MEM_LOW_TEMPERATURE;
	break;
	case 3:
	case 4:
	*temperature = POP_MEM_NORMAL_TEMPERATURE;
	break;
	case 5:
	case 6:
	case 7:
	*temperature = POP_MEM_HIGH_TEMPERATURE;
	break;
	default:
	return -EINVAL;
	}

	return 0;
	}

	static int pop_mem_tm_get_trip_type(struct thermal_zone_device *thermal,
	int trip, enum thermal_trip_type *type)
	{
	struct pop_mem_tm_device *tm = thermal->devdata;

	if (!tm \|\| trip < 0 \|\| !type)
	return -EINVAL;

	if (trip == POP_MEM_TRIP_OUT_OF_SPEC)
	*type = THERMAL_TRIP_CRITICAL;
	else
	return -EINVAL;

	return 0;
	}

	static int pop_mem_tm_get_trip_temperature(struct thermal_zone_device *thermal,
	int trip, unsigned long *temperature)
	{
	struct pop_mem_tm_device *tm = thermal->devdata;

	if (!tm \|\| trip < 0 \|\| !temperature)
	return -EINVAL;

	if (trip == POP_MEM_TRIP_OUT_OF_SPEC)
	*temperature = POP_MEM_HIGH_TEMPERATURE;
	else
	return -EINVAL;

	return 0;
	}


	static int pop_mem_tm_get_crit_temperature(struct thermal_zone_device *thermal,
	unsigned long *temperature)
	{
	struct pop_mem_tm_device *tm = thermal->devdata;

	if (!tm \|\| !temperature)
	return -EINVAL;

	*temperature = POP_MEM_HIGH_TEMPERATURE;

	return 0;
	}


	static struct thermal_zone_device_ops pop_mem_thermal_zone_ops = {
	.get_temp = pop_mem_tm_get_temperature,
	.get_trip_type = pop_mem_tm_get_trip_type,
	.get_trip_temp = pop_mem_tm_get_trip_temperature,
	.get_crit_temp = pop_mem_tm_get_crit_temperature,
	};


	static int __devinit pop_mem_tm_probe(struct platform_device *pdev)
	{
	int rc, len, numcontrollers;
	struct resource *controller_mem = NULL;
	struct resource *res_mem = NULL;
	struct pop_mem_tm_device *tmdev = NULL;
	void __iomem *base = NULL;

	rc = len = 0;
	numcontrollers = get_num_populated_chipselects();

	if (pdev->id >= numcontrollers) {
	pr_err("%s: memory controller %d does not exist", __func__,
	pdev->id);
	rc = -ENODEV;
	goto fail;
	}

	controller_mem = platform_get_resource_byname(pdev,
	IORESOURCE_MEM, "physbase");
	if (!controller_mem) {
	pr_err("%s: could not get resources for controller %d",
	__func__, pdev->id);
	rc = -EFAULT;
	goto fail;
	}

	len = controller_mem->end - controller_mem->start + 1;

	res_mem = request_mem_region(controller_mem->start, len,
	controller_mem->name);
	if (!res_mem) {
	pr_err("%s: Could not request memory region: "
	"start=%p, len=%d\n", __func__,
	(void *) controller_mem->start, len);
	rc = -EBUSY;
	goto fail;

	}

	base = ioremap(res_mem->start, len);
	if (!base) {
	pr_err("%s: Could not ioremap: start=%p, len=%d\n",
	__func__, (void *) controller_mem->start, len);
	rc = -EBUSY;
	goto fail;

	}

	tmdev = kzalloc(sizeof(*tmdev), GFP_KERNEL);
	if (tmdev == NULL) {
	pr_err("%s: kzalloc() failed.\n", __func__);
	rc = -ENOMEM;
	goto fail;
	}

	if (numcontrollers == 1) {
	tmdev->refresh_mask = POP_MEM_LPDDR1_REFRESH_MASK;
	tmdev->refresh_shift = POP_MEM_LPDDR1_REFRESH_SHIFT;
	} else {
	tmdev->refresh_mask = POP_MEM_LPDDR2_REFRESH_MASK;
	tmdev->refresh_shift = POP_MEM_LPDDR2_REFRESH_SHIFT;
	}
	tmdev->baseaddr = (unsigned long) base;
	tmdev->tz_dev = thermal_zone_device_register("msm_popmem_tz",
	POP_MEM_TRIP_NUM, tmdev,
	&pop_mem_thermal_zone_ops,
	0, 0, 0, 0);

	if (tmdev->tz_dev == NULL) {
	pr_err("%s: thermal_zone_device_register() failed.\n",
	__func__);
	goto fail;
	}

	platform_set_drvdata(pdev, tmdev);

	pr_notice("%s: device %d probed successfully\n", __func__, pdev->id);

	return rc;

	fail:
	if (base)
	iounmap(base);
	if (res_mem)
	release_mem_region(controller_mem->start, len);
	kfree(tmdev);

	return rc;
	}

	static int __devexit pop_mem_tm_remove(struct platform_device *pdev)
	{

	int len;
	struct pop_mem_tm_device *tmdev = platform_get_drvdata(pdev);
	struct resource *controller_mem;

	iounmap((void __iomem *)tmdev->baseaddr);

	controller_mem = platform_get_resource_byname(pdev,
	IORESOURCE_MEM, "physbase");
	len = controller_mem->end - controller_mem->start + 1;
	release_mem_region(controller_mem->start, len);

	thermal_zone_device_unregister(tmdev->tz_dev);
	platform_set_drvdata(pdev, NULL);
	kfree(tmdev);

	return 0;
	}

	static struct platform_driver pop_mem_tm_driver = {
	.probe = pop_mem_tm_probe,
	.remove = pop_mem_tm_remove,
	.driver = {
	.name = "msm_popmem-tm",
	.owner = THIS_MODULE
	},
	};

	static int __init pop_mem_tm_init(void)
	{
	return platform_driver_register(&pop_mem_tm_driver);
	}

	static void __exit pop_mem_tm_exit(void)
	{
	platform_driver_unregister(&pop_mem_tm_driver);
	}

	module_init(pop_mem_tm_init);
	module_exit(pop_mem_tm_exit);

	MODULE_LICENSE("GPL v2");
	MODULE_DESCRIPTION("Pop memory thermal manager driver");
	MODULE_VERSION("1.0");
	MODULE_ALIAS("platform:popmem-tm");