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); } }
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; }
static void fs_enet_netpoll(struct net_device *dev) { disable_irq(dev->irq); fs_enet_interrupt(dev->irq, dev); enable_irq(dev->irq); }
static int mstar_gflip_drv_resume(struct platform_device *dev) { MDrv_GFLIP_Resume(&_gflip_regs_save); enable_irq(E_IRQ_GOP); return 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; }
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; }
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; }
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; }
/*********************************************************************** * * 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; }
/* 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); }
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 ] */ }
void enable_timer() { init_system_clock(&real_tm); enable_irq(TIMER_IRQ); timefly = last_timefly = 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], ®); THR_REG_MSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[4][0], ®); thrd = gp2a_reg[5][1]+(data->offset_value); THR_REG_LSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[5][0], ®); THR_REG_MSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[6][0], ®); } 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; }
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; }
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"); }
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; }
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; }
static void do_wakeup(struct work_struct *work) { enable_irq(bp_wakeup_ap_irq); }
//--------------------------------------------- // 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; }
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; }
//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; }
static void wl1251_enable_line_irq(struct wl1251 *wl) { return enable_irq(wl->irq); }
/* * 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; }
static void wl1271_spi_enable_interrupts(struct wl1271 *wl) { enable_irq(wl->irq); }
/* * 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; }