atmel触摸屏驱动分析

最新代码在：https://github.com/atmel-maxtouch/linux 3847行

从下往上走读：

版权信息

/* Module information */
MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
MODULE_LICENSE("GPL");

设备树匹配的名称：

static const struct i2c_device_id mxt_id[] = {
    { "qt602240_ts", 0 },
    { "atmel_mxt_ts", 0 },
    { "atmel_mxt_tp", 0 },
    { "maxtouch", 0 },
    { "mXT224", 0 },
    { }
};

待机模式操作

static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);

#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \  
const struct dev_pm_ops name = { \  
    SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \  
}  

移除操作

static int mxt_remove(struct i2c_client *client)
{
    struct mxt_data *data = i2c_get_clientdata(client);

    sysfs_remove_group(&client->dev.kobj, &mxt_fw_attr_group);
    mxt_debug_msg_remove(data);
    mxt_sysfs_remove(data);

#ifndef __POLL
    if (data->irq)
        free_irq(data->irq, data);
#endif

    regulator_put(data->reg_avdd);
    regulator_put(data->reg_vdd);
    mxt_free_input_device(data);
    mxt_free_object_table(data);
    kfree(data);

    return 0;
}

插入操作

static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    struct mxt_data *data;
    const struct mxt_platform_data *pdata;
    int error;

    pdata = mxt_get_platform_data(client);  //获取平台数据
    if (IS_ERR(pdata))
        return PTR_ERR(pdata);

    data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;

    snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
        client->adapter->nr, client->addr);

    data->client = client;
    data->pdata = pdata;
    i2c_set_clientdata(client, data);   //保存数据

    if (data->pdata->cfg_name)  //配置文件名
        mxt_update_file_name(&data->client->dev,
                    &data->cfg_name,
                    data->pdata->cfg_name,
                    strlen(data->pdata->cfg_name));

    init_completion(&data->chg_completion);
    init_completion(&data->reset_completion);
    init_completion(&data->crc_completion);
    mutex_init(&data->debug_msg_lock);

    if (pdata->suspend_mode == MXT_SUSPEND_REGULATOR) {
        __D;
        error = mxt_acquire_irq(data);
        if (error)
            goto err_free_mem;

        error = mxt_probe_regulators(data);
        if (error)
            goto err_free_irq;

        disable_irq(data->irq);
    }

    error = sysfs_create_group(&client->dev.kobj, &mxt_fw_attr_group);
    if (error) {
        dev_err(&client->dev, "Failure %d creating fw sysfs group\n",
            error);
        return error;
    }

    error = mxt_initialize(data);
    if (error)
        goto err_free_irq;

    return 0;

err_free_irq:
    if (data->irq)
        free_irq(data->irq, data);
err_free_mem:
    kfree(data);
    return error;
}

获取平台数据

static const struct mxt_platform_data *
mxt_get_platform_data(struct i2c_client *client)
{
    const struct mxt_platform_data *pdata;

    pdata = dev_get_platdata(&client->dev);  //已经获取过就直接返回
    if (pdata)
        return pdata;

    pdata = mxt_parse_dt(client);       //解析dts//初始化gpio_reset，cfg_name，input_name，gpio-keymap，suspend_mode
    if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
        return pdata;

    pdata = mxt_parse_acpi(client);
    if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
        return pdata;

    pdata = mxt_default_pdata(client);
    if (!IS_ERR(pdata))
        return pdata;

    dev_err(&client->dev, "No platform data specified\n");
    return ERR_PTR(-EINVAL);
}

获取中断

static int mxt_acquire_irq(struct mxt_data *data)
{
    int error;
#ifndef __POLL
    if (!data->irq) {   //没有中断的话申请中断线程
        error = request_threaded_irq(data->client->irq, NULL,
                mxt_interrupt,
                data->pdata->irqflags | IRQF_ONESHOT,
                data->client->name, data);
        if (error) {
            dev_err(&data->client->dev, "Error requesting irq\n");
            return error;
        }

        /* Presence of data->irq means IRQ initialised */
        data->irq = data->client->irq;
    } else {    //存在中断，则使能
        enable_irq(data->irq);
    }
#endif
    if (data->object_table && data->use_retrigen_workaround) {
        error = mxt_process_messages_until_invalid(data);
        if (error)
            return error;
    }

    return 0;
}

中断服务例程

static irqreturn_t mxt_interrupt(int irq, void *dev_id)
{
    struct mxt_data *data = dev_id;

    complete(&data->chg_completion);

    if (data->in_bootloader) {
        if (data->flash && &data->flash->work)
            cancel_delayed_work_sync(&data->flash->work);

        return IRQ_RETVAL(mxt_check_bootloader(data));
    }

    if (!data->object_table)
        return IRQ_HANDLED;

    if (data->T44_address) {    //有T44地址
        return mxt_process_messages_t44(data);
    } else {
        return mxt_process_messages(data);
    }
}

处理消息

static irqreturn_t mxt_process_messages(struct mxt_data *data)
{
    int total_handled, num_handled;
    u8 count = data->last_message_count;

    if (count < 1 || count > data->max_reportid)
        count = 1;

    /* include final invalid message */
    total_handled = mxt_read_and_process_messages(data, count + 1);
    if (total_handled < 0)
        return IRQ_NONE;
    /* if there were invalid messages, then we are done */
    else if (total_handled <= count)
        goto update_count;

    /* keep reading two msgs until one is invalid or reportid limit */
    do {
        num_handled = mxt_read_and_process_messages(data, 2);
        if (num_handled < 0)
            return IRQ_NONE;

        total_handled += num_handled;

        if (num_handled < 2)
            break;
    } while (total_handled < data->num_touchids);

update_count:
    data->last_message_count = total_handled;

    if (data->update_input) {
        mxt_input_sync(data);
        data->update_input = false;
    }

    return IRQ_HANDLED;
}