自学教程：C++ HS_LOG函数代码示例

static void usb_headset_detect(int type){    int state_h2w = 0;    int state_usb = 0;    HS_DBG();    mutex_lock(&hi->mutex_lock);    state_h2w = switch_get_state(&hi->sdev_h2w);    switch (type) {    case USB_NO_HEADSET:        hi->usb_headset.type = USB_NO_HEADSET;        hi->usb_headset.status = STATUS_DISCONNECTED;        state_h2w &= ~MASK_USB_HEADSET;        state_usb = GOOGLE_USB_AUDIO_UNPLUG;        HS_LOG_TIME("Remove USB_HEADSET (state %d, %d)",                    state_h2w, state_usb);        break;    case USB_AUDIO_OUT:        hi->usb_headset.type = USB_AUDIO_OUT;        hi->usb_headset.status = STATUS_CONNECTED_ENABLED;        state_h2w |= BIT_USB_AUDIO_OUT;        state_usb = GOOGLE_USB_AUDIO_ANLG;        HS_LOG_TIME("Insert USB_AUDIO_OUT (state %d, %d)",                    state_h2w, state_usb);        break;    default:        HS_LOG("Unknown headset type");    }    switch_set_state(&hi->sdev_h2w, state_h2w);    switch_set_state(&hi->sdev_usb_audio, state_usb);    mutex_unlock(&hi->mutex_lock);}

void headset_ext_detect(int type){	HS_DBG();	switch (type) {	case H2W_NO_HEADSET:		/* Release Key */	case H2W_HEADSET:	case H2W_35MM_HEADSET:	case H2W_REMOTE_CONTROL:	case H2W_USB_CRADLE:	case H2W_UART_DEBUG:	case H2W_TVOUT:		break;	case USB_NO_HEADSET:		/* Release Key */	case USB_AUDIO_OUT:#ifdef CONFIG_SUPPORT_USB_SPEAKER	case USB_AUDIO_OUT_DGTL:#endif		usb_headset_detect(type);		break;	default:		HS_LOG("Unknown headset type");	}}

static void headset_notifier_update(int id){    if (!hi) {        HS_LOG("HS_MGR driver is not ready");        return;    }    switch (id) {    case HEADSET_REG_HPIN_GPIO:        break;    case HEADSET_REG_REMOTE_ADC:        update_mic_status(HS_DEF_MIC_DETECT_COUNT);        break;    case HEADSET_REG_REMOTE_KEYCODE:    case HEADSET_REG_RPC_KEY:        break;    case HEADSET_REG_MIC_STATUS:        update_mic_status(HS_DEF_MIC_DETECT_COUNT);        break;    case HEADSET_REG_MIC_BIAS:    case HEADSET_REG_MIC_SELECT:    case HEADSET_REG_KEY_INT_ENABLE:    case HEADSET_REG_KEY_ENABLE:    case HEADSET_REG_INDICATOR_ENABLE:        break;    default:        break;    }}

static struct file *openFile(char *path,int flag,int mode){	mm_segment_t old_fs;	old_fs = get_fs();	set_fs(KERNEL_DS);	fp=filp_open(path, flag, mode);	set_fs(old_fs);	if(IS_ERR(fp))	   HS_LOG("File Open Error:%s",path);	if(!fp->f_op)	   HS_LOG("File Operation Method Error!!");	if (fp) return fp;	else return NULL;}

int hs_notify_key_event(int key_code){    struct button_work *work;    HS_DBG();    if (hi->hs_35mm_type == HEADSET_UNKNOWN_MIC ||            hi->hs_35mm_type == HEADSET_NO_MIC ||            hi->h2w_35mm_type == HEADSET_NO_MIC)        update_mic_status(HS_DEF_MIC_DETECT_COUNT);    else if (!hs_hpin_stable()) {        HS_LOG("The HPIN is unstable, SKIP THE BUTTON EVENT.");        return 1;    } else {        work = kzalloc(sizeof(struct button_work), GFP_KERNEL);        if (!work) {            HS_ERR("Failed to allocate button memory");            return 1;        }        work->key_code = key_code;        INIT_DELAYED_WORK(&work->key_work, button_35mm_work_func);        queue_delayed_work(button_wq, &work->key_work,                           HS_JIFFIES_BUTTON);    }    return 1;}

static void onewire_init_work_func(struct work_struct *work){    HS_LOG("Open %s", hi->pdata.onewire_tty_dev);    fp = openFile(hi->pdata.onewire_tty_dev,O_CREAT|O_RDWR|O_NONBLOCK,0666);    if (fp != NULL) {        if (!fp->private_data)            HS_LOG("No private data");        else {            HS_LOG("Private data exist");            closeFile(fp);            return;        }    } else        HS_LOG("%s, openFile is NULL pointer/n", __func__);    closeFile(fp);}

int headset_notifier_register(struct headset_notifier *notifier){    if (!notifier->func) {        HS_LOG("NULL register function");        return 0;    }    switch (notifier->id) {    case HEADSET_REG_HPIN_GPIO:        HS_LOG("Register HPIN_GPIO notifier");        hs_mgr_notifier.hpin_gpio = notifier->func;        break;    case HEADSET_REG_REMOTE_ADC:        HS_LOG("Register REMOTE_ADC notifier");        hs_mgr_notifier.remote_adc = notifier->func;        break;    case HEADSET_REG_RPC_KEY:        HS_LOG("Register RPC_KEY notifier");        hs_mgr_notifier.rpc_key = notifier->func;        break;    case HEADSET_REG_MIC_STATUS:        HS_LOG("Register MIC_STATUS notifier");        hs_mgr_notifier.mic_status = notifier->func;        break;    case HEADSET_REG_MIC_BIAS:        HS_LOG("Register MIC_BIAS notifier");        hs_mgr_notifier.mic_bias_enable = notifier->func;        break;    case HEADSET_REG_MIC_SELECT:        HS_LOG("Register MIC_SELECT notifier");        hs_mgr_notifier.mic_select = notifier->func;        break;    case HEADSET_REG_KEY_INT_ENABLE:        HS_LOG("Register KEY_INT_ENABLE notifier");        hs_mgr_notifier.key_int_enable = notifier->func;        break;    case HEADSET_REG_KEY_ENABLE:        HS_LOG("Register KEY_ENABLE notifier");        hs_mgr_notifier.key_enable = notifier->func;        break;    default:        HS_LOG("Unknown register ID");        return 0;    }    return 1;}

static void hs_1wire_deinit(void){	char all_zero = 0xaa;	if (fp) {		if (hi->pdata.tx_level_shift_en)			gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 0);		hr_msleep(20);		writeFile(fp, &all_zero, 1); 		HS_LOG("Write 0xaa to unblock");		hr_msleep(10);		HS_LOG("close file");		closeFile(fp);		fp = NULL;		if (hi->pdata.tx_level_shift_en)			gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);	}}

void headset_button_event(int is_press, int type){	HS_DBG();	if (!hs_hpin_stable()) {		HS_LOG("The HPIN is unstable, SKIP THE BUTTON EVENT.");		return;	}	if (!get_mic_state()) {		HS_LOG("IGNORE key %d (Not support MIC)", type);		return;	}	if (!is_press)		button_released(type);	else if (!atomic_read(&hi->btn_state))		button_pressed(type);}

static void irq_init_work_func(struct work_struct *work){	HS_DBG();	if (hi->pdata.hpin_gpio) {		HS_LOG("Enable detect IRQ");		set_irq_type(hi->hpin_irq, IRQF_TRIGGER_LOW);		enable_irq(hi->hpin_irq);	}	if (hi->pdata.key_gpio) {		HS_LOG("Enable button IRQ");		hi->key_irq_type = IRQF_TRIGGER_LOW;		set_irq_type(hi->key_irq, hi->key_irq_type);		enable_irq(hi->key_irq);	}}

static int headset_1wire_parse_dt(struct htc_hs_1wire_data *wire){    int i,ret = 0;    const char *ttyname;    u32 remoteadc[6] = {0};    struct device_node *dt = wire->dev->of_node;    HS_LOG("%s", __func__);    wire->pdata->tx_level_shift_en = of_get_named_gpio(dt, "hs_1wire,tx_level_shift_en", 0);    if (gpio_is_valid(wire->pdata->tx_level_shift_en)) {        HS_LOG("tx_lv_en:%d", wire->pdata->tx_level_shift_en);    } else        HS_LOG("tx_lv_en parser err");    ret = of_property_read_u32_array(dt, "hs_1wire,one_wire_remote", remoteadc, 6);    if (ret < 0) {        HS_LOG("remote parser failure");    } else {        for (i = 0; i < ARRAY_SIZE(remoteadc); i++) {            wire->pdata->one_wire_remote[i] = (char)remoteadc[i];        }        HS_LOG("remote: %#x %#x %#x", remoteadc[0], remoteadc[1],               remoteadc[2]);    }    ret = of_property_read_string(dt, "hs_1wire,onewire_tty_dev", &ttyname);    if (ret < 0) {        HS_LOG("tty_dev string parser failue");    } else {        snprintf(wire->pdata->onewire_tty_dev, 15, "/dev/%s", ttyname);        HS_LOG("tty=%s", wire->pdata->onewire_tty_dev);    }    return 0;}

static int hs_read_aid(void){	char in_buf[10];	int read_count, i;		read_count = readFile(fp, in_buf, 10);		HS_LOG("[1wire]read_count = %d", read_count);		if (read_count > 0) {			for (i = 0; i < read_count; i++) {				HS_LOG("[1wire]in_buf[%d] = 0x%x", i, in_buf[i]);				if ((in_buf[i] & 0xF0) == 0x80 && in_buf[i] > 0x80) {					hi->aid = in_buf[i];					return 0;				}			}		}	return -1;}

static int hs_gpio_request_irq(unsigned int gpio, unsigned int *irq,			       irq_handler_t handler, unsigned long flags,			       const char *name, unsigned int wake){	int ret = 0;	HS_DBG();	ret = gpio_request(gpio, name);	if (ret < 0)		return ret;	ret = gpio_direction_input(gpio);	if (ret < 0) {		gpio_free(gpio);		return ret;	}	if (!(*irq)) {		ret = gpio_to_irq(gpio);		if (ret < 0) {			gpio_free(gpio);			return ret;		}		HS_LOG("gpio_to_irq ret = %d", ret);		*irq = (unsigned int) ret;	}	HS_LOG("[HS] irq=%d", *irq);	ret = request_irq(*irq, handler, flags, name, NULL);	if (ret < 0) {		gpio_free(gpio);		return ret;	}	ret = set_irq_wake(*irq, wake);	if (ret < 0) {		free_irq(*irq, 0);		gpio_free(gpio);		return ret;	}	return 1;}

static void hs_gpio_uart_set(int value){	value = !!value;	if (value != headset_uart_enable) {		headset_uart_enable = value;		HS_LOG("%s headset uart", value? "enable": "disable");		gpio_set_value(hi->pdata.uart_gpio, value);	}}

static struct file *openFile(char *path,int flag,int mode){	mm_segment_t old_fs;	mutex_lock(&hi->mutex_lock);	old_fs = get_fs();	set_fs(KERNEL_DS);	HS_LOG("Open: fp count = %d", ++fp_count);	fp=filp_open(path, flag, mode);	set_fs(old_fs);	if (!fp)		return NULL;	if(IS_ERR(fp))	   HS_LOG("File Open Error:%s",path);	if(!fp->f_op)	   HS_LOG("File Operation Method Error!!");	return fp;}

static int hs_1wire_report_type(char **string){	const int type_num = 3; /*How many 1-wire accessories supported*/	char *hs_type[] = {		"headset_beats_20",		"headset_mic_midtier",		"headset_beats_solo_20",	};	hi->aid &= 0x7f;	HS_LOG("[1wire]AID = 0x%x", hi->aid);	if (hi->aid > type_num || hi->aid < 1) {		*string = "1wire_unknown";		return 14;	}else {		*string = hs_type[hi->aid - 1];		HS_LOG("Report %s type, size %d", *string, sizeof(hs_type[hi->aid -1]));		return sizeof(hs_type[hi->aid -1]);	}}

int closeFile(struct file *fp){	mm_segment_t old_fs;	old_fs = get_fs();	set_fs(KERNEL_DS);	HS_LOG("Close: fp count = %d", --fp_count);	filp_close(fp,NULL);	set_fs(old_fs);	return 0;}

static int hs_8x60_remote_adc(int *adc){	int ret = 0;	HS_DBG();	ret = pm8058_htc_config_mpp_and_adc_read(adc, 1, CHANNEL_ADC_HDSET,						 hi->pdata.adc_mpp,						 hi->pdata.adc_amux);	if (ret) {		*adc = -1;		HS_LOG("Failed to read remote ADC");		return 0;	}	HS_LOG("Remote ADC %d (0x%X)", *adc, *adc);	return 1;}

static int hs_1wire_report_type(char **string){    const int type_num = 3;    char *hs_type[] = {        "headset_mic_1wire",        "headset_mic_midtier",        "headset_mic_oneseg",    };    hi->aid &= 0x7f;    HS_LOG("[1wire]AID = 0x%x", hi->aid);    if (hi->aid > type_num || hi->aid < 1) {        *string = "1wire_unknown";        return 14;    } else {        *string = hs_type[hi->aid - 1];        HS_LOG("Report %s type, size %d", *string, sizeof(hs_type[hi->aid -1]));        return sizeof(hs_type[hi->aid -1]);    }}

/*One-wire button event handler*/int button_1wire_work_func(){	int cnt = 0;	char a_buf[20];	int count = 0;	int r,bflag;	int key = 99;	while(1){		bflag=0;		r=readFile(fp,a_buf,10);		if(r>0){			HS_LOG("Read %d bytes, count:%d, %s",r,count,a_buf);			for(cnt = 0; cnt < r; cnt++){				HS_LOG("0x%x /n", (int) a_buf[cnt]);				if ((int)a_buf[cnt]==123){					key = 3;					bflag=1;				}				if ((int)a_buf[cnt]==125){					key = 1;					bflag=1;				}				if ((int)a_buf[cnt]==126){					key = 2;					bflag=1;				}				if ((int)a_buf[cnt]==127){					key = 0;					bflag=1;			}		}		}		count++;		if(bflag == 1 || count == CHECK_COUNT)			break;		msleep(1);	}	return key;}

static int hs_pmic_remote_threshold(uint32_t adc){	int i = 0;	int ret = 0;	uint32_t status;	struct hs_pmic_rpc_request req;	struct hs_pmic_rpc_reply rep;	HS_DBG_LOG();	if (!(pmic_info->pdata.driver_flag & DRIVER_HS_PMIC_DYNAMIC_THRESHOLD))		return 0;	req.hs_controller = cpu_to_be32(pmic_info->pdata.hs_controller);	req.hs_switch = cpu_to_be32(pmic_info->pdata.hs_switch);	req.current_uA = cpu_to_be32(HS_PMIC_HTC_CURRENT_THRESHOLD);	for (i = 0; i < ARRAY_SIZE(current_threshold_lut); i++) {		if (adc >= current_threshold_lut[i].adc_min &&		    adc <= current_threshold_lut[i].adc_max)			req.current_uA = cpu_to_be32(current_threshold_lut[i].						     current_uA);	}	ret = msm_rpc_call_reply(endpoint_current,				 HS_PMIC_RPC_CLIENT_PROC_THRESHOLD,				 &req, sizeof(req), &rep, sizeof(rep),				 HS_RPC_TIMEOUT);	if (ret < 0) {		HS_LOG("Failed to send remote threshold RPC");		return 0;	} else {		status = be32_to_cpu(rep.status);		if (status != HS_PMIC_RPC_ERR_SUCCESS) {			HS_LOG("Failed to set remote threshold");			return 0;		}	}	return 1;}

int hs_notify_key_event(int key_code){	struct button_work *work;	HS_DBG();	if (hi->hs_35mm_type == HEADSET_INDICATOR) {		HS_LOG("Not support remote control");		return 1;	}	if (hi->hs_35mm_type == HEADSET_UNKNOWN_MIC ||	    hi->hs_35mm_type == HEADSET_NO_MIC ||	    hi->h2w_35mm_type == HEADSET_NO_MIC)		update_mic_status(HS_DEF_MIC_DETECT_COUNT);	else if (hi->hs_35mm_type == HEADSET_UNSTABLE)		update_mic_status(0);	else if (!hs_hpin_stable()) {		HS_LOG("IGNORE key %d (Unstable HPIN)", key_code);		return 1;	} else if (hi->hs_35mm_type == HEADSET_UNPLUG && hi->is_ext_insert == 1) {		HS_LOG("MIC status is changed from float, re-polling to decide accessory type");		update_mic_status(HS_DEF_MIC_DETECT_COUNT);		return 1;	} else if (hi->hs_35mm_type == HEADSET_UNPLUG && hi->is_ext_insert == 1) {		HS_LOG("MIC status is changed from float, re-polling to decide accessory type");		update_mic_status(HS_DEF_MIC_DETECT_COUNT);		return 1;	} else {		work = kzalloc(sizeof(struct button_work), GFP_KERNEL);		if (!work) {			HS_ERR("Failed to allocate button memory");			return 1;		}		work->key_code = key_code;		INIT_DELAYED_WORK(&work->key_work, button_35mm_work_func);		queue_delayed_work(button_wq, &work->key_work,				   HS_JIFFIES_BUTTON);	}	return 1;}

static void enable_metrico_headset(int enable){	HS_DBG();	if (enable && !hi->metrico_status) {#if 0		enable_mos_test(1);#endif		hi->metrico_status = 1;		HS_LOG("Enable metrico headset");	}	if (!enable && hi->metrico_status) {#if 0		enable_mos_test(0);#endif		hi->metrico_status = 0;		HS_LOG("Disable metrico headset");	}}

void headset_button_event(int is_press, int type){	HS_DBG();	if (hi->hs_35mm_type == HEADSET_UNPLUG &&	    hi->h2w_35mm_type == HEADSET_UNPLUG) {		HS_LOG("IGNORE key %d (HEADSET_UNPLUG)", type);		return;	}	if (!hs_hpin_stable()) {		HS_LOG("IGNORE key %d (Unstable HPIN)", type);		return;	}	if (!is_press)		button_released(type);	else if (!atomic_read(&hi->btn_state))		button_pressed(type);}

static void button_35mm_work_func(struct work_struct *work){    int key;    struct button_work *works;    wake_lock_timeout(&hi->hs_wake_lock, HS_WAKE_LOCK_TIMEOUT);    HS_DBG();    works = container_of(work, struct button_work, key_work.work);    hi->key_level_flag = works->key_code;    if (hi->key_level_flag) {        switch (hi->key_level_flag) {        case 1:            HS_LOG("3.5mm RC: Play Pressed");            key = HS_MGR_KEYCODE_MEDIA;            break;        case 2:            HS_LOG("3.5mm RC: BACKWARD Pressed");            key = HS_MGR_KEYCODE_BACKWARD;            break;        case 3:            HS_LOG("3.5mm RC: FORWARD Pressed");            key = HS_MGR_KEYCODE_FORWARD;            break;        default:            HS_LOG("3.5mm RC: WRONG Button Pressed");            kfree(works);            return;        }        headset_button_event(1, key);    } else { /* key release */        if (atomic_read(&hi->btn_state))            headset_button_event(0, atomic_read(&hi->btn_state));        else            HS_LOG("3.5mm RC: WRONG Button Release");    }    kfree(works);}

static void update_mic_status(int count){	HS_DBG();	if (hi->is_ext_insert) {		HS_LOG("Start MIC status polling (%d)", count);		cancel_delayed_work_sync(&mic_detect_work);		hi->mic_detect_counter = count;		queue_delayed_work(detect_wq, &mic_detect_work,				   HS_JIFFIES_MIC_DETECT);	}}

static int hs_pmic_remote_adc(int *adc){	int ret = 0;	struct rpc_request_hdr req;	struct hs_rpc_client_rep_adc rep;	HS_DBG_LOG();	ret = msm_rpc_call_reply(endpoint_adc, HS_RPC_CLIENT_PROC_ADC,				 &req, sizeof(req), &rep, sizeof(rep),				 HS_RPC_TIMEOUT);	if (ret < 0) {		HS_LOG("Failed to read remote ADC");		return 0;	}	*adc = (int) be32_to_cpu(rep.adc);	HS_LOG("Remote ADC %d (0x%X)", *adc, *adc);	return 1;}

int closeFile(struct file *fp){    mm_segment_t old_fs;    old_fs = get_fs();    set_fs(KERNEL_DS);    HS_LOG("Close: fp count = %d", --fp_count);    filp_close(fp,NULL);    set_fs(old_fs);    mutex_unlock(&hi->mutex_lock);    wake_unlock(&onewire_open_wake_lock);    return 0;}

/*One-wire button event handler*/int button_1wire_work_func(){	int cnt = 0;	char a_buf[20];	int count = 0;	int r,bflag;	while(1){		bflag=0;		r=readFile(fp,a_buf,10);		if(r>0){			HS_LOG("Read %d bytes, count:%d, %s",r,count,a_buf);			for(cnt = 0; cnt < r; cnt++){				HS_LOG("0x%x /n", (int) a_buf[cnt]);				if ((int)a_buf[cnt]==49){					hi->key_level_flag = 3;					bflag=1;				}				if ((int)a_buf[cnt]==50){					hi->key_level_flag = 1;					bflag=1;				}				if ((int)a_buf[cnt]==51){					hi->key_level_flag = 2;					bflag=1;				}				if ((int)a_buf[cnt]==52)					bflag=1;			}		}		count++;		if(bflag == 1 || count == CHECK_COUNT)			break;		msleep(1);	}	return 1;}

static void cancel_button_work_func(struct work_struct *work){	int counter = 10, ret = 0;	HS_DBG();	ret = cancel_delayed_work(&button_gpio_work);	if (ret)            HS_LOG("cancel_delayed_work &button_gpio_work ok");	while(counter--)	{		if(queue_delayed_work(button_wq, &button_gpio_work, unstable_jiffies))		{		    HS_LOG("queue_delayed_work &button_gpio_work ok");		    break;		}		msleep(2);	}	queue_delayed_work(button_wq, &hs_key_irq_enable, irq_delay);}