定时器函数

在终端函数中使用了休眠函数或者包含休眠函数的函数。中断函数中是不可以使用休眠函数的，一旦在中断中休眠，则cpu就无法被抢占，因为中断函数中的休眠是无法唤醒的，所以一旦休眠，就等于cpu死在了中断。

此外，也要注意，凡是中断函数调用到的函数或者是间接被中断函数调用到的函数都不能含有任何休眠函数。

// SPDX-License-Identifier: GPL-2.0-only
/*
 * tsys02d.c - Support for Measurement-Specialties tsys02d temperature sensor
 *
 * Copyright (c) 2015 Measurement-Specialties
 *
 * (7-bit I2C slave address 0x40)
 *
 * Datasheet:
 *  http://www.meas-spec.com/downloads/Digital_Sensor_TSYS02D.pdf
 */
#include <linux/sched.h>   //wake_up_process()
#include <linux/kthread.h> //kthread_create()、kthread_run()
#include <linux/init.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/stat.h>
#include <linux/module.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/input.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "../common/ms_sensors/ms_sensors_i2c.h"

#define TSYS02D_RESET 0xFE

static const int tsys02d_samp_freq[4] = {20, 40, 70, 140};
/* String copy of the above const for readability purpose */
static const char tsys02d_show_samp_freq[] = "20 40 70 140";

#define KEYINPUT_CNT 1			 /* 设备号个数 */
#define KEYINPUT_NAME "keyinput" /* 名字 */
#define KEY0VALUE 0X01			 /* KEY0 按键值 */
#define INVAKEY 0XFF			 /* 无效的按键值 */
#define KEY_NUM 1				 /* 按键数量 */
int g_run=0;

static struct kobject *helloworld_kobj;
static struct i2c_client *g_client;
static struct semaphore sem;//信号量

struct timer_list my_timer;

struct irq_keydesc
{
    int gpio;                            /* gpio */
    int irqnum;                          /* 中断号 */
    unsigned char value;                 /* 按键对应的键值 */
    char name[10];                       /* 名字 */
    irqreturn_t (*handler)(int, void *); /* 中断服务函数 */
};

/* keyinput 设备结构体 */
struct keyinput_dev
{
	dev_t devid;							/* 设备号 */
	struct cdev cdev;						/* cdev */
	struct class *class;					/* 类 */
	struct device *device;					/* 设备 */
	struct device_node *nd;					/* 设备节点 */
	struct timer_list timer;				/* 定义一个定时器 */
	struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按键描述数组 */
	unsigned char curkeynum;				/* 当前的按键号 */
	struct input_dev *inputdev;				/* input 结构体 */
};

struct keyinput_dev keyinputdev; /* key input 设备 */

ssize_t MyRead_ok(struct i2c_client *client, int *p_ret)
{
	printk("V 1. 02        ---in %s\n", __func__);
	int ret = 0;
	struct i2c_msg msg[2];
	struct i2c_msg write_msg[1];
	unsigned char args, data[2];
	unsigned char tep_args[3] = {1, 0x85, 0x83};

	//先write
	write_msg[0].addr = 0x48;
	write_msg[0].flags = 0;
	write_msg[0].len = 3;
	write_msg[0].buf = tep_args;
	//printk("%s start i2c_transfer");
	ret = i2c_transfer(client->adapter, write_msg, 1);
	//printk("%s , ret =%d \n" , __func__ , ret);
	if (ret != 1)
	{
	}
	else
	{
	}

printk("msleep(1); %s\n" , __func__);
	msleep(1);

	args = 0;
	/* 先传读地址 */
	msg[0].addr = 0x48;
	msg[0].buf = &args;

	msg[0].len = 1;
	msg[0].flags = 0;
	/* 再 读 */
	msg[1].addr = 0x48;
	msg[1].buf = data;
	msg[1].len = 2;
	msg[1].flags = 1; /* 读 */
					  //	printk("start   i2c_transfer\n");
	if (2 == i2c_transfer(client->adapter, msg, 2))
	{
		printk("read--->%d , %d\n", data[0], data[1]);
		/* 读成功 */
		//printk("success\n");
		unsigned short *p = (unsigned short *)data;
		printk("%d\n", *p);

		unsigned short d = *p;
		unsigned short d1 = *p;
		int m_ret = (((d >> 8) & 0x0ff) + ((d1 << 8) & 0xff00)) >> 4;
		//开始转化
		printk("final result------------------------>= %d\n", m_ret);
		*p_ret = m_ret;

		//return  0;
	}
	else
	{
		printk("i2c_transfer !=2\n");
		//return  -EIO;
	}
	return *p_ret;
}

static struct task_struct *test_task;


static void timer_function(struct timer_list *t)
{
    printk("in %s  start up \n" , __func__);
    up(&sem);
    printk("in %s   up  ok \n" , __func__);
	g_run=1;
	printk("----------------- in%s , ", __func__);
#if 1
	unsigned char value;
	unsigned char num;
	int m_ret=0;
	struct irq_keydesc *keydesc;
	//struct keyinput_dev *dev = (struct keyinput_dev *)arg;

	//num = dev->curkeynum;

	//开始读取数据
	//MyRead_ok(g_client, &m_ret);
	//printk("%s-----------------------------------------%d\n",__func__ , m_ret);

	input_report_key(dev->inputdev, keydesc->value, m_ret);
	
	//input_sync(dev->inputdev);
#endif
	printk("----------------out %s\n", __func__);
	my_timer.expires = jiffies + 3*HZ;
	add_timer(&my_timer);
}

static int tsys02d_read_raw(struct iio_dev *indio_dev,
							struct iio_chan_spec const *channel, int *val,
							int *val2, long mask)
{
	printk("in %s\n", __func__);
	return 0;
}

static int tsys02d_write_raw(struct iio_dev *indio_dev,
							 struct iio_chan_spec const *chan,
							 int val, int val2, long mask)
{
	printk("in %s\n", __func__);
	return 0;
}

static int hello_value = 0;
static ssize_t hello_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
{
	int ret=0;
	printk("int %s\n" , __func__);
	MyRead_ok(g_client ,&ret);
	printk("out %s\n" , __func__);
	return sprintf(buf, "%d\n", ret);
}

static ssize_t hello_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
{
	printk("lw----hello_store  ---> %s\n", buf);
	sscanf(buf, "%du", &hello_value);
	printk("hello_value = %d\n", hello_value);
	return count;
}

static struct kobj_attribute hello_value_attribute =
	{
		.attr = {
			.name = "demo",
			.mode = 0666},
		.show = hello_show,
		.store = hello_store,
};

static const struct iio_chan_spec tsys02d_channels[] = {
	{
		.type = IIO_TEMP,
		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_PROCESSED),
		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
	}};

static ssize_t tsys02_read_battery_low(struct device *dev,
									   struct device_attribute *attr,
									   char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct ms_ht_dev *dev_data = iio_priv(indio_dev);

	return ms_sensors_show_battery_low(dev_data, buf);
}

static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(tsys02d_show_samp_freq);
static IIO_DEVICE_ATTR(battery_low, S_IRUGO,
					   tsys02_read_battery_low, NULL, 0);

static struct attribute *tsys02d_attributes[] = {
	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
	&iio_dev_attr_battery_low.dev_attr.attr,
	NULL,
};

static const struct attribute_group tsys02d_attribute_group = {
	.attrs = tsys02d_attributes,
};

static const struct iio_info tsys02d_info = {
	.read_raw = tsys02d_read_raw,
	.write_raw = tsys02d_write_raw,
	.attrs = &tsys02d_attribute_group,
};


int test_threadfunc(void *data)
{
	int m=0;
        while(1){
            if(kthread_should_stop()) break;

            printk("in %s  start down(&sem)\n" , __func__);
            down(&sem);
            printk("in %s  down (&sem)  ok \n" , __func__);
            MyRead_ok(g_client , &m);

            //printk("in %s  start down(&sem)\n" , __func__);
            //down(&sem);
            //printk("in %s  down (&sem)  ok \n" , __func__);
        }
        return 0;
}

static int tsys02d_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int retval = 0;
	printk("in %s\n", __func__);
	struct ms_ht_dev *dev_data;
	struct iio_dev *indio_dev;
	int ret;
	u64 serial_number;

    sema_init(&sem , 1);

	if (!i2c_check_functionality(client->adapter,
								 I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
									 I2C_FUNC_SMBUS_WRITE_BYTE |
									 I2C_FUNC_SMBUS_READ_I2C_BLOCK))
	{
		dev_err(&client->dev,
				"Adapter does not support some i2c transaction\n");
		return -EOPNOTSUPP;
	}

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev_data));
	if (!indio_dev)
		return -ENOMEM;

	dev_data = iio_priv(indio_dev);
	dev_data->client = client;
	dev_data->res_index = 0;
	mutex_init(&dev_data->lock);

	indio_dev->info = &tsys02d_info;
	indio_dev->name = id->name;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->channels = tsys02d_channels;
	indio_dev->num_channels = ARRAY_SIZE(tsys02d_channels);

	i2c_set_clientdata(client, indio_dev);

	dev_info(&client->dev, "Serial number : %llx", serial_number);
	g_client = client;

	helloworld_kobj = kobject_create_and_add("helloworld", kernel_kobj);
	if (!helloworld_kobj)
	{
		printk("%s kobject_create_and_add fial\n", __func__);
		return -ENOMEM;
	}
	retval = sysfs_create_file(helloworld_kobj, &(hello_value_attribute.attr));
	if (retval)
	{
		printk("%s sysfs_create_file ok\n", __func__);
		kobject_put(helloworld_kobj);
	}




	//创建一个线程
	printk("%s start kthread_create\n" , __func__);
	test_task = kthread_create(test_threadfunc, NULL, "test_task");
	if (IS_ERR(test_task))
	{
		printk("Unable to start kernel thread. ");
		test_task = NULL;
		return -1;
	}
	else{
			printk("%s kthread_create  ok\n" , __func__);
	}
	wake_up_process(test_task);

	


	printk("%s , start init_timer\n", __func__);
	my_timer.expires = jiffies + 3*HZ; //设定超时时间，5秒
	//printk("---%s the jiffies is :%ld\n", __func__ , jiffies);      //显示当前的节拍数
	timer_setup(&my_timer,timer_function , 0);//初始化定时器
	printk("---end   timer_setup%s\n" , __func__);


	
	//传递给定时器超时函数的值
	//timer.function = timer_function;//设置定时器超时函数
	//keyinputdev.timer.function = timer_function;
	printk("%s , start add_timer\n", __func__);

	add_timer(&my_timer); //添加定时器，定时器开始生效
	/* 申请 input_dev */
	printk("%s , start input_allocate_device\n", __func__);
	
	//keyinputdev.inputdev = input_allocate_device();
	//keyinputdev.inputdev->name = KEYINPUT_NAME;

	/* 初始化 input_dev，设置产生哪些事件 */
	//__set_bit(EV_KEY, keyinputdev.inputdev->evbit); /*按键事件 */
	//__set_bit(EV_REP, keyinputdev.inputdev->evbit); /* 重复事件 */

	/* 初始化 input_dev，设置产生哪些按键 */
	//__set_bit(KEY_0, keyinputdev.inputdev->keybit);

	/* 注册输入设备 */
	//ret = input_register_device(keyinputdev.inputdev);
	//if (ret)
	//{
	//	printk("register input device failed!\r\n");
	//	return ret;
	//}
	//else
	//{
	//	printk("%s ,  input_register_device ok \n", __func__);
	//}

	printk("%s start devm_iio_device__register\n", __func__);
	return devm_iio_device_register(&client->dev, indio_dev);
}



static int tsys02d_probe_old(struct i2c_client *client, const struct i2c_device_id *id)
{
	int retval = 0;
	printk("in %s\n", __func__);
	struct ms_ht_dev *dev_data;
	struct iio_dev *indio_dev;
	int ret;
	u64 serial_number;

	if (!i2c_check_functionality(client->adapter,
								 I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
									 I2C_FUNC_SMBUS_WRITE_BYTE |
									 I2C_FUNC_SMBUS_READ_I2C_BLOCK))
	{
		dev_err(&client->dev,
				"Adapter does not support some i2c transaction\n");
		return -EOPNOTSUPP;
	}

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev_data));
	if (!indio_dev)
		return -ENOMEM;

	dev_data = iio_priv(indio_dev);
	dev_data->client = client;
	dev_data->res_index = 0;
	mutex_init(&dev_data->lock);

	indio_dev->info = &tsys02d_info;
	indio_dev->name = id->name;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->channels = tsys02d_channels;
	indio_dev->num_channels = ARRAY_SIZE(tsys02d_channels);

	i2c_set_clientdata(client, indio_dev);

	dev_info(&client->dev, "Serial number : %llx", serial_number);
	g_client = client;

	helloworld_kobj = kobject_create_and_add("helloworld", kernel_kobj);
	if (!helloworld_kobj)
	{
		printk("%s kobject_create_and_add fial\n", __func__);
		return -ENOMEM;
	}
	retval = sysfs_create_file(helloworld_kobj, &(hello_value_attribute.attr));
	if (retval)
	{
		printk("%s sysfs_create_file ok\n", __func__);
		kobject_put(helloworld_kobj);
	}



	keyinputdev.inputdev = input_allocate_device();
    keyinputdev.inputdev->name = KEYINPUT_NAME;





	printk("%s , start init_timer\n", __func__);
	keyinputdev.timer.expires = jiffies + 300; //设定超时时间，5秒
	printk("---%s the jiffies is :%ld\n", __func__ , jiffies);      //显示当前的节拍数
	timer_setup(&keyinputdev.timer,(void*)timer_function , &keyinputdev.timer);//初始化定时器
	printk("---end   timer_setup%s\n" , __func__);


	
	//传递给定时器超时函数的值
	//timer.function = timer_function;//设置定时器超时函数
	//keyinputdev.timer.function = timer_function;
	printk("%s , start add_timer\n", __func__);
	add_timer(&keyinputdev.timer); //添加定时器，定时器开始生效
	/* 申请 input_dev */
	printk("%s , start input_allocate_device\n", __func__);
	keyinputdev.inputdev = input_allocate_device();
	keyinputdev.inputdev->name = KEYINPUT_NAME;

	/* 初始化 input_dev，设置产生哪些事件 */
	__set_bit(EV_KEY, keyinputdev.inputdev->evbit); /*按键事件 */
	__set_bit(EV_REP, keyinputdev.inputdev->evbit); /* 重复事件 */

	/* 初始化 input_dev，设置产生哪些按键 */
	__set_bit(KEY_0, keyinputdev.inputdev->keybit);

	/* 注册输入设备 */
	ret = input_register_device(keyinputdev.inputdev);
	if (ret)
	{
		printk("register input device failed!\r\n");
		return ret;
	}
	else
	{
		printk("%s ,  input_register_device ok \n", __func__);
	}

	printk("%s start devm_iio_device__register\n", __func__);
	return devm_iio_device_register(&client->dev, indio_dev);
}

static const struct i2c_device_id tsys02d_id[] = {
	{"tsys02d", 0},
	{}};
MODULE_DEVICE_TABLE(i2c, tsys02d_id);

static struct i2c_driver tsys02d_driver = {
	.probe = tsys02d_probe,
	.id_table = tsys02d_id,
	.driver = {
		.name = "tsys02d",
	},
};

module_i2c_driver(tsys02d_driver);

MODULE_DESCRIPTION("Measurement-Specialties tsys02d temperature driver");
MODULE_AUTHOR("William Markezana <william.markezana@meas-spec.com>");
MODULE_AUTHOR("Ludovic Tancerel <ludovic.tancerel@maplehightech.com>");
MODULE_LICENSE("GPL v2");