static int32_t msm_led_trigger_config(struct msm_led_flash_ctrl_t *fctrl,
	void *data)
{
	int rc = 0;
	struct msm_camera_led_cfg_t *cfg = (struct msm_camera_led_cfg_t *)data;
	uint32_t i;
	uint32_t curr_l, max_curr_l;
	CDBG("called led_state %d\n", cfg->cfgtype);

	if (!fctrl) {
		pr_err("failed\n");
		return -EINVAL;
	}

	switch (cfg->cfgtype) {
	case MSM_CAMERA_LED_OFF:
		CDBG("%s:%d MSM_CAMERA_LED_OFF\n", __func__, __LINE__);
		for (i = 0; i < fctrl->num_sources; i++)
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i], 0);
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger, 0);
		break;

	case MSM_CAMERA_LED_LOW:
		CDBG("%s:%d MSM_CAMERA_LED_LOW\n", __func__, __LINE__);
		if (fctrl->torch_trigger) {
			max_curr_l = fctrl->torch_max_current;
			if (cfg->torch_current > 0 &&
					cfg->torch_current < max_curr_l) {
				curr_l = cfg->torch_current;
			} else {
				curr_l = fctrl->torch_op_current;
				pr_err("LED current clamped to %d\n",
					curr_l);
			}
			led_trigger_event(fctrl->torch_trigger,
				curr_l);
		}
		break;

	case MSM_CAMERA_LED_HIGH:
		CDBG("%s:%d MSM_CAMERA_LED_HIGH\n", __func__, __LINE__);
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger, 0);
		for (i = 0; i < fctrl->num_sources; i++)
			if (fctrl->flash_trigger[i]) {
				max_curr_l = fctrl->flash_max_current[i];
				if (cfg->flash_current[i] > 0 &&
						cfg->flash_current[i] < max_curr_l) {
					curr_l = cfg->flash_current[i];
				} else {
					curr_l = fctrl->flash_op_current[i];
					pr_err("LED current clamped to %d\n",
						curr_l);
				}
				led_trigger_event(fctrl->flash_trigger[i],
					curr_l);
			}
		break;
/*                                                              */
#if 1
	case MSM_CAMERA_LED_HIGH_20P:
		/* 130 */
		for (i = 0; i < fctrl->num_sources; i++)
		{
		CDBG("MSM_CAMERA_LED_HIGH_20P   ->flash_op_current[i] =	%d\n", 130);
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i],
					42);//130);
		}
		break;
	case MSM_CAMERA_LED_HIGH_40P:
		/* 260 */
		for (i = 0; i < fctrl->num_sources; i++)
		{
		CDBG("MSM_CAMERA_LED_HIGH_40P   ->flash_op_current[i] =	%d\n", 260);
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i],
					84);//260);
		}
		break;
	case MSM_CAMERA_LED_HIGH_60P:
		/* 390 */
		for (i = 0; i < fctrl->num_sources; i++)
		{
		CDBG("MSM_CAMERA_LED_HIGH_60P   ->flash_op_current[i] =	%d\n", 390);
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i],
					168);//390);
		}
		break;
	case MSM_CAMERA_LED_HIGH_80P:
		/* 520 */
		for (i = 0; i < fctrl->num_sources; i++)
		{
		CDBG("MSM_CAMERA_LED_HIGH_80P   ->flash_op_current[i] =	%d\n", 520);
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i],
					336);//520);
		}
		break;
#endif
/*                                                              */

	case MSM_CAMERA_LED_INIT:
	case MSM_CAMERA_LED_RELEASE:
		CDBG("%s:%d MSM_CAMERA_LED_RELEASE\n", __func__, __LINE__);
		for (i = 0; i < fctrl->num_sources; i++)
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i], 0);
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger, 0);
		break;

#if defined(CONFIG_MACH_LGE)
/*           
                                    
                                
 */
	case MSM_CAMERA_LED_TORCH:		//For torch, Video recording
		CDBG("%s:%d MSM_CAMERA_LED_TORCH\n", __func__, __LINE__);
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger,
				200);
		break;
#endif

	default:
		rc = -EFAULT;
		break;
	}
	CDBG("flash_set_led_state: return %d\n", rc);
	return rc;
}
Esempio n. 2
0
static void power_supply_update_bat_leds(struct power_supply *psy)
{
	union power_supply_propval status;
	unsigned long delay_on = 0;
	unsigned long delay_off = 0;

	if (psy->get_property(psy, POWER_SUPPLY_PROP_STATUS, &status))
		return;

	dev_dbg(psy->dev, "%s %d\n", __func__, status.intval);

	switch (status.intval) {
	case POWER_SUPPLY_STATUS_FULL:
		led_trigger_event(psy->charging_full_trig, LED_FULL);
		led_trigger_event(psy->charging_trig, LED_OFF);
		led_trigger_event(psy->full_trig, LED_FULL);
		led_trigger_event(psy->charging_blink_full_solid_trig,
			LED_FULL);
		break;
	case POWER_SUPPLY_STATUS_CHARGING:
		led_trigger_event(psy->charging_full_trig, LED_FULL);
		led_trigger_event(psy->charging_trig, LED_FULL);
		led_trigger_event(psy->full_trig, LED_OFF);
		led_trigger_blink(psy->charging_blink_full_solid_trig,
			&delay_on, &delay_off);
		break;
	default:
		led_trigger_event(psy->charging_full_trig, LED_OFF);
		led_trigger_event(psy->charging_trig, LED_OFF);
		led_trigger_event(psy->full_trig, LED_OFF);
		led_trigger_event(psy->charging_blink_full_solid_trig,
			LED_OFF);
		break;
	}
}
static int32_t msm_led_trigger_config(struct msm_led_flash_ctrl_t *fctrl,
	void *data)
{
	int rc = 0;
	struct msm_camera_led_cfg_t *cfg = (struct msm_camera_led_cfg_t *)data;
	uint32_t i;
	uint32_t curr_l, max_curr_l;
	CDBG("called led_state %d\n", cfg->cfgtype);

	if (!fctrl) {
		pr_err("failed\n");
		return -EINVAL;
	}

	switch (cfg->cfgtype) {
	case MSM_CAMERA_LED_OFF:
		/* Flash off */
		for (i = 0; i < fctrl->flash_num_sources; i++)
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i], 0);
		/* Torch off */
		for (i = 0; i < fctrl->torch_num_sources; i++)
			if (fctrl->torch_trigger[i])
				led_trigger_event(fctrl->torch_trigger[i], 0);
		break;

	case MSM_CAMERA_LED_LOW:
		for (i = 0; i < fctrl->torch_num_sources; i++)
			if (fctrl->torch_trigger[i]) {
				max_curr_l = fctrl->torch_max_current[i];
				if (cfg->torch_current[i] >= 0 &&
					cfg->torch_current[i] < max_curr_l) {
					curr_l = cfg->torch_current[i];
				} else {
					curr_l = fctrl->torch_op_current[i];
					pr_debug("LED torch %d clamped %d\n",
						i, curr_l);
				}
				led_trigger_event(fctrl->torch_trigger[i],
						curr_l);
			}
		break;

	case MSM_CAMERA_LED_HIGH:
		/* Torch off */
		for (i = 0; i < fctrl->torch_num_sources; i++)
			if (fctrl->torch_trigger[i])
				led_trigger_event(fctrl->torch_trigger[i], 0);

		for (i = 0; i < fctrl->flash_num_sources; i++)
			if (fctrl->flash_trigger[i]) {
				max_curr_l = fctrl->flash_max_current[i];
				if (cfg->flash_current[i] >= 0 &&
					cfg->flash_current[i] < max_curr_l) {
					curr_l = cfg->flash_current[i];
				} else {
					curr_l = fctrl->flash_op_current[i];
					pr_debug("LED flash %d clamped %d\n",
						i, curr_l);
				}
				led_trigger_event(fctrl->flash_trigger[i],
					curr_l);
			}
		break;

	case MSM_CAMERA_LED_INIT:
	case MSM_CAMERA_LED_RELEASE:
		/* Flash off */
		for (i = 0; i < fctrl->flash_num_sources; i++)
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i], 0);
		/* Torch off */
		for (i = 0; i < fctrl->torch_num_sources; i++)
			if (fctrl->torch_trigger[i])
				led_trigger_event(fctrl->torch_trigger[i], 0);
		break;

	default:
		rc = -EFAULT;
		break;
	}
	CDBG("flash_set_led_state: return %d\n", rc);
	return rc;
}
Esempio n. 4
0
static void
wbcir_irq_tx(struct wbcir_data *data)
{
	unsigned int space;
	unsigned int used;
	u8 bytes[16];
	u8 byte;

	if (!data->txbuf)
		return;

	switch (data->txstate) {
	case WBCIR_TXSTATE_INACTIVE:
		/* TX FIFO empty */
		space = 16;
		led_trigger_event(data->txtrigger, LED_FULL);
		break;
	case WBCIR_TXSTATE_ACTIVE:
		/* TX FIFO low (3 bytes or less) */
		space = 13;
		break;
	case WBCIR_TXSTATE_ERROR:
		space = 0;
		break;
	default:
		return;
	}

	/*
	 * TX data is run-length coded in bytes: YXXXXXXX
	 * Y = space (1) or pulse (0)
	 * X = duration, encoded as (X + 1) * 10us (i.e 10 to 1280 us)
	 */
	for (used = 0; used < space && data->txoff != data->txlen; used++) {
		if (data->txbuf[data->txoff] == 0) {
			data->txoff++;
			continue;
		}
		byte = min((u32)0x80, data->txbuf[data->txoff]);
		data->txbuf[data->txoff] -= byte;
		byte--;
		byte |= (data->txoff % 2 ? 0x80 : 0x00); /* pulse/space */
		bytes[used] = byte;
	}

	while (data->txbuf[data->txoff] == 0 && data->txoff != data->txlen)
		data->txoff++;

	if (used == 0) {
		/* Finished */
		if (data->txstate == WBCIR_TXSTATE_ERROR)
			/* Clear TX underrun bit */
			outb(WBCIR_TX_UNDERRUN, data->sbase + WBCIR_REG_SP3_ASCR);
		else
			data->txstate = WBCIR_TXSTATE_DONE;
		wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR);
		led_trigger_event(data->txtrigger, LED_OFF);
		wake_up(&data->txwaitq);
	} else if (data->txoff == data->txlen) {
		/* At the end of transmission, tell the hw before last byte */
		outsb(data->sbase + WBCIR_REG_SP3_TXDATA, bytes, used - 1);
		outb(WBCIR_TX_EOT, data->sbase + WBCIR_REG_SP3_ASCR);
		outb(bytes[used - 1], data->sbase + WBCIR_REG_SP3_TXDATA);
		wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR |
				  WBCIR_IRQ_TX_EMPTY);
	} else {
		/* More data to follow... */
		outsb(data->sbase + WBCIR_REG_SP3_RXDATA, bytes, used);
		if (data->txstate == WBCIR_TXSTATE_INACTIVE) {
			wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR |
					  WBCIR_IRQ_TX_LOW);
			data->txstate = WBCIR_TXSTATE_ACTIVE;
		}
	}
}
static void ledtrig_sleep_power_suspend(struct power_suspend *h)
{
	led_trigger_event(ledtrig_sleep, LED_FULL);
}
static void ledtrig_sleep_power_resume(struct power_suspend *h)
{
	led_trigger_event(ledtrig_sleep, LED_OFF);
}
Esempio n. 7
0
/**
 *	mmc_request_done - finish processing an MMC request
 *	@host: MMC host which completed request
 *	@mrq: MMC request which request
 *
 *	MMC drivers should call this function when they have completed
 *	their processing of a request.
 */
void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
{
	struct mmc_command *cmd;
	int err;

	if(mrq == NULL)
		return;

	cmd = mrq->cmd;

	if(cmd == NULL)
		return;

	err = cmd->error;

	if (err && cmd->retries && mmc_host_is_spi(host)) {
		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
			cmd->retries = 0;
	}

	if (err && cmd->retries) {
		printk("%s: req failed (CMD%u): %d, retrying...\n",
			mmc_hostname(host), cmd->opcode, err);

		cmd->retries--;
		cmd->error = 0;
		host->ops->request(host, mrq);
	} else {
		led_trigger_event(host->led, LED_OFF);

		pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
			mmc_hostname(host), cmd->opcode, err,
			cmd->resp[0], cmd->resp[1],
			cmd->resp[2], cmd->resp[3]);

		if (mrq->data) {
//[NAGSM_Android_HDLNC_SDcard_shinjonghyun_20100507 : add LOG for MoviNAND debuging	
		/*
			pr_debug("%s:     %d bytes transferred: %d\n",
				mmc_hostname(host),
				mrq->data->bytes_xfered, mrq->data->error);
		*/
			if(mrq->data->error != 0){
				printk("%s:     %d bytes transferred: %d\n",
					mmc_hostname(host),
					mrq->data->bytes_xfered, mrq->data->error);
			}
//]NAGSM_Android_HDLNC_SDcard_shinjonghyun_20100507 : add LOG for MoviNAND debuging
		}

		if (mrq->stop) {
			pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
				mmc_hostname(host), mrq->stop->opcode,
				mrq->stop->error,
				mrq->stop->resp[0], mrq->stop->resp[1],
				mrq->stop->resp[2], mrq->stop->resp[3]);
		}

		if (mrq->done)
			mrq->done(mrq);
	}
}
static void wifi_trig_activate(struct led_classdev *led_cdev)
{

    led_trigger_event(&wifi_led_trigger,last_state?LED_FULL:LED_OFF);
}
/* ------------------------------------------------------------------------- */
static int shcamled_pmic_set_torch_led_2_current(unsigned mA)
{
	unsigned int led_current = 0;
	
	mutex_lock(&shcamled_torch_mut);

	SHCAMLED_TRACE("%s in mA:%d ucam:%d ucom:%d\n", __FUNCTION__, mA,
				   shcamled_use_torch_led_cam, shcamled_use_torch_led_comm);

	if(mA == 0) {
		if(shcamled_use_torch_led_cam == FALSE && shcamled_use_torch_led_comm == TRUE) {
			/* request turning off */
			if(flash_mode != 0){
				led_trigger_event(cam_torch_flash_0_trigger, 0);
				led_trigger_event(cam_torch_flash_1_trigger, 0);
				SHCAMLED_TRACE("%s %d wake_up_interruptible start\n", __FUNCTION__, __LINE__);
				mutex_lock(&shcamled_mut);
//				qpnp_flash_control_enable(false);
				if(atomic_read(&flash_on_prepare) == 1){
					wait_for_completion(&flash_on_complete);
				}
				flash_off_thread_active = 1;
				wake_up_interruptible(&shcamled_msg_off_wait);
				SHCAMLED_TRACE("%s %d wake_up_interruptible end\n", __FUNCTION__, __LINE__);
				flash_mode = 0;
			}
			if(torch_mode != 0){
				led_trigger_event(cam_torch_led_1_trigger, 0);
				torch_mode = 0;
			}
			shcamled_use_torch_led_comm = FALSE;
		}
	} else {
		/* calucurate mA for leds_qpnq */
		led_current = mA / 25 /* 12.5 * 2 */;
		if(led_current > 1){
			led_current = led_current - 1;
		} else {
			led_current = 0;
		}
		if(mA > 100){
			led_current = (led_current * 1000 + 0x4E) / 0x4F;
			#if defined(CONFIG_ARCH_MSM8226)
			led_current = SHCAM_LED_FLASH_CURRENT;
			#endif
		} else {
			led_current = (led_current * 200 + 0x0E) / 0x0F;
		}
		if(led_current < 1){
			led_current = 1;
		}
		SHCAMLED_TRACE("%s led_current=%d\n", __FUNCTION__, led_current);
		
		if(shcamled_use_torch_led_cam == FALSE && shcamled_use_torch_led_comm == FALSE){
			/* request turning on */
			if(mA > 100){
				if(torch_mode != 0){
					led_trigger_event(cam_torch_led_1_trigger, 0);
					torch_mode = 0;
				}
				SHCAMLED_TRACE("%s %d qpnp_flash_control_enable(true) start\n", __FUNCTION__, __LINE__);
//				qpnp_flash_control_enable(true);
				if(atomic_read(&flash_on_prepare) == 0){
					shcamled_pmic_flash_prepare();
				}
				wait_for_completion(&flash_on_complete);
				atomic_set(&flash_on_prepare, 0);
				SHCAMLED_TRACE("%s %d qpnp_flash_control_enable(true) end\n", __FUNCTION__, __LINE__);
				led_trigger_event(cam_torch_flash_0_trigger, led_current);
				led_trigger_event(cam_torch_flash_1_trigger, led_current);
				flash_mode = 1;
			} else {
				if(flash_mode != 0){
					led_trigger_event(cam_torch_flash_0_trigger, 0);
					led_trigger_event(cam_torch_flash_1_trigger, 0);
					SHCAMLED_TRACE("%s %d wake_up_interruptible start\n", __FUNCTION__, __LINE__);
					mutex_lock(&shcamled_mut);
//					qpnp_flash_control_enable(false);
					if(atomic_read(&flash_on_prepare) == 1){
						wait_for_completion(&flash_on_complete);
					}
					flash_off_thread_active = 1;
					wake_up_interruptible(&shcamled_msg_off_wait);
					SHCAMLED_TRACE("%s %d wake_up_interruptible end\n", __FUNCTION__, __LINE__);
					flash_mode = 0;
				}
				led_trigger_event(cam_torch_led_1_trigger, led_current);
				torch_mode = 1;
			}
			shcamled_use_torch_led_comm = TRUE;
		}
	}

	SHCAMLED_TRACE("%s done ucam:%d ucom:%d\n", __FUNCTION__,
				   shcamled_use_torch_led_cam, shcamled_use_torch_led_comm);

	mutex_unlock(&shcamled_torch_mut);

	return 0;
}
static int32_t msm_led_trigger_config(struct msm_led_flash_ctrl_t *fctrl,
	void *data)
{
	int rc = 0;
	struct msm_camera_led_cfg_t *cfg = (struct msm_camera_led_cfg_t *)data;
	uint32_t i;
#ifdef CONFIG_FLED_RT5033_EXT_GPIO
	rt_fled_info_t *fled_info = rt_fled_get_info_by_name(NULL);
#endif
#if 0
	uint32_t curr_l, max_curr_l;
#endif
	CDBG("called led_state %d\n", cfg->cfgtype);

	if (!fctrl) {
		pr_err("failed\n");
		return -EINVAL;
	}

	switch (cfg->cfgtype) {
	case MSM_CAMERA_LED_OFF:
		CDBG("MSM_CAMERA_LED_OFF\n");
#ifdef CONFIG_FLED_RT5033_EXT_GPIO
		if (assistive_light == true) {
			CDBG("When assistive light, Not control flash\n");
			return 0;
		}
#endif
		gpio_request(fctrl->led_irq_gpio1, NULL);
		gpio_request(fctrl->led_irq_gpio2, NULL);
		gpio_direction_output(fctrl->led_irq_gpio1, 0);
		gpio_direction_output(fctrl->led_irq_gpio2, 0);
		gpio_free(fctrl->led_irq_gpio1);
		gpio_free(fctrl->led_irq_gpio2);
#ifdef CONFIG_FLED_RT5033_EXT_GPIO
		if (lock_state) {
			if (fled_info) {
				rt5033_fled_strobe_critial_section_unlock(fled_info);
				lock_state = false;
			}
		}
#endif
		break;
#if 0
		for (i = 0; i < fctrl->num_sources; i++)
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i], 0);
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger, 0);
		break;
#endif

	case MSM_CAMERA_LED_LOW:
		CDBG("MSM_CAMERA_LED_LOW\n");
#ifdef CONFIG_FLED_RT5033_EXT_GPIO
		if (assistive_light == true) {
			CDBG("When assistive light, Not control flash\n");
			return 0;
		}
#endif
		gpio_request(fctrl->led_irq_gpio1, NULL);
		gpio_direction_output(fctrl->led_irq_gpio1, 1);
		gpio_free(fctrl->led_irq_gpio1);
		break;
#if 0
		if (fctrl->torch_trigger) {
			max_curr_l = fctrl->torch_max_current;
			if (cfg->torch_current > 0 &&
				cfg->torch_current < max_curr_l) {
				curr_l = cfg->torch_current;
			} else {
				curr_l = fctrl->torch_op_current;
				pr_debug("LED current clamped to %d\n",
					curr_l);
			}
			led_trigger_event(fctrl->torch_trigger,
				curr_l);
		}
		break;
#endif

	case MSM_CAMERA_LED_HIGH:
		CDBG("MSM_CAMERA_LED_HIGH\n");
#ifdef CONFIG_FLED_RT5033_EXT_GPIO
		if (assistive_light == true) {
			CDBG("When assistive light, Not control flash\n");
			return 0;
		}
		if (fled_info) {
			rt5033_fled_strobe_critial_section_lock(fled_info);
			lock_state = true;
		}
#endif
		gpio_request(fctrl->led_irq_gpio2, NULL);
		gpio_direction_output(fctrl->led_irq_gpio2, 1);
		gpio_free(fctrl->led_irq_gpio2);
		break;
#if 0
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger, 0);
		for (i = 0; i < fctrl->num_sources; i++)
			if (fctrl->flash_trigger[i]) {
				max_curr_l = fctrl->flash_max_current[i];
				if (cfg->flash_current[i] > 0 &&
					cfg->flash_current[i] < max_curr_l) {
					curr_l = cfg->flash_current[i];
				} else {
					curr_l = fctrl->flash_op_current[i];
					pr_debug("LED current clamped to %d\n",
						curr_l);
				}
				led_trigger_event(fctrl->flash_trigger[i],
					curr_l);
			}
		break;
#endif
	case MSM_CAMERA_LED_INIT:
	case MSM_CAMERA_LED_RELEASE:
		CDBG("MSM_CAMERA_LED_INIT\n");
#ifdef CONFIG_FLED_RT5033_EXT_GPIO
		if (assistive_light == true) {
			CDBG("When assistive light, Not control flash\n");
		} else {
			gpio_request(fctrl->led_irq_gpio1, NULL);
			gpio_request(fctrl->led_irq_gpio2, NULL);
			gpio_direction_output(fctrl->led_irq_gpio1, 0);
			gpio_direction_output(fctrl->led_irq_gpio2, 0);
			gpio_free(fctrl->led_irq_gpio1);
			gpio_free(fctrl->led_irq_gpio2);
			if (lock_state) {
				if (fled_info) {
					rt5033_fled_strobe_critial_section_unlock(fled_info);
					lock_state = false;
				}
			}
		}
#endif
		for (i = 0; i < fctrl->num_sources; i++)
			if (fctrl->flash_trigger[i])
				led_trigger_event(fctrl->flash_trigger[i], 0);
		if (fctrl->torch_trigger)
			led_trigger_event(fctrl->torch_trigger, 0);
		break;

	default:
		pr_err("LED state error!\n");
		rc = -EFAULT;
		break;
	}

	CDBG("flash_set_led_state: return %d\n", rc);
	return rc;
}
Esempio n. 11
0
void ledtrig_torch_ctrl(bool on)
{
	enum led_brightness brt = on ? LED_FULL : LED_OFF;

	led_trigger_event(ledtrig_torch, brt);
}
Esempio n. 12
0
void ledtrig_wifi_linkdown(struct led_classdev *led_cdev)
{
  led_trigger_event(&ledtrig_wifi, LED_OFF);
}
Esempio n. 13
0
void ledtrig_wifi_linkup(struct led_classdev *led_cdev)
{
  led_trigger_event(&ledtrig_wifi, INT_MAX);
}
Esempio n. 14
0
static void
mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
#ifdef CONFIG_MMC_DEBUG
	unsigned int i, sz;
	struct scatterlist *sg;
#endif

	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
		 mmc_hostname(host), mrq->cmd->opcode,
		 mrq->cmd->arg, mrq->cmd->flags);

	if (mrq->data) {
		pr_debug("%s:     blksz %d blocks %d flags %08x "
			"tsac %d ms nsac %d\n",
			mmc_hostname(host), mrq->data->blksz,
			mrq->data->blocks, mrq->data->flags,
			mrq->data->timeout_ns / 1000000,
			mrq->data->timeout_clks);
	}

	if (mrq->stop) {
		pr_debug("%s:     CMD%u arg %08x flags %08x\n",
			 mmc_hostname(host), mrq->stop->opcode,
			 mrq->stop->arg, mrq->stop->flags);
	}

	WARN_ON(!host->claimed);

	led_trigger_event(host->led, LED_FULL);

	mrq->cmd->error = 0;
	mrq->cmd->mrq = mrq;
	if (mrq->data) {
		BUG_ON(mrq->data->blksz > host->max_blk_size);
		BUG_ON(mrq->data->blocks > host->max_blk_count);
		BUG_ON(mrq->data->blocks * mrq->data->blksz >
			host->max_req_size);

#ifdef CONFIG_MMC_DEBUG
		sz = 0;
		for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
			sz += sg->length;
		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
#endif

		mrq->cmd->data = mrq->data;
		mrq->data->error = 0;
		mrq->data->mrq = mrq;
		if (mrq->stop) {
			mrq->data->stop = mrq->stop;
			mrq->stop->error = 0;
			mrq->stop->mrq = mrq;
		}

#ifdef CONFIG_MMC_PERF_PROFILING
		host->perf.start = ktime_get();
#endif
	}
	host->ops->request(host, mrq);
}
static void
wbcir_irq_tx(struct wbcir_data *data)
{
	unsigned int space;
	unsigned int used;
	u8 bytes[16];
	u8 byte;

	if (!data->txbuf)
		return;

	switch (data->txstate) {
	case WBCIR_TXSTATE_INACTIVE:
		
		space = 16;
		led_trigger_event(data->txtrigger, LED_FULL);
		break;
	case WBCIR_TXSTATE_ACTIVE:
		
		space = 13;
		break;
	case WBCIR_TXSTATE_ERROR:
		space = 0;
		break;
	default:
		return;
	}

	for (used = 0; used < space && data->txoff != data->txlen; used++) {
		if (data->txbuf[data->txoff] == 0) {
			data->txoff++;
			continue;
		}
		byte = min((u32)0x80, data->txbuf[data->txoff]);
		data->txbuf[data->txoff] -= byte;
		byte--;
		byte |= (data->txoff % 2 ? 0x80 : 0x00); 
		bytes[used] = byte;
	}

	while (data->txbuf[data->txoff] == 0 && data->txoff != data->txlen)
		data->txoff++;

	if (used == 0) {
		
		if (data->txstate == WBCIR_TXSTATE_ERROR)
			
			outb(WBCIR_TX_UNDERRUN, data->sbase + WBCIR_REG_SP3_ASCR);
		else
			data->txstate = WBCIR_TXSTATE_DONE;
		wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR);
		led_trigger_event(data->txtrigger, LED_OFF);
		wake_up(&data->txwaitq);
	} else if (data->txoff == data->txlen) {
		
		outsb(data->sbase + WBCIR_REG_SP3_TXDATA, bytes, used - 1);
		outb(WBCIR_TX_EOT, data->sbase + WBCIR_REG_SP3_ASCR);
		outb(bytes[used - 1], data->sbase + WBCIR_REG_SP3_TXDATA);
		wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR |
				  WBCIR_IRQ_TX_EMPTY);
	} else {
		
		outsb(data->sbase + WBCIR_REG_SP3_RXDATA, bytes, used);
		if (data->txstate == WBCIR_TXSTATE_INACTIVE) {
			wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR |
					  WBCIR_IRQ_TX_LOW);
			data->txstate = WBCIR_TXSTATE_ACTIVE;
		}
	}
}
static int32_t msm_led_trigger_config(struct msm_led_flash_ctrl_t *fctrl,
                                      void *data)
{
    int rc = 0;
    struct msm_camera_led_cfg_t *cfg = (struct msm_camera_led_cfg_t *)data;
    CDBG("called led_state %d\n", cfg->cfgtype);
#if defined(CONFIG_MACH_VIENNAEUR) || defined(CONFIG_MACH_LT03EUR)\
	|| defined(CONFIG_MACH_LT03SKT)	|| defined(CONFIG_MACH_LT03KTT)\
	|| defined(CONFIG_MACH_LT03LGT)
    if (is_torch_enabled == true) {
        return rc;
    }
#endif
    if (!fctrl->led_trigger[0]) {
        pr_err("failed\n");
        return -EINVAL;
    }
#if defined(CONFIG_LEDS_MAX77803)
    switch (cfg->cfgtype) {
    case MSM_CAMERA_LED_OFF:
        pr_err("CAM Flash OFF");
        max77803_led_en(0, 0);
        max77803_led_en(0, 1);
        break;

    case MSM_CAMERA_LED_LOW:
        pr_err("CAM Pre Flash ON");
        max77803_led_en(1, 0);
        break;

    case MSM_CAMERA_LED_HIGH:
        pr_err("CAM Flash ON");
        max77803_led_en(1, 1);
        break;

    case MSM_CAMERA_LED_INIT:
    case MSM_CAMERA_LED_RELEASE:
        break;

    default:
        rc = -EFAULT;
        break;
    }
// Implementation KTD2692 flashIC
#elif defined(CONFIG_MACH_VIENNAEUR) || defined(CONFIG_MACH_LT03EUR)\
	|| defined(CONFIG_MACH_LT03SKT)	|| defined(CONFIG_MACH_LT03KTT)\
	|| defined(CONFIG_MACH_LT03LGT)
    switch (cfg->cfgtype) {
#if defined(CONFIG_MACH_LT03EUR) || defined(CONFIG_MACH_LT03SKT)\
	|| defined(CONFIG_MACH_LT03KTT)	|| defined(CONFIG_MACH_LT03LGT)
    case MSM_CAMERA_LED_OFF:
        KTD2692_set_flash(MODE_CONTROL | 0x00);
        break;
    case MSM_CAMERA_LED_LOW:
        KTD2692_set_flash(LVP_SETTING | 0x00);
        KTD2692_set_flash(MOVIE_CURRENT | 0x04);
        KTD2692_set_flash(MODE_CONTROL | 0x01);
        break;
    case MSM_CAMERA_LED_HIGH:
        KTD2692_set_flash(LVP_SETTING | 0x00);
        KTD2692_set_flash(FLASH_CURRENT | 0x0F);
        KTD2692_set_flash(MODE_CONTROL | 0x02);
        break;
    case MSM_CAMERA_LED_INIT:
        break;
    case MSM_CAMERA_LED_RELEASE:
        gpio_set_value(led_torch_en, 0);
        break;
    default:
        rc = -EFAULT;
        break;
#else
    case MSM_CAMERA_LED_OFF:
        if (system_rev < 0x02) { // For KTD267 flashIC
            gpio_set_value(led_flash_en, 0);
            gpio_set_value(led_torch_en, 0);
        } else { // For KTD2692 flashIC
            KTD2692_set_flash(MODE_CONTROL | 0x00);
        }
        break;

    case MSM_CAMERA_LED_LOW:
        if (system_rev < 0x02) { // For KTD267 flashIC
            gpio_set_value(led_flash_en, 1);
            gpio_set_value(led_torch_en, 1);
        } else { // For KTD2692 flashIC
            KTD2692_set_flash(LVP_SETTING | 0x00);
            KTD2692_set_flash(MOVIE_CURRENT | 0x04);
            KTD2692_set_flash(MODE_CONTROL | 0x01);
        }
        break;

    case MSM_CAMERA_LED_HIGH:
        if (system_rev < 0x02) { // For KTD267 flashIC
            gpio_set_value(led_flash_en, 1);
            gpio_set_value(led_torch_en, 1);
        } else { // For KTD2692 flashIC
            KTD2692_set_flash(LVP_SETTING | 0x00);
            KTD2692_set_flash(FLASH_CURRENT | 0x0F);
            KTD2692_set_flash(MODE_CONTROL | 0x02);
        }
        break;

    case MSM_CAMERA_LED_INIT:
        break;

    case MSM_CAMERA_LED_RELEASE:
        if (system_rev < 0x02) { // For KTD267 flashIC
        } else { // For KTD2692 flashIC
            gpio_set_value(led_torch_en, 0);
        }
        break;

    default:
        rc = -EFAULT;
        break;
#endif
    }
#else
    switch (cfg->cfgtype) {
    case MSM_CAMERA_LED_OFF:
        led_trigger_event(fctrl->led_trigger[0], 0);
        break;

    case MSM_CAMERA_LED_LOW:
        led_trigger_event(fctrl->led_trigger[0],
                          fctrl->max_current[0] / 2);
        break;

    case MSM_CAMERA_LED_HIGH:
        led_trigger_event(fctrl->led_trigger[0], fctrl->max_current[0]);
        break;

    case MSM_CAMERA_LED_INIT:
    case MSM_CAMERA_LED_RELEASE:
        led_trigger_event(fctrl->led_trigger[0], 0);
        break;

    default:
        rc = -EFAULT;
        break;
    }
#endif
    CDBG("flash_set_led_state: return %d\n", rc);
    return rc;
}
Esempio n. 17
0
static int32_t msm_led_trigger_config(struct msm_led_flash_ctrl_t *fctrl,
	void *data)
{
	int rc = 0;

	struct msm_camera_led_cfg_t *cfg = (struct msm_camera_led_cfg_t *)data;
	CDBG("called led_state %d\n", cfg->cfgtype);

	if (!fctrl) {
		pr_err("failed\n");
		return -EINVAL;
	}

#if defined(CONFIG_LEDS_MAX77804K) && defined(CONFIG_LEDS_MAX77828)
    if (!strcmp(fctrl->flash_driver, MAX77804K_DRIVER)) {
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("%s : CAM Flash OFF\n", fctrl->flash_driver);
            max77804k_led_en(0, 0);
            max77804k_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("%s : CAM Pre Flash ON\n", fctrl->flash_driver);
            max77804k_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("%s : CAM Flash ON\n", fctrl->flash_driver);
            max77804k_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            max77804k_led_en(0, 0);
            max77804k_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
    } else if (!strcmp(fctrl->flash_driver, MAX77828_DRIVER)){ //max77828
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("%s : CAM Flash OFF\n", fctrl->flash_driver);
            max77828_led_en(0, 0);
            max77828_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("%s : CAM Pre Flash ON\n", fctrl->flash_driver);
            max77828_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("%s : CAM Flash ON\n", fctrl->flash_driver);
            max77828_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            max77828_led_en(0, 0);
            max77828_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
    }else {
        pr_err("%s : can't find valid flash driver\n", __FUNCTION__);
        pr_err("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        rc = -EINVAL;
    }
#elif defined(CONFIG_LEDS_MIC2873) && defined(CONFIG_LEDS_MAX77828)
    if (!strcmp(fctrl->flash_driver, MIC2873_DRIVER)) {//mic2873
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("%s : CAM Flash OFF\n", fctrl->flash_driver);
            mic2873_led_en(0, 0);
            mic2873_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("%s : CAM Pre Flash ON\n", fctrl->flash_driver);
            mic2873_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("%s : CAM Flash ON\n", fctrl->flash_driver);
            mic2873_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            mic2873_led_en(0, 0);
            mic2873_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
    } else if (!strcmp(fctrl->flash_driver, MAX77828_DRIVER)){ //max77828
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("%s : CAM Flash OFF\n", fctrl->flash_driver);
            max77828_led_en(0, 0);
            max77828_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("%s : CAM Pre Flash ON\n", fctrl->flash_driver);
            max77828_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("%s : CAM Flash ON\n", fctrl->flash_driver);
            max77828_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            max77828_led_en(0, 0);
            max77828_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
    }else {
        pr_err("%s : can't find valid flash driver\n", __FUNCTION__);
        pr_err("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        rc = -EINVAL;
    }
#elif defined(CONFIG_LEDS_MAX77804K)
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("CAM Flash OFF\n");
            max77804k_led_en(0, 0);
            max77804k_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("CAM Pre Flash ON\n");
            max77804k_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("CAM Flash ON\n");
            max77804k_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            max77804k_led_en(0, 0);
            max77804k_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
#elif defined(CONFIG_LEDS_MAX77828)
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("CAM Flash OFF\n");
            max77828_led_en(0, 0);
            max77828_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("CAM Pre Flash ON\n");
            max77828_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("CAM Flash ON\n");
            max77828_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            max77828_led_en(0, 0);
            max77828_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
#elif defined(CONFIG_LEDS_MIC2873)
        CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
        switch (cfg->cfgtype) {
        case MSM_CAMERA_LED_OFF:
            pr_info("CAM Flash OFF\n");
            mic2873_led_en(0, 0);
            mic2873_led_en(0, 1);
            break;

        case MSM_CAMERA_LED_LOW:
            pr_info("CAM Pre Flash ON\n");
            mic2873_led_en(1, 0);
            break;

        case MSM_CAMERA_LED_HIGH:
            pr_info("CAM Flash ON\n");
            mic2873_led_en(1, 1);
            break;

        case MSM_CAMERA_LED_INIT:
            break;

        case MSM_CAMERA_LED_RELEASE:
            pr_info("%s : CAM Flash OFF & release\n", fctrl->flash_driver);
            mic2873_led_en(0, 0);
            mic2873_led_en(0, 1);
            break;

        default:
            rc = -EFAULT;
            break;
        }
#else
	CDBG("%s : driver is %s\n", __FUNCTION__, fctrl->flash_driver);
	switch (cfg->cfgtype) {
	case MSM_CAMERA_LED_OFF:
		led_trigger_event(fctrl->led_trigger[0], 0);
		break;

	case MSM_CAMERA_LED_LOW:
		led_trigger_event(fctrl->led_trigger[0],
			fctrl->max_current[0] / 2);
		break;

	case MSM_CAMERA_LED_HIGH:
		led_trigger_event(fctrl->led_trigger[0], fctrl->max_current[0]);
		break;

	case MSM_CAMERA_LED_INIT:
	case MSM_CAMERA_LED_RELEASE:
		led_trigger_event(fctrl->led_trigger[0], 0);
		break;

	default:
		rc = -EFAULT;
		break;
	}
#endif
	CDBG("flash_set_led_state: return %d\n", rc);
	return rc;
}