taglinefilesource code
timeout415arch/alpha/kernel/osf_sys.ccurrent->timeout = ticks + jiffies;
timeout421arch/alpha/kernel/osf_sys.cif (ticks < current->timeout)
timeout422arch/alpha/kernel/osf_sys.cticks = current->timeout - ticks;
timeout425arch/alpha/kernel/osf_sys.ccurrent->timeout = 0;
timeout690arch/i386/kernel/smp.cint timeout, num_starts, j;
timeout816arch/i386/kernel/smp.ctimeout = 0;
timeout820arch/i386/kernel/smp.c&& (timeout++ < 1000));
timeout833arch/i386/kernel/smp.cfor(timeout=0;timeout<50000;timeout++)
timeout694arch/m68k/atari/config.ccurrent->timeout = jiffies + HWCLK_POLL_INTERVAL;
timeout231arch/sparc/kernel/smp.cint timeout;
timeout244arch/sparc/kernel/smp.cfor(timeout = 0; timeout < 5000000; timeout++) {
timeout441arch/sparc/kernel/smp.cint i, timeout;
timeout473arch/sparc/kernel/smp.ctimeout = CCALL_TIMEOUT;
timeout475arch/sparc/kernel/smp.cwhile(!ccall_info.processors_in[i] && timeout-- > 0)
timeout488arch/sparc/kernel/smp.ctimeout = CCALL_TIMEOUT;
timeout490arch/sparc/kernel/smp.cwhile(!ccall_info.processors_out[i] && timeout-- > 0)
timeout917arch/sparc/kernel/sys_sunos.cint sunos_poll(struct poll * ufds, size_t nfds, int timeout)
timeout937arch/sparc/kernel/sys_sunos.cif (timeout < 0)
timeout938arch/sparc/kernel/sys_sunos.ccurrent->timeout = 0x7fffffff;
timeout940arch/sparc/kernel/sys_sunos.ccurrent->timeout = jiffies + POLL_ROUND_UP(timeout, (1000/HZ));
timeout941arch/sparc/kernel/sys_sunos.cif (current->timeout <= jiffies)
timeout942arch/sparc/kernel/sys_sunos.ccurrent->timeout = 0;
timeout993arch/sparc/kernel/sys_sunos.cif (!count && current->timeout > jiffies) {
timeout1011arch/sparc/kernel/sys_sunos.ccurrent->timeout = 0;
timeout61arch/sparc/kernel/tick14.cint irq_nr, unsigned int timeout )
timeout81arch/sparc/kernel/tick14.cload_profile_irq(timeout);
timeout1662drivers/block/ataflop.cunsigned long timeout;
timeout1674drivers/block/ataflop.cfor( ok = 0, timeout = jiffies + 2*HZ+HZ/2; jiffies < timeout; ) {
timeout619drivers/block/floppy.cfd_timeout.expires = jiffies + UDP->timeout;
timeout1342drivers/block/ide-cd.ccurrent->timeout = jiffies + time;
timeout463drivers/block/ide.cvoid ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout)
timeout473drivers/block/ide.chwgroup->timer.expires = jiffies + timeout;
timeout1218drivers/block/ide.cint ide_wait_stat (ide_drive_t *drive, byte good, byte bad, unsigned long timeout)
timeout1234drivers/block/ide.ctimeout += jiffies;
timeout1240drivers/block/ide.c} while (jiffies <= timeout);
timeout2361drivers/block/ide.cunsigned long timeout;
timeout2384drivers/block/ide.ctimeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
timeout2385drivers/block/ide.ctimeout += jiffies;
timeout2387drivers/block/ide.cif (jiffies > timeout) {
timeout495drivers/block/ide.hvoid ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout);
timeout523drivers/block/ide.hint ide_wait_stat (ide_drive_t *drive, byte good, byte bad, unsigned long timeout);
timeout86drivers/block/promise.cunsigned long timeout, timer;
timeout93drivers/block/promise.ctimeout = HZ * 10;
timeout94drivers/block/promise.ctimeout += jiffies;
timeout96drivers/block/promise.cif(jiffies > timeout) {
timeout311drivers/block/promise.cunsigned long timeout;
timeout324drivers/block/promise.ctimeout = jiffies + HZ/20; /* 50ms wait */
timeout342drivers/block/promise.c} while (jiffies < timeout);
timeout453drivers/block/xd.cstatic inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout)
timeout455drivers/block/xd.cu_long expiry = jiffies + timeout;
timeout464drivers/block/xd.cstatic u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout)
timeout475drivers/block/xd.cif (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
timeout479drivers/block/xd.cif (xd_waitport(XD_STATUS,STAT_READY,STAT_READY,timeout))
timeout511drivers/block/xd.cif (xd_waitport(XD_STATUS,0,STAT_SELECT,timeout))          /* wait until deselected */
timeout399drivers/cdrom/cdu31a.ccurrent->timeout = jiffies;
timeout638drivers/cdrom/cdu31a.ccurrent->timeout = jiffies + 2*HZ;
timeout897drivers/cdrom/cdu31a.ccurrent->timeout = jiffies + HZ/10; /* Wait .1 seconds on retries */
timeout293drivers/cdrom/cm206.cint sleep_or_timeout(struct wait_queue ** wait, int timeout)
timeout296drivers/cdrom/cm206.ccd->timer.expires = jiffies + timeout;
timeout187drivers/cdrom/mcd.cstatic int getMcdStatus(int timeout);
timeout1372drivers/cdrom/mcd.cgetMcdStatus(int timeout)
timeout1376drivers/cdrom/mcd.cMcdTimeout = timeout;
timeout243drivers/cdrom/mcdx.cunsigned int timeout, int);
timeout859drivers/cdrom/mcdx.ccurrent->timeout = jiffies;
timeout863drivers/cdrom/mcdx.ccurrent->timeout = tout;
timeout866drivers/cdrom/mcdx.cwhile (current->timeout) {
timeout868drivers/cdrom/mcdx.cTRACE((SLEEP, "delay: to is %d\n", current->timeout));
timeout918drivers/cdrom/mcdx.cunsigned int timeout, int tries)
timeout945drivers/cdrom/mcdx.ctries, timeout, size, (unsigned char) cmd[0]));
timeout962drivers/cdrom/mcdx.cif (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
timeout997drivers/cdrom/mcdx.cif (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
timeout1333drivers/cdrom/mcdx.ccurrent->timeout = jiffies + 5 * HZ;
timeout1334drivers/cdrom/mcdx.cwhile (stuffp->introk && stuffp->busy && current->timeout) {
timeout1337drivers/cdrom/mcdx.cstuffp->busy, current->timeout));
timeout1341drivers/cdrom/mcdx.cif (current->timeout == 0 || !stuffp->introk) {
timeout1342drivers/cdrom/mcdx.cif (current->timeout == 0)  {
timeout1825drivers/cdrom/mcdx.cunsigned long timeout = to + jiffies;
timeout1831drivers/cdrom/mcdx.cif (jiffies > timeout) return -1;
timeout232drivers/cdrom/optcd.cinline static int flag_low(int flag, unsigned long timeout)
timeout238drivers/cdrom/optcd.cif (++count >= timeout)
timeout273drivers/cdrom/optcd.cstatic int sleep_flag_low(int flag, unsigned long timeout)
timeout279drivers/cdrom/optcd.csleep_timeout = timeout;
timeout288drivers/cdrom/optcd.cflag, timeout, flag_high ? " timeout" : ""));
timeout1062drivers/cdrom/optcd.cstatic int timeout = 0;
timeout1127drivers/cdrom/optcd.ctimeout = READ_TIMEOUT;
timeout1178drivers/cdrom/optcd.ctimeout = READ_TIMEOUT;
timeout1190drivers/cdrom/optcd.cprintk("timeout cnt: %d\n", timeout);
timeout1207drivers/cdrom/optcd.ctimeout = READ_TIMEOUT;
timeout1280drivers/cdrom/optcd.ctimeout = READ_TIMEOUT;
timeout1300drivers/cdrom/optcd.ctimeout = STOP_TIMEOUT;
timeout1304drivers/cdrom/optcd.cif (status < 0 && timeout)
timeout1318drivers/cdrom/optcd.ctimeout = 1;
timeout1331drivers/cdrom/optcd.cif (!timeout--) {
timeout1377drivers/cdrom/optcd.ctimeout = READ_TIMEOUT;
timeout580drivers/cdrom/sbpcd.cstatic u_long timeout;
timeout798drivers/cdrom/sbpcd.ccurrent->timeout = jiffies + time;
timeout941drivers/cdrom/sbpcd.cfor(timeout = jiffies + 10*HZ, i=maxtim_data; timeout > jiffies; )
timeout991drivers/cdrom/sbpcd.cu_long timeout;
timeout993drivers/cdrom/sbpcd.cfor (i=0,timeout=jiffies+HZ;i<response_count;i++) 
timeout1002drivers/cdrom/sbpcd.cif ((j!=0)||(timeout<=jiffies)) break;
timeout1006drivers/cdrom/sbpcd.cif (timeout<=jiffies) break;
timeout1123drivers/cdrom/sbpcd.cu_long timeout;
timeout1127drivers/cdrom/sbpcd.cif (flags_cmd_out & f_respo3) timeout = jiffies;
timeout1128drivers/cdrom/sbpcd.celse if (flags_cmd_out & f_respo2) timeout = jiffies + 16*HZ;
timeout1129drivers/cdrom/sbpcd.celse timeout = jiffies + 4*HZ;
timeout1138drivers/cdrom/sbpcd.cif ((j!=0)||(timeout<jiffies)) break;
timeout4148drivers/cdrom/sbpcd.cu_long timeout;
timeout4248drivers/cdrom/sbpcd.cfor (timeout=jiffies+9*HZ; ; )
timeout4257drivers/cdrom/sbpcd.cif (try != 0 || timeout <= jiffies) break;
timeout4299drivers/cdrom/sbpcd.cfor (timeout=jiffies+9*HZ; timeout > jiffies; timeout--)
timeout4308drivers/cdrom/sbpcd.cif (i != 0 || timeout <= jiffies) break;
timeout4612drivers/cdrom/sbpcd.cu_long timeout;
timeout4812drivers/cdrom/sbpcd.cfor (timeout=jiffies+HZ; timeout > jiffies; timeout--)
timeout4821drivers/cdrom/sbpcd.cif (i != 0 || timeout <= jiffies) break;
timeout5281drivers/cdrom/sbpcd.ctimeout=jiffies+2*HZ;
timeout5292drivers/cdrom/sbpcd.cwhile ((!st_diskok)||(timeout<jiffies));
timeout337drivers/cdrom/sonycd535.ccurrent->timeout = jiffies;
timeout894drivers/cdrom/sonycd535.ccurrent->timeout = jiffies + RETRY_FOR_BAD_STATUS;
timeout1093drivers/char/cyclades.cunsigned long timeout;
timeout1105drivers/char/cyclades.ctimeout = jiffies+10;
timeout1106drivers/char/cyclades.cwhile (timeout >= jiffies)
timeout1111drivers/char/cyclades.ctimeout = jiffies+10;
timeout1112drivers/char/cyclades.cwhile (timeout >= jiffies)
timeout1134drivers/char/cyclades.cunsigned long timeout;
timeout1153drivers/char/cyclades.ctimeout = jiffies+2;
timeout1154drivers/char/cyclades.cwhile (timeout >= jiffies) {
timeout1419drivers/char/cyclades.cinfo->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
timeout1422drivers/char/cyclades.cinfo->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
timeout1425drivers/char/cyclades.cinfo->timeout = 0;
timeout2397drivers/char/cyclades.ccurrent->timeout = jiffies + info->close_delay;
timeout3165drivers/char/cyclades.cinfo->timeout, info->xmit_fifo_size);
timeout321drivers/char/ftape/fdc-io.ccurrent->timeout = jiffies + 1 + (time + MSPT - 1) / MSPT;
timeout331drivers/char/ftape/fdc-io.ccurrent->timeout = 0;  /* interrupt hasn't cleared this */
timeout336drivers/char/ftape/fdc-io.cif (current->timeout > 0) {
timeout153drivers/char/ftape/fdc-io.hextern int fdc_ready_wait(int timeout);
timeout82drivers/char/ftape/ftape-ctl.cresult = ftape_ready_wait(timeout.pause, &status);
timeout94drivers/char/ftape/ftape-ctl.ctimeout.rewind, &status);
timeout106drivers/char/ftape/ftape-ctl.cresult = ftape_ready_wait(timeout.pause, &status);
timeout118drivers/char/ftape/ftape-ctl.ctimeout.rewind, &status);
timeout163drivers/char/ftape/ftape-ctl.cresult = ftape_command_wait(QIC_STOP_TAPE, timeout.stop, &status);
timeout291drivers/char/ftape/ftape-ctl.cresult = ftape_ready_wait(timeout.reset, &status);
timeout466drivers/char/ftape/ftape-ctl.ctimeout.seek = (length * 132 * SECOND) / speed;
timeout467drivers/char/ftape/ftape-ctl.ctimeout.rewind = (length * 144 * SECOND) / (10 * drive_type.speed);
timeout468drivers/char/ftape/ftape-ctl.ctimeout.reset = 20 * SECOND + timeout.rewind;
timeout470drivers/char/ftape/ftape-ctl.cTRACEx1(4, "seek timeout: %d sec", (timeout.seek + 500) / 1000);
timeout471drivers/char/ftape/ftape-ctl.cTRACEx1(4, "rewind timeout: %d sec", (timeout.rewind + 500) / 1000);
timeout493drivers/char/ftape/ftape-ctl.ctimeout.reset, &status);
timeout846drivers/char/ftape/ftape-ctl.ctimeout.seek = 650 * SECOND;
timeout847drivers/char/ftape/ftape-ctl.ctimeout.reset = 670 * SECOND;
timeout848drivers/char/ftape/ftape-ctl.ctimeout.rewind = 650 * SECOND;
timeout849drivers/char/ftape/ftape-ctl.ctimeout.head_seek = 15 * SECOND;
timeout850drivers/char/ftape/ftape-ctl.ctimeout.stop = 5 * SECOND;
timeout851drivers/char/ftape/ftape-ctl.ctimeout.pause = 16 * SECOND;
timeout53drivers/char/ftape/ftape-io.ctimeout_table timeout;
timeout133drivers/char/ftape/ftape-io.ccurrent->timeout = jiffies + ticks;
timeout145drivers/char/ftape/ftape-io.c} while (current->timeout > 0);
timeout202drivers/char/ftape/ftape-io.cftape_ready_wait(timeout.seek, &status);
timeout221drivers/char/ftape/ftape-io.cftape_ready_wait(timeout.seek, &status);
timeout315drivers/char/ftape/ftape-io.cint ftape_ready_wait(int timeout, int *status)
timeout334drivers/char/ftape/ftape-io.cif (timeout >= 0) {
timeout338drivers/char/ftape/ftape-io.ctimeout -= ((jiffies - t0) * SECOND) / HZ;
timeout339drivers/char/ftape/ftape-io.cif (timeout <= 0) {
timeout345drivers/char/ftape/ftape-io.ctimeout -= poll_delay;
timeout361drivers/char/ftape/ftape-io.cint ftape_command_wait(int command, int timeout, int *status)
timeout370drivers/char/ftape/ftape-io.cresult = ftape_ready_wait(timeout, status);
timeout376drivers/char/ftape/ftape-io.cint ftape_parameter_wait(int command, int timeout, int *status)
timeout385drivers/char/ftape/ftape-io.cresult = ftape_ready_wait(timeout, status);
timeout910drivers/char/ftape/ftape-io.cresult = ftape_parameter_wait(track, timeout.head_seek, &status);
timeout1021drivers/char/ftape/ftape-io.cresult = ftape_ready_wait(timeout.reset, &status);
timeout47drivers/char/ftape/ftape-io.hextern timeout_table timeout;
timeout62drivers/char/ftape/ftape-io.hextern int ftape_command_wait(int command, int timeout, int *status);
timeout67drivers/char/ftape/ftape-io.hextern int ftape_ready_wait(int timeout, int *status);
timeout275drivers/char/ftape/ftape-read.cresult = ftape_ready_wait(timeout.seek, &status);
timeout353drivers/char/ftape/ftape-rw.cresult = ftape_command_wait(QIC_STOP_TAPE, timeout.stop, pstatus);
timeout405drivers/char/ftape/ftape-rw.cresult = ftape_ready_wait(timeout.pause, &status);
timeout515drivers/char/ftape/ftape-rw.cresult = ftape_ready_wait(timeout.rewind, &status);
timeout753drivers/char/ftape/ftape-rw.cresult = ftape_ready_wait(timeout.pause, &status);
timeout773drivers/char/ftape/ftape-rw.cftape_ready_wait(timeout.reset, &status);
timeout789drivers/char/ftape/ftape-rw.cresult = ftape_ready_wait(timeout.reset, &status);
timeout879drivers/char/ftape/ftape-rw.cftape_ready_wait(timeout.seek, &status);
timeout912drivers/char/ftape/ftape-rw.ctimeout.rewind, &status);
timeout238drivers/char/ftape/ftape-write.cresult = ftape_ready_wait(timeout.seek, &status);
timeout718drivers/char/ftape/ftape-write.cresult = ftape_ready_wait(timeout.pause, &status);
timeout1250drivers/char/istallion.ccurrent->timeout = jiffies + len;
timeout210drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_INTERRUPT;
timeout256drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout264drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout273drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout291drivers/char/lp.ccurrent->timeout = jiffies + LP_TIME(minor);
timeout212drivers/char/lp_m68k.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout214drivers/char/lp_m68k.ccurrent->timeout = jiffies + LP_TIMEOUT_INTERRUPT;
timeout301drivers/char/lp_m68k.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout308drivers/char/lp_m68k.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout317drivers/char/lp_m68k.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
timeout334drivers/char/lp_m68k.ccurrent->timeout = jiffies + lp_table[dev].time;
timeout788drivers/char/n_tty.ccurrent->timeout = (unsigned long) -1;
timeout793drivers/char/n_tty.ccurrent->timeout = (unsigned long) -1;
timeout801drivers/char/n_tty.ccurrent->timeout = time + jiffies;
timeout804drivers/char/n_tty.ccurrent->timeout = 0;
timeout835drivers/char/n_tty.cif (!current->timeout)
timeout904drivers/char/n_tty.ccurrent->timeout = time + jiffies;
timeout912drivers/char/n_tty.ccurrent->timeout = 0;
timeout509drivers/char/pcxx.ccurrent->timeout = jiffies + info->close_delay;
timeout553drivers/char/psaux.ccurrent->timeout = jiffies + (5*HZ + 99) / 100;
timeout588drivers/char/psaux.ccurrent->timeout = jiffies + (5*HZ + 99) / 100;
timeout1110drivers/char/riscom8.cunsigned long timeout;
timeout1170drivers/char/riscom8.ctimeout = jiffies+HZ;
timeout1173drivers/char/riscom8.ccurrent->timeout = jiffies + port->timeout;
timeout1175drivers/char/riscom8.cif (jiffies > timeout)
timeout1190drivers/char/riscom8.ccurrent->timeout = jiffies + port->close_delay;
timeout75drivers/char/riscom8.hint      timeout;
timeout884drivers/char/serial.cint  timeout = 60*HZ;  /* 60 seconds === a long time :-) */
timeout892drivers/char/serial.cif (info->timeout < timeout)
timeout893drivers/char/serial.ctimeout = info->timeout;
timeout897drivers/char/serial.ctimeout = timeout / 2;
timeout898drivers/char/serial.cIRQ_timeout[irq] = timeout ? timeout : 1;
timeout1190drivers/char/serial.cinfo->timeout = ((info->xmit_fifo_size*HZ*15*quot) /
timeout1194drivers/char/serial.cinfo->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
timeout1197drivers/char/serial.cinfo->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
timeout1200drivers/char/serial.cinfo->timeout = 0;
timeout1728drivers/char/serial.ccurrent->timeout = jiffies + duration;
timeout1745drivers/char/serial.cunsigned long timeout;
timeout1757drivers/char/serial.ctimeout = jiffies+HZ/10;
timeout1758drivers/char/serial.cwhile (timeout >= jiffies)
timeout1763drivers/char/serial.ctimeout = jiffies+HZ/10;
timeout1764drivers/char/serial.cwhile (timeout >= jiffies)
timeout2106drivers/char/serial.cunsigned long timeout;
timeout2177drivers/char/serial.ctimeout = jiffies+HZ;
timeout2180drivers/char/serial.ccurrent->timeout = jiffies + info->timeout;
timeout2182drivers/char/serial.cif (jiffies > timeout)
timeout2197drivers/char/serial.ccurrent->timeout = jiffies + info->close_delay;
timeout2473drivers/char/serial.cunsigned long timeout;
timeout2503drivers/char/serial.ctimeout = jiffies+2*HZ/100;
timeout2504drivers/char/serial.cwhile (timeout >= jiffies) {
timeout840drivers/char/stallion.ccurrent->timeout = jiffies + len;
timeout717drivers/char/tpqic02.cstatic int wait_for_ready(time_t timeout)
timeout736drivers/char/tpqic02.cif (spin_t > timeout)
timeout737drivers/char/tpqic02.cspin_t = timeout;
timeout738drivers/char/tpqic02.ctimeout -= spin_t;
timeout752drivers/char/tpqic02.cspin_t += timeout;
timeout758drivers/char/tpqic02.ccurrent->timeout = jiffies + 3*HZ/10;  /* nap 0.30 sec between checks, */
timeout806drivers/char/tpqic02.cstatic int send_qic02_cmd(int cmd, time_t timeout, int ignore_ex)
timeout1054drivers/char/tpqic02.cstatic int wait_for_rewind(time_t timeout)
timeout1062drivers/char/tpqic02.cstat = wait_for_ready(timeout);
timeout1078drivers/char/tpqic02.cstatic int ll_do_qic_cmd(int cmd, time_t timeout)
timeout1087drivers/char/tpqic02.cstat = wait_for_ready(timeout);    /* wait for ready or exception */
timeout1095drivers/char/tpqic02.cprintk(TPQIC02_NAME ": ll_do_qic_cmd(%x, %ld) failed\n", cmd, (long) timeout);
timeout1105drivers/char/tpqic02.cstat = send_qic02_cmd(cmd, timeout, 0);  /* (checks for exceptions) */
timeout1131drivers/char/tpqic02.cprintk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[1](%x, %ld)", cmd, (long) timeout);
timeout1143drivers/char/tpqic02.cif (timeout == TIM_R)
timeout1144drivers/char/tpqic02.cstat = wait_for_rewind(timeout);
timeout1146drivers/char/tpqic02.cstat = wait_for_ready(timeout);
timeout1152drivers/char/tpqic02.cprintk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[2](%x, %ld)\n", cmd, (long) timeout);
timeout1259drivers/char/tpqic02.cstatic int do_qic_cmd(int cmd, time_t timeout)
timeout1278drivers/char/tpqic02.creturn ll_do_qic_cmd(cmd, timeout);
timeout43drivers/char/tty_ioctl.cvoid tty_wait_until_sent(struct tty_struct * tty, int timeout)
timeout55drivers/char/tty_ioctl.cif (timeout)
timeout56drivers/char/tty_ioctl.ccurrent->timeout = timeout + jiffies;
timeout58drivers/char/tty_ioctl.ccurrent->timeout = (unsigned) -1;
timeout69drivers/char/tty_ioctl.c} while (current->timeout);
timeout736drivers/isdn/icn/icn.ccurrent->timeout = jiffies + ICN_BOOT_TIMEOUT1;
timeout763drivers/isdn/icn/icn.ccurrent->timeout = jiffies + HZ; \
timeout904drivers/isdn/icn/icn.ccurrent->timeout = jiffies + 10;
timeout927drivers/isdn/icn/icn.ccurrent->timeout = jiffies + ICN_BOOT_TIMEOUT1;
timeout1023drivers/isdn/icn/icn.ccurrent->timeout = jiffies + 10;
timeout1150drivers/isdn/icn/icn.ccurrent->timeout = jiffies + ICN_BOOT_TIMEOUT1;
timeout1153drivers/isdn/icn/icn.ccurrent->timeout = jiffies + ICN_BOOT_TIMEOUT1;
timeout962drivers/isdn/isdn_tty.culong timeout;
timeout1025drivers/isdn/isdn_tty.ctimeout = jiffies + HZ;
timeout1029drivers/isdn/isdn_tty.ccurrent->timeout = jiffies + 20;
timeout1031drivers/isdn/isdn_tty.cif (jiffies > timeout)
timeout1055drivers/isdn/isdn_tty.ccurrent->timeout = jiffies + info->close_delay;
timeout320drivers/isdn/pcbit/edss1.cchan->fsm_timer.expires = jiffies + tentry->timeout * HZ;
timeout92drivers/isdn/pcbit/edss1.hunsigned long timeout;          /* in seconds */
timeout308drivers/net/3c505.cint timeout = jiffies + 10;
timeout312drivers/net/3c505.c} while (stat1 != inb_status(base_addr) && jiffies < timeout);
timeout313drivers/net/3c505.cif (jiffies >= timeout)
timeout329drivers/net/3c505.cint timeout;
timeout339drivers/net/3c505.ctimeout = jiffies + 2;
timeout340drivers/net/3c505.cwhile ((jiffies <= timeout) && !(inb_status(dev->base_addr) & ACRF));
timeout345drivers/net/3c505.ctimeout = jiffies + 1;
timeout346drivers/net/3c505.cwhile (jiffies <= timeout);
timeout348drivers/net/3c505.ctimeout = jiffies + 1;
timeout349drivers/net/3c505.cwhile (jiffies <= timeout);
timeout351drivers/net/3c505.ctimeout = jiffies + 1;
timeout352drivers/net/3c505.cwhile (jiffies <= timeout);
timeout354drivers/net/3c505.ctimeout = jiffies + 1;
timeout355drivers/net/3c505.cwhile (jiffies <= timeout);
timeout387drivers/net/3c505.cunsigned int timeout;
timeout389drivers/net/3c505.cfor (timeout = jiffies + 5; jiffies < timeout;) {
timeout399drivers/net/3c505.cunsigned int timeout;
timeout401drivers/net/3c505.cfor (timeout = 0; timeout < 40000; timeout++) {
timeout446drivers/net/3c505.cint timeout;
timeout487drivers/net/3c505.cfor (timeout = jiffies + 5; jiffies < timeout;) {
timeout530drivers/net/3c505.cint timeout;
timeout537drivers/net/3c505.ctimeout = jiffies + 2;
timeout538drivers/net/3c505.cwhile (((stat = get_status(dev->base_addr)) & ACRF) == 0 && jiffies < timeout);
timeout539drivers/net/3c505.cif (jiffies >= timeout) {
timeout546drivers/net/3c505.ctimeout = jiffies + 3;
timeout547drivers/net/3c505.cwhile (((stat = get_status(dev->base_addr)) & ACRF) == 0 && jiffies < timeout);
timeout548drivers/net/3c505.cif (jiffies >= timeout) {
timeout621drivers/net/3c505.ctx_pcb->data.rcv_pkt.timeout = 0;  /* set timeout to zero */
timeout701drivers/net/3c505.cint timeout;
timeout767drivers/net/3c505.ctimeout = jiffies + 3;
timeout768drivers/net/3c505.cwhile ((inb_status(dev->base_addr) & ACRF) != 0 && jiffies < timeout) {
timeout784drivers/net/3c505.cif (adapter->irx_pcb.data.rcv_resp.timeout != 0) {
timeout1010drivers/net/3c505.cint timeout = jiffies + TIMEOUT;
timeout1011drivers/net/3c505.cwhile (adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] == 0 && jiffies < timeout);
timeout1012drivers/net/3c505.cif (jiffies >= timeout)
timeout1029drivers/net/3c505.cint timeout = jiffies + TIMEOUT;
timeout1030drivers/net/3c505.cwhile (adapter->got[CMD_CONFIGURE_82586] == 0 && jiffies < timeout);
timeout1031drivers/net/3c505.cif (jiffies >= timeout)
timeout1215drivers/net/3c505.cint timeout = jiffies + TIMEOUT;
timeout1216drivers/net/3c505.cwhile (adapter->got[CMD_NETWORK_STATISTICS] == 0 && jiffies < timeout);
timeout1217drivers/net/3c505.cif (jiffies >= timeout) {
timeout1313drivers/net/3c505.cint timeout = jiffies + TIMEOUT;
timeout1314drivers/net/3c505.cwhile (adapter->got[CMD_LOAD_MULTICAST_LIST] == 0 && jiffies < timeout);
timeout1315drivers/net/3c505.cif (jiffies >= timeout) {
timeout1337drivers/net/3c505.cint timeout = jiffies + TIMEOUT;
timeout1338drivers/net/3c505.cwhile (adapter->got[CMD_CONFIGURE_82586] == 0 && jiffies < timeout);
timeout1339drivers/net/3c505.cif (jiffies >= timeout)
timeout1385drivers/net/3c505.cint timeout;
timeout1416drivers/net/3c505.ctimeout = jiffies + 30;
timeout1417drivers/net/3c505.cwhile (jiffies < timeout);
timeout1428drivers/net/3c505.ctimeout = jiffies + 30;
timeout1429drivers/net/3c505.cwhile (jiffies < timeout);
timeout1501drivers/net/3c505.cint i, tries, tries1, timeout, okay;
timeout1525drivers/net/3c505.ctimeout = jiffies + 5;
timeout1527drivers/net/3c505.cwhile (jiffies < timeout && !(inb_status(dev->base_addr) & HCRE));
timeout1530drivers/net/3c505.ctimeout = jiffies + 5;
timeout1531drivers/net/3c505.cwhile (jiffies < timeout && !(inb_status(dev->base_addr) & HCRE));
timeout1545drivers/net/3c505.ctimeout = jiffies + 10 * HZ;
timeout1546drivers/net/3c505.cwhile (jiffies < timeout && (inb_status(dev->base_addr) & 7));
timeout149drivers/net/3c505.htimeout;
timeout163drivers/net/3c505.htimeout,
timeout64drivers/net/auto_irq.cint timeout = jiffies + waittime;
timeout79drivers/net/auto_irq.cwhile (timeout > jiffies  &&  --boguscount > 0)
timeout97drivers/net/auto_irq.cint timeout = jiffies+waittime;
timeout102drivers/net/auto_irq.cwhile (timeout > jiffies  &&  --boguscount > 0)
timeout508drivers/net/de4x5.cint  timeout;                           /* Scheduling counter           */
timeout582drivers/net/de4x5.cstatic int     de4x5_suspect_state(struct device *dev, int timeout, int prev_state, int (*fn)(struct device *, int), int (*asfn)(struct device *));
timeout583drivers/net/de4x5.cstatic int     dc21040_state(struct device *dev, int csr13, int csr14, int csr15, int timeout, int next_state, int suspect_state, int (*fn)(struct device *, int));
timeout641drivers/net/de4x5.cstatic void    timeout(struct device *dev, void (*fn)(u_long data), u_long data, u_long msec);
timeout1865drivers/net/de4x5.clp->timeout = -1;
timeout1929drivers/net/de4x5.cdc21040_state(struct device *dev, int csr13, int csr14, int csr15, int timeout,
timeout1946drivers/net/de4x5.clinkBad = fn(dev, timeout);
timeout1968drivers/net/de4x5.cde4x5_suspect_state(struct device *dev, int timeout, int prev_state,
timeout1987drivers/net/de4x5.clinkBad = fn(dev, timeout);
timeout2022drivers/net/de4x5.clp->timeout = -1;
timeout2040drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2087drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2121drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2152drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2228drivers/net/de4x5.clp->timeout = -1;
timeout2260drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2306drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2398drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2418drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2419drivers/net/de4x5.clp->timeout = msec/100;
timeout2438drivers/net/de4x5.cif (!(sts & irqs) && --lp->timeout) {
timeout2441drivers/net/de4x5.clp->timeout = -1;
timeout2454drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2455drivers/net/de4x5.clp->timeout = msec/100;
timeout2460drivers/net/de4x5.cif (sisr && --lp->timeout) {
timeout2463drivers/net/de4x5.clp->timeout = -1;
timeout2476drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2477drivers/net/de4x5.clp->timeout = msec/100;
timeout2485drivers/net/de4x5.cif (!(gep & GEP_SLNK) && --lp->timeout) {
timeout2488drivers/net/de4x5.clp->timeout = -1;
timeout2504drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2505drivers/net/de4x5.clp->timeout = msec/100;
timeout2512drivers/net/de4x5.cif (test && --lp->timeout) {
timeout2515drivers/net/de4x5.clp->timeout = -1;
timeout2593drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2594drivers/net/de4x5.clp->timeout = msec/100;
timeout2604drivers/net/de4x5.cif ((!(sisr & SISR_NCR)) && (lp->tx_ring[lp->tmp].status < 0) && (--lp->timeout)) {
timeout2608drivers/net/de4x5.c!(lp->tx_ring[lp->tmp].status & (T_OWN | TD_ES)) && lp->timeout) {
timeout2613drivers/net/de4x5.clp->timeout = -1;
timeout2851drivers/net/de4x5.cif (lp->timeout < 0) {
timeout2852drivers/net/de4x5.clp->timeout = msec/100;
timeout2863drivers/net/de4x5.cif (!(sts & irqs) && (ans ^ ANS_NWOK) && --lp->timeout) {
timeout2866drivers/net/de4x5.clp->timeout = -1;
timeout3503drivers/net/de4x5.ctimeout(dev, (void *)&de4x5_ast, (u_long)dev, time_out);
timeout1715drivers/net/ppp.ccurrent->timeout = 0;
timeout1754drivers/net/ppp.ccurrent->timeout = 0;
timeout2101drivers/net/ppp.ccurrent->timeout = 0;
timeout800drivers/net/smc9194.cint  timeout = 20;
timeout830drivers/net/smc9194.cwhile ( timeout ) {
timeout837drivers/net/smc9194.ctimeout--;
timeout1291drivers/net/smc9194.cint  timeout;
timeout1325drivers/net/smc9194.ctimeout = 4;
timeout1397drivers/net/smc9194.c} while ( timeout -- ); 
timeout1274drivers/sbus/char/sunkbd.cint timeout = 0;
timeout1279drivers/sbus/char/sunkbd.cwhile((sunkbd_type==255) && timeout < 500000) {
timeout1281drivers/sbus/char/sunkbd.ctimeout += 20;
timeout1284drivers/sbus/char/sunkbd.cif(timeout>=500000) {
timeout1293drivers/sbus/char/sunkbd.ctimeout=0;
timeout1294drivers/sbus/char/sunkbd.cwhile(timeout++ < 500000)
timeout1326drivers/sbus/char/sunserial.ccurrent->timeout = jiffies + duration;
timeout1528drivers/sbus/char/sunserial.ccurrent->timeout = jiffies + info->close_delay;
timeout141drivers/sbus/char/sunserial.hint      timeout;
timeout1832drivers/scsi/53c7,8xx.cunsigned long timeout;
timeout1874drivers/scsi/53c7,8xx.ctimeout = jiffies + 5 * HZ / 10;
timeout1875drivers/scsi/53c7,8xx.cwhile ((hostdata->test_completed == -1) && jiffies < timeout)
timeout1958drivers/scsi/53c7,8xx.ctimeout = jiffies + 5 * HZ;  /* arbitrary */
timeout1959drivers/scsi/53c7,8xx.cwhile ((hostdata->test_completed == -1) && jiffies < timeout)
timeout637drivers/scsi/NCR5380.cunsigned long timeout;
timeout646drivers/scsi/NCR5380.ctimeout = jiffies + 25;
timeout665drivers/scsi/NCR5380.cwhile (probe_irq == IRQ_NONE && jiffies < timeout)
timeout906drivers/scsi/NCR5380.cunsigned long timeout;
timeout1005drivers/scsi/NCR5380.ctimeout = jiffies + 500;
timeout1006drivers/scsi/NCR5380.cwhile (jiffies < timeout && (NCR5380_read(STATUS_REG) & SR_BSY));
timeout1363drivers/scsi/NCR5380.cunsigned long timeout = jiffies + NCR_TIMEOUT;
timeout1366drivers/scsi/NCR5380.c&& jiffies < timeout)
timeout1368drivers/scsi/NCR5380.cif (jiffies >= timeout)
timeout1459drivers/scsi/NCR5380.cunsigned long timeout;
timeout1490drivers/scsi/NCR5380.cunsigned long timeout = jiffies + 2*NCR_TIMEOUT;
timeout1493drivers/scsi/NCR5380.c&& jiffies < timeout)
timeout1495drivers/scsi/NCR5380.cif (jiffies >= timeout)
timeout1621drivers/scsi/NCR5380.ctimeout = jiffies + 25; 
timeout1629drivers/scsi/NCR5380.cwhile ((jiffies < timeout) && !(NCR5380_read(STATUS_REG) & 
timeout1698drivers/scsi/NCR5380.cunsigned long timeout = jiffies + NCR_TIMEOUT;
timeout1700drivers/scsi/NCR5380.cwhile (!(NCR5380_read(STATUS_REG) & SR_REQ) && jiffies < timeout);
timeout1702drivers/scsi/NCR5380.cif (jiffies >= timeout) {
timeout2244drivers/scsi/NCR5380.cint timeout;
timeout2254drivers/scsi/NCR5380.ctimeout = 20000;
timeout2262drivers/scsi/NCR5380.cfor (; timeout && 
timeout2264drivers/scsi/NCR5380.c--timeout);
timeout2265drivers/scsi/NCR5380.cfor (; timeout && (NCR5380_read(STATUS_REG) & SR_REQ);
timeout2266drivers/scsi/NCR5380.c--timeout);
timeout2272drivers/scsi/NCR5380.cif (!timeout) 
timeout3396drivers/scsi/advansys.cscp->timeout += 2000;  /* Add 5 seconds to the request timeout. */
timeout3992drivers/scsi/advansys.cscp->timeout += 2000;  /* Add 5 seconds to the request timeout. */
timeout137drivers/scsi/aha1542.c#define WAITd(port, mask, allof, noneof, timeout)      \
timeout139drivers/scsi/aha1542.cregister WAITtimeout = timeout;          \
timeout2885drivers/scsi/aic7xxx.cunsigned long timeout;
timeout2909drivers/scsi/aic7xxx.ctimeout = jiffies + 100;  /* 1 second timeout */
timeout2910drivers/scsi/aic7xxx.cwhile ((jiffies < timeout) && ((inb(SEECTL + base) & SEERDY) == 0))
timeout990drivers/scsi/atari_NCR5380.cextern int scsi_update_timeout(Scsi_Cmnd * SCset, int timeout);
timeout1510drivers/scsi/atari_NCR5380.cunsigned long timeout;
timeout1546drivers/scsi/atari_NCR5380.cunsigned long timeout = jiffies + 2*NCR_TIMEOUT;
timeout1549drivers/scsi/atari_NCR5380.c&& jiffies < timeout && !hostdata->connected)
timeout1551drivers/scsi/atari_NCR5380.cif (jiffies >= timeout)
timeout1701drivers/scsi/atari_NCR5380.ctimeout = jiffies + 25; 
timeout1717drivers/scsi/atari_NCR5380.cwhile ((jiffies < timeout) && !(NCR5380_read(STATUS_REG) & 
timeout1729drivers/scsi/atari_NCR5380.cwhile ((jiffies < timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY));
timeout312drivers/scsi/eata_generic.h__u32 timeout;
timeout1188drivers/scsi/fdomain.cunsigned long timeout;
timeout1198drivers/scsi/fdomain.ctimeout = jiffies + 50;          /* 500 mS */
timeout1199drivers/scsi/fdomain.cwhile (jiffies < timeout) {
timeout1221drivers/scsi/fdomain.cunsigned long timeout;
timeout1231drivers/scsi/fdomain.ctimeout = jiffies + 35;    /* 350mS -- because of timeouts
timeout1234drivers/scsi/fdomain.cwhile (jiffies < timeout) {
timeout1810drivers/scsi/fdomain.cSCpnt->timeout );
timeout1736drivers/scsi/in2000.cunsigned long timeout;
timeout1795drivers/scsi/in2000.ctimeout = 1000000;
timeout1800drivers/scsi/in2000.c} while (!(asr & ASR_INT) && timeout-- > 0);
timeout1803drivers/scsi/in2000.casr, sr, read_3393_count(hostdata), timeout);
timeout1814drivers/scsi/in2000.ctimeout = 1000000;
timeout1816drivers/scsi/in2000.cwhile ((asr & ASR_CIP) && timeout-- > 0)
timeout1298drivers/scsi/scsi.cint timeout, int retries)
timeout1311drivers/scsi/scsi.cbufflen, done, timeout, retries);
timeout1369drivers/scsi/scsi.cSCpnt->timeout_per_command = timeout;
timeout2209drivers/scsi/scsi.cif (SCpnt->timeout == -1)
timeout2211drivers/scsi/scsi.cSCpnt->timeout = 0;
timeout2240drivers/scsi/scsi.cstatic int update_timeout(Scsi_Cmnd * SCset, int timeout)
timeout2265drivers/scsi/scsi.coldto = SCset->timeout;
timeout2266drivers/scsi/scsi.cSCset->timeout = timeout;
timeout2287drivers/scsi/scsi.coldto = SCset->timeout - used;
timeout2288drivers/scsi/scsi.cSCset->timeout = timeout;
timeout2295drivers/scsi/scsi.cif (SCpnt->timeout > 0) {
timeout2297drivers/scsi/scsi.cSCpnt->timeout -= used;
timeout2298drivers/scsi/scsi.cif(SCpnt->timeout <= 0) SCpnt->timeout = -1;
timeout2299drivers/scsi/scsi.cif(SCpnt->timeout > 0 && SCpnt->timeout < least)
timeout2300drivers/scsi/scsi.cleast = SCpnt->timeout;
timeout2462drivers/scsi/scsi.cSCpnt->timeout = 0;
timeout3345drivers/scsi/scsi.cSCpnt->timeout,
timeout416drivers/scsi/scsi.hint timeout_per_command, timeout_total, timeout;
timeout468drivers/scsi/scsi.hint timeout, int retries);
timeout119drivers/scsi/scsi_debug.cstatic volatile unsigned int timeout[8] ={0,};
timeout435drivers/scsi/scsi_debug.ctimeout[i] = jiffies+DISK_SPEED;
timeout439drivers/scsi/scsi_debug.ctimer_table[SCSI_DEBUG_TIMER].expires = timeout[i];
timeout447drivers/scsi/scsi_debug.cprintk("Sending command (%d %x %d %d)...", i, done, timeout[i],jiffies);
timeout494drivers/scsi/scsi_debug.cif (timeout[i] == 0) continue;
timeout495drivers/scsi/scsi_debug.cif (timeout[i] <= jiffies) break;
timeout506drivers/scsi/scsi_debug.cif (timeout[i] == 0) continue;
timeout507drivers/scsi/scsi_debug.cif (timeout[i] <= jiffies) {restore_flags(flags); goto repeat;};
timeout508drivers/scsi/scsi_debug.cif (timeout[i] > jiffies) {
timeout509drivers/scsi/scsi_debug.cif (pending > timeout[i]) pending = timeout[i];
timeout524drivers/scsi/scsi_debug.ctimeout[i] = 0;
timeout527drivers/scsi/scsi_debug.cto = timeout[i];
timeout528drivers/scsi/scsi_debug.ctimeout[i] = 0;
timeout578drivers/scsi/scsi_debug.ctimeout[j] = 0;
timeout615drivers/scsi/scsi_debug.ctimeout[i] = 0;
timeout54drivers/scsi/sg.cint timeout; /* current default value for device */
timeout79drivers/scsi/sg.cscsi_generics[dev].timeout=get_user((int *) arg);
timeout82drivers/scsi/sg.creturn scsi_generics[dev].timeout;
timeout142drivers/scsi/sg.cscsi_generics[dev].timeout=SG_DEFAULT_TIMEOUT;
timeout450drivers/scsi/sg.csg_command_done,device->timeout,SG_DEFAULT_RETRIES);
timeout579drivers/scsi/sg.cscsi_generics[i].timeout=SG_DEFAULT_TIMEOUT;
timeout244drivers/scsi/st.cint timeout, int retries)
timeout259drivers/scsi/st.cst_sleep_done, timeout, retries);
timeout1677drivers/scsi/st.cint timeout = ST_LONG_TIMEOUT;
timeout1818drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout1838drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout1854drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout1856drivers/scsi/st.ctimeout = ST_LONG_TIMEOUT * 8;
timeout1879drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout1918drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout1920drivers/scsi/st.ctimeout = ST_LONG_TIMEOUT * 8;
timeout1986drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout2007drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, datalen, timeout, MAX_RETRIES);
timeout2208drivers/scsi/st.cint timeout = ST_LONG_TIMEOUT;
timeout2271drivers/scsi/st.ctimeout = ST_TIMEOUT;
timeout2274drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, scmd, 20, timeout, MAX_READY_RETRIES);
timeout1408drivers/scsi/wd33c93.cunsigned long timeout;
timeout1426drivers/scsi/wd33c93.ctimeout = 1000000;
timeout1431drivers/scsi/wd33c93.c} while (!(asr & ASR_INT) && timeout-- > 0);
timeout1434drivers/scsi/wd33c93.casr, sr, read_wd33c93_count(regp), timeout);
timeout1445drivers/scsi/wd33c93.ctimeout = 1000000;
timeout1447drivers/scsi/wd33c93.cwhile ((asr & ASR_CIP) && timeout-- > 0)
timeout610drivers/scsi/wd7000.cregister unsigned long timeout = jiffies + WAITnexttimeout;
timeout627drivers/scsi/wd7000.ctimeout = jiffies + WAITnexttimeout;
timeout632drivers/scsi/wd7000.c}  while (freescbs < needed && jiffies <= timeout);
timeout965drivers/scsi/wd7000.cunsigned long timeout;
timeout977drivers/scsi/wd7000.ctimeout = jiffies + WAITnexttimeout;  /* wait up to 2 seconds */
timeout978drivers/scsi/wd7000.cwhile (icb.phase && jiffies < timeout)
timeout138drivers/sound/ad1848.cint             timeout = 900000;
timeout140drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
timeout141drivers/sound/ad1848.ctimeout--;
timeout157drivers/sound/ad1848.cint             timeout = 900000;
timeout159drivers/sound/ad1848.cwhile (timeout > 0 &&
timeout161drivers/sound/ad1848.ctimeout--;
timeout174drivers/sound/ad1848.cint             timeout = 0;
timeout183drivers/sound/ad1848.ctimeout = 100000;
timeout184drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
timeout185drivers/sound/ad1848.ctimeout--;
timeout189drivers/sound/ad1848.ctimeout = 100;
timeout190drivers/sound/ad1848.cwhile (timeout > 0 && !(ad_read (devc, 11) & 0x20))
timeout191drivers/sound/ad1848.ctimeout--;
timeout195drivers/sound/ad1848.ctimeout = 80000;
timeout196drivers/sound/ad1848.cwhile (timeout > 0 && ad_read (devc, 11) & 0x20)
timeout197drivers/sound/ad1848.ctimeout--;
timeout238drivers/sound/ad1848.cint             timeout = 1000;
timeout241drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
timeout242drivers/sound/ad1848.ctimeout--;
timeout264drivers/sound/ad1848.cint             timeout = 1000;
timeout266drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
timeout267drivers/sound/ad1848.ctimeout--;
timeout952drivers/sound/ad1848.cint             timeout;
timeout997drivers/sound/ad1848.ctimeout = 10000;
timeout998drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
timeout999drivers/sound/ad1848.ctimeout--;
timeout1011drivers/sound/ad1848.ctimeout = 10000;
timeout1012drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
timeout1013drivers/sound/ad1848.ctimeout--;
timeout605drivers/sound/dmasound.ccurrent->timeout = jiffies+(time_limit); \
timeout273drivers/sound/gus_midi.cint             timeout = 10;
timeout278drivers/sound/gus_midi.cwhile (timeout-- > 0 && (stat = GUS_MIDI_STATUS ()) & (MIDI_RCV_FULL | MIDI_XMIT_EMPTY))
timeout116drivers/sound/midi_synth.cint             timeout;
timeout118drivers/sound/midi_synth.cfor (timeout = 0; timeout < 32000; timeout++)
timeout260drivers/sound/midi_synth.cint             timeout = 0;
timeout268drivers/sound/midi_synth.ctimeout < 1000)
timeout269drivers/sound/midi_synth.ctimeout++;
timeout750drivers/sound/midi_synth.cint             timeout = 0;
timeout756drivers/sound/midi_synth.ctimeout < 1000)
timeout757drivers/sound/midi_synth.ctimeout++;
timeout584drivers/sound/mpu401.cint             timeout;
timeout596drivers/sound/mpu401.cfor (timeout = 30000; timeout > 0 && !output_ready (devc); timeout--);
timeout615drivers/sound/mpu401.cint             i, timeout, ok;
timeout641drivers/sound/mpu401.ctimeout = 50000;
timeout643drivers/sound/mpu401.cif (timeout-- <= 0)
timeout661drivers/sound/mpu401.cfor (timeout = 50000; timeout > 0 && !ok; timeout--)
timeout686drivers/sound/mpu401.cfor (timeout = 3000; timeout > 0 && !output_ready (devc); timeout--);
timeout703drivers/sound/mpu401.cfor (timeout = 5000; timeout > 0 && !ok; timeout--)
timeout1209drivers/sound/mpu401.cint             ok, timeout, n;
timeout1224drivers/sound/mpu401.cfor (timeout = timeout_limit; timeout > 0 && !ok; timeout--)
timeout1236drivers/sound/mpu401.cfor (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--)
timeout378drivers/sound/pss.cint             timeout;
timeout418drivers/sound/pss.cfor (timeout = 900000; timeout > 0; timeout--)
timeout800drivers/sound/pss.cint             timeout;
timeout835drivers/sound/pss.cfor (timeout = 0;
timeout836drivers/sound/pss.ctimeout < 100000 && (inb (hw_config->io_base + 3) & 0x3f) != 0x04;
timeout837drivers/sound/pss.ctimeout++);
timeout146drivers/sound/sb16_midi.cint             timeout;
timeout166drivers/sound/sb16_midi.cfor (timeout = 30000; timeout > 0 && !output_ready (); timeout--);  /*
timeout235drivers/sound/sb16_midi.cint             ok, timeout;
timeout240drivers/sound/sb16_midi.cfor (timeout = 30000; timeout < 0 && !output_ready (); timeout--);
timeout246drivers/sound/sb16_midi.cfor (timeout = 50000; timeout > 0 && !ok; timeout--)
timeout283drivers/sound/sb16_midi.cint             ok, timeout, n;
timeout295drivers/sound/sb16_midi.cfor (timeout = 30000; timeout < 0 && !output_ready (); timeout--);  /*
timeout308drivers/sound/sb16_midi.cfor (timeout = 50000; timeout > 0 && !ok; timeout--)
timeout186drivers/sound/uart6850.cint             timeout;
timeout206drivers/sound/uart6850.cfor (timeout = 30000; timeout > 0 && !output_ready (); timeout--);  /*
timeout281drivers/sound/uart6850.cint             ok, timeout;
timeout300drivers/sound/uart6850.cfor (timeout = 30000; timeout < 0 && !output_ready (); timeout--);  /*
timeout330fs/ncpfs/sock.cint timeout;
timeout374fs/ncpfs/sock.cfor (n = 0, timeout = init_timeout; ; n++, timeout <<= 1)
timeout408fs/ncpfs/sock.cif (timeout > max_timeout)
timeout418fs/ncpfs/sock.ctimeout = max_timeout;
timeout420fs/ncpfs/sock.ccurrent->timeout = jiffies + timeout;
timeout426fs/ncpfs/sock.ccurrent->timeout = 0;
timeout430fs/ncpfs/sock.cif (!current->timeout)
timeout442fs/ncpfs/sock.ctimeout = init_timeout;
timeout453fs/ncpfs/sock.ccurrent->timeout = 0;
timeout493fs/ncpfs/sock.ctimeout = max_timeout;
timeout874fs/nfs/nfsroot.cunsigned long timeout, jiff;
timeout938fs/nfs/nfsroot.cget_random_bytes(&timeout, sizeof(timeout));
timeout939fs/nfs/nfsroot.ctimeout = CONF_BASE_TIMEOUT + (timeout % (unsigned) CONF_TIMEOUT_RANDOM);
timeout955fs/nfs/nfsroot.cjiff = jiffies + timeout;
timeout968fs/nfs/nfsroot.ctimeout = timeout CONF_TIMEOUT_MULT;
timeout969fs/nfs/nfsroot.cif (timeout > CONF_TIMEOUT_MAX)
timeout970fs/nfs/nfsroot.ctimeout = CONF_TIMEOUT_MAX;
timeout49fs/nfs/rpcsock.c#define msleep(sec)  { current->timeout = sec * HZ / 1000; \
timeout178fs/nfs/rpcsock.cif (current->timeout == 0)
timeout200fs/nfs/rpcsock.ccurrent->timeout = 0;
timeout205fs/nfs/rpcsock.cif (current->timeout == 0)
timeout261fs/nfs/rpcsock.crpc_cwnd_adjust(struct rpc_sock *rsock, int timeout)
timeout265fs/nfs/rpcsock.cif (!timeout) {
timeout421fs/nfs/rpcsock.cif (current->timeout == 0)
timeout434fs/nfs/rpcsock.c} while (current->timeout && !slot->w_gotit);
timeout451fs/nfs/rpcsock.cunsigned long  timeout;
timeout453fs/nfs/rpcsock.ctimeout = strategy->to_initval;
timeout459fs/nfs/rpcsock.ccurrent->timeout = jiffies + timeout;
timeout496fs/nfs/rpcsock.ctimeout <<= 1;
timeout498fs/nfs/rpcsock.ctimeout += strategy->to_increment;
timeout499fs/nfs/rpcsock.cif (strategy->to_maxval && timeout >= strategy->to_maxval)
timeout500fs/nfs/rpcsock.ctimeout = strategy->to_maxval;
timeout506fs/nfs/rpcsock.ccurrent->timeout = 0;
timeout67fs/nfs/sock.cstruct rpc_timeout  timeout;
timeout72fs/nfs/sock.ctimeout.to_initval = server->timeo;
timeout73fs/nfs/sock.ctimeout.to_maxval = NFS_MAX_RPC_TIMEOUT*HZ/10;
timeout74fs/nfs/sock.ctimeout.to_retries = server->retrans;
timeout75fs/nfs/sock.ctimeout.to_exponential = 1;
timeout87fs/nfs/sock.cmaxtimeo = timeout.to_maxval;
timeout90fs/nfs/sock.cresult = rpc_doio(server->rsock, req, &timeout, async);
timeout109fs/nfs/sock.cif ((timeout.to_initval <<= 1) >= maxtimeo) {
timeout110fs/nfs/sock.ctimeout.to_initval = maxtimeo;
timeout715fs/proc/array.ctsk->timeout,
timeout143fs/select.cif (!count && current->timeout && !(current->signal & ~current->blocked)) {
timeout216fs/select.cunsigned long timeout;
timeout225fs/select.ctimeout = ~0UL;
timeout230fs/select.ctimeout = ROUND_UP(get_user(&tvp->tv_usec),(1000000/HZ));
timeout231fs/select.ctimeout += get_user(&tvp->tv_sec) * (unsigned long) HZ;
timeout232fs/select.cif (timeout)
timeout233fs/select.ctimeout += jiffies + 1;
timeout235fs/select.ccurrent->timeout = timeout;
timeout237fs/select.ctimeout = current->timeout - jiffies - 1;
timeout238fs/select.ccurrent->timeout = 0;
timeout239fs/select.cif ((long) timeout < 0)
timeout240fs/select.ctimeout = 0;
timeout242fs/select.cput_user(timeout/HZ, &tvp->tv_sec);
timeout243fs/select.ctimeout %= HZ;
timeout244fs/select.ctimeout *= (1000000/HZ);
timeout245fs/select.cput_user(timeout, &tvp->tv_usec);
timeout199include/asm-m68k/serial.hint      timeout;
timeout25include/asm-sparc/irq.hextern void (*load_profile_irq)( unsigned int timeout );
timeout29include/asm-sparc/irq.hunsigned int timeout);
timeout71include/linux/cyclades.hint      timeout;
timeout138include/linux/fd.hunsigned long timeout;    /* timeout for interrupt requests */
timeout34include/linux/netrom.hunsigned int timeout;
timeout215include/linux/sched.hunsigned long timeout, policy, rt_priority;
timeout313include/linux/sdla.hshort timeout  __attribute__((packed));
timeout142include/linux/serial.hint      timeout;
timeout300include/linux/tty.hextern void tty_wait_until_sent(struct tty_struct * tty, int timeout);
timeout12include/linux/wrapper.h#define current_set_timeout(val) current->timeout = val
timeout123include/linux/xd.hstatic inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout);
timeout124include/linux/xd.hstatic u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout);
timeout307include/net/sock.hint      timeout;  /* What are we waiting for? */
timeout336include/net/sock.hvoid      (*close)(struct sock *sk, unsigned long timeout);
timeout158include/net/tcp.hextern void tcp_send_delayed_ack(struct sock *sk, int timeout);
timeout106kernel/itimer.cunsigned long timeout = jiffies + interval;
timeout108kernel/itimer.cif (timeout < interval)
timeout109kernel/itimer.ctimeout = ULONG_MAX;
timeout110kernel/itimer.cp->real_timer.expires = timeout;
timeout218kernel/sched.cp->timeout = 0;
timeout298kernel/sched.cunsigned long timeout = 0;
timeout326kernel/sched.ctimeout = prev->timeout;
timeout327kernel/sched.cif (timeout && (timeout <= jiffies)) {
timeout328kernel/sched.cprev->timeout = 0;
timeout329kernel/sched.ctimeout = 0;
timeout390kernel/sched.cif (timeout) {
timeout392kernel/sched.ctimer.expires = timeout;
timeout399kernel/sched.cif (timeout)
timeout1338kernel/sched.ccurrent->timeout = expire;
timeout432net/appletalk/ddp.ccurrent->timeout = jiffies + (HZ/10);
timeout753net/ipv4/af_inet.cunsigned long timeout;
timeout775net/ipv4/af_inet.ctimeout = 0;
timeout777net/ipv4/af_inet.ctimeout = ~0UL;
timeout779net/ipv4/af_inet.ctimeout = jiffies + HZ*sk->lingertime;
timeout782net/ipv4/af_inet.ctimeout = 0;
timeout787net/ipv4/af_inet.csk->prot->close(sk, timeout);
timeout297net/ipv4/icmp.cunsigned long timeout;    /* Time quantum for rate measuring */
timeout405net/ipv4/icmp.cc->next_reset = now + r->timeout;
timeout427net/ipv4/icmp.cc->next_reset = now + r->timeout;
timeout434net/ipv4/ip_masq.cunsigned long   timeout;
timeout505net/ipv4/ip_masq.ctimeout = ip_masq_expire->udp_timeout;
timeout519net/ipv4/ip_masq.ctimeout = 1;
timeout524net/ipv4/ip_masq.ctimeout = ip_masq_expire->tcp_fin_timeout;
timeout527net/ipv4/ip_masq.celse timeout = ip_masq_expire->tcp_timeout;
timeout532net/ipv4/ip_masq.cip_masq_set_expire(ms, timeout);
timeout216net/ipv4/packet.cstatic void packet_close(struct sock *sk, unsigned long timeout)
timeout129net/ipv4/proc.ctimer_active?sp->timeout:0,
timeout310net/ipv4/raw.cstatic void raw_close(struct sock *sk, unsigned long timeout)
timeout437net/ipv4/tcp.cstatic void tcp_close(struct sock *sk, unsigned long timeout);
timeout1689net/ipv4/tcp.cstatic void tcp_close(struct sock *sk, unsigned long timeout)
timeout1743net/ipv4/tcp.cif (timeout) {
timeout1746net/ipv4/tcp.ccurrent->timeout = timeout;
timeout1747net/ipv4/tcp.cwhile(closing(sk) && current->timeout)
timeout1755net/ipv4/tcp.ccurrent->timeout=0;
timeout430net/ipv4/tcp_input.cnewsk->timeout = 0;
timeout827net/ipv4/tcp_output.cunsigned long timeout, now;
timeout831net/ipv4/tcp_output.ctimeout = sk->ato;
timeout832net/ipv4/tcp_output.cif (timeout > max_timeout)
timeout833net/ipv4/tcp_output.ctimeout = max_timeout;
timeout834net/ipv4/tcp_output.ctimeout += now;
timeout836net/ipv4/tcp_output.ctimeout = now;
timeout841net/ipv4/tcp_output.cif (!del_timer(&sk->delack_timer) || timeout < sk->delack_timer.expires)
timeout842net/ipv4/tcp_output.csk->delack_timer.expires = timeout;
timeout60net/ipv4/timer.ct->timeout = 0;
timeout66net/ipv4/timer.cvoid reset_timer (struct sock *t, int timeout, unsigned long len)
timeout69net/ipv4/timer.ct->timeout = timeout;
timeout89net/ipv4/timer.cint why = sk->timeout;
timeout574net/ipv4/udp.cstatic void udp_close(struct sock *sk, unsigned long timeout)
timeout546net/netrom/af_netrom.cnr->rtt      = nr_default.timeout / 2;
timeout547net/netrom/af_netrom.cnr->t1       = nr_default.timeout;
timeout954net/netrom/af_netrom.cunsigned short frametype, window, timeout;
timeout1034net/netrom/af_netrom.ctimeout = skb->data[36] * 256 + skb->data[35];
timeout1035net/netrom/af_netrom.cif (timeout * PR_SLOWHZ < make->nr->rtt * 2)
timeout1036net/netrom/af_netrom.cmake->nr->rtt = (timeout * PR_SLOWHZ) / 2;
timeout1414net/netrom/af_netrom.cnr_default.timeout    = NR_DEFAULT_T1;
timeout155net/netrom/nr_subr.cint len, timeout;
timeout188net/netrom/nr_subr.ctimeout  = (sk->nr->rtt / PR_SLOWHZ) * 2;
timeout205net/netrom/nr_subr.c*dptr++  = timeout % 256;
timeout206net/netrom/nr_subr.c*dptr++  = timeout / 256;