问container_of、dev_set_drvdata和dev_get_drvdata的使用

EN

    static void tsl4531_polling_worker(struct work_struct *work)
    {

        u8 buf[2];

        struct tsl4531_data *data   = container_of(to_delayed_work(work),
                            struct tsl4531_data, work);

        mutex_lock(&data->update_lock);
        buf[0] = DEVICE_LIGHT;
        buf[1] = GET_REQUEST;
        sam4l_send_request(data->pdata.sam4l,2,buf);
        mutex_unlock(&data->update_lock);

    }

    static ssize_t store_enable_value(struct device *dev,struct device_attribute *devattr,const char *buf,size_t count){

        struct tsl4531_data *data = dev_get_drvdata(dev);

        if((buf[0] == '1') && (!tsl4531_enabled)) {
            schedule_delayed_work(&data->work, msecs_to_jiffies(50));
            tsl4531_enabled = 1;

        } else if (buf[0] == '0'){
            tsl4531_enabled = 0;
            cancel_delayed_work_sync(&data->work);
            tsl4531_lux = 0;

        }

        return count;
    }

    static DEVICE_ATTR(enable,S_IRUGO | S_IWUGO,
               show_enable_value, store_enable_value );        

    static struct attribute *tsl4531_attributes[] = {
        &dev_attr_lux_show.attr,
        &dev_attr_enable.attr,
        NULL
    };

    static const struct attribute_group tsl4531_attr_group = {
        .attrs = tsl4531_attributes,
    };

    void tsl4531_callback_fun(struct work_struct *work)
    {

        struct tsl4531_data *chip = container_of(work,struct tsl4531_data,
                    pdata.work.work);

        tsl4531_lux = chip->pdata.response[2];//Need to check on which response index we get lux value

        input_report_abs(tsl4531_dev, ABS_X,tsl4531_lux);
        input_sync(tsl4531_dev);
        schedule_delayed_work(&chip->work, msecs_to_jiffies(1500));

    }

    static int __devinit tsl4531_probe(struct platform_device *pdev){
        struct tsl4531_data *chip;  
        int err=0;

        chip = kzalloc(sizeof(struct tsl4531_data), GFP_KERNEL);
        if (!chip){
            dev_dbg(&pdev->dev, "memory not allocated for tsl4531 light sensor module.\n");
            return -ENOMEM;
        }

        dev_set_drvdata(&pdev->dev,chip);//here we give address in chip to struct device

        tsl4531_dev=input_allocate_device();
        if(!tsl4531_dev) {
            dev_dbg(&pdev->dev, "memory not allocated for tsl4531_dev.\n");
            return -ENOMEM;
        }

        err=input_register_device(tsl4531_dev);
        if(err){
            dev_dbg(&pdev->dev, "input register poll the device failed ... \n");
            goto err_reg_poll;
        }

        mutex_init(&chip->update_lock);

        err = sysfs_create_group(&pdev->dev.kobj,&tsl4531_attr_group);
        if (err){
            dev_dbg(&pdev->dev, "creating sysfs group for tsl4531 sensor module failed.\n");
            goto exit_err;
        }

        INIT_DELAYED_WORK(&chip->work, tsl4531_polling_worker);
        INIT_DELAYED_WORK(&chip->pdata.work,tsl4531_callback_fun);

        chip->pdata.dev_id = DEVICE_LIGHT;

        return 0;

        return err;
    }

    static int __devexit tsl4531_remove(struct platform_device *pdev){

        struct tsl4531_data *data = dev_get_drvdata(&pdev->dev);

        cancel_delayed_work_sync(&data->work);
        cancel_delayed_work(&data->pdata.work);
        sysfs_remove_group(&pdev->dev.kobj, &tsl4531_attr_group);
        unregister_sam4l_client(&data->pdata);
        kfree(data);
        return 0;
    }

    static const struct platform_device_id tsl4531_id[] = {
        { "tsl45317", 0 },
        { }
    };

    static struct platform_driver tsl4531_driver = {
        .driver = {
            .owner = THIS_MODULE,
            .name  = "tsl45317",
        },
        .probe      = tsl4531_probe,
        .remove     = tsl4531_remove,
        .suspend    = tsl4531_suspend,
        .resume     = tsl4531_resume,
        .id_table   = tsl4531_id,
    };


    static int __init tsl4531_init(void){

        return platform_driver_register(&tsl4531_driver);
    }


    static void __exit tsl4531_exit(void){

        platform_driver_unregister(&tsl4531_driver);
    }