Exemplo n.º 1
0
static int bma020_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
	char *p = page;
	int len = 0;
	
	mutex_lock(&bma020.power_lock);
	printk("bma222_proc_read\n");
	bma020_set_mode( BMA020_MODE_NORMAL );

	bma020.state |= ACC_ENABLED;
	bma_acc_enable();

	mutex_unlock(&bma020.power_lock);

	len = (p - page) - off;
	if (len < 0) {
		len = 0;
	}

	printk("bma_proc_read: success full\n");

	*eof = (len <= count) ? 1 : 0;
	*start = page + off;
	return len;
}
int bma020_ioctl(struct inode *inode, struct file *filp, unsigned int ioctl_num,  unsigned long arg)
{
    bma020acc_t accels;
    unsigned int arg_data;
    int err = 0;

    gprintk("start\n");
    switch( ioctl_num )
    {
    case IOCTL_BMA020_GET_ACC_VALUE :
    {
        bma020_read_accel_xyz( &accels );

        gprintk( "acc data x = %d  /  y =  %d  /  z = %d\n", accels.x, accels.y, accels.z );

        if( copy_to_user( (bma020acc_t*)arg, &accels, sizeof(bma020acc_t) ) )
        {
            err = -EFAULT;
        }

    }
    break;

    case IOC_SET_ACCELEROMETER :
    {
        if( copy_from_user( (unsigned int*)&arg_data, (unsigned int*)arg, sizeof(unsigned int) ) )
        {

        }
        if( arg_data == BMA020_POWER_ON )
        {
            printk( "ioctl : bma020 power on\n" );
            bma020_set_mode( BMA020_MODE_NORMAL );
        }
        else
        {
            printk( "ioctl : bma020 power off\n" );
            bma020_set_mode( BMA020_MODE_SLEEP );
        }
    }
    break;
    default :
        break;
    }
    return err;

}
Exemplo n.º 3
0
static int bma020_accelerometer_suspend( struct platform_device* pdev, pm_message_t state )
{
	printk(" %s \n",__func__); 
	bma020_set_mode( BMA020_MODE_SLEEP );

	if (bma020.state & ACC_ENABLED) 
		bma_acc_disable();
	return 0;
}
Exemplo n.º 4
0
static int bma020_accelerometer_resume( struct platform_device* pdev )
{
	printk(" %s \n",__func__); 

	if (bma020.state & ACC_ENABLED)
		bma_acc_enable();
	
	bma020_set_mode( BMA020_MODE_NORMAL );
	return 0;
}
Exemplo n.º 5
0
static ssize_t bma020_show_accel_value(struct device *dev,struct device_attribute *attr, char *buf)
{   
	bma020acc_t accel; 
	
	bma020_set_mode(BMA020_MODE_NORMAL);
	bma020_set_range(BMA020_RANGE_2G); 
	bma020_set_bandwidth(BMA020_BW_100HZ);
	
	bma020_read_accel_xyz( &accel);	
    return sprintf(buf, "%d,%d,%d\n", accel.x,accel.y,accel.z);
}
Exemplo n.º 6
0
static int bma020_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{

	bma020acc_t acc;
	bma020_set_mode( BMA020_MODE_NORMAL );
	bma020_read_accel_xyz(&acc);
	p += sprintf(p,"[BMA020]\nX axis: %d\nY axis: %d\nZ axis: %d\n" , acc.x, acc.y, acc.z);
	len = (p - page) - off;
	if (len < 0) {
		len = 0;
	}

	*eof = (len <= count) ? 1 : 0;
	*start = page + off;
	return len;
}
int bma020_acc_start(void)
{
    int result;

    struct device *dev_t;

    bma020acc_t accels; /* only for test */
    printk("%s \n",__func__);

    result = register_chrdev( BMA150_MAJOR, ACC_DEV_NAME, &acc_fops);

    if (result < 0)
    {
        return result;
    }

    acc_class = class_create (THIS_MODULE, "BMA-dev");

    if (IS_ERR(acc_class))
    {
        unregister_chrdev( BMA150_MAJOR, ACC_DEV_NAME);
        return PTR_ERR( acc_class );
    }

    dev_t = device_create( acc_class, NULL, MKDEV(BMA150_MAJOR, 0), "%s", "accelerometer");

    if (IS_ERR(dev_t))
    {
        return PTR_ERR(dev_t);
    }

    result = i2c_acc_bma020_init();

    if(result)
    {
        return result;
    }

    bma020_chip_init();

    gprintk("[BMA020] read_xyz ==========================\n");
    bma020_read_accel_xyz( &accels );
    gprintk("[BMA020] x = %d  /  y =  %d  /  z = %d\n", accels.x, accels.y, accels.z );

    gprintk("[BMA020] ===================================\n");

    /* only for test */
#if 0
    printk( "before get xyz\n" );
    mdelay(3000);

    while(1)
    {
        bma020_read_accel_xyz( &accels );

        printk( "acc data x = %d  /  y =  %d  /  z = %d\n", accels.x, accels.y, accels.z );

        mdelay(100);
    }
#endif

#ifdef BMA020_PROC_FS
    create_proc_read_entry(DRIVER_PROC_ENTRY, 0, 0, bma020_proc_read, NULL);
#endif	//BMA020_PROC_FS

    bma020_set_mode(BMA020_MODE_SLEEP);
    gprintk("[BMA020] set_mode BMA020_MODE_SLEEP\n");

    return 0;
}
static void bma020_late_resume(struct early_suspend *handler)
{
    printk( "%s : Set MODE NORMAL\n", __func__ );
    bma020_set_mode( BMA020_MODE_NORMAL );
}
static void bma020_early_suspend(struct early_suspend *handler)
{
    printk( "%s : Set MODE SLEEP\n", __func__ );
    bma020_set_mode( BMA020_MODE_SLEEP );
}
int bma020_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,  unsigned long arg)
{
    int err = 0;
    unsigned char data[6];

    /* check cmd */
    if(_IOC_TYPE(cmd) != BMA150_IOC_MAGIC)
    {
#if DEBUG
        printk("cmd magic type error\n");
#endif
        return -ENOTTY;
    }
    if(_IOC_NR(cmd) > BMA150_IOC_MAXNR)
    {
#if DEBUG
        printk("cmd number error\n");
#endif
        return -ENOTTY;
    }

    if(_IOC_DIR(cmd) & _IOC_READ)
        err = !access_ok(VERIFY_WRITE,(void __user*)arg, _IOC_SIZE(cmd));
    else if(_IOC_DIR(cmd) & _IOC_WRITE)
        err = !access_ok(VERIFY_READ, (void __user*)arg, _IOC_SIZE(cmd));
    if(err)
    {
#if DEBUG
        printk("cmd access_ok error\n");
#endif
        return -EFAULT;
    }
#if 0
    /* check bam150_client */
    if( bma150_client == NULL)
    {
#if DEBUG
        printk("I2C driver not install\n");
#endif
        return -EFAULT;
    }
#endif

    switch(cmd)
    {
    case BMA150_READ_ACCEL_XYZ:
        err = bma020_read_accel_xyz((bma020acc_t*)data);
        if(copy_to_user((bma020acc_t*)arg,(bma020acc_t*)data,6)!=0)
        {
#if DEBUG
            printk("copy_to error\n");
#endif
            return -EFAULT;
        }
        return err;

    case BMA150_SET_RANGE:
        if(copy_from_user(data,(unsigned char*)arg,1)!=0)
        {
#if DEBUG
            printk("[BMA150] copy_from_user error\n");
#endif
            return -EFAULT;
        }
        err = bma020_set_range(*data);
        return err;

    case BMA150_SET_MODE:
        if(copy_from_user(data,(unsigned char*)arg,1)!=0)
        {
#if DEBUG
            printk("[BMA150] copy_from_user error\n");
#endif
            return -EFAULT;
        }
        err = bma020_set_mode(*data);
        return err;

    case BMA150_SET_BANDWIDTH:
        if(copy_from_user(data,(unsigned char*)arg,1)!=0)
        {
#if DEBUG
            printk("[BMA150] copy_from_user error\n");
#endif
            return -EFAULT;
        }
        err = bma020_set_bandwidth(*data);
        return err;

    default:
        return 0;
    }
}
Exemplo n.º 11
0
int bma020_acc_start(void)
{
	int result,err;
	struct input_dev *input_dev;

	struct device *dev_t;
	
	bma020acc_t accels; 
	
	result = register_chrdev( ACC_DEV_MAJOR, ACC_DEV_NAME, &acc_fops);

	if (result < 0) 
	{
		return result;
	}
	
	acc_class = class_create (THIS_MODULE, ACC_DEV_NAME);
	
	if (IS_ERR(acc_class)) 
	{
		unregister_chrdev( ACC_DEV_MAJOR, ACC_DEV_NAME);
		return PTR_ERR( acc_class );
	}

	dev_t = device_create( acc_class, NULL, MKDEV(ACC_DEV_MAJOR, 0), "%s", ACC_DEV_NAME);

	if (IS_ERR(dev_t)) 
	{
		return PTR_ERR(dev_t);
	}
	
	/*For testing*/
	if (device_create_file(dev_t, &dev_attr_acc_file) < 0)
		printk("Failed to create device file %s \n", dev_attr_acc_file.attr.name);
	
	mutex_init(&bma020.power_lock);

	/* hrtimer settings.  we poll for light values using a timer. */
	hrtimer_init(&bma020.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	bma020.acc_poll_delay = ns_to_ktime(240 * NSEC_PER_MSEC);
	bma020.timer.function = bma_timer_func;

	/* the timer just fires off a work queue request.  we need a thread
	   to read the i2c (can be slow and blocking). */
	bma020.wq = create_singlethread_workqueue("bma_wq");
	if (!bma020.wq) {
		err = -ENOMEM;
		printk("%s: could not create workqueue\n", __func__);
		goto err_create_workqueue;
	}
	/* this is the thread function we run on the work queue */
	INIT_WORK(&bma020.work_acc, bma_work_func_acc);

	/* allocate lightsensor-level input_device */
	input_dev = input_allocate_device();
	if (!input_dev) {
		printk("%s: could not allocate input device\n", __func__);
		err = -ENOMEM;
		goto err_input_allocate_device_light;
	}
	input_set_drvdata(input_dev, &bma020);
	input_dev->name = "accel";


	set_bit(EV_ABS, input_dev->evbit);	
	/* acceleration x-axis */
	input_set_capability(input_dev, EV_ABS, ABS_X);
	input_set_abs_params(input_dev, ABS_X, -1024, 1024, 0, 0);
	/* acceleration y-axis */
	input_set_capability(input_dev, EV_ABS, ABS_Y);
	input_set_abs_params(input_dev, ABS_Y, -1024, 1024, 0, 0);
	/* acceleration z-axis */
	input_set_capability(input_dev, EV_ABS, ABS_Z);
	input_set_abs_params(input_dev, ABS_Z, -1024, 1024, 0, 0);

	printk("registering lightsensor-level input device\n");
	err = input_register_device(input_dev);
	if (err < 0) {
		printk("%s: could not register input device\n", __func__);
		input_free_device(input_dev);
		goto err_input_register_device_light;
	}
	bma020.acc_input_dev = input_dev;


	err = sysfs_create_group(&input_dev->dev.kobj,&acc_attribute_group);
	if (err) {
		printk("Creating bma020 attribute group failed");
		goto error_device;
	}
//////////////////////////////////////////////////////////////////////////////
	
	result = i2c_acc_bma020_init();

	if(result)
	{
		return result;
	}

	bma020_chip_init();

	gprintk("[BMA020] read_xyz ==========================\n");
	bma020_read_accel_xyz( &accels );
	gprintk("[BMA020] x = %d  /  y =  %d  /  z = %d\n", accels.x, accels.y, accels.z );

	gprintk("[BMA020] ===================================\n");	

#ifdef BMA020_PROC_FS
	create_proc_read_entry(DRIVER_PROC_ENTRY, 0, 0, bma020_proc_read, NULL);
#endif	//BMA020_PROC_FS

	bma020_set_mode(BMA020_MODE_SLEEP);
	gprintk("[BMA020] set_mode BMA020_MODE_SLEEP\n");
	
	return 0;
error_device:
	sysfs_remove_group(&input_dev->dev.kobj, &acc_attribute_group);
err_input_register_device_light:
	input_unregister_device(bma020.acc_input_dev);
err_input_allocate_device_light:	
	destroy_workqueue(bma020.wq);
err_create_workqueue:
	mutex_destroy(&bma020.power_lock);
exit:
	return err;
}