Freescale mma845x三轴加速度传感器驱动分析

最近刚看完freescale mma8451的驱动，并且一直了驱动，自己也没怎么改代码，不过读了一下代码，还是有点体会的，下面我就来分析一下。

首先看下代码结构，有兴趣的可以从一下方式获得代码，git@github.com: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的话就修改下次定时到达的时间，这里的设计还是满巧妙的，有待学习，特别是我觉得代码写的比较规范。

下面来一张图来分析这里的处理流程。

画的太丑了，见谅！！