Exemple #1
0
static void mtk_set_vbus(struct musb *musb, int is_on)
{
    #ifndef CONFIG_MT6575T_FPGA
    DBG(0,"mt65xx_usb20_vbus++,is_on=%d\r\n",is_on);
    if(is_on) {
		//power on VBUS, implement later...
		#ifdef MTK_FAN5405_SUPPORT
		fan5405_set_opa_mode(1);
	    	fan5405_set_otg_pl(1);
		fan5405_set_otg_en(1);
		#elif defined(MTK_NCP1851_SUPPORT)
		  tbl_charger_otg_vbus((work_busy(&musb->id_pin_work.work)<< 8)| 1);
		#else
		mt_set_gpio_out(GPIO_OTG_DRVVBUS_PIN, GPIO_OUT_ONE);
		#endif
	} else{
		//power off VBUS, implement later...
		#ifdef MTK_FAN5405_SUPPORT
		fan5405_config_interface_liao(0x01,0x30);
		fan5405_config_interface_liao(0x02,0x8e);
		#elif defined(MTK_NCP1851_SUPPORT)
		  tbl_charger_otg_vbus((work_busy(&musb->id_pin_work.work)<< 8)| 0);
		#else
		mt_set_gpio_out(GPIO_OTG_DRVVBUS_PIN, GPIO_OUT_ZERO);
		#endif
	}
    #endif
    return;
}
void
intel_dsi_set_drrs_state(struct intel_encoder *intel_encoder)
{
	struct drm_i915_private *dev_priv =
				intel_encoder->base.dev->dev_private;
	struct drm_display_mode *target_mode =
				dev_priv->drrs.connector->panel.target_mode;
	struct intel_mipi_drrs_work *work = dev_priv->drrs.mipi_drrs_work;
	unsigned int ret;

	ret = work_busy(&work->work.work);
	if (ret) {
		if (work->target_mode)
			if (work->target_mode->vrefresh ==
						target_mode->vrefresh) {
				DRM_DEBUG_KMS("Repeated request for %dHz\n",
							target_mode->vrefresh);
				return;
			}
		DRM_DEBUG_KMS("Cancelling an queued/executing work\n");
		atomic_set(&work->abort_wait_loop, 1);
		cancel_delayed_work_sync(&work->work);
		atomic_set(&work->abort_wait_loop, 0);
		if (ret & WORK_BUSY_PENDING)
			drm_mode_destroy(intel_encoder->base.dev,
							work->target_mode);

	}
	work->intel_encoder = intel_encoder;
	work->target_rr_type = dev_priv->drrs_state.target_rr_type;
	work->target_mode = drm_mode_duplicate(intel_encoder->base.dev,
								target_mode);

	schedule_delayed_work(&dev_priv->drrs.mipi_drrs_work->work, 0);
}
static int ctrl_bridge_start_read(struct ctrl_bridge *dev)
{
	int	retval = 0;

	if (!dev->inturb) {
		dev_err(&dev->intf->dev, "%s: inturb is NULL\n", __func__);
		return -ENODEV;
	}

	if (work_busy(&dev->get_encap_work)) {
		pr_info("work busy, passthrough");
		return 0;
	}
	if (!dev->inturb->anchor) {
		usb_anchor_urb(dev->inturb, &dev->tx_submitted);
		retval = usb_submit_urb(dev->inturb, GFP_KERNEL);
		if (retval < 0) {
			dev_err(&dev->intf->dev,
				"%s error submitting int urb %d\n",
				__func__, retval);
			usb_unanchor_urb(dev->inturb);
		}
	}

	return retval;
}
static void mtk_set_vbus(struct musb *musb, int is_on)
{
    DBG(0,"mt65xx_usb20_vbus++,is_on=%d\r\n",is_on);
#ifndef CONFIG_MT6589_FPGA
    if(is_on){
        //power on VBUS, implement later...
    #ifdef MTK_FAN5405_SUPPORT
        fan5405_set_opa_mode(1);
        fan5405_set_otg_pl(1);
        fan5405_set_otg_en(1);
    #elif defined(MTK_BQ24158_SUPPORT)
        bq24158_set_opa_mode(1);
	bq24158_set_otg_pl(1);
	bq24158_set_otg_en(1);
//<2013/1/21-20645-jessicatseng, [Pelican] Intrgrate charging IC BQ24157 for PRE-MP SW
    #elif defined(MTK_BQ24157_SUPPORT)
        bq24157_set_opa_mode(1);
        bq24157_set_otg_pl(1);
        bq24157_set_otg_en(1);
//>2013/1/21-20645-jessicatseng
    #elif defined(MTK_NCP1851_SUPPORT) || defined(MTK_BQ24196_SUPPORT)
        tbl_charger_otg_vbus((work_busy(&musb->id_pin_work.work)<< 8)| 1);
    #else
        mt_set_gpio_out(GPIO_OTG_DRVVBUS_PIN,GPIO_OUT_ONE);
        #endif
    } else {
        //power off VBUS, implement later...
    #ifdef MTK_FAN5405_SUPPORT
        fan5405_config_interface_liao(0x01,0x30);
	fan5405_config_interface_liao(0x02,0x8e);
    #elif defined(MTK_BQ24158_SUPPORT)
        bq24158_config_interface_reg(0x01,0x30);
	bq24158_config_interface_reg(0x02,0x8e);
//<2013/1/21-20645-jessicatseng, [Pelican] Intrgrate charging IC BQ24157 for PRE-MP SW
    #elif defined(MTK_BQ24157_SUPPORT)
        bq24157_config_interface_liao(0x01,0x30);
	bq24157_config_interface_liao(0x02,0x8e);
//>2013/1/21-20645-jessicatseng
    #elif defined(MTK_NCP1851_SUPPORT) || defined(MTK_BQ24196_SUPPORT)
        tbl_charger_otg_vbus((work_busy(&musb->id_pin_work.work)<< 8)| 0);
    #else
        mt_set_gpio_out(GPIO_OTG_DRVVBUS_PIN,GPIO_OUT_ZERO);
    #endif
    }
#endif
    return;
}
void mt_usb_set_vbus(struct musb *musb, int is_on)
{
    DBG(0,"mt65xx_usb20_vbus++,is_on=%d\r\n",is_on);
#ifndef FPGA_PLATFORM
    if(is_on){
        //power on VBUS, implement later...
    #ifdef MTK_FAN5405_SUPPORT
        fan5405_set_opa_mode(1);
        fan5405_set_otg_pl(1);
        fan5405_set_otg_en(1);
    #elif defined(MTK_BQ24157_SUPPORT)
        bq24157_set_opa_mode(1);
        bq24157_set_otg_pl(1);
        bq24157_set_otg_en(1);
    #elif defined(MTK_BQ24158_SUPPORT)
        bq24158_set_opa_mode(1);
        bq24158_set_otg_pl(1);
        bq24158_set_otg_en(1);
    #elif defined(MTK_NCP1851_SUPPORT) || defined(MTK_BQ24196_SUPPORT)
        tbl_charger_otg_vbus((work_busy(&musb->id_pin_work.work)<< 8)| 1);
    #else
		mt_set_gpio_mode(GPIO_OTG_DRVVBUS_PIN,GPIO_OTG_DRVVBUS_PIN_M_GPIO);
        mt_set_gpio_out(GPIO_OTG_DRVVBUS_PIN,GPIO_OUT_ONE);
        #endif
    } else {
        //power off VBUS, implement later...
    #ifdef MTK_FAN5405_SUPPORT
        fan5405_config_interface_liao(0x01,0x30);
		fan5405_config_interface_liao(0x02,0x8e);
    #elif defined(MTK_BQ24157_SUPPORT)		
        bq24157_config_interface_liao(0x01,0x30);
        bq24157_config_interface_liao(0x02,0x8e);
    #elif defined(MTK_BQ24158_SUPPORT)		
        bq24158_config_interface_liao(0x01,0x30);
		bq24158_config_interface_liao(0x02,0x8e);
    #elif defined(MTK_NCP1851_SUPPORT) || defined(MTK_BQ24196_SUPPORT)
        tbl_charger_otg_vbus((work_busy(&musb->id_pin_work.work)<< 8)| 0);
    #else
		mt_set_gpio_mode(GPIO_OTG_DRVVBUS_PIN,GPIO_OTG_DRVVBUS_PIN_M_GPIO);
        mt_set_gpio_out(GPIO_OTG_DRVVBUS_PIN,GPIO_OUT_ZERO);
    #endif
    }
#endif
}
Exemple #6
0
int rmnet_usb_ctrl_suspend(struct rmnet_ctrl_dev *dev)
 {
	int ret = 0;
	ret = work_busy(&dev->get_encap_work);
	if (ret)
		return -EBUSY;

	usb_kill_anchored_urbs(&dev->rx_submitted);
	return 0;
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
	struct usbnet		*unet = usb_get_intfdata(iface);
	struct rmnet_ctrl_udev	*dev;

	dev = (struct rmnet_ctrl_udev *)unet->data[1];
	if (work_busy(&dev->get_encap_work))
		return -EBUSY;

	usb_kill_anchored_urbs(&dev->rx_submitted);
	if (work_busy(&dev->get_encap_work))
		return -EBUSY;

	if (usbnet_suspend(iface, message)) {
		rmnet_usb_ctrl_start_rx(dev);
		return -EBUSY;
	}

	return 0;
}
static bool suspend_sync(void)
{
	if (work_busy(&suspend_sync_work)) {
		/* When last sys_sync() work is still running,
		 * we need wait for it to be finished.
		 */
		if (!check_sys_sync())
			return false;
	}

	INIT_COMPLETION(suspend_sync_complete);
	schedule_work(&suspend_sync_work);

	return check_sys_sync();
}
int ctrl_bridge_suspend(unsigned int id)
{
	struct ctrl_bridge	*dev;

	if (id >= MAX_BRIDGE_DEVICES)
		return -EINVAL;

	dev = __dev[id];
	if (!dev)
		return -ENODEV;

	if (work_busy(&dev->get_encap_work))
		return -EBUSY;

	set_bit(SUSPENDED, &dev->flags);
	usb_kill_anchored_urbs(&dev->tx_submitted);

	return 0;
}
static int rmnet_usb_resume(struct usb_interface *iface)
{
	int			retval = 0;
	struct usbnet		*unet;
	struct rmnet_ctrl_dev	*dev;

	pr_debug("%s", __func__);
	unet = usb_get_intfdata(iface);

	dev = (struct rmnet_ctrl_dev *)unet->data[1];

	usbnet_resume(iface);
	if (work_busy(&dev->get_encap_work)) {
		pr_debug("%s ret", __func__);
		return 0;
	}
	retval = rmnet_usb_ctrl_start_rx(dev);

	return retval;
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
	struct usbnet		*unet;
	struct rmnet_ctrl_dev	*dev;

	pr_debug("%s", __func__);

	unet = usb_get_intfdata(iface);

	dev = (struct rmnet_ctrl_dev *)unet->data[1];

	if (work_busy(&dev->get_encap_work))
		return -EBUSY;

	if (usbnet_suspend(iface, message))
		return -EBUSY;

	usb_kill_anchored_urbs(&dev->rx_submitted);

	return 0;
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
	struct usbnet		*unet;
	struct rmnet_ctrl_dev	*dev;
	char *suspended[2]   = {"QMI_STATE=SUSPENDED", NULL};
	
	unet = usb_get_intfdata(iface);

	dev = (struct rmnet_ctrl_dev *)unet->data[1];

	if (work_busy(&dev->get_encap_work))
		return -EBUSY;

	if (usbnet_suspend(iface, message))
		return -EBUSY;

	usb_kill_anchored_urbs(&dev->rx_submitted);

	kobject_uevent_env(&dev->devicep->kobj, KOBJ_CHANGE,
					   suspended);
	return 0;
}
static int mbox_debugfs_msg_send(int index, mbox_msg_t *msg, mbox_msg_len_t len)
{
	if ((index > DEBUGFS_MBOXES_NUM) || (index < 1)) {
		pr_err("mailbox debugfs index %d error\n", index);
		return -EINVAL;
	}

	if (!debugfs_mboxes[index - 1].mbox) {
		pr_err("mailbox-%d debugfs no such mbox\n", index);
		return -EINVAL;
	}

	debugfs_mboxes[index - 1].msg =
			kmalloc(sizeof(mbox_msg_t) * len, GFP_KERNEL);
	if (!debugfs_mboxes[index - 1].msg) {
		pr_err("mailbox-%d debugfs no mem\n", index);
		return -ENOMEM;
	}
	memcpy(debugfs_mboxes[index - 1].msg, msg, sizeof(mbox_msg_t) * len);
	debugfs_mboxes[index - 1].len = len;
	debugfs_mboxes[index - 1].index = index;

	if (!debugfs_mboxes[index - 1].initialized) {
		INIT_WORK(&debugfs_mboxes[index - 1].work,
					mbox_debugfs_send_work);
		debugfs_mboxes[index - 1].initialized = 1;
	} else {
		pr_err("mailbox-%d debugfs has initialize its work\n", index);
	}

	if (!work_busy(&debugfs_mboxes[index - 1].work))
		schedule_work(&debugfs_mboxes[index - 1].work);
	else
		pr_err("mailbox-%d debugfs work busy, wait a moment\n", index);

	return 0;
}
Exemple #14
0
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
	struct usbnet		*unet = usb_get_intfdata(iface);
	struct rmnet_ctrl_dev	*dev;
	int			i, n, rdev_cnt, unet_id;
	int			retval = 0;

	rdev_cnt = unet->data[4] ? no_rmnet_insts_per_dev : 1;

	for (n = 0; n < rdev_cnt; n++) {
		unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev;
		unet =
		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);

		dev = (struct rmnet_ctrl_dev *)unet->data[1];
		spin_lock_irq(&unet->txq.lock);
		if (work_busy(&dev->get_encap_work) || unet->txq.qlen) {
			spin_unlock_irq(&unet->txq.lock);
			retval = -EBUSY;
			goto abort_suspend;
		}

		set_bit(EVENT_DEV_ASLEEP, &unet->flags);
		spin_unlock_irq(&unet->txq.lock);

		usb_kill_anchored_urbs(&dev->rx_submitted);
		if (work_busy(&dev->get_encap_work)) {
			spin_lock_irq(&unet->txq.lock);
			clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
			spin_unlock_irq(&unet->txq.lock);
			retval = -EBUSY;
			goto abort_suspend;
		}
	}

	for (n = 0; n < rdev_cnt; n++) {
		unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev;
		unet =
		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);

		dev = (struct rmnet_ctrl_dev *)unet->data[1];
		netif_device_detach(unet->net);
		usbnet_terminate_urbs(unet);
		netif_device_attach(unet->net);
	}

	#if defined(CONFIG_MONITOR_STREAMING_PORT_SOCKET) && defined(CONFIG_MSM_NONSMD_PACKET_FILTER)
	if (use_extend_suspend_timer) {
	    if (original_autosuspend_timer != 0) {
	        struct usb_device	*udev= unet->udev;

	        if (udev) {
	            use_extend_suspend_timer= false;
	            pm_runtime_set_autosuspend_delay(&udev->dev, original_autosuspend_timer);
	            dev_err(&udev->dev, "is_streaming_sock_connectted:%d pm_runtime_set_autosuspend_delay %d\n", is_streaming_sock_connectted, original_autosuspend_timer);
	        }
	    }
	}
	#endif 

	return 0;

abort_suspend:
	for (i = 0; i < n; i++) {
		unet_id = i + unet->driver_info->data * no_rmnet_insts_per_dev;
		unet =
		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);

		dev = (struct rmnet_ctrl_dev *)unet->data[1];
		rmnet_usb_ctrl_start_rx(dev);
		spin_lock_irq(&unet->txq.lock);
		clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
		spin_unlock_irq(&unet->txq.lock);
	}
	return retval;
}
/**
 * dwc3_ext_event_notify - callback to handle events from external transceiver
 * @otg: Pointer to the otg transceiver structure
 * @event: Event reported by transceiver
 *
 * Returns 0 on success
 */
static void dwc3_ext_event_notify(struct usb_otg *otg,
					enum dwc3_ext_events event)
{
	static bool init;
	struct dwc3_otg *dotg = container_of(otg, struct dwc3_otg, otg);
	struct dwc3_ext_xceiv *ext_xceiv = dotg->ext_xceiv;
	struct usb_phy *phy = dotg->otg.phy;
	int ret = 0;

	/* Flush processing any pending events before handling new ones */
	if (init)
		flush_delayed_work(&dotg->sm_work);

	if (event == DWC3_EVENT_PHY_RESUME) {
		if (!pm_runtime_status_suspended(phy->dev)) {
			dev_warn(phy->dev, "PHY_RESUME event out of LPM!!!!\n");
		} else {
			dev_dbg(phy->dev, "ext PHY_RESUME event received\n");
			/* ext_xceiver would have taken h/w out of LPM by now */
			ret = pm_runtime_get(phy->dev);
			if ((phy->state == OTG_STATE_A_HOST) &&
							dotg->host_bus_suspend)
				dotg->host_bus_suspend = 0;
			if (ret == -EACCES) {
				/* pm_runtime_get may fail during system
				   resume with -EACCES error */
				pm_runtime_disable(phy->dev);
				pm_runtime_set_active(phy->dev);
				pm_runtime_enable(phy->dev);
			} else if (ret < 0) {
				dev_warn(phy->dev, "pm_runtime_get failed!\n");
			}
		}
	} else if (event == DWC3_EVENT_XCEIV_STATE) {
		if (pm_runtime_status_suspended(phy->dev)) {
			dev_warn(phy->dev, "PHY_STATE event in LPM!!!!\n");
			ret = pm_runtime_get(phy->dev);
			if (ret < 0)
				dev_warn(phy->dev, "pm_runtime_get failed!!\n");
		}
		if (ext_xceiv->id == DWC3_ID_FLOAT) {
			dev_dbg(phy->dev, "XCVR: ID set\n");
			set_bit(ID, &dotg->inputs);
		} else {
			dev_dbg(phy->dev, "XCVR: ID clear\n");
			clear_bit(ID, &dotg->inputs);
		}

		if (ext_xceiv->bsv) {
			dev_dbg(phy->dev, "XCVR: BSV set\n");
			set_bit(B_SESS_VLD, &dotg->inputs);
		} else {
			dev_dbg(phy->dev, "XCVR: BSV clear\n");
			clear_bit(B_SESS_VLD, &dotg->inputs);
		}

		if (!init) {
			init = true;
			if (!work_busy(&dotg->sm_work.work))
				queue_delayed_work(system_nrt_wq,
							&dotg->sm_work, 0);

			complete(&dotg->dwc3_xcvr_vbus_init);
			dev_dbg(phy->dev, "XCVR: BSV init complete\n");
			return;
		}

		queue_delayed_work(system_nrt_wq, &dotg->sm_work, 0);
	}
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
	struct usbnet		*unet = usb_get_intfdata(iface);
	struct rmnet_ctrl_dev	*dev;
	int			i, n, rdev_cnt, unet_id;
	int			retval = 0;

	rdev_cnt = unet->data[4] ? no_rmnet_insts_per_dev : 1;

	for (n = 0; n < rdev_cnt; n++) {
		unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev;
		unet =
		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);

		dev = (struct rmnet_ctrl_dev *)unet->data[1];
		spin_lock_irq(&unet->txq.lock);
		if (work_busy(&dev->get_encap_work) || unet->txq.qlen) {
			spin_unlock_irq(&unet->txq.lock);
			retval = -EBUSY;
			goto abort_suspend;
		}

		set_bit(EVENT_DEV_ASLEEP, &unet->flags);
		spin_unlock_irq(&unet->txq.lock);

		usb_kill_anchored_urbs(&dev->rx_submitted);
		if (work_busy(&dev->get_encap_work)) {
			spin_lock_irq(&unet->txq.lock);
			clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
			spin_unlock_irq(&unet->txq.lock);
			retval = -EBUSY;
			goto abort_suspend;
		}
	}

	for (n = 0; n < rdev_cnt; n++) {
		unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev;
		unet =
		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);

		dev = (struct rmnet_ctrl_dev *)unet->data[1];
		netif_device_detach(unet->net);
		usbnet_terminate_urbs(unet);
		netif_device_attach(unet->net);
	}

	return 0;

abort_suspend:
	for (i = 0; i < n; i++) {
		unet_id = i + unet->driver_info->data * no_rmnet_insts_per_dev;
		unet =
		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);

		dev = (struct rmnet_ctrl_dev *)unet->data[1];
		rmnet_usb_ctrl_start_rx(dev);
		spin_lock_irq(&unet->txq.lock);
		clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
		spin_unlock_irq(&unet->txq.lock);
	}
	return retval;
}
Exemple #17
0
static unsigned int mmc_host_work_busy(struct work_struct *work)
{
	return work_busy(work);
}
static enum hrtimer_restart ev3_output_port_timer_callback(struct hrtimer *timer)
{
	struct ev3_output_port_data *data =
			container_of(timer, struct ev3_output_port_data, timer);
	enum motor_type prev_motor_type = data->motor_type;
	unsigned new_pin_state_flags = 0;
	unsigned new_pin5_mv = 0;

	hrtimer_forward_now(timer, ktime_set(0, OUTPUT_PORT_POLL_NS));
	data->timer_loop_cnt++;

	switch(data->con_state) {
	case CON_STATE_INIT:
		if (!data->motor) {
			ev3_output_port_float(data);
			data->timer_loop_cnt = 0;
			data->motor_type = MOTOR_NONE;
			data->con_state = CON_STATE_INIT_SETTLE;
		}
		break;
	case CON_STATE_INIT_SETTLE:
		if (data->timer_loop_cnt >= SETTLE_CNT) {
			data->timer_loop_cnt = 0;
			data->con_state = CON_STATE_NO_DEV;
		}
		break;
	case CON_STATE_NO_DEV:
		new_pin5_mv = legoev3_analog_out_pin5_value(data->analog, data->id);

		if (gpio_get_value(data->gpio[GPIO_PIN6_DIR].gpio))
			new_pin_state_flags |= BIT(PIN_STATE_FLAG_PIN6_HIGH);
		if ((new_pin5_mv < PIN5_BALANCE_LOW) || (new_pin5_mv > PIN5_BALANCE_HIGH))
			new_pin_state_flags |= BIT(PIN_STATE_FLAG_PIN5_LOADED);

		if (new_pin_state_flags != data->pin_state_flags) {
			data->pin_state_flags = new_pin_state_flags;
			data->timer_loop_cnt = 0;
		}

		if (data->pin_state_flags && (data->timer_loop_cnt >= ADD_CNT)) {
			data->pin5_float_mv = new_pin5_mv;
			data->timer_loop_cnt = 0;
			gpio_direction_output(data->gpio[GPIO_PIN6_DIR].gpio, 0);
			data->con_state = CON_STATE_PIN6_SETTLE;
		}
		break;

	case CON_STATE_PIN6_SETTLE:
		new_pin5_mv = legoev3_analog_out_pin5_value(data->analog, data->id);

		if (data->timer_loop_cnt >= SETTLE_CNT) {
			data->pin5_low_mv = new_pin5_mv;
			data->timer_loop_cnt = 0;
			gpio_direction_input(data->gpio[GPIO_PIN6_DIR].gpio);
			data->con_state = CON_STATE_CONNECTED;
			}
		break;

	case CON_STATE_CONNECTED:
		/*
		 * Make a temporary variable that we can use to determine the relative
		 * difference between pin5_float_mv and pin5_low_mv
		 */
		new_pin5_mv = ADC_REF + data->pin5_float_mv - data->pin5_low_mv;

		if ((new_pin5_mv > (ADC_REF - 50)) && (new_pin5_mv < (ADC_REF + 50))) {
			// The pin5 values are the same, let's see what we have!

			if ((data->pin5_float_mv >= PIN5_BALANCE_LOW)
				&& (data->pin5_float_mv <= PIN5_BALANCE_HIGH)
				&& (data->pin_state_flags & (0x01 << PIN_STATE_FLAG_PIN6_HIGH)))
			{
				/* NXT TOUCH SENSOR, NXT SOUND SENSOR or NEW UART SENSOR */
				data->motor_type = MOTOR_ERR;
				data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;

			} else if (data->pin5_float_mv < PIN5_NEAR_GND) {
				/* NEW DUMB SENSOR */
				data->motor_type = MOTOR_ERR;
				data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;

			} else if ((data->pin5_float_mv >= PIN5_LIGHT_LOW)
				&& (data->pin5_float_mv <= PIN5_LIGHT_HIGH))
			{
				/* NXT LIGHT SENSOR */
				data->motor_type = MOTOR_ERR;
				data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;

			} else if ((data->pin5_float_mv >= PIN5_IIC_LOW)
				&& (data->pin5_float_mv <= PIN5_IIC_HIGH))
			{
				/* NXT IIC SENSOR */
				data->motor_type = MOTOR_ERR;
				data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;

			} else if (data->pin5_float_mv < PIN5_BALANCE_LOW) {
				data->motor_type = MOTOR_TACHO;
				if (data->pin5_float_mv > PIN5_MINITACHO_HIGH2) {
					data->motor_id = LEGO_EV3_LARGE_MOTOR;
				} else if (data->pin5_float_mv > PIN5_MINITACHO_LOW2) {
					data->motor_id = LEGO_EV3_MEDIUM_MOTOR;
				} else {
					data->motor_id = LEGO_EV3_LARGE_MOTOR;
				}
				data->con_state = CON_STATE_DEVICE_CONNECTED;

			} else {
				gpio_direction_output(data->gpio[GPIO_PIN5].gpio, 1);
				data->timer_loop_cnt = 0;
				data->con_state = CON_STATE_PIN5_SETTLE;
			}

		/* Value5Float is NOT equal to Value5Low */
		} else if ((data->pin5_float_mv > PIN5_NEAR_GND)
			&& (data->pin5_float_mv < PIN5_BALANCE_LOW))
		{
			/* NEW ACTUATOR */
			data->motor_type = MOTOR_ERR;
			data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;
		} else {
			data->motor_type = MOTOR_ERR;
			data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;
		}
		break;

	case CON_STATE_PIN5_SETTLE:
		/* Update connection type, may need to force pin5 low to determine motor type */
		if (data->timer_loop_cnt >= SETTLE_CNT) {
			data->pin5_low_mv = legoev3_analog_out_pin5_value(data->analog, data->id);
			data->timer_loop_cnt = 0;
			gpio_direction_output(data->gpio[GPIO_PIN5].gpio, 0);

			if (data->pin5_low_mv < PIN5_MINITACHO_LOW1) {
				data->motor_type = MOTOR_ERR;
			} else {
				data->motor_type = MOTOR_TACHO;
				if (data->pin5_low_mv < PIN5_MINITACHO_HIGH1)
					data->motor_id = LEGO_EV3_MEDIUM_MOTOR;
				else
					data->motor_id = LEGO_EV3_LARGE_MOTOR;
			}

			data->con_state = CON_STATE_DEVICE_CONNECTED;
		}
		break;

	case CON_STATE_DEVICE_CONNECTED:
		data->timer_loop_cnt = 0;
		if (data->motor_type != MOTOR_ERR && !work_busy(&data->work)) {
			INIT_WORK(&data->work, ev3_output_port_register_motor);
			schedule_work(&data->work);
			data->con_state = CON_STATE_WAITING_FOR_DISCONNECT;
		}
		break;

	case CON_STATE_WAITING_FOR_DISCONNECT:
		new_pin5_mv = legoev3_analog_out_pin5_value(data->analog, data->id);

		if ((new_pin5_mv < PIN5_BALANCE_LOW) || (new_pin5_mv > PIN5_BALANCE_HIGH))
			data->timer_loop_cnt = 0;

		if ((data->timer_loop_cnt >= REMOVE_CNT) && !work_busy(&data->work) && data) {
			INIT_WORK(&data->work, ev3_output_port_unregister_motor);
			schedule_work(&data->work);
			data->con_state = CON_STATE_INIT;
		}
		break;

	default:
		data->con_state = CON_STATE_INIT;
		break;
	}
	/*
	 * data->tacho_motor_type determines the status for the lego-port class
	 * so we need to trigger a change uevent when it changes.
	 */
	if (prev_motor_type != data->motor_type)
		schedule_work(&data->change_uevent_work);

	return HRTIMER_RESTART;
}
Exemple #19
0
static void sec_esd_work_func(struct work_struct *work)
{
#if defined(CONFIG_FB_MSM_MIPI_NOVATEK_VIDEO_HD_PT_PANEL)
#define LCD_ESD_GPIO_CHECK_DELAY 300
	int gpio_value = 0;
#endif
	struct esd_data_t *p_esd_data =
		container_of(work, struct esd_data_t, det_work);
	p_esd_data->esd_count++;
	if (p_esd_data->esd_count <= ESD_EXCEPT_CNT)
		pr_info("%s : %d ignore Cnt(%d)\n", __func__,
			p_esd_data->esd_count, ESD_EXCEPT_CNT);
	else if (p_esd_data->esd_ignore)
		pr_info("%s : %d ignore FLAG,esd_processed:%d\n",
			__func__, p_esd_data->esd_count,
			p_esd_data->esd_processed_count);
	else {
#if defined(CONFIG_FB_MSM_MIPI_NOVATEK_VIDEO_HD_PT_PANEL)
		gpio_value = gpio_get_value(GPIO_LCD_ESD_DET);
		pr_info("%s : GPIO_LCD_ESD_DET :%d\n",__func__, gpio_value);
		msleep(LCD_ESD_GPIO_CHECK_DELAY);
		gpio_value = gpio_get_value(GPIO_LCD_ESD_DET);
		pr_info("%s : GPIO_LCD_ESD_DET :%d After Delay %d ms \n",__func__, gpio_value,LCD_ESD_GPIO_CHECK_DELAY);
#if defined(CONFIG_MACH_MELIUS_SPR)
			if(system_rev >= 3) {
#elif defined(CONFIG_MACH_MELIUS_USC)
			if(system_rev >= 2) {
#else
			if(system_rev >= 11) {
#endif
				if(gpio_value)
					lcd_esd_seq(p_esd_data);
			}
			else {
				if(!gpio_value)
					lcd_esd_seq(p_esd_data);
			}
#else
		lcd_esd_seq(p_esd_data);
#endif
	}
	p_esd_data->esd_irq_enable = true;
	return;
}

#ifdef ESD_DEBUG
static ssize_t mipi_samsung_esd_check_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct esd_data_t *p_esd_data = dev_get_drvdata(dev);
	char temp[20];

	snprintf(temp, 20, "ESD Status:%d\n", p_esd_data->refresh_ongoing);
	strncat(buf, temp, 20);
	return strnlen(buf, 20);
}

static ssize_t mipi_samsung_esd_check_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t size)
{
	struct esd_data_t *p_esd_data = dev_get_drvdata(dev);

	sec_esd_irq_handler(0, p_esd_data);
	return 1;
}

static DEVICE_ATTR(esd_check, S_IRUGO , mipi_samsung_esd_check_show,\
			 mipi_samsung_esd_check_store);
#endif

static irqreturn_t sec_esd_irq_handler(int irq, void *handle)
{
	struct esd_data_t *p_esd_data = (struct esd_data_t *) handle;
	struct msm_fb_data_type *mfd;

	if (!mipi_control.mipi_dev)
		return IRQ_HANDLED;
	else
		mfd = platform_get_drvdata(mipi_control.mipi_dev);

	if (!mfd->panel_power_on || p_esd_data->refresh_ongoing
		|| p_esd_data->esd_irq_enable == false) {
		/* Panel is not powered ON So bogus ESD/
		ESD Already executing*/
		return IRQ_HANDLED;
	}
#if defined(CONFIG_FB_MSM_MIPI_NOVATEK_VIDEO_HD_PT_PANEL)
	/* ESD occurred during Wakeup/Suspend, So ignore */
	if (mfd->resume_state)
		return IRQ_HANDLED;
#endif	
	p_esd_data->esd_irq_enable = false;
	schedule_work(&p_esd_data->det_work);

	return IRQ_HANDLED;
}

#ifdef READ_REGISTER_ESD
void esd_execute(void)
{
	if (esd_enable->esd_irq_enable) {

		if (work_busy(&esd_enable->det_work))
			pr_info("%s ESD work queue is working", __func__);
		else {
			pr_info("%s start", __func__);

			INIT_COMPLETION(esd_completion);

			schedule_work(&esd_enable->det_work);

			wait_for_completion_timeout(&esd_completion, 10 * HZ);

			pr_info("%s end", __func__);
		}
	} else
		pr_info("%s ESD is armed from ISR", __func__);
}
#endif

void register_mipi_dev(struct platform_device *mipi_dev)
{
	mipi_control.mipi_dev = mipi_dev;
}
static void set_esd_enable_work_func(struct work_struct *work)
{
	pr_info("%s is called\n", __func__);
	esd_enable->esd_ignore = false;

}

void set_esd_enable(void)
{
	pr_info("%s is called\n", __func__);
	if (!esd_enable) {
		pr_err("ESD Driver data is NULL!!\n");
		return;
	}
#if defined(CONFIG_FB_MSM_MIPI_NOVATEK_VIDEO_HD_PT_PANEL)
	schedule_delayed_work(&esd_enable->esd_enable_delay,\
	msecs_to_jiffies(100));
#else
	schedule_delayed_work(&esd_enable->esd_enable_delay,\
	msecs_to_jiffies(500));
#endif
}
 * dump debugging info about an object
 */
static noinline
void __cachefiles_printk_object(struct cachefiles_object *object,
				const char *prefix,
				u8 *keybuf)
{
	struct fscache_cookie *cookie;
	unsigned keylen, loop;

	printk(KERN_ERR "%sobject: OBJ%x\n",
	       prefix, object->fscache.debug_id);
<<<<<<< HEAD
	printk(KERN_ERR "%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
	       prefix, fscache_object_states[object->fscache.state],
	       object->fscache.flags, work_busy(&object->fscache.work),
=======
	printk(KERN_ERR "%sobjstate=%s fl=%lx swfl=%lx ev=%lx[%lx]\n",
	       prefix, fscache_object_states[object->fscache.state],
	       object->fscache.flags, object->fscache.work.flags,
>>>>>>> 296c66da8a02d52243f45b80521febece5ed498a
	       object->fscache.events,
	       object->fscache.event_mask & FSCACHE_OBJECT_EVENTS_MASK);
	printk(KERN_ERR "%sops=%u inp=%u exc=%u\n",
	       prefix, object->fscache.n_ops, object->fscache.n_in_progress,
	       object->fscache.n_exclusive);
	printk(KERN_ERR "%sparent=%p\n",
	       prefix, object->fscache.parent);

	spin_lock(&object->fscache.lock);
	cookie = object->fscache.cookie;
Exemple #21
0
static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
			 unsigned char __user *buf, size_t nr)
{
	unsigned char __user *b = buf;
	DECLARE_WAITQUEUE(wait, current);
	int c;
	int minimum, time;
	ssize_t retval = 0;
	ssize_t size;
	long timeout;
	unsigned long flags;
	int packet;
	struct tty_buffer *head;
	int count;

do_it_again:

	if (WARN_ON(!tty->read_buf))
		return -EAGAIN;

	c = job_control(tty, file);
	if (c < 0)
		return c;

	minimum = time = 0;
	timeout = MAX_SCHEDULE_TIMEOUT;
	if (!tty->icanon) {
		time = (HZ / 10) * TIME_CHAR(tty);
		minimum = MIN_CHAR(tty);
		if (minimum) {
			if (time)
				tty->minimum_to_wake = 1;
			else if (!waitqueue_active(&tty->read_wait) ||
				 (tty->minimum_to_wake > minimum))
				tty->minimum_to_wake = minimum;
		} else {
			timeout = 0;
			if (time) {
				timeout = time;
				time = 0;
			}
			tty->minimum_to_wake = minimum = 1;
		}
	}

	if (file->f_flags & O_NONBLOCK) {
		if (!mutex_trylock(&tty->atomic_read_lock))
			return -EAGAIN;
	} else {
		if (mutex_lock_interruptible(&tty->atomic_read_lock))
			return -ERESTARTSYS;
	}
	packet = tty->packet;

	add_wait_queue(&tty->read_wait, &wait);
	while (nr) {
		
		if (packet && tty->link->ctrl_status) {
			unsigned char cs;
			if (b != buf)
				break;
			spin_lock_irqsave(&tty->link->ctrl_lock, flags);
			cs = tty->link->ctrl_status;
			tty->link->ctrl_status = 0;
			spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
			if (tty_put_user(tty, cs, b++)) {
				retval = -EFAULT;
				b--;
				break;
			}
			nr--;
			break;
		}
		set_current_state(TASK_INTERRUPTIBLE);

		if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
		    ((minimum - (b - buf)) >= 1))
			tty->minimum_to_wake = (minimum - (b - buf));

		if (!input_available_p(tty, 0)) {
			if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
				retval = -EIO;
				break;
			}
			if (tty_hung_up_p(file))
				break;
			if (!timeout)
				break;
			if (file->f_flags & O_NONBLOCK) {
				retval = -EAGAIN;
				break;
			}
			if (signal_pending(current)) {
				retval = -ERESTARTSYS;
				break;
			}
			
			n_tty_set_room(tty);
			timeout = schedule_timeout(timeout);
			BUG_ON(!tty->read_buf);
			continue;
		}
		__set_current_state(TASK_RUNNING);

		
		if (packet && b == buf) {
			if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
				retval = -EFAULT;
				b--;
				break;
			}
			nr--;
		}

		if (tty->icanon && !L_EXTPROC(tty)) {
			
			while (nr && tty->read_cnt) {
				int eol;

				eol = test_and_clear_bit(tty->read_tail,
						tty->read_flags);
				c = tty->read_buf[tty->read_tail];
				spin_lock_irqsave(&tty->read_lock, flags);
				tty->read_tail = ((tty->read_tail+1) &
						  (N_TTY_BUF_SIZE-1));
				tty->read_cnt--;
				if (eol) {
					if (--tty->canon_data < 0)
						tty->canon_data = 0;
				}
				spin_unlock_irqrestore(&tty->read_lock, flags);

				if (!eol || (c != __DISABLED_CHAR)) {
					if (tty_put_user(tty, c, b++)) {
						retval = -EFAULT;
						b--;
						break;
					}
					nr--;
				}
				if (eol) {
					tty_audit_push(tty);
					break;
				}
			}
			if (retval)
				break;
		} else {
			int uncopied;
			uncopied = copy_from_read_buf(tty, &b, &nr);
			uncopied += copy_from_read_buf(tty, &b, &nr);
			if (uncopied) {
				retval = -EFAULT;
				break;
			}
		}

		if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
			n_tty_set_room(tty);
			check_unthrottle(tty);
		}

		if (b - buf >= minimum)
			break;
		if (time)
			timeout = time;
	}
	mutex_unlock(&tty->atomic_read_lock);
	remove_wait_queue(&tty->read_wait, &wait);

	if (!waitqueue_active(&tty->read_wait))
		tty->minimum_to_wake = minimum;

	__set_current_state(TASK_RUNNING);
	size = b - buf;
	if (size) {
		retval = size;
		if (nr)
			clear_bit(TTY_PUSH, &tty->flags);
	} else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
		goto do_it_again;

	n_tty_set_room(tty);
	
	if(tty->update_room_in_ldisc){
		spin_lock_irqsave(&tty->buf.lock, flags);
		head = tty->buf.head;
		if (head) {
		count = head->commit - head->read;
			if ((count || tty->buf.head != tty->buf.tail) && tty->receive_room && !work_busy(&tty->buf.work)){
				schedule_work(&tty->buf.work);
			}
		}
		spin_unlock_irqrestore(&tty->buf.lock, flags);
	}
	
	return retval;
}