mpu9250

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#include <linux/pm.h>
#include <linux/gpio.h>

#define DRIVER_NAME    "mpu9250"
#define INT_PIN_CFG     (0x37)
#define AK8963_CTRL1   (0xA)
static struct i2c_client *mpu9250_i2c_device;
#define MPU9250_I2C_ADAPTER         	(0)

//struct work_struct			polling_work ;
struct delayed_work polling_work;

s32 mpu9250_i2c_read_data(struct i2c_client *client, u8 *data, u8 length)
{
struct i2c_msg msg;
msg.addr = client->addr;
msg.flags = I2C_M_RD;
msg.len = length;
msg.buf = data;
return i2c_transfer(client->adapter, &msg, 1);
}

s32 mpu9250_i2c_write_data(struct i2c_client *client, u8 *data, u8 length)
{
struct i2c_msg msg;
msg.addr = client->addr;
msg.flags = 0;
msg.len = length;
msg.buf = data;
return i2c_transfer(client->adapter, &msg, 1);
}

void master_write_i2c_reg(struct i2c_client *client, u8 addr, u8 reg_data)
{
unsigned char data[2] = {0, 0};
unsigned int len = 0;

data[len++] = (addr & 0xff);
data[len++] = (reg_data & 0xff);

mpu9250_i2c_write_data(client, data, len);

return ;
}

void master_read_i2c_reg(struct i2c_client *client, u8 addr, u8 *ret_data, u8 length)
{

unsigned char data[2];
unsigned int len = 0;

data[len++] = (addr & 0xff);

mpu9250_i2c_write_data(client, data, len);

mpu9250_i2c_read_data(client, ret_data, length);

return ;
}
static void set_mode(struct i2c_client *client,int bypass)
{
u8 data[2] = {0,0};
u8 reg55_data = 0;

master_read_i2c_reg(client,INT_PIN_CFG,data,1);
//printk("[%s]%d: data[0] = 0x%2x\n",data[0]);
if(bypass)
reg55_data = data[0]| (0x2);
else
reg55_data = data[0] & (0xfd);
master_write_i2c_reg(client,INT_PIN_CFG,reg55_data);
//master_read_i2c_reg(client,INT_PIN_CFG,data,1);
//printk("[%s]%d: data[0] = 0x%2x\n",data[0]);
}
static void read_reg(struct i2c_client *client)
{
u8 data[2] = {0,0};
u8 i = 0 ;
u16 out_data = 0;

client->addr = 0x68;

master_read_i2c_reg(client,(59),data,1);
master_read_i2c_reg(client,(60),&data[1],1);
out_data = data[0] << 8  | data[1];
printk("x = %d,",out_data);
master_read_i2c_reg(client,(61),data,1);
master_read_i2c_reg(client,(62),&data[1],1);
out_data = data[0] << 8  | data[1];
printk("y = %d,",out_data);
master_read_i2c_reg(client,(63),data,1);
master_read_i2c_reg(client,(64),&data[1],1);
out_data = data[0] << 8  | data[1];
printk("z = %d,",out_data);
printk("acc end.-\n");

master_read_i2c_reg(client,(67),data,1);
master_read_i2c_reg(client,(68),&data[1],1);
out_data = data[0] << 8  | data[1];
printk("x = %d,",out_data);
master_read_i2c_reg(client,(69),data,1);
master_read_i2c_reg(client,(70),&data[1],1);
out_data = data[0] << 8  | data[1];
printk("y = %d,",out_data);
master_read_i2c_reg(client,(71),data,1);
master_read_i2c_reg(client,(72),&data[1],1);
out_data = data[0] << 8  | data[1];
printk("z = %d,",out_data);
printk("gyro end.-\n");

//master_read_i2c_reg(client,(73),data,2);
//printk("%d,%d---\n",data[0],data[1]);

set_mode(client,1);
client->addr=0x0c;

master_read_i2c_reg(client,(0),data,1);
master_read_i2c_reg(client,(4),&data[1],1);
out_data = data[1] << 8  | data[0];
printk("x = %d,",out_data);
master_read_i2c_reg(client,(5),data,1);
master_read_i2c_reg(client,(6),&data[1],1);
out_data = data[1] << 8  | data[0];
printk("y = %d,",out_data);
master_read_i2c_reg(client,(7),data,1);
master_read_i2c_reg(client,(8),&data[1],1);
out_data = data[1] << 8  | data[0];
printk("z = %d,",out_data);
printk("mag end.-\n");
client->addr = 0x68;
set_mode(client,0);

}
static void data_polling( struct work_struct *work )
{
printk("%s,%d=================\n",__func__,__LINE__);
read_reg(mpu9250_i2c_device);
schedule_delayed_work(&polling_work,50);

}
static int mpu9250_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
INIT_DELAYED_WORK(&polling_work, data_polling);

//set_mode(client,1);// set to bypass mode
//client->addr = 0x0C;
//master_write_i2c_reg(client,0xA,0xe);
//client->addr = 0x68;
//set_mode(client,0);

/*master_write_i2c_reg(client, 36, 0x40);
master_write_i2c_reg(client, 40, 0x0A);
master_write_i2c_reg(client, 41, 0x01);
master_write_i2c_reg(client, 42, 0x81);
master_write_i2c_reg(client, 100,0x01);
*/
schedule_work(&polling_work) ;
return 0;
}

static int mpu9250_i2c_remove(struct i2c_client *client)
{
cancel_delayed_work_sync(&polling_work);
return 0;
}

static const struct i2c_device_id mpu9250_i2c_id_table[] = {
{ DRIVER_NAME, 0 },
{ },
};
MODULE_DEVICE_TABLE(i2c, mpu9250_i2c_id_table);

static struct i2c_driver mpu9250_i2c_driver = {
.driver = {
.name	= DRIVER_NAME,
.owner	= THIS_MODULE,
},

.probe		= mpu9250_i2c_probe,
.remove		= __devexit_p(mpu9250_i2c_remove),
.id_table	= mpu9250_i2c_id_table,
};

static struct i2c_board_info mpu9250_i2c_info = {
I2C_BOARD_INFO(DRIVER_NAME, 0x68),
};

static int __init mpu9250_i2c_init(void)
{
int result = -1;
printk("%s,%d=====2============\n",__func__,__LINE__);
struct i2c_adapter *adap = i2c_get_adapter(MPU9250_I2C_ADAPTER);
mpu9250_i2c_device = i2c_new_device(adap, &mpu9250_i2c_info);

result = i2c_add_driver(&mpu9250_i2c_driver);
if (result) {
pr_err("failed\n");
return result;
}
return 0;
}

static void __exit mpu9250_i2c_exit(void)
{
i2c_del_driver(&mpu9250_i2c_driver);
i2c_unregister_device(mpu9250_i2c_device);
}

module_init(mpu9250_i2c_init);
module_exit(mpu9250_i2c_exit);

MODULE_AUTHOR("frank");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("mpu9250 sensor driver");