Freescale mma845x三轴加速度传感器驱动分析
最近刚看完freescale mma8451的驱动，并且一直了驱动，自己也没怎么改代码，不过读了一下代码，还是有点体会的，下面我就来分析一下。
首先看下代码结构，有兴趣的可以从一下方式获得代码，[email protected]:zhangjie201412/WorkSpace.git ，最好是先发mail给我，
jay@jay:~/mygit$ tree
.
└── kernel
├── arch
│ └── arm
│ └── mach-mx5
│ └── mx53_smd.c
├── drivers
│ └── hwmon
│ └── mma845x
│ ├── Makefile
│ ├── mma845x.c
│ ├── mma845x.h
│ ├── mma_char.c
│ ├── mma_core.c
│ ├── mma_input.c
│ ├── mma_regs.h
│ ├── mma_sysfs.c
│ └── mma_sysfs.h
└── include
└── linux
└── mma845x.h
其中一个头文件，然后是一个驱动包，里面内容蛮丰富的，还有就是要在板级文件里面注册platform的device端，我这里是基于iMX53的Android BSP
首先咱还是来找源头吧，找啊找，看名字就知道我们先要分析这个mma_core.c文件
static int __init init_mma845x(void)
{
/*
* register driver
*/
printk(KERN_INFO "add mma i2c driver\n");
return i2c_add_driver(&i2c_mma845x_driver);
}
/*!
* This function implements "exit" routine for driver
*/
static void __exit exit_mma845x(void)
{
printk(KERN_INFO "del mma i2c driver.\n");
#ifdef CONFIG_EARLYSUSPEND
// Register early_suspend and late_wakeup handlers
unregister_early_suspend(&mma845x_early_suspend_desc);
#endif
return i2c_del_driver(&i2c_mma845x_driver);
}
module_init(init_mma845x);
module_exit(exit_mma845x);
这个初始化和卸载模块就不多说了，注册了i2c类型的驱动，接着去platform文件中找注册的device端，mx53_smd.c
//+++add head file for g-sensor
#include <linux/mma845x.h>
//++++add for mma driver
static struct mxc_mma845x_platform_data mma845x_data = {
.gpio_pin_get = NULL,
.gpio_pin_put = NULL,
.int1 = gpio_to_irq(MX53_SMD_ACCL_INT1_IN), // ACCL_INT1 is gpio for MMA845X INT1
.int2 = gpio_to_irq(MX53_SMD_ACCL_INT2_IN), // ACCL_INT2 is gpio for MMA845X INT2
};
//-----add by Jay end
static struct i2c_board_info mxc_i2c0_board_info[] __initdata = {
{
.type = "mma845x",
.addr = 0x1C,
// .irq = gpio_to_irq(MX53_SMD_ACCL_INT1_IN), //+++++add by Jay for g-sensor interrupt mode
.platform_data = (void *)&mma845x_data, //+++add by Jay
},
{
.type = "ov5642",
.addr = 0x3C,
.platform_data = (void *)&camera_data,
},
{
.type = "mma7660",
.addr = 0x4C,
},
};
这里，填充了mma845x驱动的一些platform_data
然后是注册，
i2c_register_board_info(0, mxc_i2c0_board_info, ARRAY_SIZE(mxc_i2c0_board_info));
这个函数会把i2c0上的所有驱动都挂到platform driver的device上去，进行匹配，这里我要提示的一点是，这里的2根GPIO 中断引脚，我们要设置为input
//+++++add by Jay for g-sensor interrupt mode to get data gpio_request(MX53_SMD_ACCL_INT1_IN, "gsensor-irq"); msleep(5); gpio_direction_input(MX53_SMD_ACCL_INT1_IN); //-----end add
接下来分析mma_core.c中的probe函数，这里是最终要的一个函数了
/*!
* This function implements probe routine for driver
* client : pointer to i2c client
* id : i2c device id
* return 0 : Success
* return -ENOMEM : Memory allocation for pDev failed
* return -ENODEV : Platform data not found
*/
static int mma845x_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret = 0,
i = 0;
struct ChipInfo_t *pChip = NULL;
struct mxc_mma_device_t *pDev = NULL;
int mask = 0;
plat_data =
(struct mxc_mma845x_platform_data *) client->dev.platform_data;
if (plat_data == NULL) {
dev_err(&client->dev, "lack of platform data!\n");
return -ENODEV;
}
pDev = kzalloc(sizeof(struct mxc_mma_device_t), GFP_KERNEL);
if (!pDev) {
pDev = NULL;
return -ENOMEM;
}
printk(KERN_INFO "\r\nProbing Module: %s %s\r\n", MODULE_NAME, DRIVER_VERSION);
printk(KERN_INFO "Freescale Android 2.3 Release: %s\r\n", ANDROID_RELEASE);
printk(KERN_INFO "Build Date: %s [%s]\r\n", __DATE__, __TIME__);
i2c_set_clientdata(client, pDev);
/*
* bind the right device to the driver
*/
ret = IdentifyChipset(client);
if (ret < 0) {
printk(KERN_INFO "%s:: Unable to identify device.\r\n", __func__);
return -EIO;
}
/*
* Associate chip layer
*/
for (i = 0; i < sizeof(ChipTable) / sizeof(ChipTable[0]); i++) {
if (ChipTable[i]->ChipId == ret) {
pChip = ChipTable[i];
pChip->ChipId = ret;
pChip->client = client;
pChip->ChipType = ChipType;
break;
}
}
if (i >= (sizeof(ChipTable) / sizeof(ChipTable[0]))) {
printk(KERN_INFO "Chipset not supported by MMA driver\r\n");
return -ENOMEM;
}
gpChip = pChip;
gpDev = pDev;
SetDefaultVal(pChip);
/*
* Inialize default event codes
*/
pDev->fm_event_type = 0x25;
pDev->ornt_event_type = 0x26;
pDev->trans_event_type = 0x27;
pDev->event_type_single = 0x28;
pDev->event_type_double = 0x29;
pDev->aflag = 1;
/*
* Initialize chipset
*/
pChip->Init(pChip);
pDev->pChip = pChip;
pDev->version = 1;
/*
* configure gpio as input for interrupt monitor
*/
if(plat_data->gpio_pin_get)
plat_data->gpio_pin_get();
/*
* Register character device
*/
pDev->major = register_chrdev(0, "mma", &mma_fops);
if (ret < 0) {
printk(KERN_INFO "%s:: Unable to register device\r\n", __func__);
goto error_disable_power;
}
strcpy(pDev->devname, "mma");
printk(KERN_INFO "%s:: Registered char dev \"%s\" @ %d\r\n", __func__,
pDev->devname, pDev->major);
/*
* Initialize input layer
*/
InitializeInputInterface(pDev);
/*
* Create sysfs entries
*/
InitializeSysfs( (struct i2c_client *)client);
/*
* Initialize semaphore for interrupt
*/
sema_init(&chip_ready, 0);
setup_timer(&stall_timer, stall_timer_fn, 0);
hIstThread = kthread_run(IntServiceThread, pDev, "mxc845x_ist");
if (IS_ERR(hIstThread)) {
printk(KERN_INFO "Error creating mxc845x ist.\n");
goto error_free_irq1;
}
if (plat_data->int1 > 0) {
set_irq_type(plat_data->int1, IRQF_TRIGGER_FALLING);
ret = request_irq(plat_data->int1, mma845x_interrupt,
IRQF_TRIGGER_FALLING, DEVICE_NAME, pDev);
if (ret) {
dev_err(&client->dev, "request_irq(%d) returned error %d\n",
plat_data->int1, ret);
goto error_disable_power;
}
}
else {
gpChip->DisableInt(INT_EN_FIFO | INT_EN_DRDY);
poll_mode = 1;
}
if (plat_data->int2 > 0){
printk(KERN_INFO "%s:: Configuring interrupt IRQ [%d]\r\n", __func__,
plat_data->int2);
set_irq_type(plat_data->int2, IRQF_TRIGGER_FALLING);
ret = request_irq(plat_data->int2, mma845x_interrupt,
IRQF_TRIGGER_FALLING, DEVICE_NAME, pDev);
if (ret) {
dev_err(&client->dev, "request_irq(%d) returned error %d\n",
plat_data->int2, ret);
goto error_free_irq1;
}
}
#ifdef CONFIG_EARLYSUSPEND
register_early_suspend(&mma845x_early_suspend_desc);
#endif
注释也写的蛮清楚的但是咱还是一起来看一下
plat_data =
(struct mxc_mma845x_platform_data *) client->dev.platform_data;
if (plat_data == NULL) {
dev_err(&client->dev, "lack of platform data!\n");
return -ENODEV;
}
这里是由probe函数传进来的client参数来得到platform_data，就是我们在板级文件中填充的那些个结构体，我觉得Linux设计的这个platform架构的驱动很好，他可以很好的把驱动和设备隔离开来，虽然有的时候还是会联系到一起，但是对于可移植性更强了，因为，驱动只是对设备的统一管理，而platform device端只需要配置cpu的gpio跟deivce的连接情况，还有一些soc中继承的功能的配置以及注册。
pDev = kzalloc(sizeof(struct mxc_mma_device_t), GFP_KERNEL);
if (!pDev) {
pDev = NULL;
return -ENOMEM;
}
printk(KERN_INFO "\r\nProbing Module: %s %s\r\n", MODULE_NAME, DRIVER_VERSION);
printk(KERN_INFO "Freescale Android 2.3 Release: %s\r\n", ANDROID_RELEASE);
printk(KERN_INFO "Build Date: %s [%s]\r\n", __DATE__, __TIME__);
接着这里是给我们驱动中定义的mxc_mma_device_t结构体分配内存，然后是一些kernel info的打印没什么好说了。
还是先来看一下这个结构体吧，
/*sensor platform data structure for mma8451/mma8452/mma8453*/
struct mxc_mma845x_platform_data {
void (*gpio_pin_get) (void);
void (*gpio_pin_put) (void);
int int1;
int int2;
};
这个结构体比较简单，定义了2个中断号，还有中断GPIO的get和put，我们这边对这2个函数没有实现，我猜想get函数是对中断GPIO的配置，put是对中断GPIO的free，拙见而已，
i2c_set_clientdata(client, pDev);
/*
* bind the right device to the driver
*/
ret = IdentifyChipset(client);
if (ret < 0) {
printk(KERN_INFO "%s:: Unable to identify device.\r\n", __func__);
return -EIO;
}
/*
* Associate chip layer
*/
for (i = 0; i < sizeof(ChipTable) / sizeof(ChipTable[0]); i++) {
if (ChipTable[i]->ChipId == ret) {
pChip = ChipTable[i];
pChip->ChipId = ret;
pChip->client = client;
pChip->ChipType = ChipType;
break;
}
}
if (i >= (sizeof(ChipTable) / sizeof(ChipTable[0]))) {
printk(KERN_INFO "Chipset not supported by MMA driver\r\n");
return -ENOMEM;
}
gpChip = pChip;
gpDev = pDev;
SetDefaultVal(pChip);
/*
* Inialize default event codes
*/
pDev->fm_event_type = 0x25;
pDev->ornt_event_type = 0x26;
pDev->trans_event_type = 0x27;
pDev->event_type_single = 0x28;
pDev->event_type_double = 0x29;
pDev->aflag = 1;
/*
* Initialize chipset
*/
pChip->Init(pChip);
pDev->pChip = pChip;
pDev->version = 1;
/*
* configure gpio as input for interrupt monitor
*/
if(plat_data->gpio_pin_get)
plat_data->gpio_pin_get();
/*
* Register character device
*/
这里首先是对mma_845x器件身份的识别，来看下IdentifyChipset函数
/*!
* This function Identify the chip connected on bus and associate client driver for the chipset
* client : i2c_client pointer for i2c bus attached to device
* return chip_id : Chip id of identified device
* return -1 : Device not identified
*/
static int IdentifyChipset(struct i2c_client *client)
{
int retVal = 0;
int ChipIdentified = 0;
retVal = i2c_smbus_read_byte_data(client, REG(WHO_AM_I));
switch (retVal) {
case ID_MMA8451:
{
printk("%s:: Found MMA8451 chipset with chip ID 0x%02x\r\n",
__func__, retVal);
ChipIdentified = 1;
}
break;
case ID_MMA8452:
{
printk("%s:: Found MMA8452 chipset with chip ID 0x%02x\r\n",
__func__, retVal);
ChipIdentified = 1;
}
break;
case ID_MMA8453:
{
printk("%s:: Found MMA8453 chipset with chip ID 0x%02x\r\n",
__func__, retVal);
ChipIdentified = 1;
}
break;
default:
{
printk("%s:: Not a valid MMA845X chipset. Chip ID 0x%02x\r\n",
__func__, retVal);
ChipIdentified = 0;
}
break;
读i2c bus上面mma传感器的WHO_AM_I 寄存器，来判断连上的是哪个device
/*
* Associate chip layer
*/
for (i = 0; i < sizeof(ChipTable) / sizeof(ChipTable[0]); i++) {
if (ChipTable[i]->ChipId == ret) {
pChip = ChipTable[i];
pChip->ChipId = ret;
pChip->client = client;
pChip->ChipType = ChipType;
break;
}
}
if (i >= (sizeof(ChipTable) / sizeof(ChipTable[0]))) {
printk(KERN_INFO "Chipset not supported by MMA driver\r\n");
return -ENOMEM;
}
gpChip = pChip;
gpDev = pDev;
SetDefaultVal(pChip);
这里首先是对芯片层的一些赋值，找到这里我们注册的是哪款芯片，然后把i2c client，chip id， chiptype等信息赋值给这里的局部变量，然后再把局部变量赋值给全局的几个指针，然后再试对芯片寄存器设置一些默认值。
/*
* Inialize default event codes
*/
pDev->fm_event_type = 0x25;
pDev->ornt_event_type = 0x26;
pDev->trans_event_type = 0x27;
pDev->event_type_single = 0x28;
pDev->event_type_double = 0x29;
pDev->aflag = 1;
/*
* Initialize chipset
*/
pChip->Init(pChip);
pDev->pChip = pChip;
pDev->version = 1;
然后是初始化芯片的事件类型，这里这块芯片分很多事件类型，有撞击事件，横竖切换事件等，接下来如果pChip结构体中Init成员函数非空的话就执行这个函数。
/*
* Register character device
*/
pDev->major = register_chrdev(0, "mma", &mma_fops);
if (ret < 0) {
printk(KERN_INFO "%s:: Unable to register device\r\n", __func__);
goto error_disable_power;
}
strcpy(pDev->devname, "mma");
printk(KERN_INFO "%s:: Registered char dev \"%s\" @ %d\r\n", __func__,
pDev->devname, pDev->major);
接下来注册了一个字符类型的驱动，咱来看看这个驱动是干啥用的，最主要的还是看mma_fops这个文件操作结构体中实现了哪些个东西，mma_char.c
/*
* This structure is the file operations structure, which specifies what
* callbacks functions the kernel should call when a user mode process
* attempts to perform these operations on the device.
*/
const struct file_operations mma_fops = {
.owner = THIS_MODULE,
.open = mma_open,
.ioctl = mma_ioctl,
.release = mma_release,
.read = mma_read,
};
这里有打开关闭，读，还有ioctl功能，
/*!
* Open call for accelerometer char driver.
* inode : Pointer to the node to be opened.
* file : Pointer to file structure.
* return 0 : After successful opening.
*/
static int mma_open(struct inode * inode, struct file * file)
{
pContext_t p = file->private_data;
if (!p) {
p = kmalloc(sizeof(*p), GFP_KERNEL);
if (!p)
return -ENOMEM;
p->threshold = 5;
p->read_pos = 0;
sema_init(&p->sem, 1);
file->private_data = p;
}
return 0;
}
首先是open函数，这里还要先看下pContext_t这个结构体
typedef struct
{
struct semaphore sem;
int threshold;
int read_pos;
}Context_t, *pContext_t;
里面有3个成员变量，乍看之下还不清楚是用来干嘛的，先不管，接着往下看就明白了，回到open函数中，首先把文件结构体中的数据给这个结构体，然后判断，这里的意思应该是如果open函数被打开了一次那么就会执行if中的代码，如果已经被打开了，那么就直接返回零，if语句中也就是多结构体的初始化，还有初始化了一个信号量，然后把p指针传给file->private，代表已经被打开了，非空。
/*!
* Release call for accelerometer char driver.
* inode : Pointer to the node to be opened.
* file : Pointer to file structure.
* return 0 : After successful release of resources.
*/
static int mma_release(struct inode *inode, struct file *file)
{
pContext_t p = file->private_data;
if (p)
{
mutex_destroy(&p->lock);
kfree(p);
p = NULL;
}
return 0;
}
release中的代码就不多说了，跟open函数正好相反。
然后是比较重要的ioctl和read function
/*!
* read call for accelerometer char driver.
* inode : Pointer to the node to be opened.
* file : Pointer to file structure.
* command : contains command for register.
* arg : contains data required to apply settings specified in cmd.
* return 0 : For successful
*/
static int mma_ioctl(struct inode *inode, struct file *filp,
unsigned int command, unsigned long arg)
{
pContext_t dev = filp->private_data;
u32 threshold = 0;
switch(command)
{
case MMA_GET_THRESHOLD:
{
if (copy_to_user(&arg, &(dev->threshold), sizeof(u32)))
{
printk("ioctl, copy to user failed\n");
return -EFAULT;
}
}
break;
case MMA_GET_THRESHOLD_VALUE:
{
return dev->threshold;
}
break;
case MMA_SET_THRESHOLD:
{
if (copy_from_user(&threshold, &arg, sizeof(u32)))
{
return -EFAULT;
}
if(threshold <= 0)
{
return -EINVAL;
}
dev->threshold = threshold;
}
break;
case MMA_SET_THRESHOLD_VALUE:
{
threshold = arg;
if(threshold <= 0)
{
printk("Invalid value [0x%x]\r\n", threshold);
return -EINVAL;
}
dev->threshold = threshold;
}
break;
case MMA_GET_ACCLEROMETER_FLAG:
{
return GetAcclerometerFlag();
}
break;
case MMA_SET_ACCLEROMETER_FLAG:
{
int AcclFlag = arg;
return SetAcclerometerFlag(AcclFlag);
}
break;
default:
{
printk("%s:: Invalid IOCTL [0x%x]\r\n", __func__, command);
}
}
return 0;
}
这个ioctl函数很简单，通过switch case语句，把用户传进去的参数分类，然后做出不同的动作，其中有对threshold的设置，读取，对acclerometer_flag的设置和获取等动作。
/*!
* read call for pressure char driver.
* file : Pointer to file structure.
* buf : Pointer to user buffer in which data will be read.
* size : Size of data be read.
* ppos : Pointer to Offset in the file.
* return 1. no of bytes read - For successful read \
2. ENOMEM - file private data pointer is NULL
*/
static ssize_t mma_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
int retval = 0;
unsigned short nr = 0;
pContext_t dev = file->private_data;
int bytestocopy = 0;
unsigned long bytescopied = 0;
char __user *buff = buf;
unsigned short hdr = 0xffff;
if (!dev)
{
return -ENOMEM;
}
/* Acquire semaphore to manage re-entrancy */
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
/* Loop till data available has crossed the watermark */
nr = GetAvailableData(dev->read_pos);
while (nr < dev->threshold )
{
/* Wait on accelerometer queue (AcclQ) till condition GetAvailableData(dev->read_pos) >= dev->threshold gets satisfied */
if (wait_event_interruptible(AcclDataQ,
(GetAvailableData(dev->read_pos) >= dev->threshold)))
return -ERESTARTSYS;
nr = GetAvailableData(dev->read_pos);
}
bytescopied = copy_to_user(buff, &hdr, sizeof(unsigned short));
retval += sizeof(unsigned short);
buff += sizeof(unsigned short);
bytescopied = copy_to_user(buff, &nr, sizeof(unsigned short));
retval += sizeof(unsigned short);
buff += sizeof(unsigned short);
/* Loop here to copy bytes to user buffer */
while(nr)
{
if(dev->read_pos + nr >= ACCL_FIFO_SIZE)
{
bytestocopy = ACCL_FIFO_SIZE - dev->read_pos ;
}
else
{
bytestocopy = nr;
}
/* Copy the required records to user buffer */
bytescopied = copy_to_user(buff, &AcclDataFifo[dev->read_pos], bytestocopy * sizeof(AcclData_t));
retval += bytestocopy * sizeof(AcclData_t);
buff += bytestocopy * sizeof(AcclData_t);
nr -= bytestocopy;
/* Increment the read_pos */
dev->read_pos += bytestocopy;
if(dev->read_pos >= ACCL_FIFO_SIZE)
dev->read_pos -= ACCL_FIFO_SIZE;
}
/* release the lock */
up(&dev->sem);
/* Return the number of bytes written to buffer */
return retval;
}
这个函数看上去很复杂，其实就做了一件事情，调用copy_to_user把数据传到用户空间，其实这里我很不明白这个字符驱动到底跟我们的mma器件有什么关系，因为这里read函数中我没有看到一点关于i2cread 的内容，所以我觉得，这里这个字符驱动是多余的，不过这里对等待队列的读操作有待学习。
我们也可以自己再这里加上对I2C的读操作来把这里的read函数挂到用户空间，我想这里的ioctl函数应该是来设置threshold的，应该是用在HAL层中来被设置的。
而这里的read函数也可以当做poll模式下来读取xyz的数据，大家可以看到在read中有作比较，当读回来的数据大于threshold时才把数据copy到用户空间。
OK，这个字符驱动暂时介绍到这边，下面我们接着看mma_core.c中的probe函数
/*
* Initialize input layer
*/
InitializeInputInterface(pDev);
/*
* Create sysfs entries
*/
InitializeSysfs( (struct i2c_client *)client);
/*
* Initialize semaphore for interrupt
*/
sema_init(&chip_ready, 0);
setup_timer(&stall_timer, stall_timer_fn, 0);
hIstThread = kthread_run(IntServiceThread, pDev, "mxc845x_ist");
if (IS_ERR(hIstThread)) {
printk(KERN_INFO "Error creating mxc845x ist.\n");
goto error_free_irq1;
}
if (plat_data->int1 > 0) {
set_irq_type(plat_data->int1, IRQF_TRIGGER_FALLING);
ret = request_irq(plat_data->int1, mma845x_interrupt,
IRQF_TRIGGER_FALLING, DEVICE_NAME, pDev);
if (ret) {
dev_err(&client->dev, "request_irq(%d) returned error %d\n",
plat_data->int1, ret);
goto error_disable_power;
}
}
else {
gpChip->DisableInt(INT_EN_FIFO | INT_EN_DRDY);
poll_mode = 1;
}
if (plat_data->int2 > 0){
printk(KERN_INFO "%s:: Configuring interrupt IRQ [%d]\r\n", __func__,
plat_data->int2);
set_irq_type(plat_data->int2, IRQF_TRIGGER_FALLING);
ret = request_irq(plat_data->int2, mma845x_interrupt,
IRQF_TRIGGER_FALLING, DEVICE_NAME, pDev);
if (ret) {
dev_err(&client->dev, "request_irq(%d) returned error %d\n",
plat_data->int2, ret);
goto error_free_irq1;
}
}
这里是一些列的初始化，input sybsystem、文件系统、信号量、定时器、线程的初始化，先看输入子系统初始化过程
int InitializeInputInterface(struct mxc_mma_device_t *pDev)
{
int RetVal = 0;
int i = 0;
if(pDev == NULL)
{
printk("%s: pDev => NULL pointer\r\n", __func__);
return -EPERM;
}
pDev->inp1 = input_allocate_device();
if (!pDev->inp1)
{
RetVal = -ENOMEM;
printk(KERN_ERR
"%s: Failed to allocate input device-1\n", __func__);
return RetVal;
}
set_bit(EV_ABS, pDev->inp1->evbit); // Accelerometer readings
/* yaw */
input_set_abs_params(pDev->inp1, ABS_RX, 0, 360, 0, 0);
/* pitch */
input_set_abs_params(pDev->inp1, ABS_RY, -180, 180, 0, 0);
/* roll */
input_set_abs_params(pDev->inp1, ABS_RZ, -90, 90, 0, 0);
/* x-axis acceleration */
input_set_abs_params(pDev->inp1, ABS_X, -32768, 32767, 0, 0);
/* y-axis acceleration */
input_set_abs_params(pDev->inp1, ABS_Y, -32768, 32767, 0, 0);
/* z-axis acceleration */
input_set_abs_params(pDev->inp1, ABS_Z, -32768, 32767, 0, 0);
pDev->inp1->name = "mma8451";
RetVal = input_register_device(pDev->inp1);
if (RetVal)
{
printk(KERN_ERR "%s: Unable to register input device: %s\n",__func__, pDev->inp1->name);
return RetVal;
}
/* Register input device 2 */
pDev->inp2 = input_allocate_device();
if (!pDev->inp2)
{
RetVal = -ENOMEM;
printk(KERN_ERR "%s: Failed to allocate input device-2\n", __func__);
return RetVal;
}
/* Initialize all event codes as this is a configurable param and may change runtime from user space */
for(i = 0x20; i < 0x40; i++)
input_set_abs_params(pDev->inp2, i, 0, 255, 0, 0);
pDev->inp2->mscbit[0] = BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
pDev->inp2->name = "Accl1";
set_bit(EV_ABS, pDev->inp2->evbit);
set_bit(EV_KEY, pDev->inp2->evbit);
set_bit(EV_MSC, pDev->inp2->evbit);
RetVal = input_register_device(pDev->inp2);
bitmap_fill(pDev->inp2->keybit, KEY_MAX);
if (RetVal)
{
printk(KERN_ERR "%s: Unable to register input device: %s\n", __func__, pDev->inp2->name);
return RetVal;
}
return RetVal;
}
分别调用input_allocate_device和input_register_device函数来注册input 驱动，然后就是设置input 驱动的类型，下面还注册了一个输入设备这里我的理解是这样的，input1主要是输出xyz方向上的重力加速度分量，而input2主要是用来输出一些碰撞和震动，还有横竖切换等事件。
下面是初始化文件系统
/*!
* This method is used to Initialize Sysfs.
* client : Pointer to i2c_client structure.
* return -EPERM : Device pointer is NULL.
* return 0 : Success.
*/
struct class *sensor_class_obj = NULL;
int InitializeSysfs(struct i2c_client *client)
{
int RetVal = 0;
int i = 0;
int Iterator = 0;
int Instance = 0;
struct mxc_mma_device_t *pDev = i2c_get_clientdata(client);
struct ChipInfo_t *pChip = pDev->pChip;
struct SysfsInfo_t *pSysfsInfo = pChip->pSysfsInfo;
if(pDev == NULL)
{
printk("%s: pDev => NULL pointer\r\n", __func__);
return -EPERM;
}
if(sensor_class_obj == NULL)
{
pDev->class = class_create(THIS_MODULE, "sensor");
if (IS_ERR(pDev->class))
{
printk(KERN_ERR "Unable to create class for Mxc MMA\n");
RetVal = PTR_ERR(pDev->class);
}
sensor_class_obj = pDev->class;
}
else
{
pDev->class = sensor_class_obj;
}
client->dev.class = pDev->class;
pDev->sys_device = device_create(pDev->class, NULL, MKDEV(pDev->major, 0), pDev,"mma");
if (IS_ERR(pDev->sys_device))
{
printk(KERN_ERR "Unable to create class device for Mxc Ipu\n");
RetVal = PTR_ERR(pDev->sys_device);
return RetVal;
}
dev_set_drvdata( (struct device *)&pDev->sys_device, pDev);
for(Iterator = 0; Iterator < pChip->SysfsInfoSize; Iterator++)
{
for(Instance = 0; Instance < pSysfsInfo[Iterator].Instance; Instance++)
{
/* Create motion_detection device */
if(pSysfsInfo[Iterator].grpName != NULL)
{
pDev->sys_motion_dev = device_create(pDev->class, pDev->sys_device, MKDEV(0, 0), pDev,
"%s%d", pSysfsInfo[Iterator].grpName, Instance);
}
else
{
pDev->sys_motion_dev = pDev->sys_device;
}
for(i=0; i < pSysfsInfo[Iterator].TotalEntries; i++)
{
if(sysfs_create_file(&pDev->sys_motion_dev->kobj, &pSysfsInfo[Iterator].AttrEntry[i].attr) < 0)
printk("%s sys file creation failed.\r\n", pSysfsInfo[Iterator].AttrEntry[i].attr.name);
}
}
}
return RetVal;
}
EXPORT_SYMBOL(sensor_class_obj);
这里代码很多，在mma_sysfs.c中，其实一点都不难，就是太多了有点复杂，看过内核驱动模型的同学应该很熟悉这里，这里就是建立了一个名为sensor的class，来作为这些文件的父类，具体的我不多说了，这里的文件太多了，也讲不完，可以一边参照data sheet一边看这里的文件时用来干嘛的，这里read/write 的时候就分别会回调这里相关的函数，然后去设置寄存器。大家可以看到下面就是这里建立的文件系统
/sys/class/sensor # ls -l
lrwxrwxrwx 1 root root 0 Jan 2 01:10 mma -> ../../devices/virtual/sensor/mma
lrwxrwxrwx 1 root root 0 Jan 2 01:10 motion_detection0 -> ../../devices/virtual/sensor/mma/motion_detection0
lrwxrwxrwx 1 root root 0 Jan 2 01:10 orientation_detection0 -> ../../devices/virtual/sensor/mma/orientation_detection0
lrwxrwxrwx 1 root root 0 Jan 2 01:10 tap_detection0 -> ../../devices/virtual/sensor/mma/tap_detection0
lrwxrwxrwx 1 root root 0 Jan 2 01:10 transient_detection0 -> ../../devices/virtual/sensor/mma/transient_detection0
/sys/class/sensor #
然后是初始化信号量和定时器，这里就不多说了。
接下来是创建了一个线程并执行他，这个线程是一个死循环，也就是我们这里最关键的一个函数，之后再说。
if (plat_data->int1 > 0) {
set_irq_type(plat_data->int1, IRQF_TRIGGER_FALLING);
ret = request_irq(plat_data->int1, mma845x_interrupt,
IRQF_TRIGGER_FALLING, DEVICE_NAME, pDev);
if (ret) {
dev_err(&client->dev, "request_irq(%d) returned error %d\n",
plat_data->int1, ret);
goto error_disable_power;
}
}
else {
gpChip->DisableInt(INT_EN_FIFO | INT_EN_DRDY);
poll_mode = 1;
}
if (plat_data->int2 > 0){
printk(KERN_INFO "%s:: Configuring interrupt IRQ [%d]\r\n", __func__,
plat_data->int2);
set_irq_type(plat_data->int2, IRQF_TRIGGER_FALLING);
ret = request_irq(plat_data->int2, mma845x_interrupt,
IRQF_TRIGGER_FALLING, DEVICE_NAME, pDev);
if (ret) {
dev_err(&client->dev, "request_irq(%d) returned error %d\n",
plat_data->int2, ret);
goto error_free_irq1;
}
然后这里是申请中断，如果我们使用中断模式的话就申请中断，如果没有使用中断模式的话这里有一个flag，poll_mode被设置成1，初始化的时候是0.
porbe函数就先讲到这里，这里主要还是做了一些初始化的东西，下面来分析一下这个驱动是如何工作的，其实相关的就是这里最重要的2个东西，一个是定时器，还有一个是这个thread的处理，我们下面接着看
/*!
* This function implements interrupt handler routine
* irq : Interrupt number
* dev_id
* return IRQ_RETVAL
*/
static irqreturn_t mma845x_interrupt(int irq, void *dev_id)
{
//+++add for debug
//printk("mma--irq\n");
up(&chip_ready);
return IRQ_RETVAL(1);
}
/*!
* This routine implements a call back for stall timer
* data : Pointer to device data structure
* return NONE
*/
static void stall_timer_fn(unsigned long data)
{
//++++add for debug
//printk("mma-- poll\n");
up(&chip_ready);
}
首先看下这里的中断响应函数和定时器响应函数，这里基本啥也没做，就是释放信号量，关键就在这，我们接着看
static int IntServiceThread(void *data)
{
wait_queue_t wait;
int ret = 0;
struct mxc_mma_device_t *pDev = (struct mxc_mma_device_t *) data;
struct ChipInfo_t *pChip = pDev->pChip;
char buff[256];
init_waitqueue_entry(&wait, current);
mod_timer(&stall_timer, jiffies + (HZ));
while (!done) {
do {
ret = down_interruptible(&chip_ready);
} while (ret == -EINTR);
if (!poll_mode) {
ret = pChip->GetIntSrc();
}
else
ret = SRC_DRDY;
if (SRC_DRDY & ret) {
pChip->Read(ACCL_DATA, (void *) buff);
UpdateAcclFiFo(buff);
if (!IsSuspended) {
if (pDev->aflag == 1)
ReportEvent(pDev, ACCL_DATA, buff);
}
}
if (SRC_FIFO & ret) {
int count = 0,
i = 0;
char *pBuff = (char *) buff;
printk(KERN_DEBUG "\t[FIFO] [%ld]\r\n", jiffies);
count = pChip->Read(FIFO_DATA, (void *) buff);
for (i = 0; i < count; i++) {
UpdateAcclFiFo(pBuff + (i * sizeof(AcclData_t)));
if (!IsSuspended) {
if (pDev->aflag == 1)
ReportEvent(pDev, ACCL_DATA,
pBuff + (i * sizeof(AcclData_t)));
}
}
}
/*
* Orientation
*/
if (SRC_LNDPRT & ret) {
char *pBuff = (char *) buff;
pChip->Read(ACCL_LNDPRT, (void *) buff);
if (!IsSuspended)
ReportEvent(pDev, ACCL_LNDPRT, pBuff);
}
/*
* Motion / Freefall interrupt
*/
if (SRC_FF_MT & ret) {
pChip->Read(ACCL_FF_MT, (void *) buff);
if (!IsSuspended)
ReportEvent(pDev, ACCL_FF_MT, buff);
}
if (SRC_FF_MT_2 & ret) {
pChip->Read(ACCL_FF_MT_2, (void *) buff);
if (!IsSuspended)
ReportEvent(pDev, ACCL_FF_MT_2, buff);
}
/*
* Motion / Freefall interrupt
*/
if (SRC_PULSE & ret) {
pChip->Read(ACCL_PULSE, (void *) buff);
if (!IsSuspended)
ReportEvent(pDev, ACCL_PULSE, buff);
}
if (SRC_TRANS & ret) {
pChip->Read(ACCL_TRANS, (void *) buff);
if (!IsSuspended)
ReportEvent(pDev, ACCL_TRANS, buff);
}
if (!IsSuspended) {
if (!poll_mode) {
mod_timer(&stall_timer, jiffies + (HZ));
}
else
mod_timer(&stall_timer, jiffies + pChip->poll_time);
}
}
return 0;
}
看下我们的线程，一开始是初始化了一堆变量，然后把data转化为我们这里的一个ChipInfo_t结构体指针，然后初始化等待队列，然后是修改定时器下次定时到达时间为1秒钟，然后是一个while循环，看下这个循环中到底做了啥事情。
首先是一个do while来试图获取信号量，这里信号量被初始化为0，所以这边是得不到的，就会一直等在这边，前面我们看过定时器和中断函数中都做了对信号量的释放动作，联想到这边就是说，我们的线程不是一直在走的，只有当发生定时器时间到达和中断发生了，才会让我们这里的线程继续往下走，也就实现了这里的polling和interrupt 这2中模式。
这个线程下面的代码我们都能猜到，就是通过I2C读取芯片中的数据，然后利用input子系统push到用户空间，如果是polling mode的话就修改下次定时到达的时间，这里的设计还是满巧妙的，有待学习，特别是我觉得代码写的比较规范。
下面来一张图来分析这里的处理流程。
画的太丑了，见谅！！