Пример #1
0
void main()
{
    OLED_Init();           //初始化oled
    qd=1;
    ftm_pwm_init(FTM0,FTM_CH3,10000,0);
    ftm_pwm_init(FTM0,FTM_CH4,10000,0);
    ftm_pwm_init(FTM2,FTM_CH0,10000,0);
    ftm_pwm_init(FTM2,FTM_CH1,10000,0);
    adc_init (ADC1_SE10);
    adc_init (ADC1_SE11);
    adc_init (ADC1_SE12);
    adc_init (ADC1_SE13);                               //按键初始化
    gpio_init (PTA13, GPI,HIGH);//拨码开关初始化
    gpio_init (PTA19, GPI,HIGH);
    gpio_init (PTA24, GPI,HIGH);
    gpio_init (PTA25, GPI,HIGH);
    gpio_init (PTA26, GPI,HIGH);
    gpio_init (PTA27, GPI,HIGH);
    gpio_init (PTA28, GPI,HIGH);
    gpio_init (PTA29, GPI,HIGH);

    led_init (LED0);
    mpu6050_init();

    lptmr_delay_ms(1000);

    gyro_zero=ad_ave(100);

    gyro_zero1=ad_ave1(100);

    mpu6050_read();

    accel_accel=(accel_x-accel_zero)/16384.0;
    if(accel_accel>1)   accel_accel=1;
    if(accel_accel<-1)  accel_accel=-1;
    angle_fuse=180/pi*(asin(accel_accel));

    accel_accel1=(accel_y-accel_zero1)/16384.0;
    if(accel_accel1>1)   accel_accel1=1;
    if(accel_accel1<-1)  accel_accel1=-1;
    angle_fuse1=180/3.1415926*(asin(accel_accel1));

    pit_init_ms(PIT0, 5);                                //初始化PIT0,定时时间为: 5ms
    set_vector_handler(PIT0_VECTORn ,PIT0_IRQHandler);      //设置PIT0的中断服务函数为 PIT0_IRQHandler
    enable_irq (PIT0_IRQn);                                 //使能PIT0中断

    uart_init(UART3, 115200);
    while(aa<200);   //初始化 1秒


    DIP_switch();
    while(1)
    {


        //display[0]=angle_fuse;
        //display[1]=angle_fuse1;
        display[0]=angle_fuse3;



        oledplay();


        if(flag==1)
            mode1();
        else if (flag==2)
            mode2();
        else if (flag==3)
            mode3();
        else if (flag==4)
            mode4();



        vcan_sendware((unsigned char *)display, 20);

    }
}
Пример #2
0
static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
    int out, in;
    int key_index;
    int gpio;
    struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
    struct gpio_event_matrix_info *mi = kp->keypad_info;
    unsigned gpio_keypad_flags = mi->flags;
    unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);

    out = kp->current_output;
    if (out == mi->noutputs) {
        out = 0;
        kp->last_key_state_changed = kp->key_state_changed;
        kp->key_state_changed = 0;
        kp->some_keys_pressed = 0;
    } else {
        key_index = out * mi->ninputs;
        for (in = 0; in < mi->ninputs; in++, key_index++) {
            gpio = mi->input_gpios[in];
            if (gpio_get_value(gpio) ^ !polarity) {
                if (kp->some_keys_pressed < 3)
                    kp->some_keys_pressed++;
                kp->key_state_changed |= !__test_and_set_bit(
                                             key_index, kp->keys_pressed);
            } else
                kp->key_state_changed |= __test_and_clear_bit(
                                             key_index, kp->keys_pressed);
        }
        gpio = mi->output_gpios[out];
        if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
            gpio_set_value(gpio, !polarity);
        else
            gpio_direction_input(gpio);
        out++;
    }
    kp->current_output = out;
    if (out < mi->noutputs) {
        gpio = mi->output_gpios[out];
        if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
            gpio_set_value(gpio, polarity);
        else
            gpio_direction_output(gpio, polarity);
        hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
        return HRTIMER_NORESTART;
    }
    if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
        if (kp->key_state_changed) {
            hrtimer_start(&kp->timer, mi->debounce_delay,
                          HRTIMER_MODE_REL);
            return HRTIMER_NORESTART;
        }
        kp->key_state_changed = kp->last_key_state_changed;
    }
    if (kp->key_state_changed) {
        if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
            remove_phantom_keys(kp);
        key_index = 0;
        for (out = 0; out < mi->noutputs; out++)
            for (in = 0; in < mi->ninputs; in++, key_index++)
                report_key(kp, key_index, out, in);
    }
    if (!kp->use_irq || kp->some_keys_pressed) {
        hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
        return HRTIMER_NORESTART;
    }

    /* No keys are pressed, reenable interrupt */
    for (out = 0; out < mi->noutputs; out++) {
        if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
            gpio_set_value(mi->output_gpios[out], polarity);
        else
            gpio_direction_output(mi->output_gpios[out], polarity);
    }
    for (in = 0; in < mi->ninputs; in++)
        enable_irq(gpio_to_irq(mi->input_gpios[in]));
    wake_unlock(&kp->wake_lock);
    return HRTIMER_NORESTART;
}
Пример #3
0
static void fs_enet_netpoll(struct net_device *dev)
{
       disable_irq(dev->irq);
       fs_enet_interrupt(dev->irq, dev);
       enable_irq(dev->irq);
}
Пример #4
0
static int mstar_gflip_drv_resume(struct platform_device *dev)
{
    MDrv_GFLIP_Resume(&_gflip_regs_save);
    enable_irq(E_IRQ_GOP);
    return 0;
}
Пример #5
0
static int msm_csid_init(struct csid_device *csid_dev, uint32_t *csid_version)
{
	int rc = 0;
	struct camera_vreg_t *cam_vreg;

	if (!csid_version) {
		pr_err("%s:%d csid_version NULL\n", __func__, __LINE__);
		rc = -EINVAL;
		return rc;
	}

	if (csid_dev->csid_state == CSID_POWER_UP) {
		pr_err("%s: csid invalid state %d\n", __func__,
			csid_dev->csid_state);
		rc = -EINVAL;
		return rc;
	}

	csid_dev->base = ioremap(csid_dev->mem->start,
		resource_size(csid_dev->mem));
	if (!csid_dev->base) {
		pr_err("%s csid_dev->base NULL\n", __func__);
		rc = -ENOMEM;
		return rc;
	}

	if (CSID_VERSION == CSID_VERSION_V20)
		cam_vreg = csid_8960_vreg_info;
	else
		cam_vreg = csid_vreg_info;

	if (CSID_VERSION < CSID_VERSION_V30) {
		rc = msm_camera_config_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 1);
		if (rc < 0) {
			pr_err("%s: regulator on failed\n", __func__);
			goto vreg_config_failed;
		}
		rc = msm_camera_enable_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 1);
		if (rc < 0) {
			pr_err("%s: regulator enable failed\n", __func__);
			goto vreg_enable_failed;
		}

		if (CSID_VERSION == CSID_VERSION_V20) {
			rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
				csid_8960_clk_info, csid_dev->csid_clk,
				ARRAY_SIZE(csid_8960_clk_info), 1);
			if (rc < 0) {
				pr_err("%s: 8960: clock enable failed\n",
					 __func__);
				goto clk_enable_failed;
			}
		} else {
			msm_cam_clk_sel_src(&csid_dev->pdev->dev,
				&csid_8610_clk_info[3], csid_8610_clk_src_info,
				ARRAY_SIZE(csid_8610_clk_src_info));
			rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
				csid_8610_clk_info, csid_dev->csid_clk,
				ARRAY_SIZE(csid_8610_clk_info), 1);
			if (rc < 0) {
				pr_err("%s: 8610: clock enable failed\n",
					 __func__);
				goto clk_enable_failed;
			}
		}
	} else if (CSID_VERSION >= CSID_VERSION_V30) {
		rc = msm_camera_config_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 1);
		if (rc < 0) {
			pr_err("%s: regulator on failed\n", __func__);
			goto vreg_config_failed;
		}

		rc = msm_camera_enable_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 1);
		if (rc < 0) {
			pr_err("%s: regulator enable failed\n", __func__);
			goto vreg_enable_failed;
		}

		rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
			csid_8974_clk_info, csid_dev->csid_clk,
			ARRAY_SIZE(csid_8974_clk_info), 1);
		if (rc < 0) {
			pr_err("%s: clock enable failed\n", __func__);
			goto clk_enable_failed;
		}
	}
		CDBG("%s:%d called\n", __func__, __LINE__);
	csid_dev->hw_version =
		msm_camera_io_r(csid_dev->base + CSID_HW_VERSION_ADDR);
	CDBG("%s:%d called csid_dev->hw_version %x\n", __func__, __LINE__,
		csid_dev->hw_version);
	*csid_version = csid_dev->hw_version;

	init_completion(&csid_dev->reset_complete);

	enable_irq(csid_dev->irq->start);

	msm_csid_reset(csid_dev);
	csid_dev->csid_state = CSID_POWER_UP;
	pr_err(" %s:%d CSID_POWER_UP %d \n",__func__,__LINE__,csid_dev->csid_state);

/* LGE_CHANGE_S [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
	wake_lock_timeout(&csid_dev->csid_wake_lock, 2*HZ);	
/* LGE_CHANGE_E [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
	return rc;

clk_enable_failed:
	if (CSID_VERSION < CSID_VERSION_V30) {
		msm_camera_enable_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 0);
	} else if (CSID_VERSION >= CSID_VERSION_V30) {
		msm_camera_enable_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 0);
	}
vreg_enable_failed:
	if (CSID_VERSION < CSID_VERSION_V30) {
		msm_camera_config_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 0);
	} else if (CSID_VERSION >= CSID_VERSION_V30) {
		msm_camera_config_vreg(&csid_dev->pdev->dev,
			csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
			NULL, 0, &csid_dev->csi_vdd, 0);
	}
vreg_config_failed:
	iounmap(csid_dev->base);
	csid_dev->base = NULL;
	return rc;
}
static int msm_ehci_resume(struct msm_hcd *mhcd)
{
	struct msm_usb_host_platform_data *pdata;
	struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
	unsigned long timeout;
	unsigned temp;
	int ret;

	pdata = mhcd->dev->platform_data;

	if (!atomic_read(&mhcd->in_lpm)) {
		dev_dbg(mhcd->dev, "%s called in !in_lpm\n", __func__);
		return 0;
	}

	if (mhcd->pmic_gpio_dp_irq_enabled) {
		disable_irq_wake(mhcd->pmic_gpio_dp_irq);
		disable_irq_nosync(mhcd->pmic_gpio_dp_irq);
		mhcd->pmic_gpio_dp_irq_enabled = 0;
	}
	wake_lock(&mhcd->wlock);

	/* Vote for TCXO when waking up the phy */
	ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_ON);
	if (ret)
		dev_err(mhcd->dev, "%s failed to vote for "
			"TCXO D0 buffer%d\n", __func__, ret);

	clk_prepare_enable(mhcd->core_clk);
	clk_prepare_enable(mhcd->iface_clk);

	if (!pdata->mpm_xo_wakeup_int)
		msm_ehci_config_vddcx(mhcd, 1);

	temp = readl_relaxed(USB_USBCMD);
	temp &= ~ASYNC_INTR_CTRL;
	temp &= ~ULPI_STP_CTRL;
	writel_relaxed(temp, USB_USBCMD);

	if (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD))
		goto skip_phy_resume;

	temp = readl_relaxed(USB_PORTSC) & ~PORTSC_PHCD;
	writel_relaxed(temp, USB_PORTSC);

	timeout = jiffies + usecs_to_jiffies(PHY_RESUME_TIMEOUT_USEC);
	while ((readl_relaxed(USB_PORTSC) & PORTSC_PHCD) ||
			!(readl_relaxed(USB_ULPI_VIEWPORT) & ULPI_SYNC_STATE)) {
		if (time_after(jiffies, timeout)) {
			/*This is a fatal error. Reset the link and PHY*/
			dev_err(mhcd->dev, "Unable to resume USB. Resetting the h/w\n");
			msm_hsusb_reset(mhcd);
			break;
		}
		udelay(1);
	}

skip_phy_resume:

	usb_hcd_resume_root_hub(hcd);
	atomic_set(&mhcd->in_lpm, 0);

	if (mhcd->async_int) {
		mhcd->async_int = false;
		pm_runtime_put_noidle(mhcd->dev);
		enable_irq(hcd->irq);
	}

	if (atomic_read(&mhcd->pm_usage_cnt)) {
		atomic_set(&mhcd->pm_usage_cnt, 0);
		pm_runtime_put_noidle(mhcd->dev);
	}

	dev_info(mhcd->dev, "EHCI USB exited from low power mode\n");

	return 0;
}
INT32 wmt_plat_eirq_ctrl(ENUM_PIN_ID id, ENUM_PIN_STATE state)
{
#ifdef CONFIG_OF
	struct device_node *node;
	unsigned int irq_info[3] = { 0, 0, 0 };
#endif
	INT32 iret = -EINVAL;
	static INT32 bgf_irq_num = -1;
	static UINT32 bgf_irq_flag;
	/* TODO: [ChangeFeature][GeorgeKuo]: use another function to handle this, as done in gpio_ctrls */

	if ((PIN_STA_INIT != state)
	    && (PIN_STA_DEINIT != state)
	    && (PIN_STA_EINT_EN != state)
	    && (PIN_STA_EINT_DIS != state)) {
		WMT_PLAT_WARN_FUNC("WMT-PLAT:invalid PIN_STATE(%d) in eirq_ctrl for PIN(%d)\n", state, id);
		return -1;
	}

	switch (id) {
	case PIN_BGF_EINT:

		if (PIN_STA_INIT == state) {
#ifdef CONFIG_OF
			node = of_find_compatible_node(NULL, NULL, "mediatek,mt6735-consys");
			if (node) {
				bgf_irq_num = irq_of_parse_and_map(node, 0);
				/* get the interrupt line behaviour */
				if (of_property_read_u32_array(node, "interrupts", irq_info, ARRAY_SIZE(irq_info))) {
					WMT_PLAT_ERR_FUNC("get irq flags from DTS fail!!\n");
					return iret;
				}
				bgf_irq_flag = irq_info[2];
				WMT_PLAT_INFO_FUNC("get irq id(%d) and irq trigger flag(%d) from DT\n", bgf_irq_num,
						   bgf_irq_flag);
			} else {
				WMT_PLAT_ERR_FUNC("[%s] can't find CONSYS compatible node\n", __func__);
				return iret;
			}
#else
			bgf_irq_num = MT_CONN2AP_BTIF_WAKEUP_IRQ_ID;
			bgf_irq_flag = IRQF_TRIGGER_LOW;
#endif
			iret = request_irq(bgf_irq_num, wmt_plat_bgf_irq_isr, bgf_irq_flag, "BTIF_WAKEUP_IRQ", NULL);
			if (iret) {
				WMT_PLAT_ERR_FUNC("request_irq fail,irq_no(%d),iret(%d)\n", bgf_irq_num, iret);
				return iret;
			}
			gbgfIrqBle.counter = 1;

		} else if (PIN_STA_EINT_EN == state) {

			spin_lock_irqsave(&gbgfIrqBle.lock, gbgfIrqBle.flags);
			if (gbgfIrqBle.counter) {
				WMT_PLAT_DBG_FUNC("BGF INT has been enabled,counter(%d)\n", gbgfIrqBle.counter);
			} else {
				enable_irq(bgf_irq_num);
				gbgfIrqBle.counter++;
			}
			WMT_PLAT_DBG_FUNC("WMT-PLAT:BGFInt (en)\n");
			spin_unlock_irqrestore(&gbgfIrqBle.lock, gbgfIrqBle.flags);
		} else if (PIN_STA_EINT_DIS == state) {
			spin_lock_irqsave(&gbgfIrqBle.lock, gbgfIrqBle.flags);
			if (!gbgfIrqBle.counter) {
				WMT_PLAT_INFO_FUNC("BGF INT has been disabled,counter(%d)\n", gbgfIrqBle.counter);
			} else {
				disable_irq_nosync(bgf_irq_num);
				gbgfIrqBle.counter--;
			}
			WMT_PLAT_DBG_FUNC("WMT-PLAT:BGFInt (dis)\n");
			spin_unlock_irqrestore(&gbgfIrqBle.lock, gbgfIrqBle.flags);
		} else {
			free_irq(bgf_irq_num, NULL);
			/* de-init: nothing to do in ALPS, such as un-registration... */
		}
		iret = 0;
		break;

	default:
		WMT_PLAT_WARN_FUNC("WMT-PLAT:unsupported EIRQ(PIN_ID:%d) in eirq_ctrl\n", id);
		iret = -1;
		break;
	}

	return iret;
}
Пример #8
0
static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
	int out, in;
	int key_index;
	int gpio;
	struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned gpio_keypad_flags = mi->flags;
	unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
#if defined(SLEEP_STATE_SKIP_LONGKEY)
	unsigned int irq;
#endif
	out = kp->current_output;
	if (out == mi->noutputs) {
		out = 0;
		kp->last_key_state_changed = kp->key_state_changed;
		kp->key_state_changed = 0;
		kp->some_keys_pressed = 0;
	} else {
		key_index = out * mi->ninputs;
		for (in = 0; in < mi->ninputs; in++, key_index++) {
			gpio = mi->input_gpios[in];
			if (gpio_get_value(gpio) ^ !polarity) {
				if (kp->some_keys_pressed < 3)
					kp->some_keys_pressed++;
				kp->key_state_changed |= !__test_and_set_bit(
						key_index, kp->keys_pressed);
			} else
				kp->key_state_changed |= __test_and_clear_bit(
						key_index, kp->keys_pressed);
		}
		gpio = mi->output_gpios[out];
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(gpio, !polarity);
		else
			gpio_direction_input(gpio);
		out++;
	}
	kp->current_output = out;
	if (out < mi->noutputs) {
		gpio = mi->output_gpios[out];
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(gpio, polarity);
		else
			gpio_direction_output(gpio, polarity);
		hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
		return HRTIMER_NORESTART;
	}
	if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
		if (kp->key_state_changed) {
			hrtimer_start(&kp->timer, mi->debounce_delay,
				      HRTIMER_MODE_REL);
			return HRTIMER_NORESTART;
		}
		kp->key_state_changed = kp->last_key_state_changed;
	}

#if defined(SLEEP_STATE_SKIP_LONGKEY)
	if(long_key_state == LONG_KEY_CHECK_ACTIVE)
	{
		//printk("key event (key_press_count:%d, current_pressed_key:%d)\n", key_press_count, current_pressed_key); // GOPEACE iskim ED25 -- remove log for google security approval
		if(key_press_count++ > MAX_KEY_PRESS_COUNT)
		{
		        key_press_count = 0;

			if(lcd_wake_flag==0) // LCD off
			{
				gpio_set_value(33, 0);	// keyscan_0
				gpio_direction_output(33, 0);

				gpio_set_value(34, 0);	// keyscan_1
				gpio_direction_output(34, 0);

				//gpio_set_value(35, 0);	// keyscan_2
				//gpio_direction_output(35, 0);
				
				if(current_pressed_key == KEY_VOLUMEDOWN)
				{
				        printk("******** volume down long key **********\n");    
					irq = gpio_to_irq(42); // keysense_0		
					set_irq_type(irq , IRQ_TYPE_LEVEL_HIGH);
				}
				if(current_pressed_key == KEY_VOLUMEUP)
				{
				        printk("******** volume up long key **********\n");    
					irq = gpio_to_irq(41); // keysense_1		
					set_irq_type(irq , IRQ_TYPE_LEVEL_HIGH);
				}
				if(current_pressed_key == KEY_END/* || current_pressed_key == KEY_HOME*/)
				{
				        printk("******** power long key **********\n");  
					irq = gpio_to_irq(40); // keysense_2		
					set_irq_type(irq , IRQ_TYPE_LEVEL_HIGH);
				}
					
				for (in = 0; in < mi->ninputs; in++)
					enable_irq(gpio_to_irq(mi->input_gpios[in]));

				wake_unlock(&kp->wake_lock);

				long_key_state = LONG_KEY_PRESSED;

				return HRTIMER_NORESTART;		 
			}
		}
	}
#endif

	if (kp->key_state_changed) {
		if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
			remove_phantom_keys(kp);
		key_index = 0;
		for (out = 0; out < mi->noutputs; out++)
			for (in = 0; in < mi->ninputs; in++, key_index++)
				report_key(kp, key_index, out, in);
	}
	if (!kp->use_irq || kp->some_keys_pressed) {
		hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
		return HRTIMER_NORESTART;
	}

	/* No keys are pressed, reenable interrupt */
	for (out = 0; out < mi->noutputs; out++) {
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(mi->output_gpios[out], polarity);
		else
			gpio_direction_output(mi->output_gpios[out], polarity);
	}
	for (in = 0; in < mi->ninputs; in++)
		enable_irq(gpio_to_irq(mi->input_gpios[in]));
	wake_unlock(&kp->wake_lock);
	return HRTIMER_NORESTART;
}
Пример #9
0
static int gpio_keypad_request_irqs(struct gpio_kp *kp)
{
	int i;
	int err;
	unsigned int irq;
	unsigned long request_flags;
	struct gpio_event_matrix_info *mi = kp->keypad_info;

	switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
	default:
		request_flags = IRQF_TRIGGER_FALLING;
		break;
	case GPIOKPF_ACTIVE_HIGH:
		request_flags = IRQF_TRIGGER_RISING;
		break;
	case GPIOKPF_LEVEL_TRIGGERED_IRQ:
		request_flags = IRQF_TRIGGER_LOW;
		break;
	case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
		request_flags = IRQF_TRIGGER_HIGH;
		break;
	}

	for (i = 0; i < mi->ninputs; i++) {
		err = irq = gpio_to_irq(mi->input_gpios[i]);
		if (err < 0)
			goto err_gpio_get_irq_num_failed;

#if defined(CONFIG_MACH_TASS_CTC)
		switch(mi->input_gpios[i])
		{
			case GPIO_KBR0:
				Volume_Down_irq = irq;
				break;
				
			case GPIO_KBR1:
				Volume_Up_irq = irq;
				break;
		}
#elif defined(CONFIG_MACH_COOPER_CTC)
		switch(mi->input_gpios[i])
		{
			case GPIO_KBR2:
				Volume_Down_irq = irq;
				break;

			case GPIO_KBR1:
				Volume_Up_irq = irq;
				break;
		}

#endif		
#if defined(CONFIG_MACH_LUCAS)
		switch(mi->input_gpios[i])
		{
			case 3:
				Volume_Up_irq = irq;
				Volume_Down_irq = irq;
				break;
		}
#endif		
		err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
				  "gpio_kp", kp);
		if (err) {
			pr_err("gpiomatrix: request_irq failed for input %d, "
				"irq %d\n", mi->input_gpios[i], irq);
			goto err_request_irq_failed;
		}
#if !defined(CONFIG_MACH_LUCAS) || !defined(CONFIG_MACH_CALLISTO)/*&& !defined(CONFIG_MACH_TASS) */
//#ifndef CONFIG_MACH_LUCAS
		err = set_irq_wake(irq, 1);
		if (err) {
			pr_err("gpiomatrix: set_irq_wake failed for input %d, "
				"irq %d\n", mi->input_gpios[i], irq);
		}
#endif		
		disable_irq(irq);
		if (kp->disabled_irq) {
			kp->disabled_irq = 0;
			enable_irq(irq);
		}
	}

#if defined(CONFIG_MACH_TASS_CTC) 
	err = set_irq_wake(gpio_to_irq(GPIO_KBR3), 0);
	if (err) 
	{
		pr_err("gpiomatrix: set_irq_wake failed for input %d, "	"irq %d\n", GPIO_KBR3, irq);
	}
#endif
#if defined (CONFIG_MACH_LUCAS)
	err = set_irq_wake(gpio_to_irq(GPIO_KBR6), 1);
	if (err) 
	{
		pr_err("gpiomatrix: set_irq_wake failed for input %d, "	"irq %d\n", mi->input_gpios[i], irq);
	}
#elif defined (CONFIG_MACH_CALLISTO)
	err = set_irq_wake(gpio_to_irq(GPIO_KBR5), 1);	// hsil
	err = set_irq_wake(gpio_to_irq(GPIO_KBR6), 1);	// hsil
	err = set_irq_wake(gpio_to_irq(GPIO_VOL_UP), 1);	// hsil
#endif
	
//#ifndef CONFIG_MACH_LUCAS
	// for COOPER
	err = irq = gpio_to_irq(GPIO_POWERKEY);
	if (err < 0)
		goto err_gpio_get_irq_num_failed;
	set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
	err = request_irq(irq, gpiokey_irq_handler, IRQF_DISABLED, "gpio_key", kp);
	if (err)
	{
		printk("[PWRKEY] request_irq failed for slide\n");
		goto err_request_irq_failed;
	}
	
	err = set_irq_wake(irq, 1);
	if (err) 
		printk("[PWRKEY] register wakeup source failed\n");

#if AUTO_POWER_ON_OFF_FLAG
	init_timer(&poweroff_keypad_timer);
	poweroff_keypad_timer.function = poweroff_keypad_timer_handler;
	poweroff_keypad_timer.data = (unsigned long)kp;
	poweroff_keypad_timer.expires = jiffies + 60*HZ;

	add_timer(&poweroff_keypad_timer);
#endif

	return 0;

	for (i = mi->noutputs - 1; i >= 0; i--) {
		free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
err_request_irq_failed:
err_gpio_get_irq_num_failed:
		;
	}
	return err;
}
Пример #10
0
static int s3c2410_dma_start(struct s3c2410_dma_chan *chan)
{
    unsigned long tmp;
    unsigned long flags;

    pr_debug("s3c2410_start_dma: channel=%d\n", chan->number);

    local_irq_save(flags);

    if (chan->state == S3C2410_DMA_RUNNING) {
        pr_debug("s3c2410_start_dma: already running (%d)\n", chan->state);
        local_irq_restore(flags);
        return 0;
    }

    chan->state = S3C2410_DMA_RUNNING;

    /* check wether there is anything to load, and if not, see
     * if we can find anything to load
     */

    if (chan->load_state == S3C2410_DMALOAD_NONE) {
        if (chan->next == NULL) {
            printk(KERN_ERR "dma%d: channel has nothing loaded\n",
                   chan->number);
            chan->state = S3C2410_DMA_IDLE;
            local_irq_restore(flags);
            return -EINVAL;
        }

        s3c2410_dma_loadbuffer(chan, chan->next);
    }

    dbg_showchan(chan);

    /* enable the channel */

    if (!chan->irq_enabled) {
        enable_irq(chan->irq);
        chan->irq_enabled = 1;
    }

    /* start the channel going */

    tmp = dma_rdreg(chan, S3C2410_DMA_DMASKTRIG);
    tmp &= ~S3C2410_DMASKTRIG_STOP;
    tmp |= S3C2410_DMASKTRIG_ON;
    dma_wrreg(chan, S3C2410_DMA_DMASKTRIG, tmp);

    pr_debug("dma%d: %08lx to DMASKTRIG\n", chan->number, tmp);

#if 0
    /* the dma buffer loads should take care of clearing the AUTO
     * reloading feature */
    tmp = dma_rdreg(chan, S3C2410_DMA_DCON);
    tmp &= ~S3C2410_DCON_NORELOAD;
    dma_wrreg(chan, S3C2410_DMA_DCON, tmp);
#endif

    s3c2410_dma_call_op(chan, S3C2410_DMAOP_START);

    dbg_showchan(chan);

    /* if we've only loaded one buffer onto the channel, then chec
     * to see if we have another, and if so, try and load it so when
     * the first buffer is finished, the new one will be loaded onto
     * the channel */

    if (chan->next != NULL) {
        if (chan->load_state == S3C2410_DMALOAD_1LOADED) {

            if (s3c2410_dma_waitforload(chan, __LINE__) == 0) {
                pr_debug("%s: buff not yet loaded, no more todo\n",
                         __func__);
            } else {
                chan->load_state = S3C2410_DMALOAD_1RUNNING;
                s3c2410_dma_loadbuffer(chan, chan->next);
            }

        } else if (chan->load_state == S3C2410_DMALOAD_1RUNNING) {
            s3c2410_dma_loadbuffer(chan, chan->next);
        }
    }


    local_irq_restore(flags);

    return 0;
}
Пример #11
0
/***********************************************************************
 *
 * Function: c_entry
 *
 * Purpose: Application entry point from the startup code
 *
 * Processing:
 *     See function.
 *
 * Parameters: None
 *
 * Outputs: None
 *
 * Returns: Always returns 1
 *
 * Notes: None
 *
 **********************************************************************/
int c_entry(void)
{
  TMR_PSCALE_SETUP_T pscale;
  TMR_MATCH_SETUP_T msetup;

  /* Disable interrupts in ARM core */
  disable_irq_fiq();

  /* Setup miscellaneous board functions */
  ea3250_board_init();

  /* Set virtual address of MMU table */
  cp15_set_vmmu_addr((void *)
                     (IRAM_BASE + (256 * 1024) - (16 * 1024)));

  /* Initialize interrupt system */
  int_initialize(0xFFFFFFFF);

  /* Install standard IRQ dispatcher at ARM IRQ vector */
  int_install_arm_vec_handler(IRQ_VEC, (PFV) lpc32xx_irq_handler);

  /* Install timer interrupts handlers as a IRQ interrupts */
  int_install_irq_handler(IRQ_TIMER0, (PFV) timer0_user_interrupt);
  int_install_irq_handler(IRQ_TIMER1, (PFV) timer1_user_interrupt);

  /* Open timers - this will enable the clocks for all timers when
     match control, match output, and capture control functions
     disabled. Default clock will be internal. */
  timer0dev = timer_open(TIMER_CNTR0, 0);
  timer1dev = timer_open(TIMER_CNTR1, 0);

  /******************************************************************/
  /* Setup timer 0 for a 1Hz match rate                            */

  /* Use a prescale count time of 100uS                             */
  pscale.ps_tick_val = 0; /* Use ps_us_val value */
  pscale.ps_us_val = 100; /* 100uS */
  timer_ioctl(timer0dev, TMR_SETUP_PSCALE, (INT_32) &pscale);

  /* Use a match count value of 10000 (10000 * 100uS = 1000mS (1Hz))  */
  msetup.timer_num = 0; /* Use match register set 0 (of 0..3) */
  msetup.use_match_int = TRUE; /* Generate match interrupt on match */
  msetup.stop_on_match = FALSE; /* Do not stop timer on match */
  msetup.reset_on_match = TRUE; /* Reset timer counter on match */
  msetup.match_tick_val = 9999; /* Match is when timer count is 10000 */
  timer_ioctl(timer0dev, TMR_SETUP_MATCH, (INT_32) &msetup);

  /* Clear any latched timer 0 interrupts and enable match
   interrupt */
  timer_ioctl(timer0dev, TMR_CLEAR_INTS,
              (TIMER_CNTR_MTCH_BIT(0) | TIMER_CNTR_MTCH_BIT(1) |
               TIMER_CNTR_MTCH_BIT(2) | TIMER_CNTR_MTCH_BIT(3) |
               TIMER_CNTR_CAPT_BIT(0) | TIMER_CNTR_CAPT_BIT(1) |
               TIMER_CNTR_CAPT_BIT(2) | TIMER_CNTR_CAPT_BIT(3)));
  /******************************************************************/

  /******************************************************************/
  /* Setup timer 1 for a 4.9Hz match rate                           */

  /* Use a prescale count time of 100uS                             */
  pscale.ps_tick_val = 0; /* Use ps_us_val value */
  pscale.ps_us_val = 10; /* 100uS */
  timer_ioctl(timer1dev, TMR_SETUP_PSCALE, (INT_32) &pscale);

  /* Use a match value of 490 (490 * 100uS)                         */
  msetup.timer_num = 0; /* Use match register set 0 (of 0..3) */
  msetup.use_match_int = TRUE; /* Generate match interrupt on match */
  msetup.stop_on_match = FALSE; /* Do not stop timer on match */
  msetup.reset_on_match = TRUE; /* Reset timer counter on match */
  msetup.match_tick_val = 489;
  timer_ioctl(timer1dev, TMR_SETUP_MATCH, (INT_32) &msetup);

  /* Clear any latched timer 1 interrupts and enable match
   interrupt */
  timer_ioctl(timer1dev, TMR_CLEAR_INTS,
              (TIMER_CNTR_MTCH_BIT(0) | TIMER_CNTR_MTCH_BIT(1) |
               TIMER_CNTR_MTCH_BIT(2) | TIMER_CNTR_MTCH_BIT(3) |
               TIMER_CNTR_CAPT_BIT(0) | TIMER_CNTR_CAPT_BIT(1) |
               TIMER_CNTR_CAPT_BIT(2) | TIMER_CNTR_CAPT_BIT(3)));
  /******************************************************************/

  /* Enable timers (starts counting) */
  msecs = 0;
  timer_ioctl(timer0dev, TMR_ENABLE, 1);
  timer_ioctl(timer1dev, TMR_ENABLE, 1);

  /* Enable timer interrupts in the interrupt controller */
  int_enable(IRQ_TIMER0);
  int_enable(IRQ_TIMER1);

  /* Enable IRQ interrupts in the ARM core */
  enable_irq();

  /* Loop for 20 seconds and let interrupts toggle the LEDs */
  while (msecs < (10 * 1000));

  /* Disable timer interrupts in the interrupt controller */
  int_disable(IRQ_TIMER0);
  int_disable(IRQ_TIMER1);

  /* Disable interrupts in ARM core */
  disable_irq_fiq();

  /* Close timers */
  timer_close(timer0dev);
  timer_close(timer1dev);


  return 1;
}
Пример #12
0
/* These are pretty simple. We know the irq is never shared and the
   kernel does all the magic that's required. */
static void arc_enable_irq(struct parport *p)
{
	enable_irq(p->irq);
}
Пример #13
0
static void insert_headset(void)
{
#ifdef FEATURE_AUD_HOOK_BTN
        unsigned long irq_flags;
#endif
		int voltage = 0; /* FIH-SW2-MM-AY-hsed_type-00 */

        H2W_DBG("");

        input_sync(hi->hs_input);
        msleep(100); 
                
#ifdef FEATURE_AUD_HOOK_BTN
        /* On some non-standard headset adapters (usually those without a
        * button) the btn line is pulled down at the same time as the detect
        * line. We can check here by sampling the button line, if it is
        * low then it is probably a bad adapter so ignore the button.
        * If the button is released then we stop ignoring the button, so that
        * the user can recover from the situation where a headset is plugged
        * in with button held down.
        */

        hi->ignore_btn = 1; /* FIH-SW2-MM-AY-TAP_Tapioca-00746_00 */

        if (bn_irq_enable==0) {
                
                /* Enable button irq */
                local_irq_save(irq_flags);
                
                enable_irq(hi->irq_btn);
                
                local_irq_restore(irq_flags);
                
                bn_irq_enable=1;

                irq_set_irq_wake(hi->irq_btn, 1);
        }
#endif
	/* FIH-SW2-MM-AY-hsed_type-00 [ */

	if (isCTIAheadset) { /* FIH-SW2-MM-AY-hsed_type-03 */
		pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_ALWAYS);
		msleep(130);
		proc_comm_get_hsed_voltage(2, &voltage, 0); //it will get the prior value, not the current value. Should not omit.
		msleep(70);
		proc_comm_get_hsed_voltage(2, &voltage, 0);
		H2W_DBG("aud_hs: voltage is %d\n ", voltage);
		/* FIH-SW2-MM-AY-hsed_type-01 [ */
		if (voltage > 1700) {
	        //do not change state to issue an UEVENT.
	        //it is a earphone jack plug.
	        mHeadphone = false;
               hi->ignore_btn = 1;
	        pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_OFF);
               /* MM-RC-HEADSET-MULTIBUTTON-DETECT[* */
               #ifdef FEATURE_AUD_HOOK_BTN
	        if (bn_irq_enable) {
       	        local_irq_save(irq_flags);
       	        disable_irq(hi->irq_btn);
       	        local_irq_restore(irq_flags);
       	        bn_irq_enable=0;
       	        irq_set_irq_wake(hi->irq_btn, 0);
	        }
               #endif
               /* MM-RC-HEADSET-MULTIBUTTON-DETECT]* */
	        switch_set_state(&hi->sdev, UNKNOWN_DEVICE); /* FIH-SW2-MM-AY-hsed_type-02 */
		} else if (voltage > 700 || voltage < 400) { /* FIH-SW2-MM-AY-hsed_type-01 ] *//* SW-MM-RC-CTIA-TTY* */
	        if (gpio_get_value(hi->cable_in1) == HS_PLUG_IN) {
       	        if (gpio_get_value(hi->cable_in2) == BTN_STATE_PRESSED) {
                    switch_set_state(&hi->sdev, NOMIC_HEADSET);
                    mHeadphone=true;
                    hi->ignore_btn = 1;
                    pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_OFF);
                    H2W_DBG("aud_hs:HEADPHONE is plugging\n ");
                } else {
                    switch_set_state(&hi->sdev, HEADSET);
                    mHeadphone=false;
			#ifdef FEATURE_AUD_HOOK_BTN 
                    irq_set_irq_type(hi->irq_btn, IRQF_TRIGGER_BTN_PRESSED);
			#endif 
                    msleep(300);
                    hi->ignore_btn = 0;
                    H2W_DBG("aud_hs:HEADSET is plugging\n ");
                }
	        }
		} else {
            mHeadphone = false;
            hi->ignore_btn = 1;
            pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_OFF);
            switch_set_state(&hi->sdev, NOT_SUPPORT);
		}
		H2W_DBG("switch_get_state= %d ",switch_get_state(&hi->sdev));
	} else {
        /* FIH-SW2-MM-AY-TAP-ControlHSED_BIAS1-01 [ */
        pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_ALWAYS);
        msleep(130); /* FIH-SW2-MM-AY-Tapioca_SS-00467-00 */
        /* FIH-SW2-MM-AY-TAP-ControlHSED_BIAS1-01 ] */
	    if (gpio_get_value(hi->cable_in1) == HS_PLUG_IN) { /* FIH-SW2-MM-AY-TAP_headset_00 */
	
       	    if (gpio_get_value(hi->cable_in2) == BTN_STATE_PRESSED) { /* FIH-SW2-MM-AY-TAP_headset_00 */
                        
                switch_set_state(&hi->sdev, NOMIC_HEADSET);
			
                mHeadphone=true;
                hi->ignore_btn = 1;  /* FIH-SW2-MM-AY-TAP_Tapioca-00746_00 */
                H2W_DBG("aud_hs:HEADPHONE is plugging\n ");
	
            } else {
        
                switch_set_state(&hi->sdev, HEADSET);

                mHeadphone=false;
			
		#ifdef FEATURE_AUD_HOOK_BTN 
                irq_set_irq_type(hi->irq_btn, IRQF_TRIGGER_BTN_PRESSED);
		#endif 
                msleep(300);  /* FIH-SW2-MM-AY-TAP_Tapioca-00746_00 */
                hi->ignore_btn = 0;  /* FIH-SW2-MM-AY-TAP_Tapioca-00746_00 */
                H2W_DBG("aud_hs:HEADSET is plugging\n ");
            }
		
            H2W_DBG("switch_get_state= %d ",switch_get_state(&hi->sdev));
        }
	}
	/* FIH-SW2-MM-AY-hsed_type-00 ] */
}
Пример #14
0
void enable_timer()
{
	init_system_clock(&real_tm);
	enable_irq(TIMER_IRQ);
	timefly = last_timefly = 0;
}
Пример #15
0
static ssize_t
proximity_enable_store(struct device *dev,
                       struct device_attribute *attr,
                       const char *buf, size_t count)
{
    struct gp2a_data *data = dev_get_drvdata(dev);

    int value = 0;
    char input;
    int err = 0;
    int16_t thrd;
    u8 reg;

    err = kstrtoint(buf, 10, &value);

    if (err) {
        pr_err("%s, kstrtoint failed.", __func__);
        goto done;
    }
    if (value != 0 && value != 1)
        goto done;

    pr_info("%s, %d value = %d\n", __func__, __LINE__, value);

    if (data->proximity_enabled && !value) {	/* Prox power off */
        disable_irq(data->irq);

        proximity_onoff(0, data);
        disable_irq_wake(data->irq);
        if (data->pdata->led_on)
            data->pdata->led_on(false);
    }
    if (!data->proximity_enabled && value) {	/* prox power on */
        if (data->pdata->led_on)
            data->pdata->led_on(true);
        usleep_range(1000, 1100);
        proximity_onoff(1, data);

        err = proximity_open_calibration(data);
        if (err < 0 && err != -ENOENT)
            pr_err("%s: proximity_open_offset() failed\n",
                   __func__);
        else {
            thrd = gp2a_reg[3][1]+(data->offset_value);
            THR_REG_LSB(thrd, reg);
            gp2a_i2c_write(data, gp2a_reg[3][0], &reg);
            THR_REG_MSB(thrd, reg);
            gp2a_i2c_write(data, gp2a_reg[4][0], &reg);

            thrd = gp2a_reg[5][1]+(data->offset_value);
            THR_REG_LSB(thrd, reg);
            gp2a_i2c_write(data, gp2a_reg[5][0], &reg);
            THR_REG_MSB(thrd, reg);
            gp2a_i2c_write(data, gp2a_reg[6][0], &reg);
        }

        enable_irq_wake(data->irq);
        msleep(160);

        input = gpio_get_value_cansleep(data->pdata->p_out);
        if (input == 0) {
            input_report_abs(data->proximity_input_dev,
                             ABS_DISTANCE, 1);
            input_sync(data->proximity_input_dev);
        }

        enable_irq(data->irq);
    }
    data->proximity_enabled = value;
done:
    return count;
}
Пример #16
0
static void init(void)
{
    system_init();
    kernel_init();
#ifdef APPLICATION
    paths_init();
#endif
    buffer_init();
    enable_irq();
    lcd_init();
#ifdef HAVE_REMOTE_LCD
    lcd_remote_init();
#endif
    font_init();
    show_logo();
    button_init();
    backlight_init();
#if (CONFIG_PLATFORM & (PLATFORM_SDL|PLATFORM_MAEMO))
    sim_tasks_init();
#endif
#if (CONFIG_PLATFORM & PLATFORM_ANDROID)
    notification_init();
#endif
    lang_init(core_language_builtin, language_strings, 
              LANG_LAST_INDEX_IN_ARRAY);
#ifdef DEBUG
    debug_init();
#endif
    /* Keep the order of this 3 (viewportmanager handles statusbars)
     * Must be done before any code uses the multi-screen API */
    gui_syncstatusbar_init(&statusbars);
    gui_sync_skin_init();
    sb_skin_init();
    viewportmanager_init();

    storage_init();
    settings_reset();
    settings_load(SETTINGS_ALL);
    settings_apply(true);
    init_dircache(true);
    init_dircache(false);
#ifdef HAVE_TAGCACHE
    init_tagcache();
#endif
    sleep(HZ/2);
    tree_mem_init();
    filetype_init();
    playlist_init();
    theme_init_buffer();

#if CONFIG_CODEC != SWCODEC
    mp3_init( global_settings.volume,
              global_settings.bass,
              global_settings.treble,
              global_settings.balance,
              global_settings.loudness,
              global_settings.avc,
              global_settings.channel_config,
              global_settings.stereo_width,
              global_settings.mdb_strength,
              global_settings.mdb_harmonics,
              global_settings.mdb_center,
              global_settings.mdb_shape,
              global_settings.mdb_enable,
              global_settings.superbass);

    /* audio_init must to know the size of voice buffer so init voice first */
    talk_init();
#endif /* CONFIG_CODEC != SWCODEC */

    scrobbler_init();
#if CONFIG_CODEC == SWCODEC && defined (HAVE_PITCHSCREEN)
    tdspeed_init();
#endif /* CONFIG_CODEC == SWCODEC */

    audio_init();
    button_clear_queue(); /* Empty the keyboard buffer */
    
    settings_apply_skins();
}
static int msm_ehci_suspend(struct msm_hcd *mhcd)
{
	struct msm_usb_host_platform_data *pdata;
	struct usb_hcd *hcd = mhcd_to_hcd(mhcd);
	unsigned long timeout;
	int ret;
	u32 portsc;

	pdata = mhcd->dev->platform_data;
	if (atomic_read(&mhcd->in_lpm)) {
		dev_dbg(mhcd->dev, "%s called in lpm\n", __func__);
		return 0;
	}

	disable_irq(hcd->irq);

	/* Set the PHCD bit, only if it is not set by the controller.
	 * PHY may take some time or even fail to enter into low power
	 * mode (LPM). Hence poll for 500 msec and reset the PHY and link
	 * in failure case.
	 */
	portsc = readl_relaxed(USB_PORTSC);
	if (!(portsc & PORTSC_PHCD)) {
		writel_relaxed(portsc | PORTSC_PHCD,
				USB_PORTSC);

		timeout = jiffies + usecs_to_jiffies(PHY_SUSPEND_TIMEOUT_USEC);
		while (!(readl_relaxed(USB_PORTSC) & PORTSC_PHCD)) {
			if (time_after(jiffies, timeout)) {
				dev_err(mhcd->dev, "Unable to suspend PHY\n");
				schedule_work(&mhcd->phy_susp_fail_work);
				return -ETIMEDOUT;
			}
			udelay(1);
		}
	}

	/*
	 * PHY has capability to generate interrupt asynchronously in low
	 * power mode (LPM). This interrupt is level triggered. So USB IRQ
	 * line must be disabled till async interrupt enable bit is cleared
	 * in USBCMD register. Assert STP (ULPI interface STOP signal) to
	 * block data communication from PHY.
	 */
	writel_relaxed(readl_relaxed(USB_USBCMD) | ASYNC_INTR_CTRL |
				ULPI_STP_CTRL, USB_USBCMD);

	/*
	 * Ensure that hardware is put in low power mode before
	 * clocks are turned OFF and VDD is allowed to minimize.
	 */
	mb();

	clk_disable_unprepare(mhcd->iface_clk);
	clk_disable_unprepare(mhcd->core_clk);

	/* usb phy does not require TCXO clock, hence vote for TCXO disable */
	ret = msm_xo_mode_vote(mhcd->xo_handle, MSM_XO_MODE_OFF);
	if (ret)
		dev_err(mhcd->dev, "%s failed to devote for "
			"TCXO D0 buffer%d\n", __func__, ret);

	if (!pdata->mpm_xo_wakeup_int)
		msm_ehci_config_vddcx(mhcd, 0);

	atomic_set(&mhcd->in_lpm, 1);
	enable_irq(hcd->irq);
	if (mhcd->pmic_gpio_dp_irq) {
		mhcd->pmic_gpio_dp_irq_enabled = 1;
		enable_irq_wake(mhcd->pmic_gpio_dp_irq);
		enable_irq(mhcd->pmic_gpio_dp_irq);
	}
	wake_unlock(&mhcd->wlock);

	dev_info(mhcd->dev, "EHCI USB in low power mode\n");

	return 0;
}
Пример #18
0
static void init(void)
{
    int rc;
    bool mounted = false;
#if CONFIG_CHARGING && (CONFIG_CPU == SH7034)
    /* if nobody initialized ATA before, I consider this a cold start */
    bool coldstart = (PACR2 & 0x4000) != 0; /* starting from Flash */
#endif

    system_init();
#if defined(IPOD_VIDEO)
    audiobufend=(unsigned char *)audiobufend_lds;
    if(MEMORYSIZE==64 && probed_ramsize!=64)
    {
        audiobufend -= (32<<20);
    }
#endif
    kernel_init();

#ifdef HAVE_ADJUSTABLE_CPU_FREQ
    set_cpu_frequency(CPUFREQ_NORMAL);
#ifdef CPU_COLDFIRE
    coldfire_set_pllcr_audio_bits(DEFAULT_PLLCR_AUDIO_BITS);
#endif
    cpu_boost(true);
#endif
    
    buffer_init();

    settings_reset();

    i2c_init();
    
    power_init();

    enable_irq();
#ifdef CPU_ARM
    enable_fiq();
#endif
    /* current_tick should be ticking by now */
    CHART("ticking");

    lcd_init();
#ifdef HAVE_REMOTE_LCD
    lcd_remote_init();
#endif
    font_init();

    CHART(">show_logo");
    show_logo();
    CHART("<show_logo");
    lang_init(core_language_builtin, language_strings, 
              LANG_LAST_INDEX_IN_ARRAY);

#ifdef DEBUG
    debug_init();
#else
#ifdef HAVE_SERIAL
    serial_setup();
#endif
#endif

#if CONFIG_RTC
    rtc_init();
#endif
#ifdef HAVE_RTC_RAM
    CHART(">settings_load(RTC)");
    settings_load(SETTINGS_RTC); /* early load parts of global_settings */
    CHART("<settings_load(RTC)");
#endif

    adc_init();

    usb_init();
#if CONFIG_USBOTG == USBOTG_ISP1362
    isp1362_init();
#elif CONFIG_USBOTG == USBOTG_M5636
    m5636_init();
#endif

    backlight_init();

    button_init();

    powermgmt_init();

#if CONFIG_TUNER
    radio_init();
#endif

    /* Keep the order of this 3 (viewportmanager handles statusbars)
     * Must be done before any code uses the multi-screen API */
    CHART(">gui_syncstatusbar_init");
    gui_syncstatusbar_init(&statusbars);
    CHART("<gui_syncstatusbar_init");
    CHART(">sb_skin_init");
    sb_skin_init();
    CHART("<sb_skin_init");
    CHART(">gui_sync_wps_init");
    gui_sync_skin_init();
    CHART("<gui_sync_wps_init");
    CHART(">viewportmanager_init");
    viewportmanager_init();
    CHART("<viewportmanager_init");

#if CONFIG_CHARGING && (CONFIG_CPU == SH7034)
    /* charger_inserted() can't be used here because power_thread()
       hasn't checked power_input_status() yet */
    if (coldstart && (power_input_status() & POWER_INPUT_MAIN_CHARGER)
        && !global_settings.car_adapter_mode
#ifdef ATA_POWER_PLAYERSTYLE
        && !ide_powered() /* relies on probing result from bootloader */
#endif
        )
    {
        rc = charging_screen(); /* display a "charging" screen */
        if (rc == 1)            /* charger removed */
            power_off();
        /* "On" pressed or USB connected: proceed */
        show_logo();  /* again, to provide better visual feedback */
    }
#endif


    disk_init_subsystem();
    CHART(">storage_init");
    rc = storage_init();
    CHART("<storage_init");
    if(rc)
    {
#ifdef HAVE_LCD_BITMAP
        lcd_clear_display();
        lcd_putsf(0, 1, "ATA error: %d", rc);
        lcd_puts(0, 3, "Press ON to debug");
        lcd_update();
        while(!(button_get(true) & BUTTON_REL)); /* DO NOT CHANGE TO ACTION SYSTEM */
        dbg_ports();
#endif
        panicf("ata: %d", rc);
    }

#ifdef HAVE_EEPROM_SETTINGS
    CHART(">eeprom_settings_init");
    eeprom_settings_init();
    CHART("<eeprom_settings_init");
#endif

#ifndef HAVE_USBSTACK
    usb_start_monitoring();
    while (usb_detect() == USB_INSERTED)
    {
#ifdef HAVE_EEPROM_SETTINGS
        firmware_settings.disk_clean = false;
#endif
        /* enter USB mode early, before trying to mount */
        if (button_get_w_tmo(HZ/10) == SYS_USB_CONNECTED)
#if (CONFIG_STORAGE & STORAGE_MMC)
            if (!mmc_touched() ||
                (mmc_remove_request() == SYS_HOTSWAP_EXTRACTED))
#endif
            {
                gui_usb_screen_run(true);
                mounted = true; /* mounting done @ end of USB mode */
            }
#ifdef HAVE_USB_POWER
        if (usb_powered())      /* avoid deadlock */
            break;
#endif
    }
#endif

    if (!mounted)
    {
        CHART(">disk_mount_all");
        rc = disk_mount_all();
        CHART("<disk_mount_all");
        if (rc<=0)
        {
            lcd_clear_display();
            lcd_puts(0, 0, "No partition");
            lcd_puts(0, 1, "found.");
#ifdef HAVE_LCD_BITMAP
            lcd_puts(0, 2, "Insert USB cable");
            lcd_puts(0, 3, "and fix it.");
#endif
            lcd_update();

            while(button_get(true) != SYS_USB_CONNECTED) {};
            gui_usb_screen_run(true);
            system_reboot();
        }
    }

#if defined(SETTINGS_RESET) || (CONFIG_KEYPAD == IPOD_4G_PAD) || \
    (CONFIG_KEYPAD == IRIVER_H10_PAD)
#ifdef SETTINGS_RESET
    /* Reset settings if holding the reset button. (Rec on Archos,
       A on Gigabeat) */
    if ((button_status() & SETTINGS_RESET) == SETTINGS_RESET)
#else
    /* Reset settings if the hold button is turned on */
    if (button_hold())
#endif
    {
        splash(HZ*2, str(LANG_RESET_DONE_CLEAR));
        settings_reset();
    }
    else
#endif
    {
        CHART(">settings_load(ALL)");
        settings_load(SETTINGS_ALL);
        CHART("<settings_load(ALL)");
    }

    CHART(">init_dircache(true)");
    rc = init_dircache(true);
    CHART("<init_dircache(true)");
    if (rc < 0)
    {
#ifdef HAVE_TAGCACHE
        remove(TAGCACHE_STATEFILE);
#endif
    }

    CHART(">settings_apply(true)");
    settings_apply(true);        
    CHART("<settings_apply(true)");
    CHART(">init_dircache(false)");
    init_dircache(false);
    CHART("<init_dircache(false)");
#ifdef HAVE_TAGCACHE
    CHART(">init_tagcache");
    init_tagcache();
    CHART("<init_tagcache");
#endif

#ifdef HAVE_EEPROM_SETTINGS
    if (firmware_settings.initialized)
    {
        /* In case we crash. */
        firmware_settings.disk_clean = false;
        CHART(">eeprom_settings_store");
        eeprom_settings_store();
        CHART("<eeprom_settings_store");
    }
#endif
    playlist_init();
    tree_mem_init();
    filetype_init();
    scrobbler_init();
#if CONFIG_CODEC == SWCODEC && defined (HAVE_PITCHSCREEN)
    tdspeed_init();
#endif /* CONFIG_CODEC == SWCODEC */
    theme_init_buffer();

#if CONFIG_CODEC != SWCODEC
    /* No buffer allocation (see buffer.c) may take place after the call to
       audio_init() since the mpeg thread takes the rest of the buffer space */
    mp3_init( global_settings.volume,
              global_settings.bass,
              global_settings.treble,
              global_settings.balance,
              global_settings.loudness,
              global_settings.avc,
              global_settings.channel_config,
              global_settings.stereo_width,
              global_settings.mdb_strength,
              global_settings.mdb_harmonics,
              global_settings.mdb_center,
              global_settings.mdb_shape,
              global_settings.mdb_enable,
              global_settings.superbass);

     /* audio_init must to know the size of voice buffer so init voice first */
    talk_init();
#endif /* CONFIG_CODEC != SWCODEC */

    CHART(">audio_init");
    audio_init();
    CHART("<audio_init");

#if (CONFIG_CODEC == SWCODEC) && defined(HAVE_RECORDING) && !defined(SIMULATOR)
    pcm_rec_init();
#endif

    /* runtime database has to be initialized after audio_init() */
    cpu_boost(false);

#if CONFIG_CHARGING
    car_adapter_mode_init();
#endif
#ifdef IPOD_ACCESSORY_PROTOCOL
    iap_setup(global_settings.serial_bitrate);
#endif
#ifdef HAVE_ACCESSORY_SUPPLY
    accessory_supply_set(global_settings.accessory_supply);
#endif
#ifdef HAVE_LINEOUT_POWEROFF
    lineout_set(global_settings.lineout_active);
#endif
#ifdef HAVE_HOTSWAP_STORAGE_AS_MAIN
    CHART("<check_bootfile(false)");
    check_bootfile(false); /* remember write time and filesize */
    CHART(">check_bootfile(false)");
#endif
    CHART("<settings_apply_skins");
    settings_apply_skins();
    CHART(">settings_apply_skins");
}
Пример #19
0
static ssize_t pn544_dev_read(struct file *filp, char __user *buf,
		size_t count, loff_t *offset)
{
	struct pn544_dev *pn544_dev = filp->private_data;
	char tmp[MAX_BUFFER_SIZE];
	int ret;

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	pr_debug("%s : reading %zu bytes.\n", __func__, count);
#ifdef FEATURE_PN544_KERNEL_LOG
    pr_info("==> %s #1 (ven, firm, irq)=(%d, %d, %d)\n", __func__, gpio_get_value(pn544_dev->ven_gpio), gpio_get_value(pn544_dev->firm_gpio), gpio_get_value(pn544_dev->irq_gpio));
#endif

	mutex_lock(&pn544_dev->read_mutex);

	if (!gpio_get_value(pn544_dev->irq_gpio)) {
		if (filp->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			goto fail;
		}

		pn544_dev->irq_enabled = true;

#ifdef READ_IRQ_MODIFY
		do_reading=0;
#endif

		enable_irq(pn544_dev->client->irq);
#ifdef READ_IRQ_MODIFY
		ret = wait_event_interruptible(pn544_dev->read_wq, do_reading);
#else
		ret = wait_event_interruptible(pn544_dev->read_wq,
				gpio_get_value(pn544_dev->irq_gpio));
#endif
		pn544_disable_irq(pn544_dev);

#ifdef READ_IRQ_MODIFY
		if(cancle_read == true)
		{
		    cancle_read = false;
		    ret = -1;
		    goto fail;
		}
#endif
		if (ret)
			goto fail;

	}

#ifdef FEATURE_PN544_KERNEL_LOG
    pr_info("==> %s #2 (ven, firm, irq)=(%d, %d, %d)\n", __func__, gpio_get_value(pn544_dev->ven_gpio), gpio_get_value(pn544_dev->firm_gpio), gpio_get_value(pn544_dev->irq_gpio));
#endif
	/* Read data */
	ret = i2c_master_recv(pn544_dev->client, tmp, count);
	mutex_unlock(&pn544_dev->read_mutex);

	if (ret < 0) {
		pr_err("%s: i2c_master_recv returned %d\n", __func__, ret);
		return ret;
	}
	if (ret > count) {
		pr_err("%s: received too many bytes from i2c (%d)\n",
			__func__, ret);
		return -EIO;
	}
	if (copy_to_user(buf, tmp, ret)) {
		pr_warning("%s : failed to copy to user space\n", __func__);
		return -EFAULT;
	}
	return ret;

fail:
	mutex_unlock(&pn544_dev->read_mutex);
	return ret;
}
Пример #20
0
static int lpc32xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct lpc32xx_rtc_priv *lpc32xx_rtc_dat = platform_get_drvdata(pdev);

	switch (cmd) {
	case RTC_AIE_ON:
		spin_lock_irq(&lpc32xx_rtc_dat->lock);

		if (!lpc32xx_rtc_dat->alarm_enabled)
		{
			enable_irq(lpc32xx_rtc_dat->irq);
			lpc32xx_rtc_dat->alarm_enabled = 1;
		}

		spin_unlock_irq(&lpc32xx_rtc_dat->lock);
		break;

	case RTC_AIE_OFF:
		spin_lock_irq(&lpc32xx_rtc_dat->lock);

		if (lpc32xx_rtc_dat->alarm_enabled)
		{
			disable_irq(lpc32xx_rtc_dat->irq);
			lpc32xx_rtc_dat->alarm_enabled = 0;
		}

		spin_unlock_irq(&lpc32xx_rtc_dat->lock);
		break;

	case RTC_PIE_ON:
		enable_irq(lpc32xx_rtc_dat->irq);
		break;

	case RTC_PIE_OFF:
		disable_irq(lpc32xx_rtc_dat->irq);
		break;

	case RTC_IRQP_READ:
		return put_user(1, (unsigned long __user *)arg);
		break;

	case RTC_IRQP_SET:
		/* Only 1Hz is supported */
		if (arg != 1)
			return -EINVAL;
		break;

	case RTC_EPOCH_READ:
		return put_user(epoch, (unsigned long __user *)arg);

	case RTC_EPOCH_SET:
		/* Doesn't support before 1900 */
		if (arg < 1900)
			return -EINVAL;
		epoch = arg;
		break;

	default:
		return -ENOIOCTLCMD;
	}

	return 0;
}
Пример #21
0
static void do_wakeup(struct work_struct *work)
{
    enable_irq(bp_wakeup_ap_irq);
}
Пример #22
0
//---------------------------------------------
// read_pclta()
ssize_t read_pclta( struct file *dev_file, char * buffer, size_t count, loff_t * offset )

//long read_pclta(struct inode* dev_inode, struct file *dev_file, char *buffer, unsigned long count)
//read_write_t read_pclta(struct inode*, struct file *dev_file, char * buffer, count_t count)

{
	struct pclta_device *device = dev_file->private_data;
	struct pclta_packet * packet_buffer;
	byte temp_swap=0;

	CALL_MSG("Starting read_pclta()", ++pclta_call_level );
		
	// verification
	if( device == NULL ) {
		RETURN_MSG("read_pclta() ENXIO", pclta_call_level-- );
		return -ENXIO;
	}
	
//	if (last_packet_read_complete==true)
	
    	// wait for uplink packet
	packet_buffer = device->rx->tail; // read from tail.
    print_buffer(device->rx);
	

	// no data available
	if( ! packet_buffer->busy && (dev_file->f_flags & O_NONBLOCK) ) {
		RETURN_MSG("read_pclta() EWOULDBLOCK", pclta_call_level-- );
		return -EWOULDBLOCK;
	}
	else
		if( ! packet_buffer->busy ) {
    		DEBUG_MSG( "in read_pclta() packet_buffer  ADDY(tail)=%ud", (unsigned int) &packet_buffer);
     		DEBUG_MSG("p_b->length= %d ;data0=; %x data1= %x ", packet_buffer->length,packet_buffer->data[0],packet_buffer->data[1]);

			RETURN_MSG("read_pclta() ENODATA", pclta_call_level-- );
			return -ENODATA;		// nothing available
		}
		
	// check if enough space available to read.
	if( count <= packet_buffer->length ) {
	    DEBUG_MSG("ERROR: count= %d    ;  packet_buffer->length= %d",(int) count, packet_buffer->length);
		RETURN_MSG("read_pclta() EINVAL;  count > packet_buffer->length", pclta_call_level-- );
		return -EINVAL;

	}

    //swap the first two bytes and subtract one from the length
    temp_swap=packet_buffer->data[0]-1;  // subtract one from length
    packet_buffer->data[0]=packet_buffer->data[1];
    packet_buffer->data[1]=temp_swap;
	
	// copy data from buffer to user space
	copy_to_user( buffer, &packet_buffer->data[0], packet_buffer->length+1 );

	// update buffer data
	packet_buffer->busy = false;
	device->rx->tail = packet_buffer->next;
	
	
//	restart uplink if backed off
	if( device->restart_uplink ) {
		disable_irq( device->interrupt );
		device->restart_uplink = false;
		if( device->state == Idle )
			pclta_service( device );
		enable_irq( device->interrupt );
	} // restart uplink, but only if device is in the Idle State

	RETURN_MSG("SUCCESS read_pclta() length = %d", pclta_call_level--, packet_buffer->length );
	
	return packet_buffer->length+1;
}
Пример #23
0
static int dock_switch_probe(struct platform_device *pdev)
{
	int ret;
	struct dock_switch_device *dock_switch;
	struct dock_switch_platform_data *pdata = (struct dock_switch_platform_data *)
			pdev->dev.platform_data;
	if (!pdata || (!pdata->gpio_desktop && !pdata->gpio_car))
		return -EBUSY;
	dock_switch = kzalloc(sizeof(struct dock_switch_device), GFP_KERNEL);
	if (!dock_switch)
		return -ENOMEM;
	
	if (pdata->gpio_desktop) {
		dock_switch->gpio_desktop = pdata->gpio_desktop;
		dock_switch->gpio_desktop_active_low = pdata->gpio_desktop_active_low;
		ret = gpio_request(dock_switch->gpio_desktop, "switch_desktop");
		if (ret < 0) {
			loge("err_request_gpio_desktop\n");
			goto err_request_gpio_desktop;
		}

		
		gpio_direction_input(dock_switch->gpio_desktop);
		dock_switch->irq_desktop = gpio_to_irq(dock_switch->gpio_desktop);
		ret = request_irq(dock_switch->irq_desktop, dock_switch_irq_handler, 
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "switch_desktop", 
				dock_switch);
		if (ret < 0) {
			loge("err_request_irq_desktop\n");
			goto err_request_irq_desktop;
		}
		
	}
	
	if (pdata->gpio_car) {
		dock_switch->gpio_car = pdata->gpio_car;
		dock_switch->gpio_car_active_low = pdata->gpio_car_active_low;
		ret = gpio_request(dock_switch->gpio_car, "switch_car");
		if (ret < 0) {
			loge("err_request_gpio_car\n");
			goto err_request_gpio_car;
		}
		gpio_direction_input(dock_switch->gpio_car);
		dock_switch->irq_car = gpio_to_irq(dock_switch->gpio_car);
		ret = request_irq(dock_switch->irq_car, dock_switch_irq_handler, 
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "switch_car",
				dock_switch);
		if (ret < 0) {
			loge("err_request_irq_car\n");
			goto err_request_irq_car;
		}
	}
	
	
	INIT_WORK(&dock_switch->work, dock_switch_work_func);
	
	dock_switch->sdev.name = DOCK_SWITCH_NAME;
	dock_switch->sdev.print_state = dock_switch_print_state;
	ret = switch_dev_register(&dock_switch->sdev);
	if (ret < 0) {
		logd("err_register_switch\n");
		goto err_register_switch;
	}
	if (dock_switch->irq_car) 
		enable_irq(dock_switch->irq_car);
	if (dock_switch->irq_desktop)
		enable_irq(dock_switch->irq_desktop);
	platform_set_drvdata(pdev, dock_switch);
	p_dock_switch=dock_switch;
	schedule_work(&dock_switch->work);
	logd("dock_switch_probe() successed\n");
	desktop_dock_inserted();
	
	return 0;

err_register_switch:
	if (dock_switch->irq_car)
		free_irq(dock_switch->irq_car, NULL);
err_request_irq_car:
	if (dock_switch->gpio_car) 
		gpio_free(dock_switch->gpio_car);
err_request_gpio_car:
	if (dock_switch->irq_desktop)
		free_irq(dock_switch->irq_desktop, NULL);
err_request_irq_desktop:
	if (dock_switch->gpio_desktop)
		gpio_free(dock_switch->gpio_desktop);
err_request_gpio_desktop:
	kfree(dock_switch);
	
	loge("dock_switch_probe() failed\n");
	
	return ret;
}
Пример #24
0
//int write_pclta( struct file *file, const char *buffer, size_t count, loff_t * offset)						
ssize_t write_pclta( struct file *file, const char *buffer, size_t count, loff_t *offset )

{
    struct pclta_device *device = file->private_data;
    struct pclta_packet *packet_buffer;
    unsigned int length_of_msg;
    byte temp_swap=0;
    byte temp_buffer[512];
    int sum_sent=0;  // sum of bytes sent.
    byte *msg_ptr;    
	
	CALL_MSG("Starting write_pclta()", ++pclta_call_level);

	
	// verification
    if( device == NULL ) {
    	RETURN_MSG("write_pclta() ERROR device=NULL", pclta_call_level-- );
    	return -ENXIO;
	}
	
    if( 0 > verify_area( VERIFY_READ, buffer, count ) ) {
    	RETURN_MSG("write_pclta() ERROR= EFAULT verify area ", pclta_call_level-- );
    	return -EFAULT;
	}
	
    if( count < 2 ) {
    	RETURN_MSG("write_pclta() ERROR=EINVAL  count < 2 ", pclta_call_level-- );
    	return -EINVAL;
	}

	//    length=count; // karl

//    copy_from_user(&packet_buffer->length, buffer, count );  // reads NI command into the legth position

    copy_from_user(temp_buffer, buffer,count );  // reads NI command into the legth position
	msg_ptr=temp_buffer;
	while (sum_sent < count) // must send all data
	{
	
    	// wait for free buffer entry
        packet_buffer = device->tx->head;
    
    
        // no buffer available
        if( packet_buffer->busy && (file->f_flags & O_NONBLOCK) ) {
        	RETURN_MSG("write_pclta()  ERROR write_pclta()", pclta_call_level-- ); 
        	return -EWOULDBLOCK;
    	}
    	else
    		if( packet_buffer->busy ) {
    			RETURN_MSG("write_pclta() ERROR EAGAIN", pclta_call_level-- );
	    		return -EAGAIN;		// retry later
        	}


        length_of_msg=*(msg_ptr+1)+2;
        memcpy(&packet_buffer->length,msg_ptr,length_of_msg);
        

//	DEBUG_MSG("in write_pclta() Length=[%x] D0=[%x] ;D1=[%x] ;D2=[%x] ;D3=[%x] ;D4=[%x] ;D5=[%x] ;D6=[%x]",packet_buffer->length,packet_buffer->data[0],packet_buffer->data[1],packet_buffer->data[2],packet_buffer->data[3],packet_buffer->data[4],packet_buffer->data[5],packet_buffer->data[6]);

      //swap the first two bytes and subtract one from the length
        temp_swap=packet_buffer->data[0];  // [0] is the length
        packet_buffer->data[0]=packet_buffer->length;  // put the NI command at postion 0 
        packet_buffer->length=temp_swap + 1; 
//	DEBUG_MSG("write_pclta() FIX Length=[%x] D0=[%x] ;D1=[%x] ;D2=[%x] ;D3=[%x] ;D4=[%x] ;D5=[%x] ;D6=[%x]",packet_buffer->length,packet_buffer->data[0],packet_buffer->data[1],packet_buffer->data[2],packet_buffer->data[3],packet_buffer->data[4],packet_buffer->data[5],packet_buffer->data[6]);


    	// update output buffers and start downlink transfer
        device->tx->head = packet_buffer->next;
        packet_buffer->busy = true;
    
        sum_sent+=length_of_msg;
	    msg_ptr+=length_of_msg;
    }
    
    if( device->state == Idle ) {
        disable_irq( device->interrupt );
	    DEBUG_MSG("in write_pclta()  about to start_downlink  interupt= %d",device->interrupt);
        pclta_start_downlink( device );
        enable_irq( device->interrupt );
    }

       
    
	RETURN_MSG("write_pclta() finished. ", pclta_call_level-- );
    return count;
}
static long pn547_dev_ioctl(struct file *filp,
			   unsigned int cmd, unsigned long arg)
{
	struct pn547_dev *pn547_dev = filp->private_data;

	switch (cmd) {
	case PN547_SET_PWR:
		if (arg == 2) {
			/* power on with firmware download (requires hw reset)
			 */
			gpio_set_value_cansleep(pn547_dev->ven_gpio, 1);
			gpio_set_value(pn547_dev->firm_gpio, 1);
			usleep_range(10000, 10050);
			gpio_set_value_cansleep(pn547_dev->ven_gpio, 0);
			usleep_range(10000, 10050);
			gpio_set_value_cansleep(pn547_dev->ven_gpio, 1);
			usleep_range(10000, 10050);
			if (atomic_read(&pn547_dev->irq_enabled) == 0) {
				atomic_set(&pn547_dev->irq_enabled, 1);
				enable_irq(pn547_dev->client->irq);
				enable_irq_wake(pn547_dev->client->irq);
			}
			pr_info("%s power on with firmware, irq=%d\n", __func__,
				atomic_read(&pn547_dev->irq_enabled));
		} else if (arg == 1) {
			/* power on */
			if (pn547_dev->conf_gpio)
				pn547_dev->conf_gpio();
			gpio_set_value(pn547_dev->firm_gpio, 0);
			gpio_set_value_cansleep(pn547_dev->ven_gpio, 1);
			usleep_range(10000, 10050);
			if (atomic_read(&pn547_dev->irq_enabled) == 0) {
				atomic_set(&pn547_dev->irq_enabled, 1);
				enable_irq(pn547_dev->client->irq);
				enable_irq_wake(pn547_dev->client->irq);
			}
			pr_info("%s power on, irq=%d\n", __func__,
				atomic_read(&pn547_dev->irq_enabled));
		} else if (arg == 0) {
			/* power off */
			if (atomic_read(&pn547_dev->irq_enabled) == 1) {
				atomic_set(&pn547_dev->irq_enabled, 0);
				disable_irq_wake(pn547_dev->client->irq);
				disable_irq_nosync(pn547_dev->client->irq);
			}
			pr_info("%s power off, irq=%d\n", __func__,
				atomic_read(&pn547_dev->irq_enabled));
			gpio_set_value(pn547_dev->firm_gpio, 0);
			gpio_set_value_cansleep(pn547_dev->ven_gpio, 0);
			usleep_range(10000, 10050);
		} else if (arg == 3) {
			pr_info("%s Read Cancel\n", __func__);
			pn547_dev->cancel_read = true;
			atomic_set(&pn547_dev->read_flag, 1);
			wake_up(&pn547_dev->read_wq);
		} else {
			pr_err("%s bad arg %lu\n", __func__, arg);
			return -EINVAL;
		}
		break;
	default:
		pr_err("%s bad ioctl %u\n", __func__, cmd);
		return -EINVAL;
	}

	return 0;
}
Пример #26
0
static void wl1251_enable_line_irq(struct wl1251 *wl)
{
	return enable_irq(wl->irq);
}
Пример #27
0
/*
 * ioctl function
 */
long tscdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    long ret;
    spinlock_t *lock;
    struct tsc_dev *devp;
    struct clk_para temp_clk;
    struct clk *clk_hdle;
    struct intrstatus statusdata;

    ret = 0;
    devp = filp->private_data;
    lock = &devp->lock;

    if (_IOC_TYPE(cmd) != TSCDEV_IOC_MAGIC)
        return -EINVAL;
    if (_IOC_NR(cmd) > TSCDEV_IOC_MAXNR)
        return -EINVAL;

    switch (cmd) {
        case TSCDEV_WAIT_INT:
            ret = wait_event_interruptible_timeout(wait_proc, devp->irq_flag, HZ * 1);
            if (!ret && !devp->irq_flag) {
                //case: wait timeout.
                TSC_ERR("%s: wait timeout\n", __func__);
                memset(&statusdata, 0, sizeof(statusdata));
            } else {
                //case: interrupt occured.
                devp->irq_flag = 0;
                statusdata.port0chan    = devp->intstatus.port0chan;
                statusdata.port0pcr     = devp->intstatus.port0pcr;
                statusdata.port1chan    = devp->intstatus.port1chan;
                statusdata.port1pcr     = devp->intstatus.port1pcr;
            }

            //copy status data to user
            if (copy_to_user((struct intrstatus *)arg, &(devp->intstatus),
                             sizeof(struct intrstatus))) {
                return -EFAULT;
            }

            break;

        case TSCDEV_GET_PHYSICS:
            return virt_to_phys((void *)devp->pmem);

        case TSCDEV_ENABLE_INT:
            enable_irq(devp->irq);
            break;

        case TSCDEV_DISABLE_INT:
            tsc_devp->irq_flag = 1;
            wake_up_interruptible(&wait_proc);
            disable_irq(devp->irq);
            break;

        case TSCDEV_RELEASE_SEM:
            tsc_devp->irq_flag = 1;
            wake_up_interruptible(&wait_proc);
            break;

        case TSCDEV_GET_CLK:
            if (copy_from_user(&temp_clk, (struct clk_para __user *)arg,
                               sizeof(struct clk_para))) {
                TSC_ERR("%s: get clk error\n", __func__);
                return -EFAULT;
            }
            clk_hdle = clk_get(devp->dev, temp_clk.clk_name);

            if (copy_to_user((char *) & ((struct clk_para *)arg)->handle,
                             &clk_hdle, 4)) {
                TSC_ERR("%s: get clk error\n", __func__);
                return -EFAULT;
            }
            break;

        case TSCDEV_PUT_CLK:
            if (copy_from_user(&temp_clk, (struct clk_para __user *)arg,
                               sizeof(struct clk_para))) {
                TSC_ERR("%s: put clk error\n", __func__);
                return -EFAULT;
            }
            clk_put((struct clk *)temp_clk.handle);

            break;

        case TSCDEV_ENABLE_CLK:
            if (copy_from_user(&temp_clk, (struct clk_para __user *)arg,
                               sizeof(struct clk_para))) {
                TSC_ERR("%s: enable clk error\n", __func__);
                return -EFAULT;
            }

            clk_enable((struct clk *)temp_clk.handle);

            break;

        case TSCDEV_DISABLE_CLK:
            if (copy_from_user(&temp_clk, (struct clk_para __user *)arg,
                               sizeof(struct clk_para))) {
                TSC_ERR("%s: disable clk error\n", __func__);
                return -EFAULT;
            }

            clk_disable((struct clk *)temp_clk.handle);

            break;

        case TSCDEV_GET_CLK_FREQ:
            if (copy_from_user(&temp_clk, (struct clk_para __user *)arg,
                               sizeof(struct clk_para))) {
                TSC_ERR("%s: get clk freq error\n", __func__);
                return -EFAULT;
            }
            temp_clk.clk_rate = clk_get_rate((struct clk *)temp_clk.handle);

            if (copy_to_user((char *) & ((struct clk_para *)arg)->clk_rate,
                             &temp_clk.clk_rate, 4)) {
                TSC_ERR("%s: get clk freq error\n", __func__);
                return -EFAULT;
            }
            break;

        case TSCDEV_SET_SRC_CLK_FREQ:
            break;

        case TSCDEV_SET_CLK_FREQ:
            if (copy_from_user(&temp_clk, (struct clk_para __user *)arg,
                               sizeof(struct clk_para))) {
                TSC_ERR("%s: set clk error\n", __func__);
                return -EFAULT;
            }

            clk_set_rate((struct clk *)temp_clk.handle, temp_clk.clk_rate);

            break;

        default:
            TSC_ERR("%s: invalid cmd\n", __func__);
            ret = -EINVAL;
            break;
    }

    return ret;
}
Пример #28
0
static void wl1271_spi_enable_interrupts(struct wl1271 *wl)
{
	enable_irq(wl->irq);
}
Пример #29
0
/*
 * This thread processes interrupts reported by the Primary Interrupt Handler.
 */
static int twl6030_irq_thread(void *data)
{
	long irq = (long)data;
	static unsigned i2c_errors;
	static const unsigned max_i2c_errors = 100;
	int ret;

	current->flags |= PF_NOFREEZE;

	while (!kthread_should_stop()) {
		int i;
		union {
		u8 bytes[4];
		u32 int_sts;
		} sts;
		u32 int_sts; /* sts.int_sts converted to CPU endianness */

		/* Wait for IRQ, then read PIH irq status (also blocking) */
		wait_for_completion_interruptible(&irq_event);

		/* read INT_STS_A, B and C in one shot using a burst read */
		ret = twl_i2c_read(TWL_MODULE_PIH, sts.bytes,
				REG_INT_STS_A, 3);
		if (ret) {
			pr_warning("twl6030: I2C error %d reading PIH ISR\n",
					ret);
			if (++i2c_errors >= max_i2c_errors) {
				printk(KERN_ERR "Maximum I2C error count"
						" exceeded.  Terminating %s.\n",
						__func__);
				break;
			}
			complete(&irq_event);
			continue;
		}



		sts.bytes[3] = 0; /* Only 24 bits are valid*/

		/*
		 * Since VBUS status bit is not reliable for VBUS disconnect
		 * use CHARGER VBUS detection status bit instead.
		 */
		if (sts.bytes[2] & 0x10)
			sts.bytes[2] |= 0x08;

		int_sts = le32_to_cpu(sts.int_sts);
		for (i = 0; int_sts; int_sts >>= 1, i++) {
			local_irq_disable();
			if (int_sts & 0x1) {
				int module_irq = twl6030_irq_base +
					twl6030_interrupt_mapping[i];
				generic_handle_irq(module_irq);

			}
		local_irq_enable();
		}

		/*
		 * NOTE:
		 * Simulation confirms that documentation is wrong w.r.t the
		 * interrupt status clear operation. A single *byte* write to
		 * any one of STS_A to STS_C register results in all three
		 * STS registers being reset. Since it does not matter which
		 * value is written, all three registers are cleared on a
		 * single byte write, so we just use 0x0 to clear.
		 */
		ret = twl_i2c_write_u8(TWL_MODULE_PIH, 0x00, REG_INT_STS_A);
		if (ret)
			pr_warning("twl6030: I2C error in clearing PIH ISR\n");

		enable_irq(irq);
	}

	return 0;
}
static ssize_t pn547_dev_read(struct file *filp, char __user *buf,
		size_t count, loff_t *offset)
{
	struct pn547_dev *pn547_dev = filp->private_data;
	char tmp[MAX_BUFFER_SIZE];
	int ret;
        //pr_info("%s ++ \n", __func__);

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;
        //pr_info("%s : read request for %zu bytes.\n", __func__, count);

	/* not add wake lock in the dev read function */
    //wake_lock(&pn547_dev->wl);
    mutex_lock(&pn547_dev->read_mutex);
	if (!gpio_get_value(pn547_dev->irq_gpio)) {
		if (filp->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			goto fail;
		}
            //pr_info("Waiting for PN547 IRQ.\n");

		pn547_dev->irq_enabled = true;
		pn547_dev->do_reading = 0;
		enable_irq(pn547_dev->client->irq);
		ret = wait_event_interruptible(pn547_dev->read_wq,
				pn547_dev->do_reading);

		pn547_disable_irq(pn547_dev);
            //pr_info("PN547 IRQ high.\n");

		if (pn547_dev->cancel_read) {
			pn547_dev->cancel_read = false;
			ret = -1;
			goto fail;
		}

		if (ret)
			goto fail;

	}
	//mutex_lock(&pn547_dev->read_mutex);

	/* Read data */
	ret = i2c_master_recv(pn547_dev->client, tmp, count);
    mutex_unlock(&pn547_dev->read_mutex);
    //wake_unlock(&pn547_dev->wl);
	
        //pr_info("%s : i2c read %zu bytes. status : %d\n", __func__, count, ret);

	if (ret < 0) {
		pr_err("%s: PN547 i2c_master_recv returned %d\n", __func__, ret);
		//mutex_unlock(&pn547_dev->read_mutex);
		return ret;
	}

	if (ret > count) {
		pr_err("%s: received too many bytes from i2c (%d)\n",
			__func__, ret);
		//mutex_unlock(&pn547_dev->read_mutex);
		return -EIO;
	}

	if (copy_to_user(buf, tmp, ret)) {
		pr_warning("%s : failed to copy to user space\n", __func__);
		//mutex_unlock(&pn547_dev->read_mutex);
		return -EFAULT;
	}
	//mutex_unlock(&pn547_dev->read_mutex);
	return ret;

fail:
	mutex_unlock(&pn547_dev->read_mutex);
    //wake_unlock(&pn547_dev->wl);
	
        pr_err("%s : goto fail, and ret : %d \n", __func__,ret);
	return ret;
}