MT6737 平台TP driver分析(二)

最新推荐文章于 2021-05-07 02:49:49 发布
最新推荐文章于 2021-05-07 02:49:49 发布
阅读量1.9k 收藏 6
点赞数 1
分类专栏： android驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuewen2008/article/details/79107894
版权

tp厂商驱动文件分析
\kernel-3.18\drivers\input\touchscreen\mediatek\NT11206
这里写图片描述
\kernel-3.18\drivers\input\touchscreen\mediatek\NT11206\NVTtouch_206.c

static int __init nvt_driver_init(void)
{
    int32_t ret = 0;

    NVT_INFO("NVT touch panel driver init!\n");
    tpd_get_dts_info();//获得dts中的配置信息
    ret = tpd_driver_add(&nvt_device_driver);//将tp厂商的驱动文件添加到tp驱动链表中tpd_driver_list
    if ( ret < 0){
        NVT_ERROR("add generic driver failed\n");
        goto err_driver;
    }
    NVT_INFO("nvt_driver_init finished\n");

err_driver:
    return ret;
}

nvt_device_driver

static struct tpd_driver_t nvt_device_driver =
{
    .tpd_device_name = NVT_I2C_NAME,
    .tpd_local_init = nvt_local_init,//之前分析mtk_tpd.c文件中遇到的tpd_local_init函数
    .suspend = nvt_ts_suspend,//tp休眠函数
    .resume = nvt_ts_resume,//tp唤醒函数
};

static int nvt_local_init(void)
{
   NVT_INFO("nvt_local_init");
   NVT_INFO("Device Tree get regulator!");
   tpd->reg = regulator_get(tpd->tpd_dev, "vtouch");
#if I2C_DMA_SUPPORT
    tpd->dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);

    gpDMABuf_va = (uint8_t *)dma_alloc_coherent(&tpd->dev->dev, DMA_MAX_TRANSACTION_LENGTH, &gpDMABuf_pa, GFP_KERNEL);
    if(!gpDMABuf_va){
        NVT_ERROR("Allocate DMA I2C Buffer failed!\n");
        NVT_INFO("ate DMA I2C Buffer failed!\n");
    }
    memset(gpDMABuf_va, 0, DMA_MAX_TRANSACTION_LENGTH);
#endif

    if (i2c_add_driver(&nvt_i2c_driver) != 0)//注册i2c从设备驱动
    {
        NVT_ERROR("unable to add i2c driver.\n");
        return -1;
    }

    if (tpd_load_status == 0)
    {
        NVT_ERROR("add error touch panel driver.\n");
        i2c_del_driver(&nvt_i2c_driver);
        return -1;
    }

    NVT_INFO("%s: finished\n", __func__);

    tpd_type_cap = 1;

    return 0;
}

nvt_local_init函数中主要是注册了i2c从设备驱动nvt_i2c_driver

static struct i2c_driver nvt_i2c_driver =
{
    .probe = nvt_i2c_probe,
    .remove = nvt_i2c_remove,
    .detect = nvt_i2c_detect,
    .driver.name = NVT_I2C_NAME,//driver名字NVT-ts
    .driver = {
           .name = NVT_I2C_NAME,
           .of_match_table = tpd_of_match,
           },
    .id_table = nvt_ts_id,
    .address_list = (const unsigned short *)forces,
};

static int nvt_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int32_t ret = 0;
    int32_t err = 0;


#if ((TOUCH_KEY_NUM > 0) || WAKEUP_GESTURE)
    int32_t retry = 0;
#endif

    NVT_INFO("tpd_i2c_probe start...");
    ts = kmalloc(sizeof(struct nvt_ts_data), GFP_KERNEL);
    if (ts == NULL) {
        dev_err(&client->dev, "%s: failed to allocated memory for nvt ts data\n", __func__);
        return -ENOMEM;
    }
    ts->client = client;
    i2c_set_clientdata(client, ts);

    if (tpd_power_switch(SWITCH_ON) < 0)//tp上电操作
    {
        NVT_ERROR("tpd_power_switch error !!!\n");
    }


    thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);//tp触摸事件处理函数
    if (IS_ERR(thread))
    {
        err = PTR_ERR(thread);
        NVT_INFO(TPD_DEVICE "failed to create kernel thread: %d\n", err);
    }

    //---request INT-pin---
    tpd_gpio_as_int(GTP_INT_PORT);//申请触摸中断
    msleep(50);

    nvt_hw_reset();//TP reset
    //msleep(500);

    //---check i2c func.---
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
        dev_err(&client->dev, "i2c_check_functionality failed. (no I2C_FUNC_I2C)\n");
        ret = -ENODEV;
        goto err_check_functionality_failed;
    }

    // need 10ms delay after POR(power on reset)
    msleep(10);

    //---check chip id---
    ret = nvt_ts_read_chipid();//读取tp chip id
    if (ret != 0x26) {
        NVT_INFO("nvt_ts_read_chipid is not 0x26. ret=0x%02X\n", ret);
        dev_err(&client->dev, "nvt_ts_read_chipid is not 0x26. ret=0x%02X\n", ret);
        ret = -EINVAL;
        goto err_chipid_failed;
    }


    //---check chip version---
    ret = nvt_ts_chip_version();//读取tp chip version

    mutex_init(&ts->lock);

    //---allocate input device---
    ts->input_dev = input_allocate_device();//分配input device结构体
    if (ts->input_dev == NULL) {
        dev_err(&client->dev, "%s: allocate input device failed\n", __func__);
        ret = -ENOMEM;
        goto err_input_dev_alloc_failed;
    }

#if BOOT_UPDATE_FIRMWARE
    nvt_fwu_wq = create_singlethread_workqueue("nvt_fwu_wq");
    if (!nvt_fwu_wq) {
        dev_err(&client->dev, "%s: nvt_fwu_wq create workqueue failed\n", __func__);
        ret = -ENOMEM;
        goto err_create_nvt_fwu_wq_failed;
    }
    INIT_DELAYED_WORK(&ts->nvt_fwu_work, Boot_Update_Firmware);//固件升级相关操作
    queue_delayed_work(nvt_fwu_wq, &ts->nvt_fwu_work, msecs_to_jiffies(4000));
#endif

    ts->abs_x_max = TOUCH_MAX_WIDTH;//最大像素宽度720
    ts->abs_y_max = TOUCH_MAX_HEIGHT;//最大像素高度1280
    ts->max_touch_num = TOUCH_MAX_FINGER_NUM;

#if TOUCH_KEY_NUM > 0
    ts->max_button_num = TOUCH_KEY_NUM;
#endif

    ts->int_trigger_type = INT_TRIGGER_TYPE;//中断触发类型.上升沿触发


    //---set input device info.---设置 input device结构体属性和参数
    ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;
    ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
    ts->input_dev->propbit[0] = BIT(INPUT_PROP_DIRECT);

#if MT_PROTOCOL_B
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0))
    input_mt_init_slots(ts->input_dev, ts->max_touch_num, 0);
#else
    input_mt_init_slots(ts->input_dev, ts->max_touch_num);
#endif
#endif

    input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);    //pressure = 255

#if TOUCH_MAX_FINGER_NUM > 1
    input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);    //area = 255

    input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);
    input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);
#if MT_PROTOCOL_B
    // no need to set ABS_MT_TRACKING_ID, input_mt_init_slots() already set it
#else
    input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, ts->max_touch_num, 0, 0);
#endif
#endif

#if TOUCH_KEY_NUM > 0//是否支持触摸按键
    for (retry = 0; retry < TOUCH_KEY_NUM; retry++) {
        input_set_capability(ts->input_dev, EV_KEY, touch_key_array_1[retry]);
    }
#endif

#if WAKEUP_GESTURE //是否支持唤醒手势
    for (retry = 0; retry < (sizeof(gesture_key_array) / sizeof(gesture_key_array[0])); retry++) {
        input_set_capability(ts->input_dev, EV_KEY, gesture_key_array[retry]);
    }
    wake_lock_init(&gestrue_wakelock, WAKE_LOCK_SUSPEND, "poll-wake-lock");
#endif

    sprintf(ts->phys, "input/ts");
    ts->input_dev->name = NVT_TS_NAME;
    ts->input_dev->phys = ts->phys;
    ts->input_dev->id.bustype = BUS_I2C;


    //---register input device---
    ret = input_register_device(ts->input_dev);//注册tp input设备
    if (ret) {
        dev_err(&client->dev, "register input device (%s) failed. ret=%d\n", ts->input_dev->name, ret);
        goto err_input_register_device_failed;
    } 

    ret = tpd_irq_registration();// 注册tp触摸中断
    if(ret != 0){
        NVT_ERROR("tpd register irq failed!\n");
        goto err_int_request_failed;
    }

    mutex_lock(&ts->lock);
    nvt_hw_reset();
    msleep(5);
    nvt_bootloader_reset();
    nvt_check_fw_reset_state(RESET_STATE_INIT);
    mutex_unlock(&ts->lock);

    //---set device node---
#if NVT_TOUCH_PROC
    ret = nvt_flash_proc_init();
    if (ret != 0) {
        dev_err(&client->dev, "nvt flash proc init failed. ret=%d\n", ret);
        goto err_init_NVT_ts;
    }
#endif

#if NVT_TOUCH_EXT_PROC
    ret = nvt_extra_proc_init();
    if (ret != 0) {
        dev_err(&client->dev, "nvt extra proc init failed. ret=%d\n", ret);
        goto err_init_NVT_ts;
    }
#endif

#if NVT_TOUCH_MP
    ret = nvt_mp_proc_init();
    if (ret != 0) {
        dev_err(&client->dev, "nvt mp proc init failed. ret=%d\n", ret);
        goto err_init_NVT_ts;
    }
#endif

    dev_info(&client->dev, "%s: finished\n", __func__);
    NVT_INFO("%s: finished\n",  __func__);
    tpd_load_status = 1;
    return 0;

err_init_NVT_ts:
    free_irq(touch_irq,ts);
err_int_request_failed:
err_input_register_device_failed:
#if BOOT_UPDATE_FIRMWARE
err_create_nvt_fwu_wq_failed:
#endif
    input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
    mutex_destroy(&ts->lock);
err_chipid_failed:
err_check_functionality_failed:
    i2c_set_clientdata(client, NULL);
    kfree(ts);
    return ret; 
}

Tp中断注册函数

static int tpd_irq_registration(void)
{
    struct device_node *node = NULL;
    int ret = 0;

    NVT_INFO("Device Tree tpd_irq_registration!");

    node = of_find_matching_node(node, touch_of_match);

    if (node) {
        /*touch_irq = gpio_to_irq(tpd_int_gpio_number);*/
        touch_irq = irq_of_parse_and_map(node, 0);
        NVT_INFO("touch_irq number %d\n", touch_irq);

        ret = request_irq(touch_irq, tpd_eint_handler, IRQF_TRIGGER_FALLING,
                    TPD_DEVICE, NULL);//申请TP中断,中断处理函数tpd_eint_handler
        if (ret > 0){
            ret = -1;
            NVT_ERROR("tpd request_irq IRQ LINE NOT AVAILABLE!.");
        }
    } else {
        NVT_INFO("tpd request_irq can not find touch eint device node!.");
    }

    return ret;
}

Tp中断处理函数

static irqreturn_t tpd_eint_handler(int irq, void *dev_id)
{
    TPD_DEBUG_PRINT_INT;

    tpd_flag = 1;//中断标记

    wake_up_interruptible(&waiter);//中断触发,唤醒进程

    return IRQ_HANDLED;
}

Tp触摸事件处理函数touch_event_handler

static int touch_event_handler(void *unused)
{
    struct sched_param param = { .sched_priority = 4 }; /*RTPM_PRIO_TPD*/
    struct i2c_client *client = ts->client;

    int32_t ret = -1;
    uint8_t point_data[64] = {0};
    uint32_t position = 0;
    uint32_t input_x = 0;
    uint32_t input_y = 0;
    uint32_t input_w = 0;

    uint8_t point_data1[64] = {0};

    uint8_t input_id = 0;
    uint8_t press_id[TOUCH_MAX_FINGER_NUM] = {0};

    int32_t i = 0;
    int32_t finger_cnt = 0;

    sched_setscheduler(current, SCHED_RR, &param);
    do
    {
        set_current_state(TASK_INTERRUPTIBLE);

        while (tpd_halt_1)
        {
        #if WAKEUP_GESTURE
            //if (bTouchInGesture == 1)
            if (bTouchIsAwake== 0)
            {
                break;
            }
        #endif
            tpd_flag = 0;
            msleep(20);
        }

        wait_event_interruptible(waiter, tpd_flag != 0);//等待触摸中断触发
        tpd_flag = 0;
        TPD_DEBUG_SET_TIME;
        set_current_state(TASK_RUNNING);

        mutex_lock(&ts->lock);
        memset(point_data,0,64);
        ret = CTP_I2C_READ(ts->client, I2C_FW_Address, point_data, 62 + 1);
        if (ret < 0) {
            dev_err(&client->dev, "%s: CTP_I2C_READ failed.(%d)\n", __func__, ret);
            goto XFER_ERROR;
        }

        finger_cnt = 0;
        input_id = (uint8_t)(point_data[1] >> 3);

        memset(press_id,0,10);//0826

        #if WAKEUP_GESTURE
            //if (bTouchInGesture == 1)
            if (bTouchIsAwake== 0){
                nvt_ts_wakeup_gesture_report(input_id);
                mutex_unlock(&ts->lock);
                continue;
            }
        #endif

        #if MT_PROTOCOL_B
            for (i = 0; i < ts->max_touch_num; i++) {
                position = 1 + 6 * i;
                input_id = (uint8_t)(point_data[position + 0] >> 3);
                if (input_id > TOUCH_MAX_FINGER_NUM)
                    continue;

                if (((point_data[position] & 0x07) == 0x01) || ((point_data[position] & 0x07) == 0x02)) {   //finger down (enter & moving)
                    input_x = (uint32_t)(point_data[position + 1] << 4) + (uint32_t) (point_data[position + 3] >> 4);
                    input_y = (uint32_t)(point_data[position + 2] << 4) + (uint32_t) (point_data[position + 3] & 0x0F);
                    input_w = (uint32_t)(point_data[position + 4]) + 10;
                    if (input_w > 255)
                        input_w = 255;

                    if ((input_x < 0) || (input_y < 0))
                        continue;
                    if ((input_x > ts->abs_x_max)||(input_y > ts->abs_y_max))
                        continue;

                    press_id[input_id - 1] = 1;
                    input_mt_slot(ts->input_dev, input_id - 1);
                    input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);

                    input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);
                    input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_y);
                    input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
                    input_report_abs(ts->input_dev, ABS_MT_PRESSURE, input_w);
                //  NVT_INFO("report abs:x=%d, y=%d\n",input_x,input_y);
                    finger_cnt++;
                }
            }

            for (i = 0; i < ts->max_touch_num; i++) {
                if (press_id[i] != 1) {
                    input_mt_slot(ts->input_dev, i);
                    input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
                    input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);
                    input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
                }
            }

            input_report_key(ts->input_dev, BTN_TOUCH, (finger_cnt > 0));

        #else

            for (i = 0; i < ts->max_touch_num; i++) {
                position = 1 + 6 * i;
                input_id = (uint8_t)(point_data[position + 0] >> 3);

                if ((point_data[position] & 0x07) == 0x03) {    // finger up (break)
                    continue;//input_report_key(ts->input_dev, BTN_TOUCH, 0);
                } else if (((point_data[position] & 0x07) == 0x01) || ((point_data[position] & 0x07) == 0x02)) {    //finger down (enter & moving)
                    input_x = (uint32_t)(point_data[position + 1] << 4) + (uint32_t) (point_data[position + 3] >> 4);
                    input_y = (uint32_t)(point_data[position + 2] << 4) + (uint32_t) (point_data[position + 3] & 0x0F);
                    input_w = (uint32_t)(point_data[position + 4]) + 10;
                    if (input_w > 255)
                        input_w = 255;

                    if ((input_x < 0) || (input_y < 0))
                        continue;
                    if ((input_x > ts->abs_x_max)||(input_y > ts->abs_y_max))
                        continue;

                    press_id[input_id - 1] = 1;
                    input_report_key(ts->input_dev, BTN_TOUCH, 1);
                    input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);
                    input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_y);
                    input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
                    input_report_abs(ts->input_dev, ABS_MT_PRESSURE, input_w);
                    input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, input_id - 1);
                //  NVT_INFO("report abs:x=%d, y=%d\n",input_x,input_y);
                    input_mt_sync(ts->input_dev); //上报事件

                    finger_cnt++;
                }
            }
            if (finger_cnt == 0) {
                input_report_key(ts->input_dev, BTN_TOUCH, 0);

                input_mt_sync(ts->input_dev);//上报事件
            }
        #endif


        #if TOUCH_KEY_NUM > 0
          //  NVT_INFO("point_data[61]=0x%x, point_data[62]=0x%x\n",point_data[61],point_data[62]);
            if (point_data[61] == 0xF8) {

                if(point_data1[62] == point_data[62])
                {

                }
                else
                {
                    point_data1[61] = point_data[61];
                    point_data1[62] = point_data[62];
                    NVT_INFO("point_data[61]=0x%x, point_data[62]=0x%x\n",point_data[61],point_data[62]);
                }  

                for (i = 0; i < TOUCH_KEY_NUM; i++) {
                    input_report_key(ts->input_dev, touch_key_array_1[i], ((point_data[62] >> i) & 0x01));//上报触摸按键事件
                }
            } else {
                for (i = 0; i < TOUCH_KEY_NUM; i++) {
                    input_report_key(ts->input_dev, touch_key_array_1[i], 0);
                }
            }
        #endif

        input_sync(ts->input_dev);//上报事件

XFER_ERROR:
        mutex_unlock(&ts->lock);

    } while (!kthread_should_stop());

    return 0;
}
记事本
关注
专栏目录
MTK MT8163 7.0 TP驱动简单移植
qf0727的专栏
12-16 8271
本文只是依照MTK MT8163 7.0框架移植进行的实际操作，基于驱动代码已经ok的情况下，并没有考虑到调试层面，如有需要必须抓log等各种方法进行调试！ 1. GT9xx驱动及驱动文件简介 1.GT9xx驱动基本信息 2.驱动文件说明 2. 驱动移植step by step 3.硬件电路及gpio配置 4.touchscreen中driver复制及
Linux内核打开ilitek,MTK平台TP驱动调用流程分析_kernel-4.4
weixin_32522079的博客
05-01 1511
MTK Touch 驱动的组成Mtk Touch driver 驱动包括：Mtkplatform 虚拟平台设备驱动、Module touch IC驱动、Inputsubsystem。Mtk platform 设备驱动是mtk为了兼容多个touchIC驱动而设计出来的虚拟驱动，它会去遍历每一个touch IC驱动，直到其中一个初始化成功。Linuxinput_subsystem是linux的输入子系...
tmd2771 MTK6737驱动
10-12
mt6737 mt6735 mt6580 android6.0平台 tmd2771驱动。 .
编写MTK6737平台的GPIO驱动例程（三）
Zorry的专栏
07-26 1048
在原先的设备驱动文件上增加上更加方便的交互方式那就是sysfs接口，使用device_create_file用于在sys下创建设备的属性节点。 注意一下device_attribute可以使用一下两种方法初始化   1、使用DEVICE_ATTR初始化结构体device_attribute，下面代码示例： static DEVICE_ATTR(demo, (S_IRUGO | S_IWU...
MT6737 平台TP driver分析(一)
天高任鸟飞海阔凭鱼跃的专栏
01-19 803
1.makefie \kernel-3.18\drivers\input\touchscreen\mediatek\makefile 2. kernel-3.18\drivers\input\touchscreen\mediatek\tpd_common_probe.c 在驱动加载函数tpd_probe_init中直接调用了tpd_device_init函数 3 kernel
联发科MT6737应用
07-10
最详细的联发科MT6737资料，当前低端手机最常见资料，当前民用安卓领域应用最火的芯片，没有之一
Android MTK TP Driver 触屏驱动
C/C#、Android driver、STM32、Linux等等。
04-26 5921
Android MTK TP Driver 触屏驱动 ——— 触屏驱动小结 智能手机驱动在LCD调试OK后,紧接着就是要将TP搞定了。此篇简单介绍了在MTK 6765(Android9.0 / kernel-4.9）环境下的调试focaltech的驱动小结。 目录 Android MTK TP Driver 触屏驱动一、TP启动过程及驱动概述二、修改驱动文件1、添加内核驱动文件（1）驱动文件移植到指定目录（2）修改Kconfig 文件（3）修改Makefile 文件（4）修改内核主文件（5）修改内核驱
MT2503A driver al in one 文档
09-04
### MT2503A Driver All-in-One 文档解析 #### 概述 本文档针对MTK 2503平台提供了全面的驱动配置指南，包括EMI（电磁干扰）、GPIO（通用输入输出）、Audio（音频）、Camera（摄像头）、LCD（液晶显示器）、TP...
mt8788 android9.0 tp egalax_i2c
06-18
标题中的"mt8788 android9.0 tp egalax_i2c"指的是基于Mediatek mt8788芯片的Android 9.0系统，其中涉及到的tp（触摸屏）驱动是egalax_i2c。这个驱动是针对EgisTec（EETI）公司生产的I2C接口的触摸屏进行适配和操作...
MTK平台TP驱动框架解析
Tonghua_D的博客
10-20 4334
一，TP驱动代码的组成 MTK平台TP驱动主要包括两处文件： 1，kernel-3.18\drivers\input\touchscreen\mediatek\mtk_tpd.c 平台设备驱动，主要为了兼容多个不同的TP驱动IC，它会去遍历每一个编译并添加进 tpd_driver_list 中的IC驱动，直到其中一个初始化成功。 2，kernel-3.18\drivers\input\to...
MTK万能驱动
08-12
MTK万能驱动，可以用于几乎所有使用MTK平台的设备，支持Windows系统
过TP驱动测试版
11-04
TP驱动测试版。
MTK智能机USB驱动+刷机必备驱动大全
03-14
MTK智能机USB驱动+刷机必备驱动大全，支持XP_x86，Win7_x86，Win7_x64，Vista_x86，Vista_x64，amd64，自动安装板
MTK 6737平台配置ILI2511TP驱动按键复位影响屏幕显示异常
zjh1036的博客
07-09 625
网上找到一份ILI2511TP 驱动移植到对应的平台上去，打开DMA实现传输。 去掉ilitek_resume 当中的ilitek_reset(ilitek_data->reset_time); 不能拉高复位 bug解决
mtk6580 8.1 如何操作vgp1电压
zxw0775的博客
04-11 1243
今天在调试一个外设时，需要用vgp1控制，需要设置3.3v,一直没有输出来。6580 8.1平台tp默认是用vgp1控制的，用下面的代码是可以输出2.8v的 下面是ft的tp驱动部分 int fts_power_init(void) { int ret; /*set TP volt*/ tpd->reg = regulator_get(tpd->tpd_dev,...
嵌入式linux 驱动中建立进程,Tiny6410学习ing—（四）、嵌入式Linux内核驱动进阶—（5）、Linux进程控制（Proc文件系统）—③...
weixin_28724003的博客
04-28 168
感觉 proc文件系统挺简单的，这倒是省了不少事，呵呵了~~(四)、嵌入式Linux内核驱动进阶(5)、Linux进程控制(Proc文件系统)—③Proc文件系统1、定义Proc 文件系统，是一个特殊的文件系统，内核通过 Proc 文件系统将内核的一些信息输出给用户，/proc目录下的每个文件都可以绑定到一个内核函数上；文件被读写时，被绑定的相应内核函数就会被触发，有这些函数处理文件的输出和输入。...
嵌入式Linux移植代码,嵌入式Linux内核移植相关代码分析
weixin_33047553的博客
05-07 116
本文通过整理之前研发的一个项目(ARM7TDMI + uCLinux)，分析内核启动过程及需要修改的文件，以供内核移植者参考。整理过程中也同时参考了众多网友的帖子，在此谢过。由于整理过程匆忙，难免错误及讲解的不够清楚之处，请各位网友指正，这里提前谢过。本文分以下部分进行介绍：1. Bootloader及内核解压2. 内核启动方式介绍3. 内核启动地址的确定4. arch/armnommu/kern...
TP驱动调试笔记
hismee的博客
12-22 4489
以在mtk6737平台移植汇顶的GT910举例，建议正式调试的前一天把代码完整编译一遍，假如时间来不及，至少要先编译内核，编译eng或者userdebug版本。一般要提前准备：主板、TP模组、串口线、硬件原理图，供应商提供芯片手册、规格书、驱动代码和cfg参数等。 ...
硬件复位芯片SGM4073简介
天高任鸟飞海阔凭鱼跃的专栏
08-29 9789
1、GENERAL DESCRIPTIONThe SGM4073 is both a timer for resetting a mobile device and an advanced load management switch for applications requiring a highly integrated solution. SGM4073既是一个可以复位移动终端设备的定时器
MT6737芯片架构详解
"MT6737是一款由联发科(MediaTek)生产的系统级芯片(SoC)，主要用于智能手机和平板电脑。此芯片的设计包含了多种功能模块，如处理器、无线通信、音频、摄像头、电源管理等，以实现全面的设备集成。在提供的资料中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值