static void headsetobserve_work(struct work_struct *work) { int level = 0; int level2 = 0; struct rk_headset_pdata *pdata = headset_info->pdata; static unsigned int old_status = 0; DBG("---headsetobserve_work---\n"); mutex_lock(&headset_info->mutex_lock[HEADSET]); level = read_gpio(pdata->Headset_gpio); if(level < 0) goto out; msleep(100); level2 = read_gpio(pdata->Headset_gpio); if(level2 < 0) goto out; if(level2 != level) goto out; old_status = headset_info->headset_status; if(pdata->headset_in_type == HEADSET_IN_HIGH) headset_info->headset_status = level?HEADSET_IN:HEADSET_OUT; else headset_info->headset_status = level?HEADSET_OUT:HEADSET_IN; if(old_status == headset_info->headset_status) { DBG("old_status == headset_info->headset_status\n"); goto out; } DBG("(headset in is %s)headset status is %s\n", pdata->headset_in_type?"high level":"low level", headset_info->headset_status?"in":"out"); if(headset_info->headset_status == HEADSET_IN) { headset_info->cur_headset_status = BIT_HEADSET_NO_MIC; if(pdata->headset_in_type == HEADSET_IN_HIGH) irq_set_irq_type(headset_info->irq[HEADSET],IRQF_TRIGGER_FALLING); else irq_set_irq_type(headset_info->irq[HEADSET],IRQF_TRIGGER_RISING); if (pdata->Hook_gpio) { del_timer(&headset_info->headset_timer);//Start the timer, wait for switch to the headphone channel headset_info->headset_timer.expires = jiffies + 100; add_timer(&headset_info->headset_timer); goto out; } } else if(headset_info->headset_status == HEADSET_OUT) { headset_info->hook_status = HOOK_UP; if(headset_info->isHook_irq == enable) { DBG("disable headset_hook irq\n"); headset_info->isHook_irq = disable; disable_irq(headset_info->irq[HOOK]); } headset_info->cur_headset_status = 0;//~(BIT_HEADSET|BIT_HEADSET_NO_MIC); //#if defined(CONFIG_SND_RK_SOC_RK2928) || defined(CONFIG_SOC_RK3028) //rk2928_codec_set_spk(HEADSET_OUT); //#endif if(pdata->headset_in_type == HEADSET_IN_HIGH) irq_set_irq_type(headset_info->irq[HEADSET],IRQF_TRIGGER_RISING); else irq_set_irq_type(headset_info->irq[HEADSET],IRQF_TRIGGER_FALLING); } rk28_send_wakeup_key(); switch_set_state(&headset_info->sdev, headset_info->cur_headset_status); #if defined(CONFIG_SND_RK_SOC_RK2928) || defined(CONFIG_SND_RK29_SOC_RK610) if (headset_info->headset_status == HEADSET_OUT) { mdelay(200); rk2928_codec_set_spk(HEADSET_OUT); gpio_set_value(pdata->Sw_mic_gpio, headset_info->pdata->Main_mic_io_value); } #endif DBG("headset_info->cur_headset_status = %d\n",headset_info->cur_headset_status); out: mutex_unlock(&headset_info->mutex_lock[HEADSET]); }
static int mtlte_sys_sdio_thread(void *_ltedev) { struct mtlte_dev *ltedev = (struct mtlte_dev *)_ltedev; struct timer_list give_own_timer; unsigned long give_own_deley_t; /* set same task priority with original EMCS */ struct sched_param param = { .sched_priority = RTPM_PRIO_MTLTE_SYS_SDIO_THREAD }; sched_setscheduler(current, SCHED_FIFO, ¶m); init_timer(&give_own_timer); give_own_timer.function = give_own_timer_callback; give_own_timer.data = 0; lte_dev.sdio_thread_state = SDIO_THREAD_RUNNING ; while (1) { wait_event_interruptible( ltedev->sdio_thread_wq, (kthread_should_stop() /* check this first! */ || ltedev->sdio_thread_kick || ltedev->sdio_thread_kick_isr )); if (kthread_should_stop()){ break ; } if (!ltedev->card_exist){ ltedev->sdio_thread_kick =0 ; ltedev->sdio_thread_kick_isr =0 ; continue ; } #if USING_WAKE_MD_EINT if(1 == mtlte_hif_sdio_check_fw_own()) { if(ltedev->sdio_thread_kick_isr){ mtlte_hif_sdio_get_driver_own_in_main(); } else{ mtlte_hif_sdio_wake_MD_up_EINT(); wait_event_interruptible( ltedev->sdio_thread_wq, (kthread_should_stop() || ltedev->sdio_thread_kick_isr)); if (kthread_should_stop()) { lte_sdio_turnoff_wakedevice(); break; } KAL_RAWPRINT((" [SDIO][Sleep] MD acked wake_up_EINT with isr.\n")); mtlte_hif_sdio_get_driver_own_in_main(); } } #endif ltedev->sdio_thread_kick =0; ltedev->sdio_thread_kick_isr =0; mtlte_hif_sdio_process() ; #if USING_WAKE_MD_EINT if(0 == ltedev->sdio_thread_kick && 0 == ltedev->sdio_thread_kick_isr){ if(ownback_delay_ratio){ ltedev->sdio_thread_kick_own_timer = 0; //give_own_deley_t = HZ / ownback_delay_ratio; /* direct use ownback_delay_ratio as jiffies; */ give_own_deley_t = ownback_delay_ratio; give_own_timer.expires = jiffies + give_own_deley_t; add_timer(&give_own_timer); //KAL_RAWPRINT((" [SDIO][Sleep] set up timer \n")); wait_event_interruptible( ltedev->sdio_thread_wq, (kthread_should_stop()|| ltedev->sdio_thread_kick || ltedev->sdio_thread_kick_isr || ltedev->sdio_thread_kick_own_timer)); if (kthread_should_stop()) { del_timer_sync(&give_own_timer); ltedev->sdio_thread_kick_own_timer = 0; break; } /* KAL_RAWPRINT((" [SDIO][Sleep] Thread wake up, sdio_thread_kick=%d, sdio_thread_kick_isr=%d, sdio_thread_kick_own_timer=%d \n", \ ltedev->sdio_thread_kick, ltedev->sdio_thread_kick_isr, ltedev->sdio_thread_kick_own_timer)); */ if(0 == ltedev->sdio_thread_kick && 0 == ltedev->sdio_thread_kick_isr && 1 ==ltedev->sdio_thread_kick_own_timer ){ KAL_RAWPRINT((" [SDIO][Sleep] wake up by timer \n")); #ifdef MT_LTE_ONLINE_TUNE_SUPPORT ot_set_dev_sleep_sts((void*)lte_dev.sdio_func->card->host, 1); #endif mtlte_hif_sdio_give_fw_own_in_main() ; give_own_counter++; }else{ del_timer_sync(&give_own_timer); ltedev->sdio_thread_kick_own_timer = 0; } } else{ KAL_RAWPRINT((" [SDIO][Sleep] ownback_delay_ratio == 0, give own back directly \n")); #ifdef MT_LTE_ONLINE_TUNE_SUPPORT ot_set_dev_sleep_sts((void*)lte_dev.sdio_func->card->host, 1); #endif mtlte_hif_sdio_give_fw_own_in_main() ; } } #endif } lte_dev.sdio_thread_state = SDIO_THREAD_IDLE ; KAL_RAWPRINT(("[REMOVE] =======> mtlte_sys_sdio_thread\n")); return 0 ; }
/* * Write endpoint. This routine attempts to break the passed in buffer * into usb DATA0/1 packet size chunks and send them to the host. * (The lower-level driver tries to do this too, but easier for us * to manage things here.) * * We are at the mercy of the host here, in that it must send an IN * token to us to pull this data back, so hopefully some higher level * protocol is expecting traffic to flow in that direction so the host * is actually polling us. To guard against hangs, a 5 second timeout * is used. * * This routine takes some care to only report bytes sent that have * actually made it across the wire. Thus we try to stay in lockstep * with the completion routine and only have one packet on the xmit * hardware at a time. Multiple simultaneous writers will get * "undefined" results. * */ static ssize_t usbc_write( struct file *pFile, const char * pUserBuffer, size_t stCount, loff_t *pPos ) { ssize_t retval = 0; ssize_t stSent = 0; DECLARE_WAITQUEUE( wait, current ); PRINTK( KERN_DEBUG "%swrite() %d bytes\n", pszMe, stCount ); down( &xmit_sem ); // only one thread onto the hardware at a time while( stCount != 0 && retval == 0 ) { int nThisTime = MIN( TX_PACKET_SIZE, stCount ); copy_from_user( tx_buf, pUserBuffer, nThisTime ); sending = nThisTime; retval = pxa_usb_send( tx_buf, nThisTime, tx_done_callback ); if ( retval < 0 ) { char * p = what_the_f( retval ); printk( "%sCould not queue xmission. rc=%d - %s\n", pszMe, retval, p ); sending = 0; break; } /* now have something on the diving board */ add_wait_queue( &wq_write, &wait ); tx_timer.expires = jiffies + ( HZ * 5 ); add_timer( &tx_timer ); while( 1 ) { set_current_state( TASK_INTERRUPTIBLE ); if ( sending == 0 ) { /* it jumped into the pool */ del_timer( &tx_timer ); retval = last_tx_result; if ( retval == 0 ) { stSent += last_tx_size; pUserBuffer += last_tx_size; stCount -= last_tx_size; } else printk( "%sxmission error rc=%d - %s\n", pszMe, retval, what_the_f(retval) ); break; } else if ( signal_pending( current ) ) { del_timer( &tx_timer ); printk( "%ssignal\n", pszMe ); retval = -ERESTARTSYS; break; } schedule(); } set_current_state( TASK_RUNNING ); remove_wait_queue( &wq_write, &wait ); } up( &xmit_sem ); if ( 0 == retval ) retval = stSent; return retval; }
static void setup_keys_timer(void) { init_timer(&keys_timers); keys_timers.function = keys_timer_handler; add_timer(&keys_timers); }
static void ace_fsm_dostate(struct ace_device *ace) { struct request *req; u32 status; u16 val; int count; #if defined(DEBUG) dev_dbg(ace->dev, "fsm_state=%i, id_req_count=%i\n", ace->fsm_state, ace->id_req_count); #endif /* Verify that there is actually a CF in the slot. If not, then * bail out back to the idle state and wake up all the waiters */ status = ace_in32(ace, ACE_STATUS); if ((status & ACE_STATUS_CFDETECT) == 0) { ace->fsm_state = ACE_FSM_STATE_IDLE; ace->media_change = 1; set_capacity(ace->gd, 0); dev_info(ace->dev, "No CF in slot\n"); /* Drop all in-flight and pending requests */ if (ace->req) { __blk_end_request_all(ace->req, -EIO); ace->req = NULL; } while ((req = blk_fetch_request(ace->queue)) != NULL) __blk_end_request_all(req, -EIO); /* Drop back to IDLE state and notify waiters */ ace->fsm_state = ACE_FSM_STATE_IDLE; ace->id_result = -EIO; while (ace->id_req_count) { complete(&ace->id_completion); ace->id_req_count--; } } switch (ace->fsm_state) { case ACE_FSM_STATE_IDLE: /* See if there is anything to do */ if (ace->id_req_count || ace_get_next_request(ace->queue)) { ace->fsm_iter_num++; ace->fsm_state = ACE_FSM_STATE_REQ_LOCK; mod_timer(&ace->stall_timer, jiffies + HZ); if (!timer_pending(&ace->stall_timer)) add_timer(&ace->stall_timer); break; } del_timer(&ace->stall_timer); ace->fsm_continue_flag = 0; break; case ACE_FSM_STATE_REQ_LOCK: if (ace_in(ace, ACE_STATUS) & ACE_STATUS_MPULOCK) { /* Already have the lock, jump to next state */ ace->fsm_state = ACE_FSM_STATE_WAIT_CFREADY; break; } /* Request the lock */ val = ace_in(ace, ACE_CTRL); ace_out(ace, ACE_CTRL, val | ACE_CTRL_LOCKREQ); ace->fsm_state = ACE_FSM_STATE_WAIT_LOCK; break; case ACE_FSM_STATE_WAIT_LOCK: if (ace_in(ace, ACE_STATUS) & ACE_STATUS_MPULOCK) { /* got the lock; move to next state */ ace->fsm_state = ACE_FSM_STATE_WAIT_CFREADY; break; } /* wait a bit for the lock */ ace_fsm_yield(ace); break; case ACE_FSM_STATE_WAIT_CFREADY: status = ace_in32(ace, ACE_STATUS); if (!(status & ACE_STATUS_RDYFORCFCMD) || (status & ACE_STATUS_CFBSY)) { /* CF card isn't ready; it needs to be polled */ ace_fsm_yield(ace); break; } /* Device is ready for command; determine what to do next */ if (ace->id_req_count) ace->fsm_state = ACE_FSM_STATE_IDENTIFY_PREPARE; else ace->fsm_state = ACE_FSM_STATE_REQ_PREPARE; break; case ACE_FSM_STATE_IDENTIFY_PREPARE: /* Send identify command */ ace->fsm_task = ACE_TASK_IDENTIFY; ace->data_ptr = ace->cf_id; ace->data_count = ACE_BUF_PER_SECTOR; ace_out(ace, ACE_SECCNTCMD, ACE_SECCNTCMD_IDENTIFY); /* As per datasheet, put config controller in reset */ val = ace_in(ace, ACE_CTRL); ace_out(ace, ACE_CTRL, val | ACE_CTRL_CFGRESET); /* irq handler takes over from this point; wait for the * transfer to complete */ ace->fsm_state = ACE_FSM_STATE_IDENTIFY_TRANSFER; ace_fsm_yieldirq(ace); break; case ACE_FSM_STATE_IDENTIFY_TRANSFER: /* Check that the sysace is ready to receive data */ status = ace_in32(ace, ACE_STATUS); if (status & ACE_STATUS_CFBSY) { dev_dbg(ace->dev, "CFBSY set; t=%i iter=%i dc=%i\n", ace->fsm_task, ace->fsm_iter_num, ace->data_count); ace_fsm_yield(ace); break; } if (!(status & ACE_STATUS_DATABUFRDY)) { ace_fsm_yield(ace); break; } /* Transfer the next buffer */ ace->reg_ops->datain(ace); ace->data_count--; /* If there are still buffers to be transfers; jump out here */ if (ace->data_count != 0) { ace_fsm_yieldirq(ace); break; } /* transfer finished; kick state machine */ dev_dbg(ace->dev, "identify finished\n"); ace->fsm_state = ACE_FSM_STATE_IDENTIFY_COMPLETE; break; case ACE_FSM_STATE_IDENTIFY_COMPLETE: ace_fix_driveid(ace->cf_id); ace_dump_mem(ace->cf_id, 512); /* Debug: Dump out disk ID */ if (ace->data_result) { /* Error occured, disable the disk */ ace->media_change = 1; set_capacity(ace->gd, 0); dev_err(ace->dev, "error fetching CF id (%i)\n", ace->data_result); } else { ace->media_change = 0; /* Record disk parameters */ set_capacity(ace->gd, ata_id_u32(ace->cf_id, ATA_ID_LBA_CAPACITY)); dev_info(ace->dev, "capacity: %i sectors\n", ata_id_u32(ace->cf_id, ATA_ID_LBA_CAPACITY)); } /* We're done, drop to IDLE state and notify waiters */ ace->fsm_state = ACE_FSM_STATE_IDLE; ace->id_result = ace->data_result; while (ace->id_req_count) { complete(&ace->id_completion); ace->id_req_count--; } break; case ACE_FSM_STATE_REQ_PREPARE: req = ace_get_next_request(ace->queue); if (!req) { ace->fsm_state = ACE_FSM_STATE_IDLE; break; } blk_start_request(req); /* Okay, it's a data request, set it up for transfer */ dev_dbg(ace->dev, "request: sec=%llx hcnt=%x, ccnt=%x, dir=%i\n", (unsigned long long)blk_rq_pos(req), blk_rq_sectors(req), blk_rq_cur_sectors(req), rq_data_dir(req)); ace->req = req; ace->data_ptr = req->buffer; ace->data_count = blk_rq_cur_sectors(req) * ACE_BUF_PER_SECTOR; ace_out32(ace, ACE_MPULBA, blk_rq_pos(req) & 0x0FFFFFFF); count = blk_rq_sectors(req); if (rq_data_dir(req)) { /* Kick off write request */ dev_dbg(ace->dev, "write data\n"); ace->fsm_task = ACE_TASK_WRITE; ace_out(ace, ACE_SECCNTCMD, count | ACE_SECCNTCMD_WRITE_DATA); } else { /* Kick off read request */ dev_dbg(ace->dev, "read data\n"); ace->fsm_task = ACE_TASK_READ; ace_out(ace, ACE_SECCNTCMD, count | ACE_SECCNTCMD_READ_DATA); } /* As per datasheet, put config controller in reset */ val = ace_in(ace, ACE_CTRL); ace_out(ace, ACE_CTRL, val | ACE_CTRL_CFGRESET); /* Move to the transfer state. The systemace will raise * an interrupt once there is something to do */ ace->fsm_state = ACE_FSM_STATE_REQ_TRANSFER; if (ace->fsm_task == ACE_TASK_READ) ace_fsm_yieldirq(ace); /* wait for data ready */ break; case ACE_FSM_STATE_REQ_TRANSFER: /* Check that the sysace is ready to receive data */ status = ace_in32(ace, ACE_STATUS); if (status & ACE_STATUS_CFBSY) { dev_dbg(ace->dev, "CFBSY set; t=%i iter=%i c=%i dc=%i irq=%i\n", ace->fsm_task, ace->fsm_iter_num, blk_rq_cur_sectors(ace->req) * 16, ace->data_count, ace->in_irq); ace_fsm_yield(ace); /* need to poll CFBSY bit */ break; } if (!(status & ACE_STATUS_DATABUFRDY)) { dev_dbg(ace->dev, "DATABUF not set; t=%i iter=%i c=%i dc=%i irq=%i\n", ace->fsm_task, ace->fsm_iter_num, blk_rq_cur_sectors(ace->req) * 16, ace->data_count, ace->in_irq); ace_fsm_yieldirq(ace); break; } /* Transfer the next buffer */ if (ace->fsm_task == ACE_TASK_WRITE) ace->reg_ops->dataout(ace); else ace->reg_ops->datain(ace); ace->data_count--; /* If there are still buffers to be transfers; jump out here */ if (ace->data_count != 0) { ace_fsm_yieldirq(ace); break; } /* bio finished; is there another one? */ if (__blk_end_request_cur(ace->req, 0)) { /* dev_dbg(ace->dev, "next block; h=%u c=%u\n", * blk_rq_sectors(ace->req), * blk_rq_cur_sectors(ace->req)); */ ace->data_ptr = ace->req->buffer; ace->data_count = blk_rq_cur_sectors(ace->req) * 16; ace_fsm_yieldirq(ace); break; } ace->fsm_state = ACE_FSM_STATE_REQ_COMPLETE; break; case ACE_FSM_STATE_REQ_COMPLETE: ace->req = NULL; /* Finished request; go to idle state */ ace->fsm_state = ACE_FSM_STATE_IDLE; break; default: ace->fsm_state = ACE_FSM_STATE_IDLE; break; } }
void tlobby_main::pre_show(twindow& window) { SCOPE_LB; roomlistbox_ = find_widget<tlistbox>(&window, "room_list", false, true); #ifdef GUI2_EXPERIMENTAL_LISTBOX connect_signal_notify_modified( *roomlistbox_, std::bind(&tlobby_main::room_switch_callback, *this, std::ref(window))); #else roomlistbox_->set_callback_value_change( dialog_callback<tlobby_main, &tlobby_main::room_switch_callback>); #endif gamelistbox_ = find_widget<tlistbox>(&window, "game_list", false, true); #ifdef GUI2_EXPERIMENTAL_LISTBOX connect_signal_notify_modified( *gamelistbox_, std::bind(&tlobby_main::gamelist_change_callback, *this, std::ref(window))); #else gamelistbox_->set_callback_value_change( dialog_callback<tlobby_main, &tlobby_main::gamelist_change_callback>); #endif window.keyboard_capture(gamelistbox_); player_list_.init(window); player_list_.sort_by_name->set_value(preferences::playerlist_sort_name()); player_list_.sort_by_relation->set_value(preferences::playerlist_sort_relation()); player_list_.update_sort_icons(); player_list_.sort_by_name->set_callback_state_change( std::bind(&tlobby_main::player_filter_callback, this, _1)); player_list_.sort_by_relation->set_callback_state_change( std::bind(&tlobby_main::player_filter_callback, this, _1)); chat_log_container_ = find_widget<tmulti_page>(&window, "chat_log_container", false, true); window.set_enter_disabled(true); window_ = &window; chat_input_ = find_widget<ttext_box>(&window, "chat_input", false, true); assert(chat_input_); connect_signal_pre_key_press( *chat_input_, std::bind(&tlobby_main::chat_input_keypress_callback, this, _3, _4, _5, std::ref(window))); connect_signal_mouse_left_click( find_widget<tbutton>(&window, "create", false), std::bind(&tlobby_main::create_button_callback, this, std::ref(window))); connect_signal_mouse_left_click( find_widget<tbutton>(&window, "refresh", false), std::bind(&tlobby_main::refresh_button_callback, this, std::ref(window))); connect_signal_mouse_left_click( find_widget<tbutton>(&window, "show_preferences", false), std::bind(&tlobby_main::show_preferences_button_callback, this, std::ref(window))); connect_signal_mouse_left_click( find_widget<tbutton>(&window, "join_global", false), std::bind(&tlobby_main::join_global_button_callback, this, std::ref(window))); find_widget<tbutton>(&window, "join_global", false).set_active(false); connect_signal_mouse_left_click( find_widget<tbutton>(&window, "observe_global", false), std::bind(&tlobby_main::observe_global_button_callback, this, std::ref(window))); find_widget<tbutton>(&window, "observe_global", false).set_active(false); ttoggle_button& skip_replay = find_widget<ttoggle_button>(&window, "skip_replay", false); skip_replay.set_value(preferences::skip_mp_replay()); skip_replay.set_callback_state_change( std::bind(&tlobby_main::skip_replay_changed_callback, this, _1)); filter_friends_ = find_widget<ttoggle_button>(&window, "filter_with_friends", false, true); filter_ignored_ = find_widget<ttoggle_button>(&window, "filter_without_ignored", false, true); filter_slots_ = find_widget<ttoggle_button>(&window, "filter_vacant_slots", false, true); filter_invert_ = find_widget<ttoggle_button>(&window, "filter_invert", false, true); filter_text_ = find_widget<ttext_box>(&window, "filter_text", false, true); filter_friends_->set_callback_state_change( std::bind(&tlobby_main::game_filter_change_callback, this, _1)); filter_ignored_->set_callback_state_change( std::bind(&tlobby_main::game_filter_change_callback, this, _1)); filter_slots_->set_callback_state_change( std::bind(&tlobby_main::game_filter_change_callback, this, _1)); filter_invert_->set_callback_state_change( std::bind(&tlobby_main::game_filter_change_callback, this, _1)); connect_signal_pre_key_press( *filter_text_, std::bind(&tlobby_main::game_filter_keypress_callback, this, _5)); room_window_open("lobby", true); active_window_changed(); game_filter_reload(); // Force first update to be directly. tlobby_main::network_handler(); lobby_update_timer_ = add_timer( game_config::lobby_network_timer, std::bind(&tlobby_main::network_handler, this), true); }
void mdp4_overlay_update_dsi_cmd(struct msm_fb_data_type *mfd) { MDPIBUF *iBuf = &mfd->ibuf; uint8 *src; int ptype; struct mdp4_overlay_pipe *pipe; int bpp; int ret; if (mfd->key != MFD_KEY) return; dsi_mfd = mfd; /* keep it */ /* MDP cmd block enable */ mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); if (dsi_pipe == NULL) { ptype = mdp4_overlay_format2type(mfd->fb_imgType); if (ptype < 0) printk(KERN_INFO "%s: format2type failed\n", __func__); pipe = mdp4_overlay_pipe_alloc(ptype, MDP4_MIXER0); if (pipe == NULL) printk(KERN_INFO "%s: pipe_alloc failed\n", __func__); pipe->pipe_used++; pipe->mixer_stage = MDP4_MIXER_STAGE_BASE; pipe->mixer_num = MDP4_MIXER0; pipe->src_format = mfd->fb_imgType; mdp4_overlay_panel_mode(pipe->mixer_num, MDP4_PANEL_DSI_CMD); ret = mdp4_overlay_format2pipe(pipe); if (ret < 0) printk(KERN_INFO "%s: format2type failed\n", __func__); init_timer(&dsi_clock_timer); dsi_clock_timer.function = dsi_clock_tout; dsi_clock_timer.data = (unsigned long) mfd; dsi_clock_timer.expires = 0xffffffff; add_timer(&dsi_clock_timer); tout_expired = jiffies; dsi_pipe = pipe; /* keep it */ mdp4_init_writeback_buf(mfd, MDP4_MIXER0); pipe->blt_addr = 0; } else { pipe = dsi_pipe; } /* * configure dsi stream id * dma_p = 0, dma_s = 1 */ MDP_OUTP(MDP_BASE + 0x000a0, 0x10); /* disable dsi trigger */ MDP_OUTP(MDP_BASE + 0x000a4, 0x00); /* whole screen for base layer */ src = (uint8 *) iBuf->buf; { struct fb_info *fbi; fbi = mfd->fbi; if (pipe->is_3d) { bpp = fbi->var.bits_per_pixel / 8; pipe->src_height = pipe->src_height_3d; pipe->src_width = pipe->src_width_3d; pipe->src_h = pipe->src_height_3d; pipe->src_w = pipe->src_width_3d; pipe->dst_h = pipe->src_height_3d; pipe->dst_w = pipe->src_width_3d; pipe->srcp0_ystride = msm_fb_line_length(0, pipe->src_width, bpp); } else { /* 2D */ pipe->src_height = fbi->var.yres; pipe->src_width = fbi->var.xres; pipe->src_h = fbi->var.yres; pipe->src_w = fbi->var.xres; pipe->dst_h = fbi->var.yres; pipe->dst_w = fbi->var.xres; pipe->srcp0_ystride = fbi->fix.line_length; } pipe->src_y = 0; pipe->src_x = 0; pipe->dst_y = 0; pipe->dst_x = 0; pipe->srcp0_addr = (uint32)src; } mdp4_overlay_rgb_setup(pipe); mdp4_mixer_stage_up(pipe); mdp4_overlayproc_cfg(pipe); mdp4_overlay_dmap_xy(pipe); mdp4_overlay_dmap_cfg(mfd, 0); mdp4_mipi_vsync_enable(mfd, pipe, 0); /* MDP cmd block disable */ mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); wmb(); }
int pet_data_init(struct map_session_data *sd, struct s_pet *pet) { struct pet_data *pd; int i=0,interval=0; nullpo_retr(1, sd); Assert((sd->status.pet_id == 0 || sd->pd == 0) || sd->pd->msd == sd); if(sd->status.account_id != pet->account_id || sd->status.char_id != pet->char_id) { sd->status.pet_id = 0; return 1; } if (sd->status.pet_id != pet->pet_id) { if (sd->status.pet_id) { //Wrong pet?? Set incuvate to no and send it back for saving. pet->incuvate = 1; intif_save_petdata(sd->status.account_id,pet); sd->status.pet_id = 0; return 1; } //The pet_id value was lost? odd... restore it. sd->status.pet_id = pet->pet_id; } i = search_petDB_index(pet->class_,PET_CLASS); if(i < 0) { sd->status.pet_id = 0; return 1; } sd->pd = pd = (struct pet_data *)aCalloc(1,sizeof(struct pet_data)); pd->bl.type = BL_PET; pd->bl.id = npc_get_new_npc_id(); pd->msd = sd; pd->petDB = &pet_db[i]; pd->db = mob_db(pet->class_); memcpy(&pd->pet, pet, sizeof(struct s_pet)); status_set_viewdata(&pd->bl, pet->class_); unit_dataset(&pd->bl); pd->ud.dir = sd->ud.dir; pd->bl.m = sd->bl.m; pd->bl.x = sd->bl.x; pd->bl.y = sd->bl.y; unit_calc_pos(&pd->bl, sd->bl.x, sd->bl.y, sd->ud.dir); pd->bl.x = pd->ud.to_x; pd->bl.y = pd->ud.to_y; map_addiddb(&pd->bl); status_calc_pet(pd,1); pd->last_thinktime = gettick(); pd->state.skillbonus = 0; if( battle_config.pet_status_support ) run_script(pet_db[i].pet_script,0,sd->bl.id,0); if( pd->petDB && pd->petDB->equip_script ) status_calc_pc(sd,0); if( battle_config.pet_hungry_delay_rate != 100 ) interval = (pd->petDB->hungry_delay*battle_config.pet_hungry_delay_rate)/100; else interval = pd->petDB->hungry_delay; if( interval <= 0 ) interval = 1; pd->pet_hungry_timer = add_timer(gettick() + interval, pet_hungry, sd->bl.id, 0); return 0; }
void merc_hom_init_timers(struct homun_data * hd) { if (hd->hungry_timer == -1) hd->hungry_timer = add_timer(gettick()+hd->homunculusDB->hungryDelay,merc_hom_hungry,hd->master->bl.id,0); hd->regen.state.block = 0; //Restore HP/SP block. }
static void ipt_ulog_packet(unsigned int hooknum, const struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct ipt_ulog_info *loginfo, const char *prefix) { ulog_buff_t *ub; ulog_packet_msg_t *pm; size_t size, copy_len; struct nlmsghdr *nlh; struct timeval tv; /* ffs == find first bit set, necessary because userspace * is already shifting groupnumber, but we need unshifted. * ffs() returns [1..32], we need [0..31] */ unsigned int groupnum = ffs(loginfo->nl_group) - 1; /* calculate the size of the skb needed */ if (loginfo->copy_range == 0 || loginfo->copy_range > skb->len) copy_len = skb->len; else copy_len = loginfo->copy_range; size = NLMSG_SPACE(sizeof(*pm) + copy_len); ub = &ulog_buffers[groupnum]; spin_lock_bh(&ulog_lock); if (!ub->skb) { if (!(ub->skb = ulog_alloc_skb(size))) goto alloc_failure; } else if (ub->qlen >= loginfo->qthreshold || size > skb_tailroom(ub->skb)) { /* either the queue len is too high or we don't have * enough room in nlskb left. send it to userspace. */ ulog_send(groupnum); if (!(ub->skb = ulog_alloc_skb(size))) goto alloc_failure; } pr_debug("qlen %d, qthreshold %Zu\n", ub->qlen, loginfo->qthreshold); /* NLMSG_PUT contains a hidden goto nlmsg_failure !!! */ nlh = NLMSG_PUT(ub->skb, 0, ub->qlen, ULOG_NL_EVENT, sizeof(*pm)+copy_len); ub->qlen++; pm = NLMSG_DATA(nlh); /* We might not have a timestamp, get one */ if (skb->tstamp.tv64 == 0) __net_timestamp((struct sk_buff *)skb); /* copy hook, prefix, timestamp, payload, etc. */ pm->data_len = copy_len; tv = ktime_to_timeval(skb->tstamp); put_unaligned(tv.tv_sec, &pm->timestamp_sec); put_unaligned(tv.tv_usec, &pm->timestamp_usec); put_unaligned(skb->mark, &pm->mark); pm->hook = hooknum; if (prefix != NULL) strncpy(pm->prefix, prefix, sizeof(pm->prefix)); else if (loginfo->prefix[0] != '\0') strncpy(pm->prefix, loginfo->prefix, sizeof(pm->prefix)); else *(pm->prefix) = '\0'; if (in && in->hard_header_len > 0 && skb->mac_header != skb->network_header && in->hard_header_len <= ULOG_MAC_LEN) { memcpy(pm->mac, skb_mac_header(skb), in->hard_header_len); pm->mac_len = in->hard_header_len; } else pm->mac_len = 0; if (in) strncpy(pm->indev_name, in->name, sizeof(pm->indev_name)); else pm->indev_name[0] = '\0'; if (out) strncpy(pm->outdev_name, out->name, sizeof(pm->outdev_name)); else pm->outdev_name[0] = '\0'; /* copy_len <= skb->len, so can't fail. */ if (skb_copy_bits(skb, 0, pm->payload, copy_len) < 0) BUG(); /* check if we are building multi-part messages */ if (ub->qlen > 1) ub->lastnlh->nlmsg_flags |= NLM_F_MULTI; ub->lastnlh = nlh; /* if timer isn't already running, start it */ if (!timer_pending(&ub->timer)) { ub->timer.expires = jiffies + flushtimeout * HZ / 100; add_timer(&ub->timer); } /* if threshold is reached, send message to userspace */ if (ub->qlen >= loginfo->qthreshold) { if (loginfo->qthreshold > 1) nlh->nlmsg_type = NLMSG_DONE; ulog_send(groupnum); } spin_unlock_bh(&ulog_lock); return; nlmsg_failure: pr_debug("error during NLMSG_PUT\n"); alloc_failure: pr_debug("Error building netlink message\n"); spin_unlock_bh(&ulog_lock); }
/* If we are writing the enable field, we start/stop the kernel timer */ static int loadtest_intvec_enable(int cpu, ctl_table * table, int write, void __user *buffer, size_t * lenp, loff_t *ppos) { int rc; ICP_OBJ *o = &obj[cpu]; ICP_LOAD_TEST *lt = &o->loadtest; init_timer(<->timer); lt->timer.function = ipc_load_timer_func; lt->timer.expires = 0; lt->timer.data = (ulong) cpu; if (!table || !table->data) return -EINVAL; if (write) { /* use generic int handler to get input value */ rc = proc_dointvec(table, write, buffer, lenp, ppos); if (rc < 0) return rc; if (!lt->timerStarted && lt->enable) { if (lt->useThread) { cpumask_t cpu_mask; sema_init(<->threadSemaphore, 0); init_completion(<->threadCompletion); cpumask_set_cpu(cpu, &cpu_mask); lt->threadPid = kernel_thread(ipc_load_test_thread, &o->cpu_enum, 0); sched_setaffinity(lt->threadPid, &cpu_mask); cpumask_clear_cpu(cpu, &cpu_mask); } if (lt->loadPeriod > MAX_LOAD_PERIOD) lt->loadPeriod = MAX_LOAD_PERIOD; lt->timer.expires = jiffies + msecs_to_jiffies(lt->loadPeriod); add_timer(<->timer); lt->timerStarted = 1; } else if (lt->timerStarted && !lt->enable) { lt->timerStarted = 0; /* Kill load testing thread */ if (lt->useThread) { if (lt->threadPid >= 0) { kill_proc_info(SIGTERM, SEND_SIG_PRIV, lt->threadPid); wait_for_completion(<-> threadCompletion); } lt->threadPid = -1; } } } else { /* nothing special for read */ return proc_dointvec(table, write, buffer, lenp, ppos); } return rc; }
static int mmci_probe(struct amba_device *dev, void *id) { struct mmc_platform_data *plat = dev->dev.platform_data; struct mmci_host *host; struct mmc_host *mmc; int ret; /* must have platform data */ if (!plat) { ret = -EINVAL; goto out; } ret = amba_request_regions(dev, DRIVER_NAME); if (ret) goto out; mmc = mmc_alloc_host(sizeof(struct mmci_host), &dev->dev); if (!mmc) { ret = -ENOMEM; goto rel_regions; } host = mmc_priv(mmc); host->clk = clk_get(&dev->dev, "MCLK"); if (IS_ERR(host->clk)) { ret = PTR_ERR(host->clk); host->clk = NULL; goto host_free; } ret = clk_use(host->clk); if (ret) goto clk_free; ret = clk_enable(host->clk); if (ret) goto clk_unuse; host->plat = plat; host->mclk = clk_get_rate(host->clk); host->mmc = mmc; host->base = ioremap(dev->res.start, SZ_4K); if (!host->base) { ret = -ENOMEM; goto clk_disable; } mmc->ops = &mmci_ops; mmc->f_min = (host->mclk + 511) / 512; mmc->f_max = min(host->mclk, fmax); mmc->ocr_avail = plat->ocr_mask; /* * We can do SGIO */ mmc->max_hw_segs = 16; mmc->max_phys_segs = NR_SG; /* * Since we only have a 16-bit data length register, we must * ensure that we don't exceed 2^16-1 bytes in a single request. * Choose 64 (512-byte) sectors as the limit. */ mmc->max_sectors = 64; /* * Set the maximum segment size. Since we aren't doing DMA * (yet) we are only limited by the data length register. */ mmc->max_seg_size = mmc->max_sectors << 9; spin_lock_init(&host->lock); writel(0, host->base + MMCIMASK0); writel(0, host->base + MMCIMASK1); writel(0xfff, host->base + MMCICLEAR); ret = request_irq(dev->irq[0], mmci_irq, SA_SHIRQ, DRIVER_NAME " (cmd)", host); if (ret) goto unmap; ret = request_irq(dev->irq[1], mmci_pio_irq, SA_SHIRQ, DRIVER_NAME " (pio)", host); if (ret) goto irq0_free; writel(MCI_IRQENABLE, host->base + MMCIMASK0); amba_set_drvdata(dev, mmc); mmc_add_host(mmc); printk(KERN_INFO "%s: MMCI rev %x cfg %02x at 0x%08lx irq %d,%d\n", mmc_hostname(mmc), amba_rev(dev), amba_config(dev), dev->res.start, dev->irq[0], dev->irq[1]); init_timer(&host->timer); host->timer.data = (unsigned long)host; host->timer.function = mmci_check_status; host->timer.expires = jiffies + HZ; add_timer(&host->timer); return 0; irq0_free: free_irq(dev->irq[0], host); unmap: iounmap(host->base); clk_disable: clk_disable(host->clk); clk_unuse: clk_unuse(host->clk); clk_free: clk_put(host->clk); host_free: mmc_free_host(mmc); rel_regions: amba_release_regions(dev); out: return ret; }
/* * Begin the file transfer process */ void initiate_transfer(int last_ackno) { // Init list of timers timer_list = (struct packet_timer**)calloc(MAX_TIMERS, sizeof(struct packet_timer*)); // Start thread to poll list of timers and check if any have timed out pthread_t pthread; pthread_create(&pthread, NULL, poll_timers, NULL); // Create and add all DAT timers, don't start them until they're sent //printf("Creating and adding DAT timers...\n"); pthread_mutex_lock(&timers_mutex); int j; for(j=0; data_packets[j] != 0; j++) { //if(j){printf("Attempting to create timer with data_packets[%d]...\n",j);} struct packet_timer* DAT_timer = create_timer(data_packets[j]->header.ackno, -1); add_timer(timer_list, DAT_timer); } //print_stoppedTimers(timer_list); pthread_mutex_unlock(&timers_mutex); // send SYN //printf("creating SYN packet...\n"); struct packet* SYN_pckt = create_packet(NULL, 0, SYN, first_seqno); //printf("created SYN packet\n"); // update statistics send_packet(SYN_pckt, socketfd, adr_receiver); // sent, unique, SYN, seqno, length) print_log(true, true, SYN, SYN_pckt->header.seqno, SYN_pckt->payload_length); bytes_sent += SYN_pckt->payload_length; unique_bytes_sent += SYN_pckt->payload_length; SYN_packets_sent++; // start SYN's timer pthread_mutex_lock(&timers_mutex); //printf("Creating SYN timer...\n"); struct packet_timer* SYN_timer = create_timer(SYN_pckt->header.ackno, clock()); add_timer(timer_list, SYN_timer); start_timer(SYN_pckt->header.ackno, timer_list); //printf("Created, added, and started SYN timer\n"); pthread_mutex_unlock(&timers_mutex); // wait on SYN's ACK while(1) { struct sockaddr_in adr_src; struct packet* rec_pckt = receive_packet(socketfd, &adr_src); if(rec_pckt && rec_pckt->header.type == ACK) { print_log(false, true, ACK, rec_pckt->header.seqno, rec_pckt->payload_length); // update statistics ACK_packets_received++; printf("sender: SYN acknowledged\n"); pthread_mutex_lock(&timers_mutex); stop_timer(timer_list, SYN_pckt->header.ackno); pthread_mutex_unlock(&timers_mutex); break; } // resend the SYN packet send_packet(SYN_pckt, socketfd, adr_receiver); print_log(true, false, SYN, SYN_pckt->header.seqno, SYN_pckt->payload_length); // update statistics bytes_sent += SYN_pckt->payload_length; SYN_packets_sent++; if(clock()/CLOCKS_PER_SEC >= SENDER_TIMEOUT_S) { terminate(-2); } } // Init window struct window* window = (struct window*)malloc(sizeof(*window)); window->size = WINDOW_SIZE; window->occupied = 0; window->base_seqno = data_packets[0]->header.seqno; // Send initial wave of data packets to fill the window //printf("sender: initial wave of data...\n"); fill_window(window); //printf("Window:\n size->%d\n base_seqno->%d\n occupied->%d\n",window->size,window->base_seqno,window->occupied); // Receive ACKs, send data to fill the window, and check for timeouts while(1) { /* pthread_mutex_lock(&timers_mutex); print_runningTimers(timer_list); pthread_mutex_unlock(&timers_mutex); */ // wait for packet struct sockaddr_in adr_src; struct packet* rec_pckt; if((rec_pckt = receive_packet(socketfd, &adr_src)) != NULL) { print_log(false, true, ACK, rec_pckt->header.seqno, rec_pckt->payload_length); // handle received ACKs handle_packet(rec_pckt); } // Update the window's base_seqno as ACKs are received //printf("Updating window...\n"); update_windowBase(window); /* send new data packets if window permits */ //printf("Filling window...\n"); fill_window(window); //printf("Resending timedout packets...\n"); resend_timedoutPackets(); // check if all the data packets have been successfully acknowledged if(allPacketsAcknowledged() == true) { printf("ALL PACKETS ACKNOWLEDGED\n"); // send FIN int FIN_seqno = last_ackno; struct packet* FIN_pckt = create_packet(NULL, 0, FIN, FIN_seqno); send_packet(FIN_pckt, socketfd, adr_receiver); print_log(true, true, FIN, FIN_pckt->header.seqno, FIN_pckt->payload_length); // Update statistics bytes_sent += FIN_pckt->payload_length; unique_bytes_sent += FIN_pckt->payload_length; FIN_packets_sent++; // Start its timer pthread_mutex_lock(&timers_mutex); struct packet_timer* FIN_timer = create_timer(FIN_pckt->header.ackno, clock()); add_timer(timer_list, FIN_timer); start_timer(FIN_timer->pckt_ackno, timer_list); pthread_mutex_unlock(&timers_mutex); // wait for FIN's ACK if((rec_pckt = receive_packet(socketfd, &adr_src)) != NULL) { print_log(false, true, ACK, rec_pckt->header.seqno, rec_pckt->payload_length); handle_packet(rec_pckt); if(rec_pckt->header.seqno == FIN_pckt->header.ackno) { printf("FIN ACK RECEIVED\n"); print_statistics(); terminate(0); } } } // Global timeout if(clock()/CLOCKS_PER_SEC >= SENDER_TIMEOUT_S) { terminate(-2); } } }
int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid) { struct sta_info *sta = container_of(pubsta, struct sta_info, sta); struct ieee80211_sub_if_data *sdata = sta->sdata; struct ieee80211_local *local = sdata->local; u8 *state; int ret = 0; u16 start_seq_num; trace_api_start_tx_ba_session(pubsta, tid); if (WARN_ON(!local->ops->ampdu_action)) return -EINVAL; if ((tid >= STA_TID_NUM) || !(local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION)) return -EINVAL; #ifdef CONFIG_MAC80211_HT_DEBUG printk(KERN_DEBUG "Open BA session requested for %pM tid %u\n", pubsta->addr, tid); #endif /* CONFIG_MAC80211_HT_DEBUG */ /* * The aggregation code is not prepared to handle * anything but STA/AP due to the BSSID handling. * IBSS could work in the code but isn't supported * by drivers or the standard. */ if (sdata->vif.type != NL80211_IFTYPE_STATION && sdata->vif.type != NL80211_IFTYPE_AP_VLAN && sdata->vif.type != NL80211_IFTYPE_AP) return -EINVAL; if (test_sta_flags(sta, WLAN_STA_DISASSOC)) { #ifdef CONFIG_MAC80211_HT_DEBUG printk(KERN_DEBUG "Disassociation is in progress. " "Denying BA session request\n"); #endif return -EINVAL; } if (test_sta_flags(sta, WLAN_STA_BLOCK_BA)) { #ifdef CONFIG_MAC80211_HT_DEBUG printk(KERN_DEBUG "Suspend in progress. " "Denying BA session request\n"); #endif return -EINVAL; } spin_lock_bh(&sta->lock); spin_lock(&local->ampdu_lock); /* we have tried too many times, receiver does not want A-MPDU */ if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) { ret = -EBUSY; goto err_unlock_sta; } state = &sta->ampdu_mlme.tid_state_tx[tid]; /* check if the TID is not in aggregation flow already */ if (*state != HT_AGG_STATE_IDLE) { #ifdef CONFIG_MAC80211_HT_DEBUG printk(KERN_DEBUG "BA request denied - session is not " "idle on tid %u\n", tid); #endif /* CONFIG_MAC80211_HT_DEBUG */ ret = -EAGAIN; goto err_unlock_sta; } /* * While we're asking the driver about the aggregation, * stop the AC queue so that we don't have to worry * about frames that came in while we were doing that, * which would require us to put them to the AC pending * afterwards which just makes the code more complex. */ ieee80211_stop_queue_by_reason( &local->hw, ieee80211_ac_from_tid(tid), IEEE80211_QUEUE_STOP_REASON_AGGREGATION); /* prepare A-MPDU MLME for Tx aggregation */ sta->ampdu_mlme.tid_tx[tid] = kmalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC); if (!sta->ampdu_mlme.tid_tx[tid]) { #ifdef CONFIG_MAC80211_HT_DEBUG if (net_ratelimit()) printk(KERN_ERR "allocate tx mlme to tid %d failed\n", tid); #endif ret = -ENOMEM; goto err_wake_queue; } skb_queue_head_init(&sta->ampdu_mlme.tid_tx[tid]->pending); /* Tx timer */ sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.function = sta_addba_resp_timer_expired; sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.data = (unsigned long)&sta->timer_to_tid[tid]; init_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer); /* Ok, the Addba frame hasn't been sent yet, but if the driver calls the * call back right away, it must see that the flow has begun */ *state |= HT_ADDBA_REQUESTED_MSK; start_seq_num = sta->tid_seq[tid] >> 4; ret = drv_ampdu_action(local, sdata, IEEE80211_AMPDU_TX_START, pubsta, tid, &start_seq_num); if (ret) { #ifdef CONFIG_MAC80211_HT_DEBUG printk(KERN_DEBUG "BA request denied - HW unavailable for" " tid %d\n", tid); #endif /* CONFIG_MAC80211_HT_DEBUG */ *state = HT_AGG_STATE_IDLE; goto err_free; } /* Driver vetoed or OKed, but we can take packets again now */ ieee80211_wake_queue_by_reason( &local->hw, ieee80211_ac_from_tid(tid), IEEE80211_QUEUE_STOP_REASON_AGGREGATION); spin_unlock(&local->ampdu_lock); spin_unlock_bh(&sta->lock); /* send an addBA request */ sta->ampdu_mlme.dialog_token_allocator++; sta->ampdu_mlme.tid_tx[tid]->dialog_token = sta->ampdu_mlme.dialog_token_allocator; sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num; ieee80211_send_addba_request(sdata, pubsta->addr, tid, sta->ampdu_mlme.tid_tx[tid]->dialog_token, sta->ampdu_mlme.tid_tx[tid]->ssn, 0x40, 5000); sta->ampdu_mlme.addba_req_num[tid]++; /* activate the timer for the recipient's addBA response */ sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires = jiffies + ADDBA_RESP_INTERVAL; add_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer); #ifdef CONFIG_MAC80211_HT_DEBUG printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid); #endif return 0; err_free: kfree(sta->ampdu_mlme.tid_tx[tid]); sta->ampdu_mlme.tid_tx[tid] = NULL; err_wake_queue: ieee80211_wake_queue_by_reason( &local->hw, ieee80211_ac_from_tid(tid), IEEE80211_QUEUE_STOP_REASON_AGGREGATION); err_unlock_sta: spin_unlock(&local->ampdu_lock); spin_unlock_bh(&sta->lock); return ret; }
static int __devinit crtouch_probe(struct i2c_client *client, const struct i2c_device_id *id) { int result; struct input_dev *input_dev; int error = 0; s32 mask_trigger = 0; /*to be able to communicate by i2c with crtouch (dev)*/ client_public = client; crtouch = kzalloc(sizeof(struct crtouch_data), GFP_KERNEL); if (!crtouch) return -ENOMEM; input_dev = input_allocate_device(); if (!input_dev) { result = -ENOMEM; goto err_free_mem; } crtouch->input_dev = input_dev; crtouch->client = client; crtouch->workqueue = create_singlethread_workqueue("crtouch"); INIT_WORK(&crtouch->work, report_MT); if (crtouch->workqueue == NULL) { printk(KERN_DEBUG "couldn't create workqueue\n"); result = -ENOMEM; goto err_wqueue; } error = read_resolution(); if (error < 0) { printk(KERN_DEBUG "couldn't read size of screen\n"); result = -EIO; goto err_free_wq; } data_configuration = i2c_smbus_read_byte_data(client, CONFIGURATION); data_configuration &= CLEAN_SLIDE_EVENTS; data_configuration |= SET_MULTITOUCH; i2c_smbus_write_byte_data(client, CONFIGURATION, data_configuration); mask_trigger = i2c_smbus_read_byte_data(client, TRIGGER_EVENTS); mask_trigger |= SET_TRIGGER_RESISTIVE; i2c_smbus_write_byte_data(client, TRIGGER_EVENTS, mask_trigger); i2c_smbus_write_byte_data(client, TRIGGER_EVENTS, mask_trigger); crtouch->input_dev->name = "CRTOUCH Input Device"; crtouch->input_dev->id.bustype = BUS_I2C; __set_bit(EV_ABS, crtouch->input_dev->evbit); __set_bit(EV_KEY, crtouch->input_dev->evbit); __set_bit(BTN_TOUCH, crtouch->input_dev->keybit); __set_bit(ABS_X, crtouch->input_dev->absbit); __set_bit(ABS_Y, crtouch->input_dev->absbit); __set_bit(ABS_PRESSURE, crtouch->input_dev->absbit); __set_bit(EV_SYN, crtouch->input_dev->evbit); /*register keys that will be reported by crtouch*/ __set_bit(KEY_A, crtouch->input_dev->keybit); __set_bit(KEY_B, crtouch->input_dev->keybit); __set_bit(KEY_C, crtouch->input_dev->keybit); __set_bit(KEY_D, crtouch->input_dev->keybit); __set_bit(KEY_E, crtouch->input_dev->keybit); __set_bit(KEY_F, crtouch->input_dev->keybit); __set_bit(KEY_G, crtouch->input_dev->keybit); __set_bit(KEY_H, crtouch->input_dev->keybit); __set_bit(KEY_I, crtouch->input_dev->keybit); __set_bit(KEY_J, crtouch->input_dev->keybit); __set_bit(KEY_K, crtouch->input_dev->keybit); __set_bit(KEY_L, crtouch->input_dev->keybit); input_set_abs_params(crtouch->input_dev, ABS_X, XMIN, xmax, 0, 0); input_set_abs_params(crtouch->input_dev, ABS_Y, YMIN, ymax, 0, 0); input_set_abs_params(crtouch->input_dev, ABS_MT_POSITION_X, XMIN, xmax, 0, 0); input_set_abs_params(crtouch->input_dev, ABS_MT_POSITION_Y, YMIN, ymax, 0, 0); input_set_abs_params(crtouch->input_dev, ABS_MT_TOUCH_MAJOR, 0, 1, 0, 0); input_set_abs_params(crtouch->input_dev, ABS_MT_TRACKING_ID, 0, 1, 0, 0); input_set_abs_params(crtouch->input_dev, ABS_PRESSURE, 0, 1, 0, 0); printk(KERN_DEBUG "CR-TOUCH max values X: %d Y: %d\n", xmax, ymax); result = input_register_device(crtouch->input_dev); if (result) goto err_free_wq; if (alloc_chrdev_region(&dev_number, 0, 2, DEV_NAME) < 0) { printk(KERN_DEBUG "couldn't allocate cr-touch device with dev\n"); goto err_unr_dev; } cdev_init(&crtouch_cdev , &file_ops_crtouch); if (cdev_add(&crtouch_cdev, dev_number, 1)) { printk(KERN_DEBUG "couldn't register cr-touch device with dev\n"); goto err_unr_chrdev; } crtouch_class = class_create(THIS_MODULE, DEV_NAME); if (crtouch_class == NULL) { printk(KERN_DEBUG "unable to create a class\n"); goto err_unr_cdev; } if (device_create(crtouch_class, NULL, dev_number, NULL, DEV_NAME) == NULL) { printk(KERN_DEBUG "unable to create a device\n"); goto err_unr_class; } #ifdef WAKE_SIGNAL result = gpio_request(PIN_WAKE, "GPIO_WAKE_CRTOUCH"); if (result != 0) { printk(KERN_DEBUG "error requesting GPIO %d\n", result); goto err_unr_createdev; } result = gpio_direction_output(PIN_WAKE, GPIOF_OUT_INIT_HIGH); if (result != 0) { printk(KERN_DEBUG "error config GPIO PIN direction %d\n", result); goto err_free_pin; } gpio_set_value(PIN_WAKE, VCC); #endif /* WAKE_SIGNAL */ #ifdef IRQ_EVENT_HANDLING /*request gpio to used as interrupt*/ result = gpio_request(GPIO_IRQ, "GPIO_INTERRUPT_CRTOUCH"); if (result != 0) { printk(KERN_DEBUG "error requesting GPIO for IRQ %d\n", result); goto err_free_pin; } result = gpio_direction_input(GPIO_IRQ); if (result != 0) { printk(KERN_DEBUG "error config IRQ PIN direction %d\n", result); goto err_free_pinIrq; } /* request irq trigger falling */ result = request_irq(gpio_to_irq(GPIO_IRQ), crtouch_irq, IRQF_TRIGGER_FALLING, IRQ_NAME, crtouch_irq); if (result < 0) { printk(KERN_DEBUG "unable to request IRQ\n"); goto err_free_pinIrq; } #else /* IRQ_EVENT_HANDLING */ /* * Register timer to implement IRQ polling */ init_timer(&tsc_poll_timer); tsc_poll_timer.function = tsc_poll_handler; tsc_poll_timer.expires = jiffies + IRQ_POLL_PERIOD; add_timer(&tsc_poll_timer); #endif /* IRQ_EVENT_HANDLING */ /*clean interrupt pin*/ i2c_smbus_read_byte_data(client, STATUS_REGISTER_1); return 0; #ifdef IRQ_EVENT_HANDLING err_free_pinIrq: gpio_free(GPIO_IRQ); #endif #if defined(IRQ_EVENT_HANDLING) || defined(WAKE_SIGNAL) err_free_pin: #endif #ifdef WAKE_SIGNAL gpio_free(PIN_WAKE); err_unr_createdev: #endif #if defined(IRQ_EVENT_HANDLING) || defined(WAKE_SIGNAL) device_destroy(crtouch_class, dev_number); #endif err_unr_class: class_destroy(crtouch_class); err_unr_cdev: cdev_del(&crtouch_cdev); err_unr_chrdev: unregister_chrdev_region(dev_number, 1); err_unr_dev: input_unregister_device(crtouch->input_dev); err_free_wq: destroy_workqueue(crtouch->workqueue); err_wqueue: input_free_device(crtouch->input_dev); err_free_mem: kfree(crtouch); return result; }
static ssize_t cdata_write(struct file *filp, const char *buf, size_t size, loff_t *off) { struct cdata_t *cdata = (struct cdata *)filp->private_data; struct timer_list *timer; struct timer_list *sched; unsigned char *pixel; unsigned int index; unsigned int i; wait_queue_head_t *wq; wait_queue_t wait; unsigned long flags; /* controlling the resources, keep avoiding concurrency */ down_interruptible(&cdata->sem); //mutex_lock(&cdata->mutex); spin_lock_irqsave(&cdata->lock, flags); //due to spin_lock on flush_lcd... pixel = cdata->buf; index = cdata->index; spin_unlock_irqrestore(&cdata->lock, flags); timer = &cdata->flush_timer; sched = &cdata->sched_timer; wq = &cdata->wq; /* */ up(&cdata->sem); //mutex_unlock(&cdata->mutex); for (i = 0; i < size; i++) { if (index >= BUF_SIZE) { //every 1 secs trigger flush, but we must in running mode(second timer) down_interruptible(&cdata->sem); cdata->index = index; up(&cdata->sem); timer->expires = jiffies + 1*HZ; //5 secs timer->function = flush_lcd; timer->data = (unsigned long)cdata; add_timer(timer); //for wakup, if not set, we let kernel driver in INTERRUPTIBLE mode sched->expires = jiffies + 10; //0.1 secs sched->function = cdata_wake_up; sched->data = (unsigned long)cdata; add_timer(sched); wait.flags = 0; wait.task = current; add_wait_queue(wq, &wait); repeat: current->state = TASK_INTERRUPTIBLE; schedule(); down_interruptible(&cdata->sem); index = cdata->index; up(&cdata->sem); if (index != 0) goto repeat; printk(KERN_INFO "CDATA: exit repeat\n"); remove_wait_queue(wq, &wait); del_timer(sched); } copy_from_user(&pixel[index], &buf[i], 1); index++; } cdata->index = index; return 0; }
/*========================================== * Removes a instance, all its maps and npcs. *------------------------------------------*/ int instance_destroy(short instance_id) { struct instance_data *im; struct party_data *p; int i, type = 0, count = 0; unsigned int now = (unsigned int)time(NULL); if(instance_id <= 0 || instance_id > MAX_INSTANCE_DATA) return 1; im = &instance_data[instance_id]; if(im->state == INSTANCE_FREE) return 1; if(im->state == INSTANCE_IDLE) { for(i = 0; i < instance_wait.count; i++) { if(instance_wait.id[i] == instance_id) { instance_wait.count--; memmove(&instance_wait.id[i],&instance_wait.id[i+1],sizeof(instance_wait.id[0])*(instance_wait.count-i)); memset(&instance_wait.id[instance_wait.count], 0, sizeof(instance_wait.id[0])); for(i = 0; i < instance_wait.count; i++) if(instance_data[instance_wait.id[i]].state == INSTANCE_IDLE) if((p = party_search(instance_data[instance_wait.id[i]].party_id)) != NULL) clif_instance_changewait( party_getavailablesd( p ), i+1, 1); if(instance_wait.count) instance_wait.timer = add_timer(gettick()+INSTANCE_INTERVAL, instance_subscription_timer, 0, 0); else instance_wait.timer = -1; type = 0; break; } } } else { if(im->keep_limit && im->keep_limit <= now) type = 1; else if(im->idle_limit && im->idle_limit <= now) type = 2; else type = 3; for(i = 0; i < MAX_MAP_PER_INSTANCE; i++) count += map_delinstancemap(im->map[i].m); } if(im->keep_timer != -1) { delete_timer(im->keep_timer, instance_delete_timer); im->keep_timer = -1; } if(im->idle_timer != -1) { delete_timer(im->idle_timer, instance_delete_timer); im->idle_timer = -1; } if((p = party_search(im->party_id))) { p->instance_id = 0; if(type) clif_instance_changestatus( party_getavailablesd( p ), type, 0, 1 ); else clif_instance_changewait( party_getavailablesd( p ), 0xffff, 1 ); } if( im->vars ) { db_destroy(im->vars); im->vars = NULL; } ShowInfo("[Instance] Destroyed %d.\n", instance_id); memset(&instance_data[instance_id], 0, sizeof(instance_data[instance_id])); return 0; }
static int __init s3c_keypad_probe(struct platform_device *pdev) { struct resource *res, *keypad_mem, *keypad_irq; struct input_dev *input_dev; struct s3c_keypad *s3c_keypad; int ret, size; int key, code; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&pdev->dev,"no memory resource specified\n"); return -ENOENT; } size = (res->end - res->start) + 1; keypad_mem = request_mem_region(res->start, size, pdev->name); if (keypad_mem == NULL) { dev_err(&pdev->dev, "failed to get memory region\n"); ret = -ENOENT; goto err_req; } key_base = ioremap(res->start, size); if (key_base == NULL) { printk(KERN_ERR "Failed to remap register block\n"); ret = -ENOMEM; goto err_map; } keypad_clock = clk_get(&pdev->dev, "keypad"); if (IS_ERR(keypad_clock)) { dev_err(&pdev->dev, "failed to find keypad clock source\n"); ret = PTR_ERR(keypad_clock); goto err_clk; } clk_enable(keypad_clock); s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL); input_dev = input_allocate_device(); if (!s3c_keypad || !input_dev) { ret = -ENOMEM; goto err_alloc; } platform_set_drvdata(pdev, s3c_keypad); s3c_keypad->dev = input_dev; writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON); writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC); /* Set GPIO Port for keypad mode and pull-up disable*/ s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS); writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL); /* create and register the input driver */ set_bit(EV_KEY, input_dev->evbit); /*Commenting the generation of repeat events*/ //set_bit(EV_REP, input_dev->evbit); s3c_keypad->nr_rows = KEYPAD_ROWS; s3c_keypad->no_cols = KEYPAD_COLUMNS; s3c_keypad->total_keys = MAX_KEYPAD_NR; for(key = 0; key < s3c_keypad->total_keys; key++){ code = s3c_keypad->keycodes[key] = keypad_keycode[key]; if(code<=0) continue; set_bit(code & KEY_MAX, input_dev->keybit); } //printk("%s, keypad row number is %d, column is %d",__FUNCTION__, s3c_keypad->nr_rows, s3c_keypad->no_cols); set_bit(26 & KEY_MAX, input_dev->keybit); input_dev->name = DEVICE_NAME; input_dev->phys = "s3c-keypad/input0"; input_dev->id.bustype = BUS_HOST; input_dev->id.vendor = 0x0001; input_dev->id.product = 0x0001; input_dev->id.version = 0x0001; input_dev->keycode = keypad_keycode; ret = input_register_device(input_dev); if (ret) { printk("Unable to register s3c-keypad input device!!!\n"); goto out; } /* Scan timer init */ init_timer(&keypad_timer); keypad_timer.function = keypad_timer_handler; keypad_timer.data = (unsigned long)s3c_keypad; /* For IRQ_KEYPAD */ keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (keypad_irq == NULL) { dev_err(&pdev->dev, "no irq resource specified\n"); ret = -ENOENT; goto err_irq; } ret = request_irq(keypad_irq->start, s3c_keypad_isr, IRQF_SAMPLE_RANDOM, DEVICE_NAME, (void *) pdev); if (ret) { printk("request_irq failed (IRQ_KEYPAD) !!!\n"); ret = -EIO; goto err_irq; } mdelay(100); keypad_timer.expires = jiffies + (HZ/100); if (is_timer_on == FALSE) { add_timer(&keypad_timer); is_timer_on = TRUE; } else { mod_timer(&keypad_timer,keypad_timer.expires); } s3c_keygpio_isr_setup((void *)s3c_keypad); printk( DEVICE_NAME " Initialized\n"); if (device_create_file(&pdev->dev, &dev_attr_key_pressed) < 0) { printk("%s s3c_keypad_probe\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_key_pressed.attr.name); } return 0; out: free_irq(keypad_irq->start, input_dev); free_irq(keypad_irq->end, input_dev); err_irq: input_free_device(input_dev); kfree(s3c_keypad); err_alloc: clk_disable(keypad_clock); clk_put(keypad_clock); err_clk: iounmap(key_base); err_map: release_resource(keypad_mem); kfree(keypad_mem); err_req: return ret; }
static int __init s3c_keypad_probe(struct platform_device *pdev) { struct resource *res, *keypad_mem, *keypad_irq = NULL; struct input_dev *input_dev; struct s3c_keypad *s3c_keypad; int ret, size, key; struct s3c_keypad_extra *extra = NULL; struct s3c_keypad_slide *slide = NULL; struct s3c_keypad_special_key *special_key; struct s3c_keypad_gpio_key *gpio_key; int i; char * input_dev_name; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&pdev->dev,"no memory resource specified\n"); return -ENOENT; } size = (res->end - res->start) + 1; keypad_mem = request_mem_region(res->start, size, pdev->name); if (keypad_mem == NULL) { dev_err(&pdev->dev, "failed to get memory region\n"); ret = -ENOENT; goto err_req; } key_base = ioremap(res->start, size); if (key_base == NULL) { printk(KERN_ERR "Failed to remap register block\n"); ret = -ENOMEM; goto err_map; } keypad_clock = clk_get(&pdev->dev, "keypad"); if (IS_ERR(keypad_clock)) { dev_err(&pdev->dev, "failed to find keypad clock source\n"); ret = PTR_ERR(keypad_clock); goto err_clk; } clk_enable(keypad_clock); s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL); input_dev = input_allocate_device(); input_dev_name = (char *)kmalloc(sizeof("s3c-keypad-revxxxx"), GFP_KERNEL); if (!s3c_keypad || !input_dev || !input_dev_name) { ret = -ENOMEM; goto out; } platform_set_drvdata(pdev, s3c_keypad); DPRINTK(": system_rev 0x%04x\n", system_rev); for (i=0; i<sizeof(s3c_keypad_extra)/sizeof(struct s3c_keypad_extra); i++) { // if (s3c_keypad_extra[i].board_num == g_board_num) { if (s3c_keypad_extra[i].board_num == system_rev) { extra = &s3c_keypad_extra[i]; sprintf(input_dev_name, "%s%s%04x", DEVICE_NAME, "-rev", system_rev); DPRINTK(": board rev 0x%04x is detected!\n", s3c_keypad_extra[i].board_num); break; } } if(!extra) { extra = &s3c_keypad_extra[0]; sprintf(input_dev_name, "%s%s", DEVICE_NAME, "-rev0000"); //default revison DPRINTK(": failed to detect board rev. set default rev00\n"); } DPRINTK(": input device name: %s.\n", input_dev_name); s3c_keypad->dev = input_dev; fake_slide_dev = input_dev; s3c_keypad->extra = extra; slide = extra->slide; special_key = extra->special_key; gpio_key = extra->gpio_key; writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON); writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC); /* Set GPIO Port for keypad mode and pull-up disable*/ s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS); writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL); for(key = 0; key < 64; key++){ input_set_capability(input_dev, EV_KEY, key+1); } for (i=0; i<extra->special_key_num; i++ ){ input_set_capability(input_dev, EV_KEY, (special_key+i)->keycode); } for (i=0; i<extra->gpio_key_num; i++ ){ input_set_capability(input_dev, EV_KEY, (gpio_key+i)->keycode); } if (extra->slide != NULL) input_set_capability(input_dev, EV_SW, SW_LID); input_dev->name = input_dev_name; input_dev->phys = "s3c-keypad/input0"; input_dev->id.bustype = BUS_HOST; input_dev->id.vendor = 0x0001; input_dev->id.product = 0x0001; input_dev->id.version = 0x0001; /* Scan timer init */ init_timer(&keypad_timer); keypad_timer.function = keypad_timer_handler; keypad_timer.data = (unsigned long)s3c_keypad; init_timer(&gpiokey_timer); gpiokey_timer.function = gpiokey_timer_handler; gpiokey_timer.data = (unsigned long)s3c_keypad; /* For IRQ_KEYPAD */ keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (keypad_irq == NULL) { dev_err(&pdev->dev, "no irq resource specified\n"); ret = -ENOENT; goto err_clk; } if (slide != NULL) { s3c_gpio_cfgpin(slide->gpio, S3C_GPIO_SFN(slide->gpio_af)); s3c_gpio_setpull(slide->gpio, S3C_GPIO_PULL_NONE); set_irq_type(slide->eint, IRQ_TYPE_EDGE_BOTH); ret = request_irq(slide->eint, slide_int_handler, IRQF_DISABLED, "s3c_keypad gpio key", (void *)s3c_keypad); if (ret) { printk(KERN_ERR "request_irq(%d) failed (IRQ for SLIDE) !!!\n", slide->eint); ret = -EIO; goto err_irq; } } for (i=0; i<extra->gpio_key_num; i++, gpio_key+=1) { s3c_gpio_cfgpin(gpio_key->gpio, S3C_GPIO_SFN(gpio_key->gpio_af)); s3c_gpio_setpull(gpio_key->gpio, S3C_GPIO_PULL_NONE); set_irq_type(gpio_key->eint, IRQ_TYPE_EDGE_BOTH); ret = request_irq(gpio_key->eint, gpio_int_handler, IRQF_DISABLED, "s3c_keypad gpio key", (void *)s3c_keypad); if (ret) { printk(KERN_ERR "request_irq(%d) failed (IRQ for GPIO KEY) !!!\n", gpio_key->eint); ret = -EIO; goto err_irq; } } ret = request_irq(keypad_irq->start, s3c_keypad_isr, IRQF_SAMPLE_RANDOM, DEVICE_NAME, (void *) pdev); if (ret) { printk("request_irq failed (IRQ_KEYPAD) !!!\n"); ret = -EIO; goto err_irq; } ret = input_register_device(input_dev); if (ret) { printk("Unable to register s3c-keypad input device!!!\n"); goto out; } keypad_timer.expires = jiffies + (HZ/10); if (is_timer_on == FALSE) { add_timer(&keypad_timer); is_timer_on = TRUE; } else { mod_timer(&keypad_timer,keypad_timer.expires); } printk( DEVICE_NAME " Initialized\n"); return 0; out: input_free_device(input_dev); kfree(s3c_keypad); err_irq: free_irq(keypad_irq->start, input_dev); free_irq(keypad_irq->end, input_dev); if (slide != NULL) free_irq(extra->slide->eint, s3c_keypad); gpio_key = extra->gpio_key; for (i=0; i<extra->gpio_key_num; i++, gpio_key+=1) free_irq(gpio_key->eint, s3c_keypad); err_clk: clk_disable(keypad_clock); clk_put(keypad_clock); err_map: iounmap(key_base); err_req: release_resource(keypad_mem); kfree(keypad_mem); return ret; }
/* log handler for internal netfilter logging api */ static void nfulnl_log_packet(unsigned int pf, unsigned int hooknum, const struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const struct nf_loginfo *li_user, const char *prefix) { unsigned int size, data_len; struct nfulnl_instance *inst; const struct nf_loginfo *li; unsigned int qthreshold; unsigned int plen; if (li_user && li_user->type == NF_LOG_TYPE_ULOG) li = li_user; else li = &default_loginfo; inst = instance_lookup_get(li->u.ulog.group); if (!inst) return; plen = 0; if (prefix) plen = strlen(prefix) + 1; /* all macros expand to constant values at compile time */ /* FIXME: do we want to make the size calculation conditional based on * what is actually present? way more branches and checks, but more * memory efficient... */ size = NLMSG_SPACE(sizeof(struct nfgenmsg)) + NFA_SPACE(sizeof(struct nfulnl_msg_packet_hdr)) + NFA_SPACE(sizeof(u_int32_t)) /* ifindex */ + NFA_SPACE(sizeof(u_int32_t)) /* ifindex */ #ifdef CONFIG_BRIDGE_NETFILTER + NFA_SPACE(sizeof(u_int32_t)) /* ifindex */ + NFA_SPACE(sizeof(u_int32_t)) /* ifindex */ #endif + NFA_SPACE(sizeof(u_int32_t)) /* mark */ + NFA_SPACE(sizeof(u_int32_t)) /* uid */ + NFA_SPACE(plen) /* prefix */ + NFA_SPACE(sizeof(struct nfulnl_msg_packet_hw)) + NFA_SPACE(sizeof(struct nfulnl_msg_packet_timestamp)); UDEBUG("initial size=%u\n", size); spin_lock_bh(&inst->lock); if (inst->flags & NFULNL_CFG_F_SEQ) size += NFA_SPACE(sizeof(u_int32_t)); if (inst->flags & NFULNL_CFG_F_SEQ_GLOBAL) size += NFA_SPACE(sizeof(u_int32_t)); qthreshold = inst->qthreshold; /* per-rule qthreshold overrides per-instance */ if (qthreshold > li->u.ulog.qthreshold) qthreshold = li->u.ulog.qthreshold; switch (inst->copy_mode) { case NFULNL_COPY_META: case NFULNL_COPY_NONE: data_len = 0; break; case NFULNL_COPY_PACKET: if (inst->copy_range == 0 || inst->copy_range > skb->len) data_len = skb->len; else data_len = inst->copy_range; size += NFA_SPACE(data_len); UDEBUG("copy_packet, therefore size now %u\n", size); break; default: goto unlock_and_release; } if (inst->qlen >= qthreshold || (inst->skb && size > skb_tailroom(inst->skb))) { /* either the queue len is too high or we don't have * enough room in the skb left. flush to userspace. */ UDEBUG("flushing old skb\n"); /* timer "holds" one reference (we have another one) */ if (del_timer(&inst->timer)) instance_put(inst); __nfulnl_send(inst); } if (!inst->skb) { inst->skb = nfulnl_alloc_skb(inst->nlbufsiz, size); if (!inst->skb) goto alloc_failure; } UDEBUG("qlen %d, qthreshold %d\n", inst->qlen, qthreshold); inst->qlen++; __build_packet_message(inst, skb, data_len, pf, hooknum, in, out, li, prefix, plen); /* timer_pending always called within inst->lock, so there * is no chance of a race here */ if (!timer_pending(&inst->timer)) { instance_get(inst); inst->timer.expires = jiffies + (inst->flushtimeout*HZ/100); add_timer(&inst->timer); } unlock_and_release: spin_unlock_bh(&inst->lock); instance_put(inst); return; alloc_failure: UDEBUG("error allocating skb\n"); /* FIXME: statistics */ goto unlock_and_release; }
static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm) { dpcm->timer.expires = 1 + jiffies; add_timer(&dpcm->timer); }
static void dummy_systimer_rearm(struct dummy_systimer_pcm *dpcm) { dpcm->timer.expires = jiffies + (dpcm->frac_period_rest + dpcm->rate - 1) / dpcm->rate; add_timer(&dpcm->timer); }
/** * @brief Card initial function. * @param work[in]: Work structure. * @return None. */ static void gp_sdcard_work_init(struct work_struct *work) { gpSDInfo_t* sd = container_of(work, gpSDInfo_t,init); int pin_handle; pin_handle = gp_board_pin_func_request((sd->device_id==0)?GP_PIN_SD0:GP_PIN_SD1, GP_BOARD_WAIT_FOREVER); if(pin_handle<0) { DERROR("SD%d: can't get pin handle\n", sd->device_id); goto init_work_end; } /* ----- Initial SD module (controller) ----- */ gpHalSDInit(sd->device_id); /* ----- Initial SD card ----- */ gp_sdcard_cardinit(sd); gp_board_pin_func_release(pin_handle); if(sd->present==1) { if(sd->card_type == SDIO) { sd->pin_handle = gp_board_pin_func_request((sd->device_id==0)?GP_PIN_SD0:GP_PIN_SD1, GP_BOARD_WAIT_FOREVER); if(sd->pin_handle<0) { DERROR("SD%d: can't get pin handle\n", sd->device_id); goto init_work_end; } DEBUG("SDIO card detected\n"); gp_sdio_insert_device(sd->device_id, sd->RCA); } else { sd->queue = blk_init_queue(gp_sdcard_request, &sd->lock); if(sd->queue==NULL) { DERROR("NO MEMORY: queue\n"); goto init_work_end; } blk_queue_ordered(sd->queue, QUEUE_ORDERED_DRAIN, NULL); queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sd->queue); blk_queue_logical_block_size(sd->queue, 512); blk_queue_max_sectors(sd->queue, SD_MAX_SECTORS ); blk_queue_max_phys_segments(sd->queue, SD_MAX_PHY_SEGMENTS); blk_queue_max_hw_segments(sd->queue, SD_MAX_HW_SEGMENTS); blk_queue_max_segment_size(sd->queue, SD_MAX_PHY_SEGMENTS_SIZE); /* ----- Initial scatter list ----- */ sd->sg = kmalloc(sizeof(struct scatterlist) *SD_MAX_PHY_SEGMENTS, GFP_KERNEL); if (!sd->sg) { DERROR("NO MEMORY: queue\n"); goto fail_thread; } sg_init_table(sd->sg, SD_MAX_PHY_SEGMENTS); init_MUTEX(&sd->thread_sem); /* ----- Enable thread ----- */ sd->thread = kthread_run(gp_sdcard_queue_thread, sd, "sd-qd"); if (IS_ERR(sd->thread)) { goto fail_thread; } sd->queue->queuedata = sd; /* ----- Setup gendisk structure ----- */ sd->gd = alloc_disk(SD_MINORS); if (sd->gd==NULL) { DERROR("NO MEMORY: gendisk\n"); blk_cleanup_queue(sd->queue); goto fail_gd; } /* ----- Set gendisk structure ----- */ sd->gd->major = sd_major; sd->gd->first_minor = sd->device_id*SD_MINORS; sd->gd->fops = &gp_sdcard_ops; sd->gd->queue = sd->queue; sd->gd->private_data = sd; snprintf (sd->gd->disk_name, 32, "sdcard%c", sd->device_id + 'a'); set_capacity(sd->gd,sd->capacity); add_disk(sd->gd); } goto init_work_end; } else { DERROR("Initial fail\n"); goto init_work_end; } fail_gd: /* ----- Then terminate our worker thread ----- */ kthread_stop(sd->thread); fail_thread: if (sd->sg) kfree(sd->sg); sd->sg = NULL; blk_cleanup_queue (sd->queue); init_work_end: sd->timer.expires = jiffies + SD_CD_POLL; add_timer(&sd->timer); }
static int __devinit gpio_keys_probe(struct platform_device *pdev) { struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; struct gpio_keys_drvdata *ddata; struct device *dev = &pdev->dev; struct input_dev *input; int i, error; int wakeup = 0; ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL); input = input_allocate_device(); if (!ddata || !input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; #ifdef CONFIG_SENSORS_HALL ddata->gpio_flip_cover = pdata->gpio_flip_cover; #endif #ifdef CONFIG_MACH_GC1 ddata->gpio_strobe_insert = pdata->gpio_strobe_insert; #endif mutex_init(&ddata->disable_lock); platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; #ifdef CONFIG_SENSORS_HALL input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, SW_FLIP); #endif #ifdef CONFIG_MACH_GC1 input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, SW_STROBE_INSERT); #endif input->open = gpio_keys_open; input->close = gpio_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { struct gpio_keys_button *button = &pdata->buttons[i]; struct gpio_button_data *bdata = &ddata->data[i]; unsigned int type = button->type ?: EV_KEY; bdata->input = input; bdata->button = button; error = gpio_keys_setup_key(pdev, bdata, button); if (error) goto fail2; if (button->wakeup) wakeup = 1; input_set_capability(input, type, button->code); } error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } ddata->sec_key = device_create(sec_class, NULL, 0, ddata, "sec_key"); if (IS_ERR(ddata->sec_key)) dev_err(dev, "Failed to create sec_key device\n"); error = sysfs_create_group(&ddata->sec_key->kobj, &sec_key_attr_group); if (error) { dev_err(dev, "Failed to create the test sysfs: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } /* get current state of buttons */ for (i = 0; i < pdata->nbuttons; i++) gpio_keys_report_event(&ddata->data[i]); input_sync(input); #ifdef CONFIG_FAST_BOOT /*Fake power off*/ input_set_capability(input, EV_KEY, KEY_FAKE_PWR); setup_timer(&fake_timer, gpio_keys_fake_off_check, (unsigned long)input); wake_lock_init(&fake_lock, WAKE_LOCK_SUSPEND, "fake_lock"); #endif device_init_wakeup(&pdev->dev, wakeup); #if defined(CONFIG_MACH_KONA) #ifdef AUTO_POWER_ON_OFF_FLAG init_timer(&poweroff_keypad_timer); poweroff_keypad_timer.function = poweroff_keypad_timer_handler; poweroff_keypad_timer.data = (unsigned long)&ddata->data[0]; poweroff_keypad_timer.expires = jiffies + 40*HZ; add_timer(&poweroff_keypad_timer); printk("AUTO_POWER_ON_OFF_FLAG Test Start !!!\n"); #endif #endif return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); sysfs_remove_group(&ddata->sec_key->kobj, &sec_key_attr_group); fail2: while (--i >= 0) { free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]); if (ddata->data[i].timer_debounce) del_timer_sync(&ddata->data[i].timer); cancel_work_sync(&ddata->data[i].work); gpio_free(pdata->buttons[i].gpio); } platform_set_drvdata(pdev, NULL); fail1: input_free_device(input); kfree(ddata); return error; }
void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq) { drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private; drm_via_blitq_t *blitq = dev_priv->blit_queues + engine; int cur; int done_transfer; unsigned long irqsave=0; uint32_t status = 0; DRM_DEBUG("DMA blit handler called. engine = %d, from_irq = %d, blitq = 0x%lx\n", engine, from_irq, (unsigned long) blitq); if (from_irq) { spin_lock(&blitq->blit_lock); } else { spin_lock_irqsave(&blitq->blit_lock, irqsave); } done_transfer = blitq->is_active && (( status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) & VIA_DMA_CSR_TD); done_transfer = done_transfer || ( blitq->aborting && !(status & VIA_DMA_CSR_DE)); cur = blitq->cur; if (done_transfer) { blitq->blits[cur]->aborted = blitq->aborting; blitq->done_blit_handle++; DRM_WAKEUP(blitq->blit_queue + cur); cur++; if (cur >= VIA_NUM_BLIT_SLOTS) cur = 0; blitq->cur = cur; /* * Clear transfer done flag. */ VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TD); blitq->is_active = 0; blitq->aborting = 0; schedule_work(&blitq->wq); } else if (blitq->is_active && time_after_eq(jiffies, blitq->end)) { /* * Abort transfer after one second. */ via_abort_dmablit(dev, engine); blitq->aborting = 1; blitq->end = jiffies + DRM_HZ; } if (!blitq->is_active) { if (blitq->num_outstanding) { via_fire_dmablit(dev, blitq->blits[cur], engine); blitq->is_active = 1; blitq->cur = cur; blitq->num_outstanding--; blitq->end = jiffies + DRM_HZ; if (!timer_pending(&blitq->poll_timer)) { blitq->poll_timer.expires = jiffies+1; add_timer(&blitq->poll_timer); } } else { if (timer_pending(&blitq->poll_timer)) { del_timer(&blitq->poll_timer); } via_dmablit_engine_off(dev, engine); } } if (from_irq) { spin_unlock(&blitq->blit_lock); } else { spin_unlock_irqrestore(&blitq->blit_lock, irqsave); } }
static int aml_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_pcm_runtime *rtd = substream->runtime; struct aml_runtime_data *prtd = rtd->private_data; audio_stream_t *s = &prtd->s; int ret = 0; switch (cmd) { case SNDRV_PCM_TRIGGER_START: #if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6 //witch_mod_gate_by_type(MOD_AUDIO, 1); #endif del_timer_sync(&prtd->timer); spin_lock(&s->lock); prtd->timer.expires = jiffies + 1; del_timer(&prtd->timer); add_timer(&prtd->timer); // TODO if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK){ //printk("aml_pcm_trigger: playback start\n"); //clock_gating_status |= clock_gating_playback; //aml_clock_gating(clock_gating_status); //codec_power_switch(substream, clock_gating_status); audio_enable_ouput(1); }else{ //printk("aml_pcm_trigger: capture start\n"); //clock_gating_status |= clock_gating_capture; //aml_clock_gating(clock_gating_status); //codec_power_switch(substream, clock_gating_status); audio_in_i2s_enable(1); { int * ppp = (int*)(rtd->dma_area+rtd->dma_bytes*2-8); ppp[0] = 0x78787878; ppp[1] = 0x78787878; } } s->active = 1; spin_unlock(&s->lock); break; /* SNDRV_PCM_TRIGGER_START */ case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_STOP: // TODO spin_lock(&s->lock); s->active = 0; if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK){ //printk("aml_pcm_trigger: playback stop\n"); audio_enable_ouput(0); // clock_gating_status &= ~clock_gating_playback; //aml_clock_gating(clock_gating_status); //codec_power_switch(substream, clock_gating_status); }else{ //printk("aml_pcm_trigger: capture stop\n"); // clock_gating_status &= ~clock_gating_capture; audio_in_i2s_enable(0); } #if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6 // switch_mod_gate_by_type(MOD_AUDIO, 0); #endif spin_unlock(&s->lock); break; case SNDRV_PCM_TRIGGER_RESUME: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: // TODO spin_lock(&s->lock); #if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6 //switch_mod_gate_by_type(MOD_AUDIO, 1); #endif s->active = 1; if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK){ //printk("aml_pcm_trigger: playback resume\n"); audio_enable_ouput(1); // clock_gating_status |= clock_gating_playback; //aml_clock_gating(clock_gating_status); //codec_power_switch(substream, clock_gating_status); }else{ //printk("aml_pcm_trigger: capture resume\n"); audio_in_i2s_enable(1); // clock_gating_status |= clock_gating_capture; //aml_clock_gating(clock_gating_status); //codec_power_switch(substream, clock_gating_status); { int * ppp = (int*)(rtd->dma_area+rtd->dma_bytes*2-8); ppp[0] = 0x78787878; ppp[1] = 0x78787878; } } spin_unlock(&s->lock); break; default: ret = -EINVAL; } /* if(clock_gating_status&clock_gating_playback){ if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK) aml_pcm_work.substream = substream; } else aml_pcm_work.substream = substream; if(clock_gating_status) { schedule_work(&aml_pcm_work.aml_codec_workqueue); } */ //schedule_work(&aml_pcm_work.aml_codec_workqueue); return ret; }
/* * Writes the given message to S390 system console */ static void sclp_console_write(struct console *console, const char *message, unsigned int count) { unsigned long flags; void *page; int written; if (count == 0) return; spin_lock_irqsave(&sclp_con_lock, flags); /* * process escape characters, write message into buffer, * send buffer to SCLP */ do { /* make sure we have a console output buffer */ if (sclp_conbuf == NULL) { if (list_empty(&sclp_con_pages)) sclp_console_full++; while (list_empty(&sclp_con_pages)) { if (sclp_con_suspended) goto out; if (sclp_console_drop_buffer()) break; spin_unlock_irqrestore(&sclp_con_lock, flags); sclp_sync_wait(); spin_lock_irqsave(&sclp_con_lock, flags); } page = sclp_con_pages.next; list_del((struct list_head *) page); sclp_conbuf = sclp_make_buffer(page, sclp_con_columns, sclp_con_width_htab); } /* try to write the string to the current output buffer */ written = sclp_write(sclp_conbuf, (const unsigned char *) message, count); if (written == count) break; /* * Not all characters could be written to the current * output buffer. Emit the buffer, create a new buffer * and then output the rest of the string. */ spin_unlock_irqrestore(&sclp_con_lock, flags); sclp_conbuf_emit(); spin_lock_irqsave(&sclp_con_lock, flags); message += written; count -= written; } while (count > 0); /* Setup timer to output current console buffer after 1/10 second */ if (sclp_conbuf != NULL && sclp_chars_in_buffer(sclp_conbuf) != 0 && !timer_pending(&sclp_con_timer)) { init_timer(&sclp_con_timer); sclp_con_timer.function = sclp_console_timeout; sclp_con_timer.data = 0UL; sclp_con_timer.expires = jiffies + HZ/10; add_timer(&sclp_con_timer); } out: spin_unlock_irqrestore(&sclp_con_lock, flags); }
irqreturn_t interrupt_handler(int dummy, void *card_inst) { RspMessage rcvmsg; int channel; int card = (int)(unsigned long) card_inst; if(!IS_VALID_CARD(card)) { pr_debug("Invalid param: %d is not a valid card id\n", card); return IRQ_NONE; } pr_debug("%s: Entered Interrupt handler\n", sc_adapter[card]->devicename); /* * Pull all of the waiting messages off the response queue */ while (!receivemessage(card, &rcvmsg)) { /* * Push the message to the adapter structure for * send_and_receive to snoop */ if(sc_adapter[card]->want_async_messages) memcpy(&(sc_adapter[card]->async_msg), &rcvmsg, sizeof(RspMessage)); channel = (unsigned int) rcvmsg.phy_link_no; /* * Trap Invalid request messages */ if(IS_CM_MESSAGE(rcvmsg, 0, 0, Invalid)) { pr_debug("%s: Invalid request Message, rsp_status = %d\n", sc_adapter[card]->devicename, rcvmsg.rsp_status); break; } /* * Check for a linkRead message */ if (IS_CE_MESSAGE(rcvmsg, Lnk, 1, Read)) { pr_debug("%s: Received packet 0x%x bytes long at 0x%lx\n", sc_adapter[card]->devicename, rcvmsg.msg_data.response.msg_len, rcvmsg.msg_data.response.buff_offset); rcvpkt(card, &rcvmsg); continue; } /* * Handle a write acknoledgement */ if(IS_CE_MESSAGE(rcvmsg, Lnk, 1, Write)) { pr_debug("%s: Packet Send ACK on channel %d\n", sc_adapter[card]->devicename, rcvmsg.phy_link_no); sc_adapter[card]->channel[rcvmsg.phy_link_no-1].free_sendbufs++; continue; } /* * Handle a connection message */ if (IS_CE_MESSAGE(rcvmsg, Phy, 1, Connect)) { unsigned int callid; setup_parm setup; pr_debug("%s: Connect message: line %d: status %d: cause 0x%x\n", sc_adapter[card]->devicename, rcvmsg.phy_link_no, rcvmsg.rsp_status, rcvmsg.msg_data.byte_array[2]); memcpy(&callid,rcvmsg.msg_data.byte_array,sizeof(int)); if(callid>=0x8000 && callid<=0xFFFF) { pr_debug("%s: Got Dial-Out Rsp\n", sc_adapter[card]->devicename); indicate_status(card, ISDN_STAT_DCONN, (unsigned long)rcvmsg.phy_link_no-1,NULL); } else if(callid>=0x0000 && callid<=0x7FFF) { pr_debug("%s: Got Incoming Call\n", sc_adapter[card]->devicename); strcpy(setup.phone,&(rcvmsg.msg_data.byte_array[4])); strcpy(setup.eazmsn, sc_adapter[card]->channel[rcvmsg.phy_link_no-1].dn); setup.si1 = 7; setup.si2 = 0; setup.plan = 0; setup.screen = 0; indicate_status(card, ISDN_STAT_ICALL,(unsigned long)rcvmsg.phy_link_no-1,(char *)&setup); indicate_status(card, ISDN_STAT_DCONN,(unsigned long)rcvmsg.phy_link_no-1,NULL); } continue; } /* * Handle a disconnection message */ if (IS_CE_MESSAGE(rcvmsg, Phy, 1, Disconnect)) { pr_debug("%s: disconnect message: line %d: status %d: cause 0x%x\n", sc_adapter[card]->devicename, rcvmsg.phy_link_no, rcvmsg.rsp_status, rcvmsg.msg_data.byte_array[2]); indicate_status(card, ISDN_STAT_BHUP,(unsigned long)rcvmsg.phy_link_no-1,NULL); indicate_status(card, ISDN_STAT_DHUP,(unsigned long)rcvmsg.phy_link_no-1,NULL); continue; } /* * Handle a startProc engine up message */ if (IS_CM_MESSAGE(rcvmsg, 5, 0, MiscEngineUp)) { pr_debug("%s: Received EngineUp message\n", sc_adapter[card]->devicename); sc_adapter[card]->EngineUp = 1; sendmessage(card, CEPID,ceReqTypeCall,ceReqClass0,ceReqCallGetMyNumber,1,0,NULL); sendmessage(card, CEPID,ceReqTypeCall,ceReqClass0,ceReqCallGetMyNumber,2,0,NULL); init_timer(&sc_adapter[card]->stat_timer); sc_adapter[card]->stat_timer.function = check_phystat; sc_adapter[card]->stat_timer.data = card; sc_adapter[card]->stat_timer.expires = jiffies + CHECKSTAT_TIME; add_timer(&sc_adapter[card]->stat_timer); continue; } /* * Start proc response */ if (IS_CM_MESSAGE(rcvmsg, 2, 0, StartProc)) { pr_debug("%s: StartProc Response Status %d\n", sc_adapter[card]->devicename, rcvmsg.rsp_status); continue; } /* * Handle a GetMyNumber Rsp */ if (IS_CE_MESSAGE(rcvmsg,Call,0,GetMyNumber)){ strcpy(sc_adapter[card]->channel[rcvmsg.phy_link_no-1].dn,rcvmsg.msg_data.byte_array); continue; } /* * PhyStatus response */ if(IS_CE_MESSAGE(rcvmsg, Phy, 2, Status)) { unsigned int b1stat, b2stat; /* * Covert the message data to the adapter->phystat code */ b1stat = (unsigned int) rcvmsg.msg_data.byte_array[0]; b2stat = (unsigned int) rcvmsg.msg_data.byte_array[1]; sc_adapter[card]->nphystat = (b2stat >> 8) | b1stat; /* endian?? */ pr_debug("%s: PhyStat is 0x%2x\n", sc_adapter[card]->devicename, sc_adapter[card]->nphystat); continue; } /* * Handle a GetFramFormat */ if(IS_CE_MESSAGE(rcvmsg, Call, 0, GetFrameFormat)) { if(rcvmsg.msg_data.byte_array[0] != HDLC_PROTO) { unsigned int proto = HDLC_PROTO; /* * Set board format to HDLC if it wasn't already */ pr_debug("%s: current frame format: 0x%x, will change to HDLC\n", sc_adapter[card]->devicename, rcvmsg.msg_data.byte_array[0]); sendmessage(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallSetFrameFormat, (unsigned char) channel +1, 1,&proto); } continue; } /* * Hmm... */ pr_debug("%s: Received unhandled message (%d,%d,%d) link %d\n", sc_adapter[card]->devicename, rcvmsg.type, rcvmsg.class, rcvmsg.code, rcvmsg.phy_link_no); } /* while */
/* 每个struct sock的时钟函数 */ void net_timer (unsigned long data) { struct sock *sk = (struct sock*)data; /* 相当于获取时钟的类型吧, */ int why = sk->timeout; /* timeout is overwritten by 'delete_timer' and 'reset_timer' */ /* 判断sock是否已被其他进程使用,或者当前是否正在执行网络的下半部分, * 如果当前正在执行网络的下半部分,则重新设置sock的timer,同时添加到 * 内核时钟当中,等待下次执行 */ if (sk->inuse || in_inet_bh()) { sk->timer.expires = 10; add_timer(&sk->timer); return; } /* 设置sock为用 */ sk->inuse = 1; DPRINTF ((DBG_TMR, "net_timer: found sk=%X why = %d\n", sk, why)); if (sk->wfront && before(sk->window_seq, sk->wfront->h.seq) && sk->send_head == NULL && sk->ack_backlog == 0 && sk->state != TCP_TIME_WAIT) reset_timer(sk, TIME_PROBE0, sk->rto); else if (sk->keepopen) reset_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN); /* Always see if we need to send an ack. */ /* 看看还有没有收到的数据包没有应答 */ if (sk->ack_backlog) { /* sock发送确认数据包*/ sk->prot->read_wakeup (sk); if (! sk->dead) wake_up_interruptible (sk->sleep); } /* Now we need to figure out why the socket was on the timer. */ switch (why) { case TIME_DONE: if (! sk->dead || sk->state != TCP_CLOSE) { printk ("non dead socket in time_done\n"); release_sock (sk); break; } destroy_sock (sk); break; case TIME_DESTROY: /* We've waited for a while for all the memory associated with * the socket to be freed. We need to print an error message. */ /* 如果sock的发送缓冲区和接收缓冲区都为空,则直接在后面的语句当中释放 */ if(sk->wmem_alloc!=0 || sk->rmem_alloc!=0) { DPRINTF ((DBG_TMR, "possible memory leak. sk = %X\n", sk)); sk->wmem_alloc++; /* So it DOESNT go away */ destroy_sock (sk); sk->wmem_alloc--; /* Might now have hit 0 - fall through and do it again if so */ sk->inuse = 0; /* This will be ok, the destroy won't totally work */ } if(sk->wmem_alloc==0 && sk->rmem_alloc==0) destroy_sock(sk); /* Socket gone, DONT update sk->inuse! */ break; case TIME_CLOSE: /* We've waited long enough, close the socket. */ sk->state = TCP_CLOSE; delete_timer (sk); /* Kill the ARP entry in case the hardware has changed. */ arp_destroy_maybe (sk->daddr); if (!sk->dead) wake_up_interruptible (sk->sleep); sk->shutdown = SHUTDOWN_MASK; reset_timer (sk, TIME_DESTROY, TCP_DONE_TIME); release_sock (sk); break; case TIME_PROBE0: /* 窗口探测定时器,也被称为坚持定时器 */ tcp_send_probe0(sk); release_sock (sk); break; case TIME_WRITE: /* 超时重传定时器 */ /* try to retransmit. */ /* It could be we got here because we needed to send an ack. * So we need to check for that. */ if (sk->send_head) { if (jiffies < (sk->send_head->when + sk->rto)) { reset_timer (sk, TIME_WRITE, (sk->send_head->when + sk->rto - jiffies)); release_sock (sk); break; } /* printk("timer: seq %d retrans %d out %d cong %d\n", sk->send_head->h.seq, sk->retransmits, sk->packets_out, sk->cong_window); */ DPRINTF ((DBG_TMR, "retransmitting.\n")); /* 调用tcp协议的超时重传函数 */ sk->prot->retransmit (sk, 0); if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7)) || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) { DPRINTF ((DBG_TMR, "timer.c TIME_WRITE time-out 1\n")); arp_destroy_maybe (sk->daddr); ip_route_check (sk->daddr); } if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) { DPRINTF ((DBG_TMR, "timer.c TIME_WRITE time-out 2\n")); sk->err = ETIMEDOUT; if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_LAST_ACK) { sk->state = TCP_TIME_WAIT; reset_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); } else { sk->prot->close (sk, 1); break; } } } release_sock (sk); break; case TIME_KEEPOPEN: /* 保活定时器 */ /* Send something to keep the connection open. */ if (sk->prot->write_wakeup) sk->prot->write_wakeup (sk); sk->retransmits++; /* 因为是重发定时,所以会增加超时重发次数 */ if (sk->shutdown == SHUTDOWN_MASK) { sk->prot->close (sk, 1); sk->state = TCP_CLOSE; } if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7)) || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) { DPRINTF ((DBG_TMR, "timer.c TIME_KEEPOPEN time-out 1\n")); arp_destroy_maybe (sk->daddr); ip_route_check (sk->daddr); release_sock (sk); break; } if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) { DPRINTF ((DBG_TMR, "timer.c TIME_KEEPOPEN time-out 2\n")); arp_destroy_maybe (sk->daddr); sk->err = ETIMEDOUT; if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2) { sk->state = TCP_TIME_WAIT; if (!sk->dead) wake_up_interruptible (sk->sleep); release_sock (sk); } else { sk->prot->close (sk, 1); } break; } release_sock (sk); break; default: printk ("net timer expired - reason unknown, sk=%08X\n", (int)sk); release_sock (sk); break; } }
static void jpeg_device_dec_run(void *priv) { struct jpeg_ctx *ctx = priv; struct jpeg_dev *dev = ctx->dev; struct jpeg_dec_param dec_param; struct vb2_buffer *vb = NULL; unsigned long flags; dev = ctx->dev; spin_lock_irqsave(&ctx->slock, flags); printk(KERN_DEBUG "dec_run.\n"); if (timer_pending(&ctx->dev->watchdog_timer) == 0) { ctx->dev->watchdog_timer.expires = jiffies + msecs_to_jiffies(JPEG_WATCHDOG_INTERVAL); add_timer(&ctx->dev->watchdog_timer); } set_bit(0, &ctx->dev->hw_run); dev->mode = DECODING; dec_param = ctx->param.dec_param; jpeg_sw_reset(dev->reg_base); jpeg_set_interrupt(dev->reg_base); jpeg_set_encode_tbl_select(dev->reg_base, 0); vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx); jpeg_set_stream_buf_address(dev->reg_base, dev->vb2->plane_addr(vb, 0)); vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx); if (dec_param.out_plane == 1) jpeg_set_frame_buf_address(dev->reg_base, dec_param.out_fmt, dev->vb2->plane_addr(vb, 0), 0, 0); else if (dec_param.out_plane == 2) { jpeg_set_frame_buf_address(dev->reg_base, dec_param.out_fmt, dev->vb2->plane_addr(vb, 0), dev->vb2->plane_addr(vb, 1), 0); } else if (dec_param.out_plane == 3) jpeg_set_frame_buf_address(dev->reg_base, dec_param.out_fmt, dev->vb2->plane_addr(vb, 0), dev->vb2->plane_addr(vb, 1), dev->vb2->plane_addr(vb, 2)); if (dec_param.out_width > 0 && dec_param.out_height > 0) { if ((dec_param.out_width * 2 == dec_param.in_width) && (dec_param.out_height * 2 == dec_param.in_height)) jpeg_set_dec_scaling(dev->reg_base, JPEG_SCALE_2, JPEG_SCALE_2); else if ((dec_param.out_width * 4 == dec_param.in_width) && (dec_param.out_height * 4 == dec_param.in_height)) jpeg_set_dec_scaling(dev->reg_base, JPEG_SCALE_4, JPEG_SCALE_4); else jpeg_set_dec_scaling(dev->reg_base, JPEG_SCALE_NORMAL, JPEG_SCALE_NORMAL); } jpeg_set_dec_out_fmt(dev->reg_base, dec_param.out_fmt); jpeg_set_dec_bitstream_size(dev->reg_base, dec_param.size); jpeg_set_enc_dec_mode(dev->reg_base, DECODING); spin_unlock_irqrestore(&ctx->slock, flags); }