Ejemplos de hs_rpc_init en C++ (Cpp)

Ejemplo n.º 1

Archivo: rpc_server_handset.c Proyecto: fqazi/Alcatel-OT980-Kernel

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "amss2w";//"h2w";//changed by flin to fix the framework detect 
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		ipdev->name = pdev->dev.platform_data;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc)
		goto err_hs_rpc_init;

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 2

Archivo: rpc_server_handset.c Proyecto: justsoso8/kernel_zte_n780

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_WAKEUP);
	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	
	 //disable KEY_END, enable KEY_SLEEP
	//input_set_capability(ipdev, EV_KEY, KEY_END);
	input_set_capability(ipdev, EV_KEY, KEY_SLEEP);
	
	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}
   
   #if defined(CONFIG_ZTE_PLATFORM)
	wake_lock_init(&hs_wake_lock, WAKE_LOCK_SUSPEND, "hs");
   #endif
   

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 3

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}
#ifdef CONFIG_FEATURE_KCC_F45
	g_init_flag = true;
	if (kc_changer_ic_is_audio(kc_changer_ic_get_accessory())) {
		kc_hs_jack_change_state(true);
	}
#endif

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 4

Archivo: rpc_server_handset.c Proyecto: ISTweak/android_kernel_sharp_msm7x30

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

#if 1
	struct api_remote_req_t1 {
		struct rpc_request_hdr hdr;
	} send_p;
#endif

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

#ifdef FLIP_USE	/* FLIP */
	hs->sdev_flip.name	= "flip";
	hs->sdev_flip.print_name = msm_flip_print_name;
	
	rc = switch_dev_register(&hs->sdev_flip);
	if (rc)
		goto err_switch_dev_register;
		
	hs->sdev_flip_chatt.name	= "flip_chatt";
	hs->sdev_flip_chatt.print_name = msm_flip_chatt_print_name;
	
	rc = switch_dev_register(&hs->sdev_flip_chatt);
	if (rc)
		goto err_switch_dev_register;
#endif
#if 0	
	hs->sdev_hssw.name	= "headphone_switch";
	hs->sdev_hssw.print_name = msm_hssw_print_name;
	
	rc = switch_dev_register(&hs->sdev_hssw);
	if (rc)
		goto err_switch_dev_register;
#endif
	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;


	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

#if 0
	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);
#else
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
#endif
#ifdef FLIP_USE	/* FLIP */
	input_set_capability(ipdev, EV_SW, SW_LID);
	
#ifdef CONFIG_PERF_LOCK_ENABLE
	perf_lock_init(&flip_perf_lock, PERF_LOCK_HIGHEST, "Flip");
#endif
	
#endif

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

#if 1
	rc = msm_rpc_call_reply(rpc_svc_p,
							HS_SHEXTDET_API_INITIALIZE_REMOTE_PROC,
							&send_p,sizeof(send_p),
							NULL,0,
							5 * HZ);
	if(rc)
		goto err_hs_rpc_init;
#endif

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
#ifdef FLIP_USE	/* FLIP */
	switch_dev_unregister(&hs->sdev_flip);
	switch_dev_unregister(&hs->sdev_flip_chatt);
#endif
#if 0
	switch_dev_unregister(&hs->sdev_hssw);
#endif
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 5

Archivo: rpc_server_handset.c Proyecto: hiikezoe/android_kernel_fujitsu_f11d

static int __devinit hs_probe(struct platform_device *pdev)
{
    int rc = 0;
    struct input_dev *ipdev;

    hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
    if (!hs)
        return -ENOMEM;

    hs->sdev.name	= "h2w";
    hs->sdev.print_name = msm_headset_print_name;

    rc = switch_dev_register(&hs->sdev);
    if (rc)
        goto err_switch_dev_register;

    ipdev = input_allocate_device();
    if (!ipdev) {
        rc = -ENOMEM;
        goto err_alloc_input_dev;
    }
    input_set_drvdata(ipdev, hs);

    hs->ipdev = ipdev;

    if (pdev->dev.platform_data)
        hs->hs_pdata = pdev->dev.platform_data;

    if (hs->hs_pdata->hs_name)
        ipdev->name = hs->hs_pdata->hs_name;
    else
        ipdev->name	= DRIVER_NAME;

    ipdev->id.vendor	= 0x0001;
    ipdev->id.product	= 1;
    ipdev->id.version	= 1;

    input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
    input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
    input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
    input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
    input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
    input_set_capability(ipdev, EV_KEY, KEY_POWER);
    input_set_capability(ipdev, EV_KEY, KEY_END);
#if defined(T_QCI_IS3)
    input_set_capability(ipdev, EV_KEY, KEY_CHG_ST_NONE);
    input_set_capability(ipdev, EV_KEY, KEY_CHG_ST_OVP);
    input_set_capability(ipdev, EV_KEY, KEY_CHG_ST_OVC);
    input_set_capability(ipdev, EV_KEY, KEY_CHG_ST_OVD);
    input_set_capability(ipdev, EV_KEY, KEY_CHG_ST_EXP);
    input_set_capability(ipdev, EV_KEY, KEY_TEMP_MSM_OVER_LEYER_1);
    input_set_capability(ipdev, EV_KEY, KEY_TEMP_MSM_OVER_LEYER_2);
    input_set_capability(ipdev, EV_KEY, KEY_TEMP_MSM_OVER_LEYER_3);
    input_set_capability(ipdev, EV_KEY, KEY_TEMP_MSM_OVER_RESUME_NORMAL);
#endif

    rc = input_register_device(ipdev);
    if (rc) {
        dev_err(&ipdev->dev,
                "hs_probe: input_register_device rc=%d\n", rc);
        goto err_reg_input_dev;
    }

    platform_set_drvdata(pdev, hs);

    rc = hs_rpc_init();
    if (rc) {
        dev_err(&ipdev->dev, "rpc init failure\n");
        goto err_hs_rpc_init;
    }

#if defined(T_QCI_IS3)
    qci_set_chg_err_key_ready();
#endif

    return 0;

err_hs_rpc_init:
    input_unregister_device(ipdev);
    ipdev = NULL;
err_reg_input_dev:
    input_free_device(ipdev);
err_alloc_input_dev:
    switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
    kfree(hs);
    return rc;
}

Ejemplo n.º 6

Archivo: rpc_server_handset.c Proyecto: ghk/StreakKernel

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);


  
  pwrkey_down = 0;
  INIT_DELAYED_WORK(&pwrkey_work, pwrkey_work_func);
  pwrkey_wqueue = create_singlethread_workqueue("pwrkey_workqueue");
  if(pwrkey_wqueue) 
  {
    printk("[KEY]Enable feature: Power Key 8 sec, then power down!\n");
  }
  else  
  {
    printk("[KEY]pwrkey_wqueue create FAIL!\n");
    goto err_hs_rpc_init;
  }
  

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 7

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;
	printk(" hs_probe start. \n"); //ps2 p13106
	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;
////////////////////////////////////////////////////////////////////////////////////

#if defined(T_LASER2)
	printk(" CONFIG_MACH_MSM8X55_LASER2 hs_probe start. \n"); //ps2 p13106
	
	hs->type=EARJACK_STATE_OFF;
	hs->hs_on=hs->mic_on=0;
	hs->remotekey_pressed = 0;
	hs->remotekey_first = 0;
  hs->remotekey_count=0;
  #if (BOARD_VER > WS20 )
  // Initialize Voltage Mic bias
  vreg_Earjack_GP6 = vreg_get(NULL, "gp6");
	rc = vreg_set_level(vreg_Earjack_GP6, 2700);
	if (rc) {
		printk(KERN_ERR "%s: vreg_Earjack_GP6 set level failed (%d)\n", __func__, rc);
		return -1;
	}

	rc = vreg_disable(vreg_Earjack_GP6);
	if (rc) {
		printk(KERN_ERR "%s: #include <mach/vreg.h> enable failed (%d)\n", __func__, rc);
		return -1;
	}	
  #endif //(BOARD_VER > WS20 )

	// Initialize Work Queue
	INIT_DELAYED_WORK(&earjack_work,earjack_detect_func);          // INIT WORK
	INIT_DELAYED_WORK(&remotekey_work,remotekey_detect_func);

	// Initialize Wakelocks
	wake_lock_init(&earjack_wake_lock, WAKE_LOCK_SUSPEND, "earjack_wake_lock_init");
	wake_lock_init(&remotekey_wake_lock, WAKE_LOCK_SUSPEND, "remotekey_wake_lock_init");

	// Get GPIO's
	gpio_request(EARJACK_DET, "earjack_det");
	gpio_request(REMOTEKEY_DET, "remotekey_det");
	gpio_tlmm_config(GPIO_CFG(EARJACK_DET, 0, GPIO_CFG_INPUT,GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	rc = request_irq(gpio_to_irq(EARJACK_DET), Earjack_Det_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "earjack_det-irq", hs);

	gpio_tlmm_config(GPIO_CFG(REMOTEKEY_DET, 0, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	rc = request_irq(gpio_to_irq(REMOTEKEY_DET), Remotekey_Det_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "remotekey-irq", hs);

	// Init Mutex
	set_irq_wake(gpio_to_irq(EARJACK_DET), 1);
	set_irq_wake(gpio_to_irq(REMOTEKEY_DET), 1);

  // check earjack is inserted
	wake_lock(&earjack_wake_lock);
	schedule_delayed_work(&earjack_work, 10);    // after 100ms start function of earjack_detect_func
	
	
#endif // defined(T_LASER2)


	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 8

Archivo: rpc_server_handset.c Proyecto: Californication/lge-kernel-msm7x27-ics-3.0.8

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	/* LGE_UPDATE_S	myunghee.kim 2011.12.09 						*/
	/* WiredAccessoryObserver.java check h2w device not h2w_headset for headset detecdtion */
	/* so we modified board-u0-sound.c & this file						*/
	/* modify here because of OS Upgrade							*/
	/* original code : hs->sdev.name	= "h2w";					*/
	hs->sdev.name	= "h2w_handset";
	/* LGE_UPDATE_E										*/
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 9

Archivo: rpc_server_handset.c Proyecto: Devil-KernelHacker/IM-A710K-Nova_Kernel-Project

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);
	#ifdef CONFIG_EF18_BOARD // shpark
	/*input_set_capability(ipdev, EV_KEY, KEY_SEND);*/
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	#endif
#ifdef FEATURE_SKY_CHG_LOGO
	input_set_capability(ipdev, EV_KEY, KEY_BATTERY);
#endif

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

	#ifdef CONFIG_EF18_BOARD
	rc = sysfs_create_group(&pdev->dev.kobj, &dev_attr_grp);
    if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: sysfs_create_group rc=%d\n", rc);
		goto err_hs_rpc_init;
	}
	#endif

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}

Ejemplo n.º 10

Archivo: rpc_server_handset.c Proyecto: effortless/2.6.35

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

#ifndef CONFIG_LGE_HEADSET
	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;
#endif

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
#ifdef CONFIG_MACH_MSM7X27_ALOHAV
	input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
#endif
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
#ifndef CONFIG_LGE_HEADSET
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
#endif
	kfree(hs);
	return rc;
}

Ejemplo n.º 11

Archivo: rpc_server_handset.c Proyecto: tsuyo-kou/KTG_Kernel

static int __devinit hs_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct input_dev *ipdev;

	hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
	if (!hs)
		return -ENOMEM;

	hs->sdev.name	= "h2w";
	hs->sdev.print_name = msm_headset_print_name;

	rc = switch_dev_register(&hs->sdev);
	if (rc)
		goto err_switch_dev_register;

	ipdev = input_allocate_device();
	if (!ipdev) {
		rc = -ENOMEM;
		goto err_alloc_input_dev;
	}
	input_set_drvdata(ipdev, hs);

	hs->ipdev = ipdev;

	if (pdev->dev.platform_data)
		hs->hs_pdata = pdev->dev.platform_data;

	if (hs->hs_pdata->hs_name)
		ipdev->name = hs->hs_pdata->hs_name;
	else
		ipdev->name	= DRIVER_NAME;

	ipdev->id.vendor	= 0x0001;
	ipdev->id.product	= 1;
	ipdev->id.version	= 1;

	input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
	input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
	input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
	input_set_capability(ipdev, EV_KEY, KEY_POWER);
	input_set_capability(ipdev, EV_KEY, KEY_END);

	rc = input_register_device(ipdev);
	if (rc) {
		dev_err(&ipdev->dev,
				"hs_probe: input_register_device rc=%d\n", rc);
		goto err_reg_input_dev;
	}

	platform_set_drvdata(pdev, hs);

	rc = hs_rpc_init();
	if (rc) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}

        /* Initialize timer for emulating end key */
        init_timer(&hs->endkey_timer);
        hs->endkey_timer.function = endkey_timeout;
        hs->endkey_timer.data = (unsigned long)hs;

	return 0;

err_hs_rpc_init:
	input_unregister_device(ipdev);
	ipdev = NULL;
err_reg_input_dev:
	input_free_device(ipdev);
err_alloc_input_dev:
	switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
	kfree(hs);
	return rc;
}