static void musb_id_pin_work(struct work_struct *data)
{
    u8 devctl = 0;
    unsigned long flags;

    spin_lock_irqsave(&mtk_musb->lock, flags);
    musb_generic_disable(mtk_musb);
    spin_unlock_irqrestore(&mtk_musb->lock, flags);

	down(&mtk_musb->musb_lock);
	DBG(0, "work start, is_host=%d\n", mtk_musb->is_host);
	if(mtk_musb->in_ipo_off) {
		DBG(0, "do nothing due to in_ipo_off\n");
		goto out;
	}

	mtk_musb ->is_host = musb_is_host();
	DBG(0,"musb is as %s\n",mtk_musb->is_host?"host":"device");
	switch_set_state((struct switch_dev *)&otg_state, mtk_musb->is_host);

	if (mtk_musb->is_host) {
		//setup fifo for host mode
		ep_config_from_table_for_host(mtk_musb);
		wake_lock(&mtk_musb->usb_lock);
		musb_platform_set_vbus(mtk_musb, 1);

        /* for no VBUS sensing IP*/
        #if 1
		/* wait VBUS ready */
		msleep(100);
		/* clear session*/
		devctl = musb_readb(mtk_musb->mregs,MUSB_DEVCTL);
		musb_writeb(mtk_musb->mregs, MUSB_DEVCTL, (devctl&(~MUSB_DEVCTL_SESSION)));
		/* USB MAC OFF*/
		/* VBUSVALID=0, AVALID=0, BVALID=0, SESSEND=1, IDDIG=X */
		USBPHY_SET8(0x6c, 0x10);
		USBPHY_CLR8(0x6c, 0x2e);
		USBPHY_SET8(0x6d, 0x3e);
		DBG(0,"force PHY to idle, 0x6d=%x, 0x6c=%x\n",USBPHY_READ8(0x6d), USBPHY_READ8(0x6c));
		/* wait */
		msleep(5);
		/* restart session */
		devctl = musb_readb(mtk_musb->mregs,MUSB_DEVCTL);
		musb_writeb(mtk_musb->mregs, MUSB_DEVCTL, (devctl| MUSB_DEVCTL_SESSION));
		/* USB MAC ONand Host Mode*/
		/* VBUSVALID=1, AVALID=1, BVALID=1, SESSEND=0, IDDIG=0 */
		USBPHY_CLR8(0x6c, 0x10);
		USBPHY_SET8(0x6c, 0x2c);
		USBPHY_SET8(0x6d, 0x3e);
		DBG(0,"force PHY to host mode, 0x6d=%x, 0x6c=%x\n",USBPHY_READ8(0x6d), USBPHY_READ8(0x6c));
        #endif

		musb_start(mtk_musb);
		MUSB_HST_MODE(mtk_musb);
		switch_int_to_device(mtk_musb);
	} else {
		DBG(0,"devctl is %x\n",musb_readb(mtk_musb->mregs,MUSB_DEVCTL));
		musb_writeb(mtk_musb->mregs,MUSB_DEVCTL,0);
		if (wake_lock_active(&mtk_musb->usb_lock))
			wake_unlock(&mtk_musb->usb_lock);
		musb_platform_set_vbus(mtk_musb, 0);

        /* for no VBUS sensing IP */
        #if 1
        /* USB MAC OFF*/
		/* VBUSVALID=0, AVALID=0, BVALID=0, SESSEND=1, IDDIG=X */
		USBPHY_SET8(0x6c, 0x10);
		USBPHY_CLR8(0x6c, 0x2e);
		USBPHY_SET8(0x6d, 0x3e);
		DBG(0,"force PHY to idle, 0x6d=%x, 0x6c=%x\n", USBPHY_READ8(0x6d), USBPHY_READ8(0x6c));
        #endif

		musb_stop(mtk_musb);
		//ALPS00849138
		mtk_musb->xceiv->state =  OTG_STATE_B_IDLE;
		MUSB_DEV_MODE(mtk_musb);
		switch_int_to_host(mtk_musb);
	}
out:
	DBG(0, "work end, is_host=%d\n", mtk_musb->is_host);
	up(&mtk_musb->musb_lock);

}
Beispiel #2
0
static void pm8058_drvx_led_brightness_set(struct led_classdev *led_cdev,
					   enum led_brightness brightness)
{
	struct pm8058_led_data *ldata;
	int *pduties;
	int id, mode;
	int lut_flag;
	int milliamps;
	int enable = 0;

	ldata = container_of(led_cdev, struct pm8058_led_data, ldev);

	pwm_disable(ldata->pwm_led);
	cancel_delayed_work_sync(&ldata->led_delayed_work);

	id = bank_to_id(ldata->bank);
	mode = (id == PM_PWM_LED_KPD) ? PM_PWM_CONF_PWM1 :
					PM_PWM_CONF_PWM1 + (ldata->bank - 4);

	brightness = (brightness > LED_FULL) ? LED_FULL : brightness;
	brightness = (brightness < LED_OFF) ? LED_OFF : brightness;
	LED_INFO_LOG("%s: bank %d brightness %d +\n", __func__,
	       ldata->bank, brightness);

	enable = (brightness) ? 1 : 0;
	if (strcmp(ldata->ldev.name, "charming-led") == 0)
		charming_led_enable(enable);

	lut_flag = ldata->lut_flag & ~(PM_PWM_LUT_LOOP | PM_PWM_LUT_REVERSE);

	if (brightness) {
		milliamps = (ldata->flags & PM8058_LED_DYNAMIC_BRIGHTNESS_EN) ?
			    ldata->out_current * brightness / LED_FULL :
			    ldata->out_current;
		pm8058_pwm_config_led(ldata->pwm_led, id, mode, milliamps);
		if (ldata->flags & PM8058_LED_LTU_EN) {
			pduties = &duties[ldata->start_index];
			pm8058_pwm_lut_config(ldata->pwm_led,
					      ldata->period_us,
					      pduties,
					      ldata->duty_time_ms,
					      ldata->start_index,
					      ldata->duites_size,
					      0, 0,
					      lut_flag);
			pm8058_pwm_lut_enable(ldata->pwm_led, 0);
			pm8058_pwm_lut_enable(ldata->pwm_led, 1);
		} else {
			pwm_config(ldata->pwm_led, 64000, 64000);
			pwm_enable(ldata->pwm_led);
		}
	} else {
		if (ldata->flags & PM8058_LED_LTU_EN) {
			wake_lock(&pmic_led_wake_lock);
			pduties = &duties[ldata->start_index +
					  ldata->duites_size];
			pm8058_pwm_lut_config(ldata->pwm_led,
					      ldata->period_us,
					      pduties,
					      ldata->duty_time_ms,
					      ldata->start_index +
					      ldata->duites_size,
					      ldata->duites_size,
					      0, 0,
					      lut_flag);
			pm8058_pwm_lut_enable(ldata->pwm_led, 1);
			queue_delayed_work(g_led_work_queue,
					   &ldata->led_delayed_work,
					   msecs_to_jiffies(ldata->duty_time_ms * ldata->duty_time_ms));

			LED_INFO_LOG("%s: bank %d fade out brightness %d -\n", __func__,
			ldata->bank, brightness);
			return;
		} else
			pwm_disable(ldata->pwm_led);
		pm8058_pwm_config_led(ldata->pwm_led, id, mode, 0);
	}
	LED_INFO_LOG("%s: bank %d brightness %d -\n", __func__, ldata->bank, brightness);
}
static void smd_tty_notify(void *priv, unsigned event)
{
	struct smd_tty_info *info = priv;
	struct tty_struct *tty;
	unsigned long flags;

	switch (event) {
	case SMD_EVENT_DATA:
		spin_lock_irqsave(&info->reset_lock, flags);
		if (!info->is_open) {
			spin_unlock_irqrestore(&info->reset_lock, flags);
			break;
		}
		spin_unlock_irqrestore(&info->reset_lock, flags);
		/* There may be clients (tty framework) that are blocked
		 * waiting for space to write data, so if a possible read
		 * interrupt came in wake anyone waiting and disable the
		 * interrupts
		 */
		if (smd_write_avail(info->ch)) {
			smd_disable_read_intr(info->ch);
			tty = tty_port_tty_get(&info->port);
			if (tty)
				wake_up_interruptible(&tty->write_wait);
			tty_kref_put(tty);
		}
		spin_lock_irqsave(&info->ra_lock, flags);
		if (smd_read_avail(info->ch)) {
			wake_lock(&info->ra_wake_lock);
			tasklet_hi_schedule(&info->tty_tsklt);
		}
		spin_unlock_irqrestore(&info->ra_lock, flags);
		break;

	case SMD_EVENT_OPEN:
		spin_lock_irqsave(&info->reset_lock, flags);
		info->in_reset = 0;
		info->in_reset_updated = 1;
		info->is_open = 1;
		wake_up_interruptible(&info->ch_opened_wait_queue);
		spin_unlock_irqrestore(&info->reset_lock, flags);
		break;

	case SMD_EVENT_CLOSE:
		spin_lock_irqsave(&info->reset_lock, flags);
		info->in_reset = 1;
		info->in_reset_updated = 1;
		info->is_open = 0;
		wake_up_interruptible(&info->ch_opened_wait_queue);
		spin_unlock_irqrestore(&info->reset_lock, flags);
		/* schedule task to send TTY_BREAK */
		tasklet_hi_schedule(&info->tty_tsklt);

		tty = tty_port_tty_get(&info->port);
		if (tty->index == LOOPBACK_IDX)
			schedule_delayed_work(&loopback_work,
					msecs_to_jiffies(1000));
		tty_kref_put(tty);
		break;
#ifdef CONFIG_LGE_USES_SMD_DS_TTY
		/*           
                                                        
                                                    
                                                 
                                                       
                                                       
                                                   
                                                       
                                                 
                                     
   */
	case SMD_EVENT_REOPEN_READY:
		/* smd channel is closed completely */
		spin_lock_irqsave(&info->reset_lock, flags);
		info->in_reset = 1;
		info->in_reset_updated = 1;
		info->is_open = 0;
		wake_up_interruptible(&info->ch_opened_wait_queue);
		spin_unlock_irqrestore(&info->reset_lock, flags);
		break;
#endif
	}
}
Beispiel #4
0
static inline void lock_pm_wake(struct modem_link_pm *pm)
{
	if (!wake_lock_active(&pm->wlock))
		wake_lock(&pm->wlock);
}
/*
 * Internal function. Schedule delayed work in the MMC work queue.
 */
static int mmc_schedule_delayed_work(struct delayed_work *work,
				     unsigned long delay)
{
	wake_lock(&mmc_delayed_work_wake_lock);
	return queue_delayed_work(workqueue, work, delay);
}
Beispiel #6
0
/*----------------------------------------------------------
 *	fcsmd_open
 *---------------------------------------------------------*/
static int fcsmd_open (struct inode *inode, struct file *filp)
{
	wake_lock(&fcsmd_wakelock);
	return 0;
}
static int snddev_icodec_open_rx(struct snddev_icodec_state *icodec)
{
	int trc, err;
	int smps_mode = PMAPP_SMPS_MODE_VOTE_PWM;
	struct msm_afe_config afe_config;
	struct snddev_icodec_drv_state *drv = &snddev_icodec_drv;
	struct lpa_codec_config lpa_config;

	wake_lock(&drv->rx_idlelock);

	if ((icodec->data->acdb_id == ACDB_ID_HEADSET_SPKR_MONO) ||
		(icodec->data->acdb_id == ACDB_ID_HEADSET_SPKR_STEREO)) {
		/* Vote PMAPP_SMPS_MODE_VOTE_PFM for headset */
		smps_mode = PMAPP_SMPS_MODE_VOTE_PFM;
		MM_DBG("snddev_icodec_open_rx: PMAPP_SMPS_MODE_VOTE_PFM \n");
	} else
		MM_DBG("snddev_icodec_open_rx: PMAPP_SMPS_MODE_VOTE_PWM \n");

	/* Vote for SMPS mode*/
	err = pmapp_smps_mode_vote(SMPS_AUDIO_PLAYBACK_ID,
				PMAPP_VREG_S4, smps_mode);
	if (err != 0)
		MM_ERR("pmapp_smps_mode_vote error %d\n", err);

	/* enable MI2S RX master block */
	/* enable MI2S RX bit clock */
	trc = clk_set_rate(drv->rx_mclk,
		SNDDEV_ICODEC_CLK_RATE(icodec->sample_rate));
	if (IS_ERR_VALUE(trc))
		goto error_invalid_freq;
	clk_enable(drv->rx_mclk);
	clk_enable(drv->rx_sclk);
	/* clk_set_rate(drv->lpa_codec_clk, 1); */ /* Remove if use pcom */
	clk_enable(drv->lpa_p_clk);
	clk_enable(drv->lpa_codec_clk);
	clk_enable(drv->lpa_core_clk);

	/* Enable LPA sub system
	 */
	drv->lpa = lpa_get();
	if (!drv->lpa)
		goto error_lpa;
	lpa_config.sample_rate = icodec->sample_rate;
	lpa_config.sample_width = 16;
	lpa_config.output_interface = LPA_OUTPUT_INTF_WB_CODEC;
	lpa_config.num_channels = icodec->data->channel_mode;
	lpa_cmd_codec_config(drv->lpa, &lpa_config);

	/* Set audio interconnect reg to LPA */
	audio_interct_codec(AUDIO_INTERCT_LPA);

	/* Set MI2S */
	mi2s_set_codec_output_path((icodec->data->channel_mode == 2 ?
	MI2S_CHAN_STEREO : MI2S_CHAN_MONO_PACKED), WT_16_BIT);

	if (icodec->data->voltage_on)
		icodec->data->voltage_on();

	/* Configure ADIE */
	trc = adie_codec_open(icodec->data->profile, &icodec->adie_path);
	if (IS_ERR_VALUE(trc))
		goto error_adie;
	/* OSR default to 256, can be changed for power optimization
	 * If OSR is to be changed, need clock API for setting the divider
	 */
	adie_codec_setpath(icodec->adie_path, icodec->sample_rate, 256);
	lpa_cmd_enable_codec(drv->lpa, 1);
	/* Start AFE */
	afe_config.sample_rate = icodec->sample_rate / 1000;
	afe_config.channel_mode = icodec->data->channel_mode;
	afe_config.volume = AFE_VOLUME_UNITY;
	trc = afe_enable(AFE_HW_PATH_CODEC_RX, &afe_config);
	if (IS_ERR_VALUE(trc))
		goto error_afe;
	/* Enable ADIE */
	adie_codec_proceed_stage(icodec->adie_path, ADIE_CODEC_DIGITAL_READY);
	adie_codec_proceed_stage(icodec->adie_path,
					ADIE_CODEC_DIGITAL_ANALOG_READY);

	/* Enable power amplifier */
	if (icodec->data->pamp_on)
		icodec->data->pamp_on();

	icodec->enabled = 1;

	wake_unlock(&drv->rx_idlelock);
	return 0;

error_afe:
	adie_codec_close(icodec->adie_path);
	icodec->adie_path = NULL;
error_adie:
	lpa_put(drv->lpa);
error_lpa:
	clk_disable(drv->lpa_p_clk);
	clk_disable(drv->lpa_codec_clk);
	clk_disable(drv->lpa_core_clk);
	clk_disable(drv->rx_sclk);
	clk_disable(drv->rx_mclk);
error_invalid_freq:

	MM_ERR("encounter error\n");

	wake_unlock(&drv->rx_idlelock);
	return -ENODEV;
}
Beispiel #8
0
static __devinit int sec_battery_probe(struct platform_device *pdev)
{
    struct sec_battery_platform_data *pdata = pdev->dev.platform_data;
    struct chg_data *chg;
    int ret = 0;

    pr_info("%s : Samsung Battery Driver Loading\n", __func__);

    chg = kzalloc(sizeof(*chg), GFP_KERNEL);
    if (!chg)
        return -ENOMEM;

    chg->pdata = pdata;

    if (!chg->pdata || !chg->pdata->adc_table) {
        pr_err("%s : No platform data & adc_table supplied\n", __func__);
        ret = -EINVAL;
        goto err_bat_table;
    }

    chg->psy_bat.name = "battery",
                 chg->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY,
                              chg->psy_bat.properties = sec_battery_props,
                                           chg->psy_bat.num_properties = ARRAY_SIZE(sec_battery_props),
                                                        chg->psy_bat.get_property = sec_bat_get_property,

                                                                     chg->psy_usb.name = "usb",
                                                                                  chg->psy_usb.type = POWER_SUPPLY_TYPE_USB,
                                                                                               chg->psy_usb.supplied_to = supply_list,
                                                                                                            chg->psy_usb.num_supplicants = ARRAY_SIZE(supply_list),
                                                                                                                         chg->psy_usb.properties = sec_power_properties,
                                                                                                                                      chg->psy_usb.num_properties = ARRAY_SIZE(sec_power_properties),
                                                                                                                                                   chg->psy_usb.get_property = sec_usb_get_property,

                                                                                                                                                                chg->psy_ac.name = "ac",
                                                                                                                                                                            chg->psy_ac.type = POWER_SUPPLY_TYPE_MAINS,
                                                                                                                                                                                        chg->psy_ac.supplied_to = supply_list,
                                                                                                                                                                                                    chg->psy_ac.num_supplicants = ARRAY_SIZE(supply_list),
                                                                                                                                                                                                                chg->psy_ac.properties = sec_power_properties,
                                                                                                                                                                                                                            chg->psy_ac.num_properties = ARRAY_SIZE(sec_power_properties),
                                                                                                                                                                                                                                        chg->psy_ac.get_property = sec_ac_get_property,

                                                                                                                                                                                                                                                    chg->present = 1;
    chg->polling_interval = POLLING_INTERVAL;
    chg->bat_info.batt_health = POWER_SUPPLY_HEALTH_GOOD;
    chg->bat_info.batt_is_full = false;
    chg->set_charge_timeout = false;
    chg->bat_info.batt_improper_ta = false;
    chg->is_recharging = false;
#ifdef CONFIG_BATTERY_MAX17042
    // Get battery type from fuelgauge driver.
    if(chg->pdata && chg->pdata->fuelgauge_cb)
        chg->battery_type = (battery_type_t)chg->pdata->fuelgauge_cb(
                                REQ_TEST_MODE_INTERFACE, TEST_MODE_BATTERY_TYPE_CHECK, 0);

    // Check UV charging case.
    if(chg->pdata && chg->pdata->pmic_charger &&
            chg->pdata->pmic_charger->get_connection_status) {
        if(chg->pdata->pmic_charger->get_connection_status() &&
                check_UV_charging_case(chg))
            chg->low_batt_boot_flag = true;
    }
    else
        chg->low_batt_boot_flag = false;

    // init delayed work
    INIT_DELAYED_WORK(&chg->full_chg_work, full_comp_work_handler);

    // Init low batt check threshold values.
    if(chg->battery_type == SDI_BATTERY_TYPE)
        chg->check_start_vol = 3550;  // Under 3.55V
    else if(chg->battery_type == ATL_BATTERY_TYPE)
        chg->check_start_vol = 3450;  // Under 3.45V
#endif

    chg->cable_status = CABLE_TYPE_NONE;
    chg->charging_status = CHARGING_STATUS_NONE;

    mutex_init(&chg->mutex);

    platform_set_drvdata(pdev, chg);

    wake_lock_init(&chg->vbus_wake_lock, WAKE_LOCK_SUSPEND,
                   "vbus_present");
    wake_lock_init(&chg->work_wake_lock, WAKE_LOCK_SUSPEND,
                   "sec_battery_work");

    INIT_WORK(&chg->bat_work, sec_bat_work);

    chg->monitor_wqueue =
        create_freezeable_workqueue(dev_name(&pdev->dev));
    if (!chg->monitor_wqueue) {
        pr_err("Failed to create freezeable workqueue\n");
        ret = -ENOMEM;
        goto err_wake_lock;
    }

    chg->last_poll = alarm_get_elapsed_realtime();
    alarm_init(&chg->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
               sec_battery_alarm);

    /* init power supplier framework */
    ret = power_supply_register(&pdev->dev, &chg->psy_bat);
    if (ret) {
        pr_err("Failed to register power supply psy_bat\n");
        goto err_wqueue;
    }

    ret = power_supply_register(&pdev->dev, &chg->psy_usb);
    if (ret) {
        pr_err("Failed to register power supply psy_usb\n");
        goto err_supply_unreg_bat;
    }

    ret = power_supply_register(&pdev->dev, &chg->psy_ac);
    if (ret) {
        pr_err("Failed to register power supply psy_ac\n");
        goto err_supply_unreg_usb;
    }

    sec_bat_create_attrs(chg->psy_bat.dev);

    chg->callbacks.set_cable = sec_bat_set_cable;
    chg->callbacks.set_status = sec_bat_set_status;
    chg->callbacks.force_update = sec_bat_force_update;
    if (chg->pdata->register_callbacks)
        chg->pdata->register_callbacks(&chg->callbacks);

    wake_lock(&chg->work_wake_lock);
    queue_work(chg->monitor_wqueue, &chg->bat_work);

    p1_lpm_mode_check(chg);

    return 0;

err_supply_unreg_ac:
    power_supply_unregister(&chg->psy_ac);
err_supply_unreg_usb:
    power_supply_unregister(&chg->psy_usb);
err_supply_unreg_bat:
    power_supply_unregister(&chg->psy_bat);
err_wqueue:
    destroy_workqueue(chg->monitor_wqueue);
    cancel_work_sync(&chg->bat_work);
    alarm_cancel(&chg->alarm);
err_wake_lock:
    wake_lock_destroy(&chg->work_wake_lock);
    wake_lock_destroy(&chg->vbus_wake_lock);
    mutex_destroy(&chg->mutex);
err_bat_table:
    kfree(chg);
    return ret;
}
Beispiel #9
0
static int sec_cable_status_update(struct chg_data *chg)
{
    int ret;
    bool vdc_status = false;
    ktime_t ktime;
    struct timespec cur_time;

    /* if max8998 has detected vdcin */
    if (chg->pdata && chg->pdata->pmic_charger &&
            chg->pdata->pmic_charger->get_connection_status &&
            chg->pdata->pmic_charger->get_connection_status())
    {
        vdc_status = true;
        if (chg->bat_info.dis_reason) {
            pr_info("%s : battery status discharging : %d\n",
                    __func__, chg->bat_info.dis_reason);
            /* have vdcin, but cannot charge */
            chg->charging = false;
            ret = sec_bat_charging_control(chg);
            if (ret < 0)
                goto err;
            chg->bat_info.charging_status =
                chg->bat_info.batt_is_full ?
                POWER_SUPPLY_STATUS_FULL :
                POWER_SUPPLY_STATUS_NOT_CHARGING;
            chg->discharging_time = 0;
            chg->set_batt_full = 0;
            goto update;
        } else if (chg->discharging_time == 0) {
            ktime = alarm_get_elapsed_realtime();
            cur_time = ktime_to_timespec(ktime);
            chg->discharging_time =
                chg->bat_info.batt_is_full ||
                chg->set_charge_timeout ?
                cur_time.tv_sec + TOTAL_RECHARGING_TIME :
                cur_time.tv_sec + TOTAL_CHARGING_TIME;
        }

        /* able to charge */
        chg->charging = true;
        /* if we have vdcin but we cannot detect the cable type,
        force to AC so we can charge anyway */
        if (chg->cable_status == CABLE_TYPE_NONE)
            chg->cable_status = CABLE_TYPE_AC;
        ret = sec_bat_charging_control(chg);
        if (ret < 0)
            goto err;

        chg->bat_info.charging_status = chg->bat_info.batt_is_full ?
                                        POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
    }
    else {
        /* no vdc in, not able to charge */
        vdc_status = false;
        chg->charging = false;
        ret = sec_bat_charging_control(chg);
        if (ret < 0)
            goto err;

        chg->bat_info.charging_status = POWER_SUPPLY_STATUS_DISCHARGING;

        chg->bat_info.batt_is_full = false;
        chg->set_charge_timeout = false;
        chg->set_batt_full = 0;
        chg->bat_info.dis_reason = 0;
        chg->discharging_time = 0;
        chg->bat_info.batt_improper_ta = false;
        chg->is_recharging = false;
    }

update:
    if(chg->bat_info.charging_status == POWER_SUPPLY_STATUS_FULL ||
            chg->bat_info.charging_status == POWER_SUPPLY_STATUS_CHARGING) {
        /* Update DISCHARGING status in case of USB cable or Improper charger */
        if(chg->cable_status==CABLE_TYPE_USB || chg->bat_info.batt_improper_ta)
            chg->bat_info.charging_status = POWER_SUPPLY_STATUS_DISCHARGING;
    }

    if ((chg->cable_status != CABLE_TYPE_NONE) && vdc_status)
        wake_lock(&chg->vbus_wake_lock);
    else
        wake_lock_timeout(&chg->vbus_wake_lock, HZ / 2);

    return 0;
err:
    return ret;
}
Beispiel #10
0
static void pcm_in_prevent_sleep(struct pcm *audio)
{
	pr_debug("%s:\n", __func__);
	wake_lock(&audio->wakelock);
	wake_lock(&audio->idlelock);
}
Beispiel #11
0
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;
}
static irqreturn_t gpio_event_input_irq_handler(int irq, void *dev_id)
{
    struct gpio_key_state *ks = dev_id;
    struct gpio_input_state *ds = ks->ds;
    int keymap_index = ks - ds->key_state;
    const struct gpio_event_direct_entry *key_entry;
    unsigned long irqflags;
#ifndef CONFIG_MFD_MAX8957
    int pressed;
#endif
    KEY_LOGD("%s, irq=%d, use_irq=%d\n", __func__, irq, ds->use_irq);

    if (!ds->use_irq)
        return IRQ_HANDLED;

    key_entry = &ds->info->keymap[keymap_index];

    if (key_entry->code == KEY_POWER && power_key_intr_flag == 0) {
        irq_set_irq_type(irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING);
        power_key_intr_flag = 1;
        KEY_LOGD("%s, keycode = %d, first intr", __func__, key_entry->code);
    }
    if (ds->info->debounce_time.tv64) {
        spin_lock_irqsave(&ds->irq_lock, irqflags);
        if (ks->debounce & DEBOUNCE_WAIT_IRQ) {
            ks->debounce = DEBOUNCE_UNKNOWN;
            if (ds->debounce_count++ == 0) {
                wake_lock(&ds->wake_lock);
#ifndef CONFIG_MFD_MAX8957
                hrtimer_start(
                    &ds->timer, ds->info->debounce_time,
                    HRTIMER_MODE_REL);
#endif
            }
            if (ds->info->flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
                KEY_LOGD("gpio_event_input_irq_handler: "
                         "key %x-%x, %d (%d) start debounce\n",
                         ds->info->type, key_entry->code,
                         keymap_index, key_entry->gpio);
        } else {
            disable_irq_nosync(irq);
            ks->debounce = DEBOUNCE_UNSTABLE;
        }
        spin_unlock_irqrestore(&ds->irq_lock, irqflags);
    } else {
#ifdef CONFIG_MFD_MAX8957
        queue_work(ki_queue, &ks->work);
#else
        pressed = gpio_get_value(key_entry->gpio) ^
                  !(ds->info->flags & GPIOEDF_ACTIVE_HIGH);
        if (ds->info->flags & GPIOEDF_PRINT_KEYS)
            KEY_LOGD("gpio_event_input_irq_handler: key %x-%x, %d "
                     "(%d) changed to %d\n",
                     ds->info->type, key_entry->code, keymap_index,
                     key_entry->gpio, pressed);
        input_event(ds->input_devs->dev[key_entry->dev], ds->info->type,
                    key_entry->code, pressed);
        input_sync(ds->input_devs->dev[key_entry->dev]);
#endif
    }
    return IRQ_HANDLED;
}
Beispiel #13
0
void esp_wake_lock(void)
{
#ifdef CONFIG_HAS_WAKELOCK
    wake_lock(&esp_wake_lock_);
#endif
}
static int __init msm_otg_probe(struct platform_device *pdev)
{
	int ret = 0;
	struct resource *res;
	struct msm_otg *dev;
	struct msm_otg_platform_data *pdata;

	dev = kzalloc(sizeof(struct msm_otg), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	dev->otg.dev = &pdev->dev;

	if (pdev->dev.platform_data) {
		pdata = pdev->dev.platform_data;
		dev->rpc_connect = pdata->rpc_connect;
		dev->phy_reset = pdata->phy_reset;
	}

	if (dev->rpc_connect) {
		ret = dev->rpc_connect(1);
		pr_info("%s: rpc_connect(%d)\n", __func__, ret);
		if (ret) {
			pr_err("%s: rpc connect failed\n", __func__);
			ret = -ENODEV;
			goto free_dev;
		}
	}

	dev->clk = clk_get(&pdev->dev, "usb_hs_clk");
	if (IS_ERR(dev->clk)) {
		pr_err("%s: failed to get usb_hs_clk\n", __func__);
		ret = PTR_ERR(dev->clk);
		goto rpc_fail;
	}
	dev->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
	if (IS_ERR(dev->clk)) {
		pr_err("%s: failed to get usb_hs_pclk\n", __func__);
		ret = PTR_ERR(dev->pclk);
		goto put_clk;
	}
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		pr_err("%s: failed to get platform resource mem\n", __func__);
		ret = -ENODEV;
		goto put_pclk;
	}

	dev->regs = ioremap(res->start, resource_size(res));
	if (!dev->regs) {
		pr_err("%s: ioremap failed\n", __func__);
		ret = -ENOMEM;
		goto put_pclk;
	}
	dev->irq = platform_get_irq(pdev, 0);
	if (!dev->irq) {
		pr_err("%s: platform_get_irq failed\n", __func__);
		ret = -ENODEV;
		goto free_regs;
	}

	/* enable clocks */
	clk_enable(dev->clk);
	clk_enable(dev->pclk);

	otg_reset(dev);

	ret = request_irq(dev->irq, msm_otg_irq, IRQF_SHARED,
					"msm_otg", dev);
	if (ret) {
		pr_info("%s: request irq failed\n", __func__);
		clk_disable(dev->clk);
		clk_disable(dev->pclk);
		goto free_regs;
	}

	the_msm_otg = dev;
	dev->otg.set_peripheral = msm_otg_set_peripheral;
	dev->otg.set_host = msm_otg_set_host;
	dev->otg.set_suspend = msm_otg_set_suspend;
	if (otg_set_transceiver(&dev->otg)) {
		WARN_ON(1);
		goto free_regs;
	}

	wake_lock_init(&dev->wlock,
			WAKE_LOCK_SUSPEND, "usb_bus_active");
	wake_lock(&dev->wlock);
	msm_otg_debugfs_init(dev);
	device_init_wakeup(&pdev->dev, 1);

	return 0;
free_regs:
	iounmap(dev->regs);
put_pclk:
	clk_put(dev->pclk);
put_clk:
	clk_put(dev->clk);
rpc_fail:
	dev->rpc_connect(0);
free_dev:
	kfree(dev);
	return ret;
}
Beispiel #15
0
static inline void prevent_suspend(void)
{
	wake_lock(&s5k3e2fx_wake_lock);
}
void wcnss_prevent_suspend()
{
	if (penv)
		wake_lock(&penv->wcnss_wake_lock);
}
static int if_usb_resume(struct usb_interface *intf)
{
	int i, ret;
	struct sk_buff *skb;
	struct usb_link_device *usb_ld = usb_get_intfdata(intf);
	struct if_usb_devdata *pipe;
	struct urb *urb;

	spin_lock_irq(&usb_ld->lock);
	if (!atomic_dec_return(&usb_ld->suspend_count)) {
		spin_unlock_irq(&usb_ld->lock);

		mif_debug("\n");
		wake_lock(&usb_ld->susplock);

		/* HACK: Runtime pm does not allow requesting autosuspend from
		 * resume callback, delayed it after resume */
		queue_delayed_work(system_nrt_wq, &usb_ld->runtime_pm_work,
							msecs_to_jiffies(50));

		for (i = 0; i < IF_USB_DEVNUM_MAX; i++) {
			pipe = &usb_ld->devdata[i];
			while ((urb = usb_get_from_anchor(&pipe->urbs))) {
				ret = usb_rx_submit(pipe, urb, GFP_KERNEL);
				if (ret < 0) {
					usb_put_urb(urb);
					mif_err(
					"usb_rx_submit error with (%d)\n",
						ret);
					return ret;
				}
				usb_put_urb(urb);
			}
		}

		while ((urb = usb_get_from_anchor(&usb_ld->deferred))) {
			mif_debug("got urb (0x%p) from anchor & resubmit\n",
					urb);
			ret = usb_submit_urb(urb, GFP_KERNEL);
			if (ret < 0) {
				mif_err("resubmit failed\n");
				skb = urb->context;
				dev_kfree_skb_any(skb);
				usb_free_urb(urb);
				ret = pm_runtime_put_autosuspend(
						&usb_ld->usbdev->dev);
				if (ret < 0 && ret != -EAGAIN)
					mif_debug("pm_runtime_put_autosuspend "
							"failed: %d\n", ret);
			}
		}
		SET_SLAVE_WAKEUP(usb_ld->pdata, 1);
		udelay(100);
		SET_SLAVE_WAKEUP(usb_ld->pdata, 0);

		/* if_usb_resume() is atomic. post_resume_work is
		 * a kind of bottom halves
		 */
		queue_delayed_work(system_nrt_wq, &usb_ld->post_resume_work, 0);

		return 0;
	}

	spin_unlock_irq(&usb_ld->lock);
	return 0;
}
void ssp_dump_task(struct work_struct *work)
{
#if CONFIG_SEC_DEBUG
	struct ssp_big *big;
	struct file *dump_file;
	struct ssp_msg *msg;
	char *buffer;
	char strFilePath[100];
	struct timeval cur_time;
	mm_segment_t fs;
	int buf_len, packet_len, residue;
	int iRet = 0, index = 0, iRetTrans = 0, iRetWrite = 0;

	big = container_of(work, struct ssp_big, work);
	ssp_errf("start ssp dumping (%d)(%d)",
		big->data->bMcuDumpMode, big->data->uDumpCnt);

	big->data->uDumpCnt++;
	wake_lock(&big->data->ssp_wake_lock);

	fs = get_fs();
	set_fs(get_ds());

	if (big->data->bMcuDumpMode == true) {
		do_gettimeofday(&cur_time);
#ifdef CONFIG_SENSORS_SSP_ENG
		snprintf(strFilePath, sizeof(strFilePath), "%s%d.dump",
			DUMP_FILE_PATH,	(int)cur_time.tv_sec);
		dump_file = filp_open(strFilePath,
				O_RDWR | O_CREAT | O_APPEND, 0660);
#else
		snprintf(strFilePath, sizeof(strFilePath), "%s.dump",
			DUMP_FILE_PATH);
		dump_file = filp_open(strFilePath,
				O_RDWR | O_CREAT | O_TRUNC, 0660);
#endif

		if (IS_ERR(dump_file)) {
			ssp_errf("Can't open dump file");
			set_fs(fs);
			iRet = PTR_ERR(dump_file);
			wake_unlock(&big->data->ssp_wake_lock);
			kfree(big);
			return;
		}
	} else {
		dump_file = NULL;
	}

	buf_len = big->length > DATA_PACKET_SIZE
			? DATA_PACKET_SIZE : big->length;
	buffer = kzalloc(buf_len, GFP_KERNEL);
	residue = big->length;

	while (residue > 0) {
		packet_len = residue > DATA_PACKET_SIZE
				? DATA_PACKET_SIZE : residue;

		msg = kzalloc(sizeof(*msg), GFP_KERNEL);
		msg->cmd = MSG2SSP_AP_GET_BIG_DATA;
		msg->length = packet_len;
		msg->options = AP2HUB_READ | (index++ << SSP_INDEX);
		msg->data = big->addr;
		msg->buffer = buffer;
		msg->free_buffer = 0;

		iRetTrans = ssp_spi_sync(big->data, msg, 1000);
		if (iRetTrans != SUCCESS) {
			ssp_errf("Fail to receive data %d (%d)",
				iRetTrans, residue);
			break;
		}

		if (big->data->bMcuDumpMode == true) {
			iRetWrite = vfs_write(dump_file, (char __user *)buffer,
						packet_len, &dump_file->f_pos);
			if (iRetWrite < 0) {
				ssp_errf("Can't write dump to file");
				break;
			}
		}
		residue -= packet_len;
	}

	if (big->data->bMcuDumpMode == true) {
		if (iRetTrans != SUCCESS || iRetWrite < 0) { /* error case */
			char FAILSTRING[100];
			snprintf(FAILSTRING, sizeof(FAILSTRING),
				"FAIL OCCURED(%d)(%d)(%d)", iRetTrans,
				iRetWrite, big->length);
			vfs_write(dump_file, (char __user *)FAILSTRING,
					strlen(FAILSTRING), &dump_file->f_pos);
		}

		filp_close(dump_file, current->files);
	}

	big->data->bDumping = false;

	set_fs(fs);

	wake_unlock(&big->data->ssp_wake_lock);
	kfree(buffer);
	kfree(big);
#endif
	ssp_errf("done");
}
static int
msm_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
{
	DECLARE_COMPLETION_ONSTACK(complete);
	struct msm_i2c_dev *dev = i2c_get_adapdata(adap);
	int ret, ret_wait;
	long timeout;
	unsigned long flags;

	/*
	 * If there is an i2c_xfer after driver has been suspended,
	 * grab wakelock to abort suspend.
	 */
	if (dev->is_suspended)
		wake_lock(&dev->wakelock);
	clk_enable(dev->clk);
	enable_irq(dev->irq);

	ret = msm_i2c_poll_notbusy(dev, 1, msgs);
	if (ret) {
		dev_err(dev->dev, "Still busy in starting xfer(%02X)\n",
			msgs->addr);
		if (!dev->skip_recover) {
			ret = msm_i2c_recover_bus_busy(dev);
			if (ret)
				goto err;
		}
	}

	spin_lock_irqsave(&dev->lock, flags);
	if (dev->flush_cnt) {
		dev_warn(dev->dev, "%d unrequested bytes read\n",
			 dev->flush_cnt);
	}
	dev->msg = msgs;
	dev->rem = num;
	dev->pos = -1;
	dev->ret = num;
	dev->need_flush = false;
	dev->flush_cnt = 0;
	dev->cnt = msgs->len;
	dev->complete = &complete;

	msm_i2c_interrupt_locked(dev);
	spin_unlock_irqrestore(&dev->lock, flags);

	/*
	 * Now that we've setup the xfer, the ISR will transfer the data
	 * and wake us up with dev->err set if there was an error
	 */

	timeout = wait_for_completion_timeout(&complete, HZ);
	ret_wait = msm_i2c_poll_notbusy(dev, 0, msgs);
	spin_lock_irqsave(&dev->lock, flags);
	if (dev->flush_cnt) {
		dev_warn(dev->dev, "%d unrequested bytes read\n",
			 dev->flush_cnt);
	}
	ret = dev->ret;
	dev->complete = NULL;
	dev->msg = NULL;
	dev->rem = 0;
	dev->pos = 0;
	dev->ret = 0;
	dev->flush_cnt = 0;
	dev->cnt = 0;
	spin_unlock_irqrestore(&dev->lock, flags);
	if (ret_wait) /* Read may not have stopped in time */
	{
		dev_err(dev->dev, "Still busy after xfer completion (%02X)\n", msgs->addr);
		if (ret_wait == -GSENSOR_TIMEDOUT)
			ret = 2; // in most situations the value of ret is 2 (dev->ret), we set it to 2 just to be sure that function i2c_read_block doesn't repeats the read
		if (!dev->skip_recover) {
			ret_wait = msm_i2c_recover_bus_busy(dev);
			if (ret_wait)
				goto err;
		}
	}
	if (!timeout) {
		dev_err(dev->dev, "Transaction timed out\n");
		ret = -ETIMEDOUT;
	}

	if (ret < 0) {
		dev_err(dev->dev, "Error during data xfer (%d) (%02X)\n",
			ret, msgs->addr);
		if (!dev->skip_recover)
			msm_i2c_recover_bus_busy(dev);
	}
err:
	disable_irq(dev->irq);
	clk_disable(dev->clk);
	if (dev->is_suspended)
		wake_unlock(&dev->wakelock);

	return ret;
}
int debug_crash_dump(struct ssp_data *data, char *pchRcvDataFrame, int iLength)
{
	struct timeval cur_time;
	char strFilePath[100];
	int iRetWrite = 0;
	unsigned char datacount = pchRcvDataFrame[1];
	unsigned int databodysize = iLength - 2;
	char *databody = &pchRcvDataFrame[2];
/*
	if(iLength != DEBUG_DUMP_DATA_SIZE)
	{
		ssp_errf("data length error(%d)", iLength);
		return FAIL;
	}
	else
		ssp_errf("length(%d)", databodysize);
*/
	ssp_errf("length(%d)", databodysize);

	if (data->bSspShutdown) {
		ssp_infof("ssp shutdown, stop dumping");
		return FAIL;
	}

	if (data->bMcuDumpMode == true)	{
		wake_lock(&data->ssp_wake_lock);

		if (data->realtime_dump_file == NULL) {
			backup_fs = get_fs();
			set_fs(get_ds());

			do_gettimeofday(&cur_time);

			snprintf(strFilePath, sizeof(strFilePath), "%s%d.dump",
				DEBUG_DUMP_FILE_PATH, (int)cur_time.tv_sec);
			data->realtime_dump_file = filp_open(strFilePath,
					O_RDWR | O_CREAT | O_APPEND, 0660);

			ssp_err("save_crash_dump : open file(%s)", strFilePath);

			if (IS_ERR(data->realtime_dump_file)) {
				ssp_errf("Can't open dump file");
				set_fs(backup_fs);
				data->realtime_dump_file = NULL;
				wake_unlock(&data->ssp_wake_lock);
				return FAIL;
			}
		}

		data->total_dump_size += databodysize;
		/* ssp_errf("total receive size(%d)", data->total_dump_size); */
		iRetWrite = vfs_write(data->realtime_dump_file,
					(char __user *)databody, databodysize,
					&data->realtime_dump_file->f_pos);
		if (iRetWrite < 0) {
			ssp_errf("Can't write dump to file");
			wake_unlock(&data->ssp_wake_lock);
			return FAIL;
		}

		if (datacount == DEBUG_DUMP_DATA_COMPLETE) {
			ssp_errf("close file(size=%d)", data->total_dump_size);
			filp_close(data->realtime_dump_file, current->files);
			set_fs(backup_fs);
			data->uDumpCnt++;
			data->total_dump_size = 0;
			data->realtime_dump_file = NULL;
			data->bDumping = false;
		}

		wake_unlock(&data->ssp_wake_lock);

		/*
		if(iLength == 2*1024)
			queue_refresh_task(data, 0);
		*/
	}

	return SUCCESS;
}
static int snddev_icodec_open_tx(struct snddev_icodec_state *icodec)
{
	int trc;
	int i, err;
	struct msm_afe_config afe_config;
	struct snddev_icodec_drv_state *drv = &snddev_icodec_drv;;

	wake_lock(&drv->tx_idlelock);

	/* Vote for PWM mode*/
	err = pmapp_smps_mode_vote(SMPS_AUDIO_RECORD_ID,
			PMAPP_VREG_S4, PMAPP_SMPS_MODE_VOTE_PWM);
	if (err != 0)
		MM_ERR("pmapp_smps_mode_vote error %d\n", err);

	/* Reuse pamp_on for TX platform-specific setup  */
	if (icodec->data->pamp_on)
		icodec->data->pamp_on();

	for (i = 0; i < icodec->data->pmctl_id_sz; i++) {
		pmic_hsed_enable(icodec->data->pmctl_id[i],
			 PM_HSED_ENABLE_PWM_TCXO);
	}

	/* enable MI2S TX master block */
	/* enable MI2S TX bit clock */
	trc = clk_set_rate(drv->tx_mclk,
		SNDDEV_ICODEC_CLK_RATE(icodec->sample_rate));
	if (IS_ERR_VALUE(trc))
		goto error_invalid_freq;
	clk_enable(drv->tx_mclk);
	clk_enable(drv->tx_sclk);

	/* Set MI2S */
	mi2s_set_codec_input_path((icodec->data->channel_mode == 2 ?
	MI2S_CHAN_STEREO : MI2S_CHAN_MONO_RAW), WT_16_BIT);
	/* Configure ADIE */
	trc = adie_codec_open(icodec->data->profile, &icodec->adie_path);
	if (IS_ERR_VALUE(trc))
		goto error_adie;
	/* Enable ADIE */
	adie_codec_setpath(icodec->adie_path, icodec->sample_rate, 256);
	adie_codec_proceed_stage(icodec->adie_path, ADIE_CODEC_DIGITAL_READY);
	adie_codec_proceed_stage(icodec->adie_path,
	ADIE_CODEC_DIGITAL_ANALOG_READY);

	/* Start AFE */
	afe_config.sample_rate = icodec->sample_rate / 1000;
	afe_config.channel_mode = icodec->data->channel_mode;
	afe_config.volume = AFE_VOLUME_UNITY;
	trc = afe_enable(AFE_HW_PATH_CODEC_TX, &afe_config);
	if (IS_ERR_VALUE(trc))
		goto error_afe;


	icodec->enabled = 1;

	wake_unlock(&drv->tx_idlelock);
	return 0;

error_afe:
	adie_codec_close(icodec->adie_path);
	icodec->adie_path = NULL;
error_adie:
	clk_disable(drv->tx_sclk);
	clk_disable(drv->tx_mclk);
error_invalid_freq:

	/* Disable mic bias */
	for (i = 0; i < icodec->data->pmctl_id_sz; i++) {
		pmic_hsed_enable(icodec->data->pmctl_id[i],
			 PM_HSED_ENABLE_OFF);
	}

	if (icodec->data->pamp_off)
		icodec->data->pamp_off();

	MM_ERR("encounter error\n");

	wake_unlock(&drv->tx_idlelock);
	return -ENODEV;
}
Beispiel #22
0
static long ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
#ifdef QA_TEST
	int i;
#endif

	/* DbgOut(KERN_INFO "tspdrv: ioctl cmd[0x%x].\n", cmd); */
	switch (cmd) {
	case TSPDRV_STOP_KERNEL_TIMER:
		/*
		** As we send one sample ahead of time, we need to finish
		** playing the last sample before stopping the timer.
		** So we just set a flag here.
		*/
		if (true == g_bisplaying)
			g_bstoprequested = true;

#ifdef VIBEOSKERNELPROCESSDATA
		/* Last data processing to disable amp and stop timer */
		VibeOSKernelProcessData(NULL);
#endif

#ifdef QA_TEST
		if (g_nforcelog_index) {
			for (i = 0; i < g_nforcelog_index; i++) {
				printk(KERN_INFO "%d\t%d\n"
					   , g_ntime, g_nforcelog[i]);
				g_ntime += TIME_INCREMENT;
			}
		}
		g_ntime = 0;
		g_nforcelog_index = 0;
#endif
		break;

	case TSPDRV_MAGIC_NUMBER:
	case TSPDRV_SET_MAGIC_NUMBER:
		filp->private_data = (void *)TSPDRV_MAGIC_NUMBER;
		break;

	case TSPDRV_ENABLE_AMP:
		wake_lock(&vib_wake_lock);
		ImmVibeSPI_ForceOut_AmpEnable(arg);
		DbgRecorderReset((arg));
		DbgRecord((arg, ";------- TSPDRV_ENABLE_AMP ---------\n"));
		break;

	case TSPDRV_DISABLE_AMP:
		/*
		** Small fix for now to handle proper combination of
		** TSPDRV_STOP_KERNEL_TIMER and TSPDRV_DISABLE_AMP together
		** If a stop was requested, ignore the request as the amp
		** will be disabled by the timer proc when it's ready
		*/
		if (!g_bstoprequested)
			ImmVibeSPI_ForceOut_AmpDisable(arg);
		wake_unlock(&vib_wake_lock);
		break;

	case TSPDRV_GET_NUM_ACTUATORS:
		return NUM_ACTUATORS;
	}

	return 0;
}
Beispiel #23
0
/******************************************************************************
 *    function:   smt113j_spi_thread_Init
 *    brief   :   
 *    date    :   
 *    author  :   
 *
 *    return  :   none
 *    input   :   none
 *    output  :   none
 ******************************************************************************/
static int smt113j_spi_thread_Init ( void )
{
	int ret = 0;
	struct sched_param param = { .sched_priority = 99 };
	
	DEBUG_PRINT("smt113j_spi_thread_Init: Start");
	
	spi_work_thread = kmalloc ( sizeof ( smt113j_spi_thread_t ), GFP_KERNEL );
	
	if ( !spi_work_thread ) 
	{
		ERROR_PRINT ("smt113j_spi_thread_Init : Kmalloc Error");
		return ( -EFAULT );
	}

	spi_work_thread->status = SMT113J_SPI_SYNC_STOP;

	spin_lock_init( &spi_work_thread->tmm_lock );

	init_waitqueue_head ( &spi_work_thread->thread_wait );

	/*** Thread generation and run ***/
	spi_work_thread->thread_task = kthread_run ( smt113j_spi_thread_loop, 
												 NULL, 
												 "SMT113J_SPI_Task" );
	
	if ( IS_ERR ( spi_work_thread->thread_task )) 
	{
		ERROR_PRINT ("smt113j_spi_thread_Init : kthread_run error : %p", 
					 spi_work_thread->thread_task);
		goto ERROR2;
	}
	
	ret = sched_setscheduler ( spi_work_thread->thread_task, 
							   SCHED_FIFO, 
							   &param );
	
	if ( ret < 0 ) 
	{
		ERROR_PRINT (
			"smt113j_spi_thread_Init : sched_setscheduler error ret[ %d ]", 
			ret );
		goto ERROR3;
	}

	DEBUG_PRINT("smt113j_spi_thread_Init: End");

	return ( ret );

ERROR3:
	spi_work_thread->status = SMT113J_SPI_SYNC_STOP;
	wake_up_interruptible ( &( spi_work_thread->thread_wait ));
	kthread_stop ( spi_work_thread->thread_task );

ERROR2:
	kfree ( spi_work_thread );

	ERROR_PRINT ("smt113j_spi_thread_Init : Error");
	
	return ( ret );
}


/******************************************************************************
 *    function:   smt113j_spi_thread_Start
 *    brief   :   
 *    date    :   
 *    author  :   
 *
 *    return  :   none
 *    input   :   none
 *    output  :   none
 ******************************************************************************/
static int smt113j_spi_thread_Start ( void )
{
	DEBUG_PRINT("smt113j_spi_thread_Start : Start!");
	DEBUG_PRINT("-> spi_work_thread->status[%d]", spi_work_thread->status );

	/* multiple check */
	if ( SMT113J_SPI_SYNC_RUN == spi_work_thread->status ) 
	{
		DEBUG_PRINT("smt113j_spi_thread_Start( Double ) : End!");
		return ( 0 );
	}
	/* thread run status set */
	spi_work_thread->status = SMT113J_SPI_SYNC_RUN;
	
	pwrite = 0;
	pread  = 0;
	
	wake_lock(&smt113j_spi_wake_lock);
	
	/* wakeup event */
	wake_up_interruptible ( &(spi_work_thread->thread_wait ));

	DEBUG_PRINT("smt113j_spi_thread_Start : End!");
	DEBUG_PRINT("-> spi_work_thread->status[%d]", spi_work_thread->status );

	return ( 0 );
}
void baseband_xmm_set_power_status(unsigned int status)
{
	struct baseband_power_platform_data *data = baseband_power_driver_data;
	int value = 0;
    unsigned long flags;

	pr_debug("%s n(%d),o(%d)\n", __func__, status, baseband_xmm_powerstate );

	if (baseband_xmm_powerstate == status)
		return;

	switch (status) {
	case BBXMM_PS_L0:
		if (modem_sleep_flag) {
			pr_debug("%s Resume from L3 without calling resume" "function\n",  __func__);
				baseband_xmm_power_driver_handle_resume(data);
		}	
		pr_debug("PM_ST : L0\n");
		baseband_xmm_powerstate = status;
		if (!wake_lock_active(&wakelock))
			wake_lock(&wakelock);
		value = gpio_get_value(data->modem.xmm.ipc_hsic_active);
		//pr_debug("GPIO [R]: before L0 Host_active = %d \n", value); 
		if (!value) {
			gpio_set_value(data->modem.xmm.ipc_hsic_active, 1);
			pr_debug("GPIO [W]: L0 Host_active -> 1 \n"); 
		}
		if (modem_power_on) {
			modem_power_on = false;
			baseband_modem_power_on(data);
		}
		pr_debug("gpio host active high->\n");
		break;
		
	case BBXMM_PS_L2:
		pr_debug("PM_ST : L2\n");
		baseband_xmm_powerstate = status;
		spin_lock_irqsave(&xmm_lock, flags);
		if (wakeup_pending) {
			spin_unlock_irqrestore(&xmm_lock, flags);
			baseband_xmm_power_L2_resume();
		 } else {
			spin_unlock_irqrestore(&xmm_lock, flags);
			if (wake_lock_active(&wakelock))
				wake_unlock(&wakelock);
		modem_sleep_flag = true;
		}
		if (short_autosuspend && enable_short_autosuspend && &usbdev->dev) {
			pr_debug("autosuspend delay %d ms, disable short_autosuspend\n",DEFAULT_AUTOSUSPEND_DELAY);
			queue_work(workqueue_susp, &work_defaultsusp);
			short_autosuspend = false;
		}
		break;
		
	case BBXMM_PS_L3:
		if (baseband_xmm_powerstate == BBXMM_PS_L2TOL0) {
			if (!gpio_get_value(data->modem.xmm.ipc_ap_wake)) {
				spin_lock_irqsave(&xmm_lock, flags);
				wakeup_pending = true;
				spin_unlock_irqrestore(&xmm_lock, flags);
				pr_info("%s: L2 race condition-CP wakeup"
						" pending\n", __func__);
			}
		}
		pr_info("L3\n");
		if (wake_lock_active(&wakelock)) {
			pr_debug("%s: releasing wakelock before L3\n", __func__);
			wake_unlock(&wakelock);
		}
		if (wakeup_pending == false) {
			gpio_set_value(data->modem.xmm.ipc_hsic_active, 0);
			pr_debug("gpio host active low->\n");
		}
		break;
	case BBXMM_PS_L2TOL0:
		spin_lock_irqsave(&xmm_lock, flags);
		system_suspending = false;
		wakeup_pending = false;
		spin_unlock_irqrestore(&xmm_lock, flags);
		/* do this only from L2 state */
		if (baseband_xmm_powerstate == BBXMM_PS_L2) {
			baseband_xmm_powerstate = status;
			pr_debug("BB XMM POWER STATE = %d\n", status);
			baseband_xmm_power_L2_resume();
		}
		baseband_xmm_powerstate = status;
		break;
	default:
		baseband_xmm_powerstate = status;
		break;
	}
	pr_debug("BB XMM POWER STATE = %s(%d)\n", pwrstate_cmt[status], status);
}
Beispiel #25
0
static void gpio_keys_report_event(struct gpio_button_data *bdata)
{
	struct gpio_keys_button *button = bdata->button;
	struct input_dev *input = bdata->input;
	unsigned int type = button->type ?: EV_KEY;
	int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0)
		^ button->active_low;
#ifdef CONFIG_MACH_GC1
	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
	struct gpio_button_data *tmp_bdata;
	static bool overlapped;
	static unsigned int hotkey;
	unsigned int index_hotkey = 0;
	bool zoomkey = false;

#ifdef CONFIG_FAST_BOOT

	/*Fake pwr off control*/
	if (fake_shut_down || fake_pressed) {
		if (button->code == KEY_POWER) {
			if (!!state) {
				printk(KERN_DEBUG"[Keys] start fake check\n");
				fake_pressed = true;
				if (!wake_lock_active(&fake_lock))
					wake_lock(&fake_lock);
				mod_timer(&fake_timer,
					jiffies + msecs_to_jiffies(500));
			} else {
				printk(KERN_DEBUG"[Keys] end fake checkPwr 0\n");
				fake_pressed = false;
				if (wake_lock_active(&fake_lock))
					wake_unlock(&fake_lock);
			}
		}
		bdata->wakeup = false;
		return ;
	}
#endif
	if (system_rev < 6 && system_rev >= 2) {
		if (overlapped) {
			if (hotkey == button->code && !state) {
				bdata->key_state = !!state;
				bdata->wakeup = false;
				overlapped = false;
#ifdef CONFIG_SAMSUNG_PRODUCT_SHIP
				printk(KERN_DEBUG"[KEYS] Ignored\n");
#else
				printk(KERN_DEBUG"[KEYS] Ignore %d %d\n",
						hotkey, state);
#endif
				return;
			}
		}

		gpio_keys_check_zoom_exception(button->code, &zoomkey,
				&hotkey, &index_hotkey);
	} else if (system_rev >= 6) {
		/*exclusive check for zoom dial*/
		unsigned int zoom_type = 0;
		unsigned int current_zoom_state = 0;
		bool pass_cur_event = false;

		if (is_zoom_key(button->code, &zoom_type)) {
			current_zoom_state = check_zoom_state(ddata);

			if (zoom_type == ZOOM_IN
				&& current_zoom_state == ZOOM_OUT)
					pass_cur_event = true;
			else if (zoom_type == ZOOM_OUT
				&& current_zoom_state == ZOOM_IN)
					pass_cur_event = true;

			if (pass_cur_event) {
#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
				printk(KERN_DEBUG "[keys] Pass zoom"
					"current %d, code %d\n",
					current_zoom_state, button->code);
#endif
				return ;
			}
		}
	}
#endif

	if (type == EV_ABS) {
		if (state) {
			input_event(input, type, button->code, button->value);
			input_sync(input);
			}
	} else {
		if (bdata->wakeup && !state) {
			input_event(input, type, button->code, !state);
			input_sync(input);
			if (button->code == KEY_POWER)
				printk(KERN_DEBUG"[keys] f PWR %d\n", !state);
		}

		bdata->key_state = !!state;
		bdata->wakeup = false;


#ifdef CONFIG_MACH_GC1
		if (system_rev < 6 && system_rev >= 2
				&& zoomkey && state) {
			tmp_bdata = &ddata->data[index_hotkey];

			if (tmp_bdata->key_state) {
#ifdef CONFIG_SAMSUNG_PRODUCT_SHIP
				printk(KERN_DEBUG"[KEYS] overlapped\n");
#else
				printk(KERN_DEBUG"[KEYS] overlapped. Forced release c %d h %d\n",
					tmp_bdata->button->code, hotkey);
#endif
				input_event(input, type, hotkey, 0);
				input_sync(input);

				overlapped = true;
			}
		}

		if (system_rev >= 6) {
			/* forced release*/
			if (button->code == KEY_CAMERA_ZOOMIN && !state) {
				tmp_bdata = &ddata->data[5];
				if (tmp_bdata->key_state) {
					input_event(input, type, 0x221,
						!!state);
					input_sync(input);
					printk(KERN_DEBUG"[KEYS] forced 0x221 key release\n");
				}
			}

			if (button->code == KEY_CAMERA_ZOOMOUT && !state) {
				tmp_bdata = &ddata->data[6];
				if (tmp_bdata->key_state) {
					input_event(input, type, 0x222,
						!!state);
					input_sync(input);
					printk(KERN_DEBUG"[KEYS] forced 0x222 key release\n");
				}
			}

			/*forced press*/
			if (button->code == 0x221 && state) {
				tmp_bdata = &ddata->data[3];
				if (!tmp_bdata->key_state) {
					input_event(input, type,
						KEY_CAMERA_ZOOMIN, !!state);
					input_sync(input);
					printk(KERN_DEBUG"[KEYS] forced 0x215 key press\n");
				}
			}

			if (button->code == 0x222 && state) {
				tmp_bdata = &ddata->data[4];
				if (!tmp_bdata->key_state) {
					input_event(input, type,
						KEY_CAMERA_ZOOMOUT, !!state);
					input_sync(input);
					printk(KERN_DEBUG"[KEYS] forced 0x216 key press\n");
				}
			}
		}

#endif
		input_event(input, type, button->code, !!state);
		input_sync(input);

		if (button->code == KEY_POWER)
			printk(KERN_DEBUG"[keys]PWR %d\n", !!state);
	}
}
Beispiel #26
0
static void twl6030_determine_charge_state(struct twl6030_bci_device_info *di)
{
	u8 stat1;
	int newstate = STATE_BATTERY;

	/* TODO: i2c error -> fault? */
	twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1, CONTROLLER_STAT1);

	/* TODO: why is STAT1.0 (BAT_TEMP_OVRANGE) always set? */
	/* printk("battery: determine_charge_state() stat1=%02x int1=%02x\n", stat1, int1); */
	
	if (stat1 & VBUS_DET) {
		/* dedicated charger detected by PHY? */
		if (di->usb_event == USB_EVENT_CHARGER)
			newstate = STATE_AC;
		else
			newstate = STATE_USB;

		if (!di->vbus_online) {
			di->vbus_online = 1;
			wake_lock(&usb_wake_lock);
		}
	} else {
		/* ensure we don't have a stale USB_EVENT_CHARGER should detect bounce */
		di->usb_event = USB_EVENT_NONE;

		if (di->vbus_online) {
			di->vbus_online = 0;
			/* give USB and userspace some time to react before suspending */
			wake_lock_timeout(&usb_wake_lock, HZ / 2);
		}
	}

	if (di->state == newstate)
		return;

	switch (newstate) {
	case STATE_FAULT:
	case STATE_BATTERY:
		if (is_charging(di))
			twl6030_stop_usb_charger(di);
		break;
	case STATE_USB:
	case STATE_AC:
		/* moving out of STATE_FULL should only happen on unplug
		 * or if we actually run down the battery capacity
		 */
		if (di->state == STATE_FULL) {
			newstate = STATE_FULL;
			break;
		}

		/* TODO: high current? */
		if (!is_charging(di))
			twl6030_start_usb_charger(di, 500);
		break;
	}

	if (di->state != newstate) {
		printk("battery: state %s -> %s\n",
			twl6030_state[di->state], twl6030_state[newstate]);
		di->state = newstate;
		power_supply_changed(&di->bat);
		power_supply_changed(&di->usb);
	}
}
static int __devinit bq24157_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int ret = 0;
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct bq24157_platform_data *pdata = client->dev.platform_data;

	printk("%s name : %s\n", __func__, client->name);

	/*First check the functionality supported by the host*/
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
		printk("%s functionality check failed 1 \n", __func__);
		return -EIO;
	}
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
		printk("%s functionality check failed 2 \n", __func__);
		return -EIO;
	}

	if(bq24157_client == NULL)
	{
		bq24157_client = client; 
	}
	else
	{
		printk("%s bq24157_client is not NULL. bq24157_client->name : %s\n", __func__, bq24157_client->name);
		ret = -ENXIO;
		goto err_bq24157_client_is_not_NULL;
	}

#if defined(CONFIG_SPA)
	spa_external_event = spa_get_external_event_handler();
#endif

	ret = bq24157_read_chip_info();
	if(ret)
	{
		printk("%s fail to read chip info\n", __func__);
		goto err_read_chip_info;
	}

	ret = bq24157_init_data();
	if(ret)
	{
		printk("%s fail to init data\n", __func__);
		goto err_init_data;
	}

	if(pdata->cd == 0)
	{
		printk("%s please assign cd pin GPIO\n", __func__);
		ret = -1;
		goto err_gpio_request_cd;
	}

	ret = gpio_request(pdata->cd, "bq24157_CD");
        if(ret)
        {
                dev_err(&client->dev,"bq24157: Unable to get gpio %d\n", pdata->cd);
                goto err_gpio_request_cd;
        }
	bq24157_chg_en = pdata->cd;

#if defined(CONFIG_SPA)
        ret = spa_chg_register_enable_charge(bq24157_enable_charge);
        if(ret)
        {
                printk("%s fail to register enable_charge function\n", __func__);
                goto err_register_enable_charge;
        }
        ret = spa_chg_register_disable_charge(bq24157_disable_charge);
        if(ret)
        {
                printk("%s fail to register disable_charge function\n", __func__);
                goto err_register_disable_charge;
        }
        spa_external_event = spa_get_external_event_handler();
#endif

	INIT_DELAYED_WORK(&pdata->stat_irq_work, bq24157_stat_irq_work);
	wake_lock_init(&pdata->stat_irq_wakelock, WAKE_LOCK_SUSPEND, "bq24157_stat_irq");	
	
	if(client->irq){
                printk("%s irq : %d\n", __func__, client->irq);

		/* check init status */ 
		if((gpio_get_value(GPIO_IRQ(bq24157_client->irq))? 1 : 0) == 1)
		{
			wake_lock(&pdata->stat_irq_wakelock);
			schedule_delayed_work(&pdata->stat_irq_work, 0);
		}

                ret = gpio_request(GPIO_IRQ(client->irq), "bq24157_stat");
                if(ret)
                {
                        printk("%s gpio_request failed\n", __func__);
                        goto err_gpio_request_bq24157_stat;
                }
                gpio_direction_input(GPIO_IRQ(client->irq));
                ret = request_irq(client->irq, bq24157_stat_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "bq24157_stat", pdata);
                if(ret)
                {
                        printk("%s request_irq failed\n", __func__);
                        goto err_request_irq_bq24157_stat;
                }
        }

	return 0;

err_request_irq_bq24157_stat:
	gpio_free(client->irq);
err_gpio_request_bq24157_stat:
#if defined(CONFIG_SPA)
	spa_chg_unregister_disable_charge(bq24157_disable_charge);
err_register_disable_charge:
	spa_chg_unregister_enable_charge(bq24157_enable_charge);
err_register_enable_charge:
#endif
err_gpio_request_cd:
err_init_data:
err_read_chip_info:
#if defined(CONFIG_SPA)
	spa_external_event = NULL; 
#endif
	bq24157_client = NULL;
err_bq24157_client_is_not_NULL:
	return ret;
}
int gpio_event_matrix_func(struct gpio_event_input_devs *input_devs,
	struct gpio_event_info *info, void **data, int func)
{
	int i;
	int err;
	int key_count;
	int wakeup_keys_status;
	int irq;
	static int irq_status = 1;
	struct gpio_kp *kp;
	struct gpio_event_matrix_info *mi;

	mi = container_of(info, struct gpio_event_matrix_info, info);
	if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) {
		/* TODO: disable scanning */
		wakeup_keys_status = gpio_event_get_wakeup_keys_status() & 0x01;
		if (irq_status != wakeup_keys_status) {
			irq_status = wakeup_keys_status;
		} else {
			return 0;
		}

		for (i = 0; i < mi->ninputs; i++) {
			irq = gpio_to_irq(mi->input_gpios[i]);
			err = set_irq_wake(irq, irq_status);
		}
		/* HOME Key is wakeup source */
		for (i = 0; i < mi->nwakeups; i++) {
			irq = gpio_to_irq(mi->wakeup_gpios[i]);
			err = set_irq_wake(irq, 1);
		}

		return 0;
	}

	if (func == GPIO_EVENT_FUNC_INIT) {
		if (mi->keymap == NULL ||
		   mi->input_gpios == NULL ||
		   mi->output_gpios == NULL) {
			err = -ENODEV;
			pr_err("gpiomatrix: Incomplete pdata\n");
			goto err_invalid_platform_data;
		}
		key_count = mi->ninputs * mi->noutputs;

		pgpio_key = *data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) *
				     BITS_TO_LONGS(key_count), GFP_KERNEL);
		if (kp == NULL) {
			err = -ENOMEM;
			pr_err("gpiomatrix: Failed to allocate private data\n");
			goto err_kp_alloc_failed;
		}
		kp->input_devs = input_devs;
		kp->keypad_info = mi;
		for (i = 0; i < key_count; i++) {
			unsigned short keyentry = mi->keymap[i];
			unsigned short keycode = keyentry & MATRIX_KEY_MASK;
			unsigned short dev = keyentry >> MATRIX_CODE_BITS;
			if (dev >= input_devs->count) {
				pr_err("gpiomatrix: bad device index %d >= "
					"%d for key code %d\n",
					dev, input_devs->count, keycode);
				err = -EINVAL;
				goto err_bad_keymap;
			}
			if (keycode && keycode <= KEY_MAX)
				input_set_capability(input_devs->dev[dev],
							EV_KEY, keycode);
		}

		for (i = 0; i < mi->noutputs; i++) {
			err = gpio_request(mi->output_gpios[i], "gpio_kp_out");
			if (err) {
				pr_err("gpiomatrix: gpio_request failed for "
					"output %d\n", mi->output_gpios[i]);
				goto err_request_output_gpio_failed;
			}
			if (gpio_cansleep(mi->output_gpios[i])) {
				pr_err("gpiomatrix: unsupported output gpio %d,"
					" can sleep\n", mi->output_gpios[i]);
				err = -EINVAL;
				goto err_output_gpio_configure_failed;
			}
			if (mi->flags & GPIOKPF_DRIVE_INACTIVE)
				err = gpio_direction_output(mi->output_gpios[i],
					!(mi->flags & GPIOKPF_ACTIVE_HIGH));
			else
				err = gpio_direction_input(mi->output_gpios[i]);
			if (err) {
				pr_err("gpiomatrix: gpio_configure failed for "
					"output %d\n", mi->output_gpios[i]);
				goto err_output_gpio_configure_failed;
			}
		}
		for (i = 0; i < mi->ninputs; i++) {
			err = gpio_request(mi->input_gpios[i], "gpio_kp_in");
			if (err) {
				pr_err("gpiomatrix: gpio_request failed for "
					"input %d\n", mi->input_gpios[i]);
				goto err_request_input_gpio_failed;
			}
			err = gpio_direction_input(mi->input_gpios[i]);
			if (err) {
				pr_err("gpiomatrix: gpio_direction_input failed"
					" for input %d\n", mi->input_gpios[i]);
				goto err_gpio_direction_input_failed;
			}
		}
		kp->current_output = mi->noutputs;
		kp->key_state_changed = 1;

		hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
		kp->timer.function = gpio_keypad_timer_func;
		wake_lock_init(&kp->wake_lock, WAKE_LOCK_SUSPEND, "gpio_kp");
		err = gpio_keypad_request_irqs(kp);
		kp->use_irq = err == 0;

		kpd_dev = device_create(sec_class, NULL, 0, NULL, "sec_key");
		if (!kpd_dev)
			printk("Failed to create device(sec_key)!\n");

		if(device_create_file(kpd_dev, &dev_attr_key_pressed) < 0)
			printk("Failed to create file(%s)!\n", dev_attr_key_pressed.attr.name);

		pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for "
			"%s%s in %s mode\n", input_devs->dev[0]->name,
			(input_devs->count > 1) ? "..." : "",
			kp->use_irq ? "interrupt" : "polling");

		if (kp->use_irq)
			wake_lock(&kp->wake_lock);
		hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);

		return 0;
	}

	err = 0;
	kp = *data;

	if (kp->use_irq)
		for (i = mi->noutputs - 1; i >= 0; i--)
			free_irq(gpio_to_irq(mi->input_gpios[i]), kp);

	hrtimer_cancel(&kp->timer);
	wake_lock_destroy(&kp->wake_lock);
	for (i = mi->noutputs - 1; i >= 0; i--) {
err_gpio_direction_input_failed:
		gpio_free(mi->input_gpios[i]);
err_request_input_gpio_failed:
		;
	}
	for (i = mi->noutputs - 1; i >= 0; i--) {
err_output_gpio_configure_failed:
		gpio_free(mi->output_gpios[i]);
err_request_output_gpio_failed:
		;
	}
err_bad_keymap:
	kfree(kp);
err_kp_alloc_failed:
err_invalid_platform_data:
	return err;
}
Beispiel #29
0
void rk2918_get_charge_status(void)
{
    int charge_on = 0;
    int tmp = get_msc_connect_flag();
	int flag = dwc_vbus_status();
	static  char  last_flag = 0;


	//printk("%s...........get_msc_connect_flag=%d,dwc_vbus_status=%d\n",__FUNCTION__,tmp,flag);
#ifdef RK29_USB_CHARGE_SUPPORT
    if ((gpio_get_value(RK29_PIN0_PA0) == 0) &&(charge_on == 0) )
    {
        //if (suspend_flag) return;
 #if 1           
        if (1 == flag)         //USB PC
        {   
			charge_on = 1;
			//printk("PC\n");
        } 
 
        else
        {
             if (2 == flag)  //充电器
            {
                charge_on = 1;
				//printk("charger\n");
            }
        }
#endif
#if 0
	if (usb_insert == 2)
	{
		charge_on = 1;
		//printk("%s.......charging  with charger\n",__FUNCTION__);
	}   
#endif 
    }
	
#endif
//printk("%s...dwc_vbus_status=%d,get_msc_connect_flag=%d\n",__FUNCTION__,dwc_vbus_status(),tmp);
   if (charge_on)
    {
        if((gBatChargeStatus !=1) || (last_flag != flag)) 
        {            
            gBatChargeStatus = 1;
			last_flag = flag;
            gBatStatusChangeCnt = 0;        //状态变化开始计数
            wake_lock(&battery_wake_lock);
			if (flag == 2)
			{
				rk2918_charge_enable();
			}		
			
        }

    } 
    else 
    {
        if(gBatChargeStatus != 0) 
        {
            gBatChargeStatus = 0;
            gBatStatusChangeCnt = 0;        //状态变化开始计数
            wake_unlock(&battery_wake_lock);
		    rk2918_charge_disable();
			
        }
    }

}
Beispiel #30
0
static int aic3254_set_config(int config_tbl, int idx, int en)
{
	int len;
	struct ecodec_aic3254_state *drv = &codec_clk;
	pr_aud_info("%s: table(0x%X) index(%d)\n", __func__, config_tbl, idx);

	wake_lock(&drv->idlelock);

#if defined(CONFIG_ARCH_MSM7X30)
	if (drv->enabled == 0) {
		/* enable MI2S RX master block */
		/* enable MI2S RX bit clock */
		clk_enable(drv->rx_mclk);
		clk_enable(drv->rx_sclk);
		printk("%s: enable CLK\n", __func__);
		drv->enabled = 1;
	}
#endif

	switch (config_tbl) {
	case AIC3254_CONFIG_TX:
		/* TX */
		pr_aud_info("%s: enable tx\n", __func__);
#if defined(CONFIG_SPI_AIC3254_SELF_POWER_DOWN)
		if (en && idx != UPLINK_OFF) {
#else
		if (en) {
#endif
			if (ctl_ops->tx_amp_enable)
				ctl_ops->tx_amp_enable(0);

			aic3254_tx_config(idx);
			aic3254_tx_mode = idx;

			if (ctl_ops->tx_amp_enable)
				ctl_ops->tx_amp_enable(1);
		} else {
			aic3254_tx_config(UPLINK_OFF);
			aic3254_tx_mode = UPLINK_OFF;
#if defined(CONFIG_SPI_AIC3254_SELF_POWER_DOWN)
			if (ctl_ops->tx_amp_enable)
				ctl_ops->tx_amp_enable(0);
			aic3254_powerdown();
#endif
		}
		break;
	case AIC3254_CONFIG_RX:
		/* RX */
		pr_aud_info("%s: enable rx\n", __func__);
#if defined(CONFIG_SPI_AIC3254_SELF_POWER_DOWN)
		if (en && idx != DOWNLINK_OFF) {
#else
		if (en) {
#endif
			if (ctl_ops->rx_amp_enable)
				ctl_ops->rx_amp_enable(0);

			aic3254_rx_config(idx);
			aic3254_rx_mode = idx;

			if (ctl_ops->rx_amp_enable)
				ctl_ops->rx_amp_enable(1);
		} else {
			aic3254_rx_config(DOWNLINK_OFF);
			aic3254_rx_mode = DOWNLINK_OFF;
#if defined(CONFIG_SPI_AIC3254_SELF_POWER_DOWN)
			if (ctl_ops->rx_amp_enable)
				ctl_ops->rx_amp_enable(0);
			aic3254_powerdown();
#endif
		}
		break;
	case AIC3254_CONFIG_MEDIA:
		if (aic3254_minidsp == NULL)
			return -EFAULT;
		len = (aic3254_minidsp[idx][0].reg << 8)
			| aic3254_minidsp[idx][0].data;

		pr_aud_info("%s: miniDSP command len = %d\n", __func__, len);
		pr_aud_info("%s: rx mode %d, tx mode %d\n",
			__func__, aic3254_rx_mode, aic3254_tx_mode);

		if (ctl_ops->rx_amp_enable)
			ctl_ops->rx_amp_enable(0);

		/* step 1: power off first */
		if (aic3254_rx_mode != DOWNLINK_OFF)
			aic3254_rx_config(DOWNLINK_OFF);

		/* step 2: config DSP */
		aic3254_config(&aic3254_minidsp[idx][1], len);

		/* step 3: switch back to original path */
		if (aic3254_rx_mode != DOWNLINK_OFF)
			aic3254_rx_config(aic3254_rx_mode);
		if (aic3254_tx_mode != UPLINK_OFF)
			aic3254_tx_config(aic3254_tx_mode);

		if (ctl_ops->rx_amp_enable)
			ctl_ops->rx_amp_enable(1);

		pr_aud_info("%s: configure minidsp done\n", __func__);
		break;
	}

	wake_unlock(&drv->idlelock);
	return 0;
}

static int aic3254_open(struct inode *inode, struct file *pfile)
{
	int ret = 0;

	mutex_lock(&lock);
	if (aic3254_opend) {
		pr_aud_err("%s: busy\n", __func__);
		ret = -EBUSY;
	} else
		aic3254_opend = 1;
	mutex_unlock(&lock);

	return ret;
}

static int aic3254_release(struct inode *inode, struct file *pfile)
{
	mutex_lock(&lock);
	aic3254_opend = 0;
	mutex_unlock(&lock);

	return 0;
}