taglinefilesource code
count439drivers/block/floppy.cunsigned long addr,count;
count447drivers/block/floppy.ccount = floppy->sect*4;
count450drivers/block/floppy.ccount = 1024;
count455drivers/block/floppy.ccount = floppy->sect*floppy->head*512;
count467drivers/block/floppy.cset_dma_count(FLOPPY_DMA, count);
count972drivers/block/floppy.cint count,head_shift,track_shift,total_shift;
count983drivers/block/floppy.cfor (count = 0; count < floppy->sect; count++) {
count986drivers/block/floppy.c*here++ = 1 + (( count + total_shift ) % floppy->sect);
count180drivers/block/ll_rw_blk.cunsigned int sector, count;
count199drivers/block/ll_rw_blk.ccount = bh->b_size >> 9;
count200drivers/block/ll_rw_blk.csector = bh->b_blocknr * count;
count202drivers/block/ll_rw_blk.cif (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
count243drivers/block/ll_rw_blk.creq->nr_sectors += count;
count252drivers/block/ll_rw_blk.creq->sector - count == sector &&
count255drivers/block/ll_rw_blk.creq->nr_sectors += count;
count258drivers/block/ll_rw_blk.creq->current_nr_sectors = count;
count292drivers/block/ll_rw_blk.creq->nr_sectors = count;
count293drivers/block/ll_rw_blk.creq->current_nr_sectors = count;
count825drivers/block/mcd.cint count;
count847drivers/block/mcd.cfor (count = 0; count < 1000000; count++)
count851drivers/block/mcd.cfor (count = 0; count < 1000000; count++)
count855drivers/block/mcd.cif (count >= 1000000) {
count860drivers/block/mcd.ccount = inb(MCDPORT(0));    /* pick up the status */
count863drivers/block/mcd.cfor(count=0;count<3;count++)
count864drivers/block/mcd.cif(getValue(result+count)) {
count1037drivers/block/mcd.cint count;
count1040drivers/block/mcd.cfor (count = 0; count < 2000; count++)
count1044drivers/block/mcd.cif (count >= 2000)
count1632drivers/block/sbpcd.cstatic int yy_SubChanInfo(int frame, int count, u_char *buffer)
count1646drivers/block/sbpcd.cdrvcmd[5]=(count>>8)&0xFF;
count1647drivers/block/sbpcd.cdrvcmd[6]=count&0xFF;
count210drivers/block/xd.cu_int block,count,retry;
count219drivers/block/xd.ccount = CURRENT->nr_sectors;
count225drivers/block/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
count322drivers/block/xd.cstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count)
count329drivers/block/xd.cprintk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
count333drivers/block/xd.cwhile (count) {
count334drivers/block/xd.ctemp = count < xd_maxsectors ? count : xd_maxsectors;
count366drivers/block/xd.ccount -= temp, buffer += temp * 0x200, block += temp;
count396drivers/block/xd.cstatic u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
count398drivers/block/xd.cif (buffer < ((u_char *) 0x1000000 - count)) {    /* transfer to address < 16M? */
count399drivers/block/xd.cif (((u_int) buffer & 0xFFFF0000) != ((u_int) buffer + count) & 0xFFFF0000) {
count409drivers/block/xd.cset_dma_count(xd_dma,count);
count420drivers/block/xd.cstatic u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control)
count426drivers/block/xd.ccmdblk[4] = count;
count509drivers/block/xd.cu_char cmdblk[6],i,count = 0;
count514drivers/block/xd.cinit_drive(count);
count515drivers/block/xd.ccount++;
count518drivers/block/xd.creturn (count);
count116drivers/char/atixlmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count121drivers/char/atixlmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count125drivers/char/atixlmouse.cif (count < 3)
count142drivers/char/atixlmouse.cfor(i = 3; i < count; i++)
count126drivers/char/busmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count135drivers/char/busmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count142drivers/char/busmouse.cif (count < 3)
count144drivers/char/busmouse.cif ((r = verify_area(VERIFY_WRITE, buffer, count)))
count176drivers/char/busmouse.cfor (r = 3; r < count; r++)
count562drivers/char/console.cunsigned long count;
count567drivers/char/console.ccount = (scr_end-pos)>>1;
count571drivers/char/console.ccount = ((pos-origin)>>1)+1;
count575drivers/char/console.ccount = video_num_columns * video_num_lines;
count585drivers/char/console.c:"c" (count),
count593drivers/char/console.clong count;
count598drivers/char/console.ccount = video_num_columns-x;
count603drivers/char/console.ccount = x+1;
count607drivers/char/console.ccount = video_num_columns;
count616drivers/char/console.c:"c" (count),
count1009drivers/char/console.cunsigned char *buf, int count)
count1026drivers/char/console.cwhile (!tty->stopped &&  count) {
count1028drivers/char/console.cbuf++; n++; count--;
count1360drivers/char/console.cvoid * memsetw(void * s,unsigned short c,int count)
count1366drivers/char/console.c:"a" (c),"D" (s),"c" (count)
count49drivers/char/lp.cunsigned long count  = 0; 
count53drivers/char/lp.ccount ++;
count56drivers/char/lp.c} while(!(status & LP_PBUSY) && count < LP_CHAR(minor));
count58drivers/char/lp.cif (count == LP_CHAR(minor)) {
count63drivers/char/lp.cif (count > lp_max_count) {
count64drivers/char/lp.cprintk("lp success after %d counts.\n",count);
count65drivers/char/lp.clp_max_count=count;
count124drivers/char/lp.cstatic int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
count135drivers/char/lp.ccopy_size = (count <= LP_BUFFER_SIZE ? count : LP_BUFFER_SIZE);
count185drivers/char/lp.ccount -= bytes_written;
count187drivers/char/lp.c} while (count > 0);
count193drivers/char/lp.cchar * buf, int count)
count208drivers/char/lp.cwhile (count > 0) {
count212drivers/char/lp.cif (retval) { count--; temp++;
count266drivers/char/lp.cstatic int lp_write(struct inode * inode, struct file * file, char * buf, int count)
count269drivers/char/lp.creturn lp_write_interrupt(inode, file, buf, count);
count271drivers/char/lp.creturn lp_write_polled(inode, file, buf, count);
count435drivers/char/lp.cint count = 0;
count456drivers/char/lp.ccount++;
count459drivers/char/lp.cif (count == 0)
count26drivers/char/mem.cstatic int read_ram(struct inode * inode, struct file * file,char * buf, int count)
count31drivers/char/mem.cstatic int write_ram(struct inode * inode, struct file * file,char * buf, int count)
count36drivers/char/mem.cstatic int read_mem(struct inode * inode, struct file * file,char * buf, int count)
count41drivers/char/mem.cif (count < 0)
count45drivers/char/mem.cif (count > high_memory - p)
count46drivers/char/mem.ccount = high_memory - p;
count48drivers/char/mem.cwhile (p < PAGE_SIZE && count > 0) {
count52drivers/char/mem.ccount--;
count55drivers/char/mem.cmemcpy_tofs(buf,(void *) p,count);
count56drivers/char/mem.cread += count;
count61drivers/char/mem.cstatic int write_mem(struct inode * inode, struct file * file,char * buf, int count)
count66drivers/char/mem.cif (count < 0)
count70drivers/char/mem.cif (count > high_memory - p)
count71drivers/char/mem.ccount = high_memory - p;
count73drivers/char/mem.cwhile (p < PAGE_SIZE && count > 0) {
count77drivers/char/mem.ccount--;
count80drivers/char/mem.cmemcpy_fromfs((void *) p,buf,count);
count81drivers/char/mem.cwritten += count;
count83drivers/char/mem.creturn count;
count116drivers/char/mem.cstatic int read_kmem(struct inode *inode, struct file *file, char *buf, int count)
count120drivers/char/mem.cread1 = read_mem(inode, file, buf, count);
count123drivers/char/mem.cread2 = vread(buf + read1, (char *) file->f_pos, count - read1);
count130drivers/char/mem.cstatic int read_port(struct inode * inode,struct file * file,char * buf, int count)
count135drivers/char/mem.cwhile (count-- > 0 && i < 65536) {
count144drivers/char/mem.cstatic int write_port(struct inode * inode,struct file * file,char * buf, int count)
count149drivers/char/mem.cwhile (count-- > 0 && i < 65536) {
count158drivers/char/mem.cstatic int read_null(struct inode * node,struct file * file,char * buf,int count)
count163drivers/char/mem.cstatic int write_null(struct inode * inode,struct file * file,char * buf, int count)
count165drivers/char/mem.creturn count;
count168drivers/char/mem.cstatic int read_zero(struct inode * node,struct file * file,char * buf,int count)
count172drivers/char/mem.cfor (left = count; left > 0; left--) {
count176drivers/char/mem.creturn count;
count209drivers/char/mem.cstatic int read_full(struct inode * node,struct file * file,char * buf,int count)
count211drivers/char/mem.creturn count;
count214drivers/char/mem.cstatic int write_full(struct inode * inode,struct file * file,char * buf, int count)
count99drivers/char/msbusmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count104drivers/char/msbusmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count108drivers/char/msbusmouse.cif (count < 3)
count117drivers/char/msbusmouse.cfor (i = 3; i < count; i++)
count516drivers/char/n_tty.cchar *fp, int count)
count526drivers/char/n_tty.ci = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
count532drivers/char/n_tty.ccount -= i;
count534drivers/char/n_tty.ci = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
count540drivers/char/n_tty.cfor (i=count, p = cp, f = fp; i; i--, p++) {
count923drivers/char/n_tty.cif (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
count335drivers/char/psaux.cstatic int write_aux(struct inode * inode, struct file * file, char * buffer, int count)
count337drivers/char/psaux.cint i = count;
count348drivers/char/psaux.creturn count;
count357drivers/char/psaux.cstatic int write_qp(struct inode * inode, struct file * file, char * buffer, int count)
count359drivers/char/psaux.cint i = count;
count367drivers/char/psaux.creturn count;
count376drivers/char/psaux.cstatic int read_aux(struct inode * inode, struct file * file, char * buffer, int count)
count379drivers/char/psaux.cint i = count;
count401drivers/char/psaux.cif (count-i) {
count403drivers/char/psaux.creturn count-i;
count57drivers/char/pty.cif (tty->count > 1)
count58drivers/char/pty.cprintk("master pty_close: count = %d!!\n", tty->count);
count60drivers/char/pty.cif (tty->count > 2)
count78drivers/char/pty.cunsigned char *buf, int count)
count86drivers/char/pty.ccount = MIN(count, to->ldisc.receive_room(to));
count89drivers/char/pty.cfor (c = count; c > 0; c -= n) {
count96drivers/char/pty.cto->ldisc.receive_buf(to, buf, 0, count);
count98drivers/char/pty.creturn count;
count155drivers/char/pty.cwhile (!tty->link->count && !(current->signal & ~current->blocked))
count157drivers/char/pty.cif (!tty->link->count)
count371drivers/char/serial.cif (tty->flip.count >= TTY_FLIPBUF_SIZE)
count373drivers/char/serial.ctty->flip.count++;
count399drivers/char/serial.cint count;
count416drivers/char/serial.ccount = info->xmit_fifo_size;
count422drivers/char/serial.c} while (--count > 0);
count1171drivers/char/serial.cunsigned char *buf, int count)
count1184drivers/char/serial.cc = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
count1199drivers/char/serial.ccount -= c;
count1373drivers/char/serial.cif ((change_port || change_irq) && (info->count > 1))
count1482drivers/char/serial.cif (info->count > 1)
count1683drivers/char/serial.cprintk("rs_close ttys%d, count = %d\n", info->line, info->count);
count1685drivers/char/serial.cif ((tty->count == 1) && (info->count != 1)) {
count1694drivers/char/serial.c"info->count is %d\n", info->count);
count1695drivers/char/serial.cinfo->count = 1;
count1697drivers/char/serial.cif (--info->count < 0) {
count1699drivers/char/serial.cinfo->line, info->count);
count1700drivers/char/serial.cinfo->count = 0;
count1702drivers/char/serial.cif (info->count)
count1737drivers/char/serial.ctty->count++; /* avoid race condition */
count1741drivers/char/serial.ctty->count--;
count1762drivers/char/serial.cinfo->count = 0;
count1837drivers/char/serial.cinfo->line, info->count);
count1839drivers/char/serial.cinfo->count--;
count1872drivers/char/serial.cinfo->line, info->count);
count1879drivers/char/serial.cinfo->count++;
count1883drivers/char/serial.cinfo->line, info->count);
count1911drivers/char/serial.cinfo->count);
count1913drivers/char/serial.cinfo->count++;
count1917drivers/char/serial.cif ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
count2252drivers/char/serial.cinfo->count = 0;
count1810drivers/char/tpqic02.cstatic int tape_qic02_read(struct inode * inode, struct file * filp, char * buf, int count)
count1820drivers/char/tpqic02.cMINOR(dev), buf, count, filp->f_pos, flags);
count1822drivers/char/tpqic02.cif (count % TAPE_BLKSIZE) {  /* Only allow mod 512 bytes at a time. */
count1834drivers/char/tpqic02.cerror = verify_area(VERIFY_WRITE, buf, count);
count1836drivers/char/tpqic02.cprintk(TPQIC_NAME ": read: verify_area(WRITE, %p, %x) failed\n", buf, count);
count1843drivers/char/tpqic02.cwhile (count>=0) {
count1847drivers/char/tpqic02.cif (bytes_todo>count)
count1848drivers/char/tpqic02.cbytes_todo = count;
count1943drivers/char/tpqic02.ccount -= bytes_done;
count1980drivers/char/tpqic02.cstatic int tape_qic02_write(struct inode * inode, struct file * filp, char * buf, int count)
count1989drivers/char/tpqic02.cMINOR(dev), buf, count, filp->f_pos, flags);
count1991drivers/char/tpqic02.cif (count % TAPE_BLKSIZE) {  /* only allow mod 512 bytes at a time */
count2011drivers/char/tpqic02.cerror = verify_area(VERIFY_READ, buf, count);
count2013drivers/char/tpqic02.cprintk(TPQIC_NAME ": write: verify_area(READ, %p, %x) failed\n", buf, count);
count2020drivers/char/tpqic02.cwhile (count>=0) {
count2024drivers/char/tpqic02.cif (bytes_todo>count)
count2025drivers/char/tpqic02.cbytes_todo = count;
count2106drivers/char/tpqic02.ccount -= bytes_done;
count2110drivers/char/tpqic02.cprintk(TPQIC_NAME ": status_bytes_wr %x, buf %p, total_bytes_done %lx, count %x\n", status_bytes_wr, buf, total_bytes_done, count);
count2284drivers/char/tpqic02.cstatic int tape_qic02_readdir(struct inode * inode, struct file * filp, struct dirent * dp, int count)
count251drivers/char/tty_io.cstatic int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
count256drivers/char/tty_io.cstatic int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
count632drivers/char/tty_io.cstatic int tty_read(struct inode * inode, struct file * file, char * buf, int count)
count661drivers/char/tty_io.ci = (tty->ldisc.read)(tty,file,(unsigned char *)buf,(unsigned int)count);
count669drivers/char/tty_io.cstatic int tty_write(struct inode * inode, struct file * file, char * buf, int count)
count697drivers/char/tty_io.ci = (tty->ldisc.write)(tty,file,(unsigned char *)buf,(unsigned int)count);
count737drivers/char/tty_io.c*tty_loc && (*tty_loc)->count)
count847drivers/char/tty_io.c(*tty_loc)->count++;
count851drivers/char/tty_io.c(*o_tty_loc)->count++;
count918drivers/char/tty_io.ctty->count);
count954drivers/char/tty_io.cif (--tty->link->count < 0) {
count956drivers/char/tty_io.ctty->count, tty_name(tty));
count957drivers/char/tty_io.ctty->link->count = 0;
count960drivers/char/tty_io.cif (--tty->count < 0) {
count962drivers/char/tty_io.ctty->count, tty_name(tty));
count963drivers/char/tty_io.ctty->count = 0;
count965drivers/char/tty_io.cif (tty->count)
count978drivers/char/tty_io.cif (o_tty->count)
count1460drivers/char/tty_io.cint    count;
count1479drivers/char/tty_io.ccount = tty->flip.count;
count1480drivers/char/tty_io.ctty->flip.count = 0;
count1484drivers/char/tty_io.cif (count > tty->max_flip_cnt)
count1485drivers/char/tty_io.ctty->max_flip_cnt = count;
count1487drivers/char/tty_io.ctty->ldisc.receive_buf(tty, cp, fp, count);
count89drivers/char/vt.ckd_mksound(unsigned int count, unsigned int ticks)
count95drivers/char/vt.cif (count) {
count101drivers/char/vt.coutb_p(count & 0xff, 0x42);
count102drivers/char/vt.coutb((count >> 8) & 0xff, 0x42);
count489drivers/char/vt.cconsole_driver.table[i]->count > 0)
count504drivers/char/vt.cconsole_driver.table[i]->count == 0)
count23drivers/char/vt_kern.hvoid kd_mksound(unsigned int count, unsigned int ticks);
count42drivers/net/3c503.cstatic void el2_block_output(struct device *dev, int count,
count44drivers/net/3c503.cstatic int el2_block_input(struct device *dev, int count, char *buf,
count337drivers/net/3c503.cel2_block_output(struct device *dev, int count,
count349drivers/net/3c503.cmemcpy(dest_addr, buf, count);
count350drivers/net/3c503.cif (ei_debug > 2  &&  memcmp(dest_addr, buf, count))
count365drivers/net/3c503.cfor(i = 0; i < count; i++) {
count370drivers/net/3c503.cdev->name, i, count, boguscount);
count381drivers/net/3c503.cel2_block_input(struct device *dev, int count, char *buf, int ring_offset)
count390drivers/net/3c503.cif (dev->mem_start + ring_offset + count > end_of_ring) {
count394drivers/net/3c503.ccount -= semi_count;
count395drivers/net/3c503.cmemcpy(buf + semi_count, (char *)dev->rmem_start, count);
count396drivers/net/3c503.creturn dev->rmem_start + count;
count398drivers/net/3c503.cmemcpy(buf, (char *)dev->mem_start + ring_offset, count);
count399drivers/net/3c503.creturn ring_offset + count;
count409drivers/net/3c503.cfor(i = 0; i < count; i++) {
count414drivers/net/3c503.cdev->name, i, count, boguscount);
count416drivers/net/8390.cpkt_len = rx_frame.count - sizeof(rx_frame);
count436drivers/net/8390.cdev->name, rx_frame.count, rx_frame.status,
count463drivers/net/8390.crx_frame.count);
count157drivers/net/8390.hunsigned short count; /* header + packet lenght in bytes */
count52drivers/net/hp.cstatic int hp_block_input(struct device *dev, int count,
count54drivers/net/hp.cstatic void hp_block_output(struct device *dev, int count,
count204drivers/net/hp.chp_block_input(struct device *dev, int count, char *buf, int ring_offset)
count208drivers/net/hp.cint xfer_count = count;
count212drivers/net/hp.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count213drivers/net/hp.coutb_p(count >> 8, nic_base + EN0_RCNTHI);
count218drivers/net/hp.cinsw(nic_base - NIC_OFFSET + HP_DATAPORT,buf,count>>1);
count219drivers/net/hp.cif (count & 0x01)
count220drivers/net/hp.cbuf[count-1] = inb(nic_base - NIC_OFFSET + HP_DATAPORT), xfer_count++;
count222drivers/net/hp.cinsb(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count);
count235drivers/net/hp.creturn ring_offset + count;
count239drivers/net/hp.chp_block_output(struct device *dev, int count,
count249drivers/net/hp.cif (ei_status.word16 && (count & 0x01))
count250drivers/net/hp.ccount++;
count267drivers/net/hp.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count268drivers/net/hp.coutb_p(count >> 8,   nic_base + EN0_RCNTHI);
count275drivers/net/hp.coutsw(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count>>1);
count277drivers/net/hp.coutsb(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count);
count287drivers/net/hp.cif ((start_page << 8) + count != addr)
count289drivers/net/hp.cdev->name, (start_page << 8) + count, addr);
count46drivers/net/ne.cstatic int ne_block_input(struct device *dev, int count,
count48drivers/net/ne.cstatic void ne_block_output(struct device *dev, const int count,
count285drivers/net/ne.cne_block_input(struct device *dev, int count, char *buf, int ring_offset)
count287drivers/net/ne.cint xfer_count = count;
count299drivers/net/ne.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count300drivers/net/ne.coutb_p(count >> 8, nic_base + EN0_RCNTHI);
count305drivers/net/ne.cinsw(NE_BASE + NE_DATAPORT,buf,count>>1);
count306drivers/net/ne.cif (count & 0x01)
count307drivers/net/ne.cbuf[count-1] = inb(NE_BASE + NE_DATAPORT), xfer_count++;
count309drivers/net/ne.cinsb(NE_BASE + NE_DATAPORT, buf, count);
count333drivers/net/ne.creturn ring_offset + count;
count337drivers/net/ne.cne_block_output(struct device *dev, int count,
count346drivers/net/ne.cif (ei_status.word16 && (count & 0x01))
count347drivers/net/ne.ccount++;
count377drivers/net/ne.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count378drivers/net/ne.coutb_p(count >> 8,   nic_base + EN0_RCNTHI);
count384drivers/net/ne.coutsw(NE_BASE + NE_DATAPORT, buf, count>>1);
count386drivers/net/ne.coutsb(NE_BASE + NE_DATAPORT, buf, count);
count399drivers/net/ne.cif ((start_page << 8) + count == addr)
count405drivers/net/ne.cdev->name, (start_page << 8) + count, addr);
count150drivers/net/ppp.cchar *fp, int count);
count661drivers/net/ppp.cregister int count = ppp->xhead - ppp->xbuff;
count664drivers/net/ppp.cppp->stats.sbytes += count;
count668drivers/net/ppp.ccount,
count686drivers/net/ppp.cregister int count, actual;
count688drivers/net/ppp.ccount = ppp->xhead - ppp->xbuff;
count690drivers/net/ppp.cactual = ppp->tty->driver.write(ppp->tty, 0, ppp->xbuff, count);
count692drivers/net/ppp.cif (actual == count) {
count702drivers/net/ppp.cregister int count, actual;
count721drivers/net/ppp.ccount = ppp->xhead - ppp->xtail;
count723drivers/net/ppp.cactual = tty->driver.write(tty, 0, ppp->xtail, count);
count725drivers/net/ppp.cif (actual == count) {
count776drivers/net/ppp.ci, count;
count783drivers/net/ppp.ccount = 0;
count786drivers/net/ppp.cbuffer [count] = tty->read_q.buf[i];
count787drivers/net/ppp.cif (++count == 8) {
count789drivers/net/ppp.ccount = 0;
count793drivers/net/ppp.cppp_print_buffer (NULL, buffer, count, KERNEL_DS);
count895drivers/net/ppp.cchar *fp, int count)
count911drivers/net/ppp.cppp_print_buffer ("receive buffer", cp, count, KERNEL_DS);
count914drivers/net/ppp.cppp->stats.rbytes += count;
count916drivers/net/ppp.cwhile (count-- > 0) {
count973drivers/net/ppp.cint count = ppp->rcount;
count984drivers/net/ppp.cif (count == 0)
count988drivers/net/ppp.cppp_print_buffer ("receive frame", c, count, KERNEL_DS);
count990drivers/net/ppp.cif (count < 4) {
count991drivers/net/ppp.cPRINTKN (1,(KERN_WARNING "ppp: got runt ppp frame, %d chars\n", count));
count1003drivers/net/ppp.ccount -= 2;      /* ignore last two characters */
count1009drivers/net/ppp.ccount -= 2;
count1014drivers/net/ppp.ccount--;
count1017drivers/net/ppp.ccount -= 2;
count1021drivers/net/ppp.cif ((ppp->dev->flags & IFF_UP) && ppp_do_ip(ppp, proto, c, count)) {
count1032drivers/net/ppp.cif (ppp_us_queue (ppp, proto, c, count+2)) {
count1050drivers/net/ppp.cint count)
count1055drivers/net/ppp.c(int) proto, count, c[0]));
count1059drivers/net/ppp.c(int) proto, count));
count1086drivers/net/ppp.ccount = slhc_uncompress(ppp->slcomp, c, count);
count1087drivers/net/ppp.cif (count <= 0) {
count1097drivers/net/ppp.cif (slhc_remember(ppp->slcomp, c, count) <= 0) {
count1113drivers/net/ppp.ciph->saddr, iph->daddr, count))
count1117drivers/net/ppp.cwhile ((dev_rint(c, count, 0, ppp->dev) & ~1) != 0)
count1962drivers/net/ppp.cinline void ppp_print_hex (register char *out, char *in, int count);
count1963drivers/net/ppp.cinline void ppp_print_hex (register char *out, char *in, int count)
count1967drivers/net/ppp.cwhile (count-- > 0) {
count1977drivers/net/ppp.cinline void ppp_print_char (register char *out, char *in, int count);
count1978drivers/net/ppp.cinline void ppp_print_char (register char *out, char *in, int count)
count1982drivers/net/ppp.cwhile (count-- > 0) {
count1997drivers/net/ppp.cstatic void ppp_print_buffer(const char *name, char *buf, int count, int seg)
count2005drivers/net/ppp.cPRINTK ((KERN_DEBUG "ppp: %s, count = %d\n", name, count));
count2007drivers/net/ppp.cwhile (count > 8) {
count2012drivers/net/ppp.ccount -= 8;
count2016drivers/net/ppp.cif (count > 0) {
count2018drivers/net/ppp.cppp_print_hex  (line, buf, count);
count2019drivers/net/ppp.cppp_print_char (&line[8 * 3], buf, count);
count291drivers/net/slip.cint count;
count293drivers/net/slip.ccount = sl->rcount;
count319drivers/net/slip.ccount = slhc_uncompress(sl->slcomp, sl->rbuff, count);
count320drivers/net/slip.cif (count <= 0) {
count331drivers/net/slip.cif (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0) {
count342drivers/net/slip.cdone = dev_rint(sl->rbuff, count, 0, sl->dev);
count354drivers/net/slip.cint actual, count;
count372drivers/net/slip.ccount=slip_esc6(p, (unsigned char *)sl->xbuff,len);
count374drivers/net/slip.ccount=slip_esc(p, (unsigned char *)sl->xbuff,len);
count378drivers/net/slip.cactual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
count379drivers/net/slip.cif (actual == count) {
count383drivers/net/slip.csl->xhead = sl->xbuff + count;
count395drivers/net/slip.cregister int count, answer;
count412drivers/net/slip.ccount = sl->xhead - sl->xtail;
count414drivers/net/slip.canswer = tty->driver.write(tty, 0, sl->xtail, count);
count415drivers/net/slip.cif (answer == count) {
count667drivers/net/slip.cchar *fp, int count)
count682drivers/net/slip.cwhile (count--) {
count791drivers/net/slip.cint count = 0;
count799drivers/net/slip.cd[count++] = END;
count809drivers/net/slip.cd[count++] = ESC;
count810drivers/net/slip.cd[count++] = ESC_END;
count813drivers/net/slip.cd[count++] = ESC;
count814drivers/net/slip.cd[count++] = ESC_ESC;
count817drivers/net/slip.cd[count++] = *s;
count821drivers/net/slip.cd[count++] = END;
count822drivers/net/slip.creturn(count);
count869drivers/net/slip.cint count = 0;
count880drivers/net/slip.cd[count++] = 0x70;
count894drivers/net/slip.cd[count++] = c;
count901drivers/net/slip.cd[count++] = c;
count903drivers/net/slip.cd[count++] = 0x70;
count904drivers/net/slip.creturn(count);
count41drivers/net/smc-ultra.cstatic int ultra_block_input(struct device *dev, int count,
count43drivers/net/smc-ultra.cstatic void ultra_block_output(struct device *dev, int count,
count209drivers/net/smc-ultra.cultra_block_input(struct device *dev, int count, char *buf, int ring_offset)
count214drivers/net/smc-ultra.cif (xfer_start + count > (void*) dev->rmem_end) {
count218drivers/net/smc-ultra.ccount -= semi_count;
count219drivers/net/smc-ultra.cmemcpy(buf + semi_count, (char *)dev->rmem_start, count);
count220drivers/net/smc-ultra.creturn dev->rmem_start + count;
count222drivers/net/smc-ultra.cmemcpy(buf, xfer_start, count);
count224drivers/net/smc-ultra.creturn ring_offset + count;
count228drivers/net/smc-ultra.cultra_block_output(struct device *dev, int count, const unsigned char *buf,
count234drivers/net/smc-ultra.cmemcpy(shmem, buf, count);
count42drivers/net/wd.cstatic int wd_block_input(struct device *dev, int count,
count44drivers/net/wd.cstatic void wd_block_output(struct device *dev, int count,
count295drivers/net/wd.cwd_block_input(struct device *dev, int count, char *buf, int ring_offset)
count302drivers/net/wd.cif (count == 4) {
count309drivers/net/wd.cif (xfer_start + count > dev->rmem_end) {
count313drivers/net/wd.ccount -= semi_count;
count314drivers/net/wd.cmemcpy(buf + semi_count, (char *)dev->rmem_start, count);
count316drivers/net/wd.cmemcpy(buf, (char *)xfer_start, count);
count326drivers/net/wd.cwd_block_output(struct device *dev, int count, const unsigned char *buf,
count336drivers/net/wd.cmemcpy((char *)shmem, buf, count);
count339drivers/net/wd.cmemcpy((char *)shmem, buf, count);
count1326drivers/scsi/NCR5380.cunsigned char *phase, int *count, unsigned char **data) {
count1329drivers/scsi/NCR5380.cregister int c = *count;
count1417drivers/scsi/NCR5380.c*count = c;
count1453drivers/scsi/NCR5380.cunsigned char *phase, int *count, unsigned char **data) {
count1455drivers/scsi/NCR5380.cregister int c = *count;
count1591drivers/scsi/NCR5380.c*count -= c;
count1603drivers/scsi/NCR5380.c*count -= 1;
count1613drivers/scsi/NCR5380.c*count -= toPIO - cnt;
count1619drivers/scsi/NCR5380.c*data, *count, *(*data+*count-1), *(*data+*count));
count1709drivers/scsi/NCR5380.c*count = 0;
count267drivers/scsi/NCR5380.hunsigned char *phase, int *count, unsigned char **data);
count270drivers/scsi/NCR5380.hunsigned char *phase, int *count, unsigned char **data);
count274drivers/scsi/NCR5380.hunsigned char *ptr, unsigned int count, unsigned char mode) {
count278drivers/scsi/NCR5380.hif (count > 65536)
count279drivers/scsi/NCR5380.hcount = 65536;
count282drivers/scsi/NCR5380.hif (count > 65536 * 2) 
count283drivers/scsi/NCR5380.hcount = 65536 * 2;
count287drivers/scsi/NCR5380.hif (count > limit) count = limit;
count289drivers/scsi/NCR5380.hif ((count & 1) || (((unsigned) ptr) & 1))
count295drivers/scsi/NCR5380.hset_dma_count(instance->dma_channel, count);
count299drivers/scsi/NCR5380.hreturn count;
count303drivers/scsi/NCR5380.hunsigned char *src, unsigned int count) {
count304drivers/scsi/NCR5380.hreturn NCR5380_i386_dma_setup (instance, src, count, DMA_MODE_WRITE);
count308drivers/scsi/NCR5380.hunsigned char *src, unsigned int count) {
count309drivers/scsi/NCR5380.hreturn NCR5380_i386_dma_setup (instance, src, count, DMA_MODE_READ);
count792drivers/scsi/aha1542.cint count = 0;
count902drivers/scsi/aha1542.ccount++;
count909drivers/scsi/aha1542.creturn count;
count915drivers/scsi/aha1542.cint count = 0;
count927drivers/scsi/aha1542.ccount++;
count930drivers/scsi/aha1542.cprintk("Potential to restart %d stalled commands...\n", count);
count933drivers/scsi/aha1542.cif (count) aha1542_out(shost->io_port, &ahacmd, 1);
count756drivers/scsi/buslogic.cunsigned char cmd, count;
count928drivers/scsi/buslogic.cint count = 0;
count1088drivers/scsi/buslogic.ccount++;
count1093drivers/scsi/buslogic.creturn count;
count127drivers/scsi/g_NCR5380.cint count;
count130drivers/scsi/g_NCR5380.cfor (count = 0; current_override < NO_OVERRIDES; ++current_override) {
count167drivers/scsi/g_NCR5380.c++count;
count169drivers/scsi/g_NCR5380.creturn count;
count228drivers/scsi/hosts.cint i, j, count, pcount;
count230drivers/scsi/hosts.ccount = 0;
count259drivers/scsi/hosts.ccount++, scsi_hosts[i].name);
count262drivers/scsi/hosts.cprintk ("scsi : %d hosts.\n", count);
count264drivers/scsi/hosts.cmax_scsi_hosts = count;
count298drivers/scsi/pas16.cint  count;
count300drivers/scsi/pas16.cfor (count = 0; current_override < NO_OVERRIDES; ++current_override) {
count370drivers/scsi/pas16.c++count;
count373drivers/scsi/pas16.creturn count;
count508drivers/scsi/sd.cint count, this_count_max;
count514drivers/scsi/sd.ccount = 0;
count522drivers/scsi/sd.cif (count < SCpnt->host->sg_tablesize) count++;
count531drivers/scsi/sd.c((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
count533drivers/scsi/sd.cSCpnt->use_sg = count;  /* Number of chains */
count534drivers/scsi/sd.ccount = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
count535drivers/scsi/sd.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
count536drivers/scsi/sd.ccount = count << 1;
count537drivers/scsi/sd.cSCpnt->sglist_len = count;
count538drivers/scsi/sd.cmax_sg = count / sizeof(struct scatterlist);
count540drivers/scsi/sd.csgpnt = (struct scatterlist * ) scsi_malloc(count);
count541drivers/scsi/sd.cmemset(sgpnt, 0, count);  /* Zero so it is easy to fill */
count550drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
count551drivers/scsi/sd.ccount < SCpnt->use_sg && bh; 
count552drivers/scsi/sd.ccount++, bh = bhp) {
count556drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
count557drivers/scsi/sd.csgpnt[count].length += bh->b_size;
count560drivers/scsi/sd.cif (((int) sgpnt[count].address) + sgpnt[count].length - 1 > 
count562drivers/scsi/sd.c!sgpnt[count].alt_address) {
count563drivers/scsi/sd.csgpnt[count].alt_address = sgpnt[count].address;
count567drivers/scsi/sd.cif(dma_free_sectors < (sgpnt[count].length >> 9) + 10) {
count568drivers/scsi/sd.csgpnt[count].address = NULL;
count570drivers/scsi/sd.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
count576drivers/scsi/sd.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
count580drivers/scsi/sd.cwhile(--count >= 0){
count581drivers/scsi/sd.cif(sgpnt[count].alt_address) 
count582drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count589drivers/scsi/sd.cSCpnt->use_sg = count;
count603drivers/scsi/sd.cif (((int) sgpnt[count].address) + sgpnt[count].length +
count606drivers/scsi/sd.c!sgpnt[count].alt_address) continue;
count608drivers/scsi/sd.cif(!sgpnt[count].alt_address) {count--; continue; }
count610drivers/scsi/sd.ctmp = (char *) scsi_malloc(sgpnt[count].length + bhp->b_size);
count616drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count617drivers/scsi/sd.csgpnt[count].address = tmp;
count618drivers/scsi/sd.ccount--;
count631drivers/scsi/sd.cif(count < SCpnt->use_sg || SCpnt->use_sg > SCpnt->host->sg_tablesize){
count633drivers/scsi/sd.cprintk("Use sg, count %d %x %d\n", SCpnt->use_sg, count, dma_free_sectors);
count640drivers/scsi/sd.cfor(count=0; count<SCpnt->use_sg; count++)
count641drivers/scsi/sd.cprintk("{%d:%p %p %d}  ", count,
count642drivers/scsi/sd.csgpnt[count].address,
count643drivers/scsi/sd.csgpnt[count].alt_address,
count644drivers/scsi/sd.csgpnt[count].length);
count649drivers/scsi/sd.cfor(count=0; count<SCpnt->use_sg; count++)
count650drivers/scsi/sd.cif(sgpnt[count].alt_address)
count651drivers/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
count652drivers/scsi/sd.csgpnt[count].length);
count241drivers/scsi/seagate.cregister int count = 0, start = jiffies + 1, stop = start + 25;
count244drivers/scsi/seagate.cfor (;jiffies < stop; ++count);
count251drivers/scsi/seagate.cborken_calibration =  (count * 4) / (SLOW_RATE*1024);
count262drivers/scsi/seagate.cregister int count;
count263drivers/scsi/seagate.cfor (count = borken_calibration; count && (STATUS & STAT_REQ); 
count264drivers/scsi/seagate.c--count);
count265drivers/scsi/seagate.cif (count)
count153drivers/scsi/sg.cstatic int sg_read(struct inode *inode,struct file *filp,char *buf,int count)
count158drivers/scsi/sg.cif ((i=verify_area(VERIFY_WRITE,buf,count)))
count170drivers/scsi/sg.cif (count>=sizeof(struct sg_header))
count174drivers/scsi/sg.cif (count>device->header.pack_len)
count175drivers/scsi/sg.ccount=device->header.pack_len;
count176drivers/scsi/sg.cmemcpy_tofs(buf,device->buff,count-sizeof(struct sg_header));
count179drivers/scsi/sg.ccount=0;
count183drivers/scsi/sg.creturn count;
count207drivers/scsi/sg.cstatic int sg_write(struct inode *inode,struct file *filp,char *buf,int count)
count214drivers/scsi/sg.cif ((i=verify_area(VERIFY_READ,buf,count)))
count216drivers/scsi/sg.cif (count<sizeof(struct sg_header))
count234drivers/scsi/sg.cdevice->header.pack_len=count;
count277drivers/scsi/sg.creturn count;
count431drivers/scsi/sr.cint count, this_count_max;
count434drivers/scsi/sr.ccount = 0;
count439drivers/scsi/sr.cif(this_count) count++;
count440drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
count443drivers/scsi/sr.ccount++;
count449drivers/scsi/sr.cif (count < SCpnt->host->sg_tablesize) {
count450drivers/scsi/sr.ccount++;
count454drivers/scsi/sr.ccount--;
count458drivers/scsi/sr.cSCpnt->use_sg = count;  /* Number of chains */
count459drivers/scsi/sr.ccount = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
count460drivers/scsi/sr.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
count461drivers/scsi/sr.ccount = count << 1;
count462drivers/scsi/sr.cSCpnt->sglist_len = count;
count463drivers/scsi/sr.csgpnt = (struct scatterlist * ) scsi_malloc(count);
count469drivers/scsi/sr.ccount = 0;
count472drivers/scsi/sr.csgpnt[count].length = (SCpnt->request.sector % 4) << 9;
count473drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
count474drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
count475drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
count477drivers/scsi/sr.ccount++;
count479drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
count480drivers/scsi/sr.ccount++, bh = bh->b_reqnext) {
count482drivers/scsi/sr.csgpnt[count].address = bh->b_data;
count483drivers/scsi/sr.csgpnt[count].length = bh->b_size;
count484drivers/scsi/sr.csgpnt[count].alt_address = NULL;
count486drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(end_rec);
count487drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
count488drivers/scsi/sr.csgpnt[count].length = end_rec;
count489drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
count490drivers/scsi/sr.cif (count+1 != SCpnt->use_sg) panic("Bad sr request list");
count493drivers/scsi/sr.cif (((int) sgpnt[count].address) + sgpnt[count].length > 
count495drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
count499drivers/scsi/sr.cif(dma_free_sectors < (sgpnt[count].length >> 9) + 5) {
count500drivers/scsi/sr.csgpnt[count].address = NULL;
count502drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
count508drivers/scsi/sr.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
count511drivers/scsi/sr.cwhile(--count >= 0){
count512drivers/scsi/sr.cif(sgpnt[count].alt_address) 
count513drivers/scsi/sr.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count526drivers/scsi/sr.cfor(count=0; count<SCpnt->use_sg; count++)
count527drivers/scsi/sr.cprintk("SGlist: %d %x %x %x\n", count,
count528drivers/scsi/sr.csgpnt[count].address, 
count529drivers/scsi/sr.csgpnt[count].alt_address, 
count530drivers/scsi/sr.csgpnt[count].length);
count641drivers/scsi/st.cst_write(struct inode * inode, struct file * filp, char * buf, int count)
count663drivers/scsi/st.cif (STp->block_size == 0 && count > st_buffer_size)
count697drivers/scsi/st.cif (STp->block_size != 0 && (count % STp->block_size) != 0)
count708drivers/scsi/st.ctotal = count;
count717drivers/scsi/st.cwhile((STp->block_size == 0 && !STp->do_async_writes && count > 0) ||
count719drivers/scsi/st.c(STp->buffer)->buffer_bytes + count > write_threshold))
count722drivers/scsi/st.cdo_count = count;
count725drivers/scsi/st.cif (do_count > count)
count726drivers/scsi/st.cdo_count = count;
count769drivers/scsi/st.ccount -= do_count - transfer;
count802drivers/scsi/st.cif (count < total)
count803drivers/scsi/st.creturn total - count;
count809drivers/scsi/st.ccount -= do_count;
count819drivers/scsi/st.cif (count != 0) {
count822drivers/scsi/st.c(STp->buffer)->buffer_bytes,b_point,count);
count823drivers/scsi/st.cfilp->f_pos += count;
count824drivers/scsi/st.c(STp->buffer)->buffer_bytes += count;
count825drivers/scsi/st.ccount = 0;
count868drivers/scsi/st.cst_read(struct inode * inode, struct file * filp, char * buf, int count)
count886drivers/scsi/st.cif (STp->block_size == 0 && count > st_buffer_size)
count890drivers/scsi/st.c(count % STp->block_size) != 0)
count913drivers/scsi/st.cfor (total = 0; total < count; ) {
count922drivers/scsi/st.cblks = bytes = count;
count929drivers/scsi/st.cbytes = count;
count1051drivers/scsi/st.c(STp->buffer)->buffer_bytes, count - total);
count1053drivers/scsi/st.ctransfer = (STp->buffer)->buffer_bytes < count - total ?
count1054drivers/scsi/st.c(STp->buffer)->buffer_bytes : count - total;
count1077drivers/scsi/st.ccount = total;  /* Read only one variable length block */
count200drivers/scsi/t128.cint sig, count;
count202drivers/scsi/t128.cfor (count = 0; current_override < NO_OVERRIDES; ++current_override) {
count269drivers/scsi/t128.c++count;
count272drivers/scsi/t128.creturn count;
count127drivers/sound/audio.caudio_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count136drivers/sound/audio.cc = count;
count145drivers/sound/audio.cif (!count)      /* Flush output */
count203drivers/sound/audio.creturn count;
count207drivers/sound/audio.caudio_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count216drivers/sound/audio.cc = count;
count258drivers/sound/audio.creturn count - c;
count314drivers/sound/audio.caudio_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count320drivers/sound/audio.caudio_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count67drivers/sound/dev_table.hint count, int intrflag, int dma_restart);
count69drivers/sound/dev_table.hint count, int intrflag, int dma_restart);
count98drivers/sound/dev_table.hint offs, int count, int pmgr_flag);
count225drivers/sound/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count227drivers/sound/dma.hcount--;
count229drivers/sound/dma.hdeb_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count230drivers/sound/dma.hdeb_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count232drivers/sound/dma.hdeb_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count233drivers/sound/dma.hdeb_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count252drivers/sound/dma.hunsigned short count;
count254drivers/sound/dma.hcount = 1 + inb(io_port);
count255drivers/sound/dma.hcount += inb(io_port) << 8;
count257drivers/sound/dma.hreturn (dmanr<=3)? count : (count<<1);
count406drivers/sound/dmabuf.cDMAbuf_read (int dev, snd_rw_buf * user_buf, int count)
count419drivers/sound/dmabuf.cif (c > count)
count420drivers/sound/dmabuf.cc = count;
count584drivers/sound/dmabuf.cDMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
count629drivers/sound/dmabuf.csnd_raw_buf_phys[dev][0], count);
count646drivers/sound/dmabuf.cset_dma_count (chan, count);
count653drivers/sound/dmabuf.ccount,
count659drivers/sound/dmabuf.cphysaddr, count);
count669drivers/sound/dmabuf.creturn count;
count823drivers/sound/dmabuf.cDMAbuf_read (int dev, snd_rw_buf * user_buf, int count)
count865drivers/sound/dmabuf.cDMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
count1726drivers/sound/gus_wave.cint offs, int count, int pmgr_flag)
count1746drivers/sound/gus_wave.cif (count < sizeof_patch)
count1752drivers/sound/gus_wave.ccount -= sizeof_patch;
count1775drivers/sound/gus_wave.cif (count < patch.len)
count1778drivers/sound/gus_wave.ccount, (int) patch.len);
count1779drivers/sound/gus_wave.cpatch.len = count;
count2523drivers/sound/gus_wave.cint             this_one, count;
count2530drivers/sound/gus_wave.ccount = total_count / gus_sampling_channels;
count2540drivers/sound/gus_wave.cpcm_datasize[this_one] = count;
count2548drivers/sound/gus_wave.cDMAbuf_start_dma (dev, buf + (chn * count), count, DMA_MODE_WRITE);
count2595drivers/sound/gus_wave.cif (!pcm_active && (pcm_qlen > 2 || count < pcm_bsize))
count2620drivers/sound/gus_wave.cgus_sampling_start_input (int dev, unsigned long buf, int count,
count2628drivers/sound/gus_wave.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count81drivers/sound/midibuf.cMIDIbuf_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count86drivers/sound/midibuf.creturn count;
count91drivers/sound/midibuf.cMIDIbuf_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count113drivers/sound/midibuf.cMIDIbuf_bytes_received (int dev, unsigned char *buf, int count)
count726drivers/sound/opl3.cint offs, int count, int pmgr_flag)
count730drivers/sound/opl3.cif (count < sizeof (ins))
count237drivers/sound/pas2_pcm.cpas_pcm_output_block (int dev, unsigned long buf, int count,
count242drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static void pas_pcm_output_block(char *buf = %P, int count = %X)\n", buf, count));
count244drivers/sound/pas2_pcm.ccnt = count;
count259drivers/sound/pas2_pcm.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count262drivers/sound/pas2_pcm.ccount >>= 1;
count264drivers/sound/pas2_pcm.cif (count != pcm_count)
count268drivers/sound/pas2_pcm.cpas_write (count & 0xff, SAMPLE_BUFFER_COUNTER);
count269drivers/sound/pas2_pcm.cpas_write ((count >> 8) & 0xff, SAMPLE_BUFFER_COUNTER);
count272drivers/sound/pas2_pcm.cpcm_count = count;
count283drivers/sound/pas2_pcm.cpas_pcm_start_input (int dev, unsigned long buf, int count,
count289drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static void pas_pcm_start_input(char *buf = %P, int count = %X)\n", buf, count));
count291drivers/sound/pas2_pcm.ccnt = count;
count303drivers/sound/pas2_pcm.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count306drivers/sound/pas2_pcm.ccount >>= 1;
count308drivers/sound/pas2_pcm.cif (count != pcm_count)
count312drivers/sound/pas2_pcm.cpas_write (count & 0xff, SAMPLE_BUFFER_COUNTER);
count313drivers/sound/pas2_pcm.cpas_write ((count >> 8) & 0xff, SAMPLE_BUFFER_COUNTER);
count316drivers/sound/pas2_pcm.cpcm_count = count;
count84drivers/sound/patmgr.cpmgr_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count89drivers/sound/patmgr.cif (count != sizeof (struct patmgr_info))
count107drivers/sound/patmgr.cCOPY_TO_USER (buf, 0, (char *) mbox[dev], count);
count118drivers/sound/patmgr.creturn count;
count122drivers/sound/patmgr.cpmgr_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count126drivers/sound/patmgr.cif (count < 4)
count143drivers/sound/patmgr.cbuf, 4, count, 1);
count146drivers/sound/patmgr.cif (count != sizeof (struct patmgr_info))
count161drivers/sound/patmgr.cCOPY_FROM_USER (&((char *) mbox[dev])[4], buf, 4, count - 4);
count172drivers/sound/patmgr.creturn count;
count62drivers/sound/sb16_dsp.cstatic void     sb16_dsp_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart);
count63drivers/sound/sb16_dsp.cstatic void     sb16_dsp_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart);
count334drivers/sound/sb16_dsp.csb16_dsp_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count338drivers/sound/sb16_dsp.ccnt = count;
count344drivers/sound/sb16_dsp.cprintk ("output_block: %x %d %d\n", buf, count, intrflag);
count371drivers/sound/sb16_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count391drivers/sound/sb16_dsp.csb16_dsp_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count395drivers/sound/sb16_dsp.ccnt = count;
count401drivers/sound/sb16_dsp.cprintk ("start_input: %x %d %d\n", buf, count, intrflag);
count428drivers/sound/sb16_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count346drivers/sound/sb_dsp.csb_dsp_output_block (int dev, unsigned long buf, int count,
count355drivers/sound/sb_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count358drivers/sound/sb_dsp.ccount >>= 1;
count359drivers/sound/sb_dsp.ccount--;
count366drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) (count & 0xff));
count367drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) ((count >> 8) & 0xff));
count379drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) (count & 0xff));
count380drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) ((count >> 8) & 0xff));
count390drivers/sound/sb_dsp.csb_dsp_start_input (int dev, unsigned long buf, int count, int intrflag,
count401drivers/sound/sb_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count404drivers/sound/sb_dsp.ccount >>= 1;
count405drivers/sound/sb_dsp.ccount--;
count412drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) (count & 0xff));
count413drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) ((count >> 8) & 0xff));
count425drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) (count & 0xff));
count426drivers/sound/sb_dsp.csb_dsp_command ((unsigned char) ((count >> 8) & 0xff));
count77drivers/sound/sequencer.csequencer_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count79drivers/sound/sequencer.cint             c = count, p = 0;
count85drivers/sound/sequencer.creturn pmgr_read (dev - 1, file, buf, count);
count92drivers/sound/sequencer.cif (c != count)  /* Some data has been received */
count95drivers/sound/sequencer.creturn count - c;  /* Return what we have */
count103drivers/sound/sequencer.creturn count - c;
count116drivers/sound/sequencer.creturn count - c;
count168drivers/sound/sequencer.csequencer_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count177drivers/sound/sequencer.cDEB (printk ("sequencer_write(dev=%d, count=%d)\n", dev, count));
count183drivers/sound/sequencer.creturn pmgr_write (dev - 1, file, buf, count);
count185drivers/sound/sequencer.cc = count;
count219drivers/sound/sequencer.creturn count - c;
count262drivers/sound/sequencer.creturn count - c;
count272drivers/sound/sequencer.creturn count;
count1128drivers/sound/sequencer.csequencer_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count1134drivers/sound/sequencer.csequencer_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count7drivers/sound/sound_calls.hint DMAbuf_read (int dev, snd_rw_buf *user_buf, int count);
count14drivers/sound/sound_calls.hint DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode);
count25drivers/sound/sound_calls.hint audio_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count26drivers/sound/sound_calls.hint audio_write (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count38drivers/sound/sound_calls.hint sequencer_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count39drivers/sound/sound_calls.hint sequencer_write (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count58drivers/sound/sound_calls.hint MIDIbuf_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count59drivers/sound/sound_calls.hint MIDIbuf_write (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count65drivers/sound/sound_calls.hvoid MIDIbuf_bytes_received(int dev, unsigned char *buf, int count);
count75drivers/sound/sound_calls.hint   CMIDI_write (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count76drivers/sound/sound_calls.hint   CMIDI_read  (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count95drivers/sound/sound_calls.hvoid request_sound_timer (int count);
count104drivers/sound/sound_calls.hint sound_read_sw (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count105drivers/sound/sound_calls.hint sound_write_sw (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count201drivers/sound/sound_calls.hint pmgr_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count);
count202drivers/sound/sound_calls.hint pmgr_write (int dev, struct fileinfo *file, snd_rw_buf * buf, int count);
count220drivers/sound/sound_switch.cread_status (snd_rw_buf * buf, int count)
count227drivers/sound/sound_switch.cl = count;
count242drivers/sound/sound_switch.csound_read_sw (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count244drivers/sound/sound_switch.cDEB (printk ("sound_read_sw(dev=%d, count=%d)\n", dev, count));
count249drivers/sound/sound_switch.creturn read_status (buf, count);
count255drivers/sound/sound_switch.creturn audio_read (dev, file, buf, count);
count259drivers/sound/sound_switch.creturn sequencer_read (dev, file, buf, count);
count264drivers/sound/sound_switch.creturn MIDIbuf_read (dev, file, buf, count);
count275drivers/sound/sound_switch.csound_write_sw (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count278drivers/sound/sound_switch.cDEB (printk ("sound_write_sw(dev=%d, count=%d)\n", dev, count));
count284drivers/sound/sound_switch.creturn sequencer_write (dev, file, buf, count);
count290drivers/sound/sound_switch.creturn audio_write (dev, file, buf, count);
count297drivers/sound/sound_switch.creturn count;
count61drivers/sound/soundcard.csound_read (struct inode *inode, struct file *file, char *buf, int count)
count68drivers/sound/soundcard.creturn sound_read_sw (dev, &files[dev], buf, count);
count72drivers/sound/soundcard.csound_write (struct inode *inode, struct file *file, char *buf, int count)
count79drivers/sound/soundcard.creturn sound_write_sw (dev, &files[dev], buf, count);
count247drivers/sound/soundcard.crequest_sound_timer (int count)
count250drivers/sound/soundcard.cif (count < 0)
count251drivers/sound/soundcard.ccount = jiffies + (-count);
count253drivers/sound/soundcard.ccount += seq_time;
count255drivers/sound/soundcard.ctimer_table[SOUND_TIMER].expires = count;
count19fs/block_dev.cint block_write(struct inode * inode, struct file * filp, char * buf, int count)
count55fs/block_dev.cwhile (count>0) {
count59fs/block_dev.cif (chars > count)
count60fs/block_dev.cchars=count;
count112fs/block_dev.ccount -= chars;
count124fs/block_dev.cint block_read(struct inode * inode, struct file * filp, char * buf, int count)
count165fs/block_dev.cif (left > count)
count166fs/block_dev.cleft = count;
count462fs/exec.cchar * addr, unsigned long count)
count487fs/exec.cresult = verify_area(VERIFY_WRITE, addr, count);
count491fs/exec.cresult = file.f_op->read(inode, &file, addr, count);
count600fs/exec.cbprm.argc = count(argv);
count601fs/exec.cbprm.envc = count(envp);
count23fs/ext/dir.cstatic int ext_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count65fs/ext/dir.cstruct dirent * dirent, int count)
count72fs/ext/file.cstatic int ext_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count96fs/ext/file.cif (left > count)
count97fs/ext/file.cleft = count;
count197fs/ext/file.cstatic int ext_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count221fs/ext/file.cwhile (written<count) {
count229fs/ext/file.cif (c > count-written)
count230fs/ext/file.cc = count-written;
count68fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblock || efb->count == 254) {
count79fs/ext/freelists.cefb->count = 0;
count82fs/ext/freelists.cefb->free[efb->count++] = block;
count105fs/ext/freelists.cif (efb->count) {
count106fs/ext/freelists.cj = efb->free[--efb->count];
count152fs/ext/freelists.cunsigned long count, block;
count156fs/ext/freelists.ccount = 0;
count159fs/ext/freelists.ccount = efb->count + 1;
count167fs/ext/freelists.ccount += efb->count + 1;
count174fs/ext/freelists.csb->u.ext_sb.s_freeblockscount, count);
count176fs/ext/freelists.creturn count;
count222fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeinodeblock || efi->count == 14) {
count234fs/ext/freelists.cefi->count = 0;
count238fs/ext/freelists.cefi->free[efi->count++] = ino;
count264fs/ext/freelists.cif (efi->count) {
count265fs/ext/freelists.cj = efi->free[--efi->count];
count312fs/ext/freelists.cunsigned long count, block, ino;
count316fs/ext/freelists.ccount = 0;
count320fs/ext/freelists.ccount = efi->count + 1;
count335fs/ext/freelists.ccount += efi->count + 1;
count342fs/ext/freelists.csb->u.ext_sb.s_freeinodescount, count);
count344fs/ext/freelists.creturn count;
count250fs/ext2/balloc.cunsigned long count)
count268fs/ext2/balloc.c(block + count) > es->s_blocks_count) {
count271fs/ext2/balloc.c"block = %lu, count = %lu", block, count);
count281fs/ext2/balloc.cif (bit + count > EXT2_BLOCKS_PER_GROUP(sb))
count285fs/ext2/balloc.cblock, count);
count291fs/ext2/balloc.c(in_range (gdp->bg_block_bitmap, block, count) ||
count292fs/ext2/balloc.cin_range (gdp->bg_inode_bitmap, block, count) ||
count295fs/ext2/balloc.cin_range (block + count - 1, gdp->bg_inode_table,
count300fs/ext2/balloc.cblock, count);
count302fs/ext2/balloc.cfor (i = 0; i < count; i++) {
count26fs/ext2/dir.cchar * buf, int count)
count92fs/ext2/dir.cstruct dirent * dirent, int count)
count76fs/ext2/file.cchar * buf, int count)
count105fs/ext2/file.cif (left > count)
count106fs/ext2/file.cleft = count;
count227fs/ext2/file.cchar * buf, int count)
count258fs/ext2/file.cwhile (written < count) {
count266fs/ext2/file.cif (c > count-written)
count267fs/ext2/file.cc = count - written;
count184fs/hpfs/hpfs_fs.cchar *buf, int count);
count186fs/hpfs/hpfs_fs.cstruct dirent *dirent, int count);
count802fs/hpfs/hpfs_fs.cunsigned n, count, n_bands;
count819fs/hpfs/hpfs_fs.ccount = 0;
count828fs/hpfs/hpfs_fs.ccount += count_one_bitmap(s->s_dev, bitmaps[n]);
count831fs/hpfs/hpfs_fs.creturn count;
count842fs/hpfs/hpfs_fs.cunsigned i, count;
count848fs/hpfs/hpfs_fs.ccount = 0;
count851fs/hpfs/hpfs_fs.ccount += (test_bit(i, bits) != 0);
count854fs/hpfs/hpfs_fs.creturn count;
count864fs/hpfs/hpfs_fs.cchar *buf, int count)
count877fs/hpfs/hpfs_fs.cif (count > inode->i_size - filp->f_pos)
count878fs/hpfs/hpfs_fs.ccount = inode->i_size - filp->f_pos;
count881fs/hpfs/hpfs_fs.cwhile (count > 0) {
count893fs/hpfs/hpfs_fs.cif (n > count)
count894fs/hpfs/hpfs_fs.cn = count;
count923fs/hpfs/hpfs_fs.cif (count > inode->i_size - filp->f_pos - n + n0)
count924fs/hpfs/hpfs_fs.ccount = inode->i_size - filp->f_pos - n + n0;
count934fs/hpfs/hpfs_fs.ccount -= n0;
count1562fs/hpfs/hpfs_fs.cchar *buf, int count)
count387fs/inode.cinode->i_sem.count = 1;
count67fs/isofs/dir.cstruct dirent * dirent, int count)
count114fs/isofs/file.cstatic int isofs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count138fs/isofs/file.cif (left > count)
count139fs/isofs/file.cleft = count;
count16fs/minix/dir.cstatic int minix_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count58fs/minix/dir.cstruct dirent * dirent, int count)
count66fs/minix/file.cstatic int minix_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count90fs/minix/file.cif (left > count)
count91fs/minix/file.cleft = count;
count189fs/minix/file.cstatic int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count210fs/minix/file.cwhile (written < count) {
count218fs/minix/file.cif (c > count-written)
count219fs/minix/file.cc = count-written;
count17fs/msdos/dir.cstatic int msdos_dir_read(struct inode * inode,struct file * filp, char * buf,int count)
count23fs/msdos/dir.cstruct dirent *dirent,int count);
count58fs/msdos/dir.cstruct dirent *dirent,int count)
count108fs/msdos/fat.cint count;
count112fs/msdos/fat.cfor (count = 0; count < FAT_CACHE; count++) {
count113fs/msdos/fat.ccache[count].device = 0;
count114fs/msdos/fat.ccache[count].next = count == FAT_CACHE-1 ? NULL :
count115fs/msdos/fat.c&cache[count+1];
count224fs/msdos/fat.cint nr,count;
count228fs/msdos/fat.ccount = 0;
count229fs/msdos/fat.cfor (cache_lookup(inode,cluster,&count,&nr); count < cluster;
count230fs/msdos/fat.ccount++) {
count23fs/msdos/file.cint count);
count25fs/msdos/file.cint count);
count81fs/msdos/file.cint count)
count98fs/msdos/file.cif (filp->f_pos >= inode->i_size || count <= 0) return 0;
count100fs/msdos/file.cwhile ((left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) > 0){
count136fs/msdos/file.cint count)
count157fs/msdos/file.cif (count <= 0) return 0;
count159fs/msdos/file.cfor (start = buf; count || carry; count -= size) {
count167fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
count185fs/msdos/file.cfor (size = 0; size < count && left; size++) {
count111fs/msdos/misc.cint count,nr,limit,last,current,sector;
count120fs/msdos/misc.cfor (count = 0; count < limit; count++) {
count121fs/msdos/misc.cnr = ((count+MSDOS_SB(inode->i_sb)->prev_free) % limit)+2;
count127fs/msdos/misc.cMSDOS_SB(inode->i_sb)->prev_free = (count+MSDOS_SB(inode->i_sb)->
count129fs/msdos/misc.cif (count >= limit) {
count389fs/msdos/misc.cint count,cluster;
count391fs/msdos/misc.cfor (count = 0; count < MSDOS_SB(sb)->dir_entries/MSDOS_DPS; count++) {
count392fs/msdos/misc.cif ((cluster = raw_scan_sector(sb,MSDOS_SB(sb)->dir_start+count,
count408fs/msdos/misc.cint count,cluster;
count414fs/msdos/misc.cfor (count = 0; count < MSDOS_SB(sb)->cluster_size; count++) {
count417fs/msdos/misc.ccount,name,number,ino,res_bh,res_de)) >= 0)
count493fs/msdos/misc.cint count;
count495fs/msdos/misc.ccount = 0;
count497fs/msdos/misc.c(void) raw_scan_root(dir->i_sb,NULL,&count,NULL,NULL,NULL);
count501fs/msdos/misc.cNULL,&count,NULL,NULL,NULL);
count503fs/msdos/misc.creturn count;
count22fs/nfs/dir.cint count);
count73fs/nfs/dir.cint count)
count87fs/nfs/dir.cstruct dirent *dirent, int count)
count63fs/nfs/file.cint count)
count83fs/nfs/file.cif (file->f_pos + count > inode->i_size)
count84fs/nfs/file.ccount = inode->i_size - pos;
count85fs/nfs/file.cif (count <= 0)
count89fs/nfs/file.cfor (i = 0; i < count; i += n) {
count90fs/nfs/file.chunk = count - i;
count114fs/nfs/file.cint count)
count133fs/nfs/file.cif (count <= 0)
count140fs/nfs/file.cfor (i = 0; i < count; i += n) {
count141fs/nfs/file.chunk = count - i;
count352fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
count359fs/nfs/proc.cPRINTK("NFS call  read %d @ %d\n", count, offset);
count366fs/nfs/proc.c*p++ = htonl(count);
count367fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
count376fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count))) {
count395fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
count401fs/nfs/proc.cPRINTK("NFS call  write %d @ %d\n", count, offset);
count409fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
count410fs/nfs/proc.cp = xdr_encode_data(p, data, count);
count683fs/nfs/proc.cint cookie, int count, struct nfs_entry *entry)
count692fs/nfs/proc.cPRINTK("NFS call  readdir %d @ %d\n", count, cookie);
count708fs/nfs/proc.cfor (i = 0; i < count && *p++; i++) {
count717fs/nfs/proc.ceof = (i == count && !*p++ && *p++)
count718fs/nfs/proc.c|| (i < count && *p++);
count24fs/pipe.cstatic int pipe_read(struct inode * inode, struct file * filp, char * buf, int count)
count47fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
count49fs/pipe.cif (chars > count)
count50fs/pipe.cchars = count;
count58fs/pipe.ccount -= chars;
count71fs/pipe.cstatic int pipe_write(struct inode * inode, struct file * filp, char * buf, int count)
count81fs/pipe.cif (count <= PIPE_BUF)
count82fs/pipe.cfree = count;
count85fs/pipe.cwhile (count>0) {
count98fs/pipe.cwhile (count>0 && (free = PIPE_FREE(*inode))) {
count100fs/pipe.cif (chars > count)
count101fs/pipe.cchars = count;
count107fs/pipe.ccount -= chars;
count123fs/pipe.cstatic int pipe_readdir(struct inode * inode, struct file * file, struct dirent * de, int count)
count128fs/pipe.cstatic int bad_pipe_rw(struct inode * inode, struct file * filp, char * buf, int count)
count202fs/pipe.cstatic int connect_read(struct inode * inode, struct file * filp, char * buf, int count)
count215fs/pipe.creturn pipe_read(inode,filp,buf,count);
count39fs/proc/array.cstatic int read_core(struct inode * inode, struct file * file,char * buf, int count)
count51fs/proc/array.cif (count < 0)
count55fs/proc/array.cif (count > high_memory + PAGE_SIZE - p)
count56fs/proc/array.ccount = high_memory + PAGE_SIZE - p;
count59fs/proc/array.cif (p < sizeof(struct user) && count > 0) {
count60fs/proc/array.ccount1 = count;
count67fs/proc/array.ccount -= count1;
count71fs/proc/array.cwhile (p < 2*PAGE_SIZE && count > 0) {
count75fs/proc/array.ccount--;
count78fs/proc/array.cmemcpy_tofs(buf,(void *) (p - PAGE_SIZE),count);
count79fs/proc/array.cread += count;
count255fs/proc/array.cint count = 0;
count271fs/proc/array.c} while (count++ < 16);
count470fs/proc/array.cstatic int array_read(struct inode * inode, struct file * file,char * buf, int count)
count477fs/proc/array.cif (count < 0)
count516fs/proc/array.creturn read_core(inode, file, buf, count);
count540fs/proc/array.cif (count + file->f_pos > length)
count541fs/proc/array.ccount = length - file->f_pos;
count542fs/proc/array.cend = count + file->f_pos;
count543fs/proc/array.cmemcpy_tofs(buf, page + file->f_pos, count);
count546fs/proc/array.creturn count;
count133fs/proc/base.cstruct dirent * dirent, int count)
count127fs/proc/fd.cstruct dirent * dirent, int count)
count19fs/proc/kmsg.casmlinkage int sys_syslog(int type, char * bug, int count);
count31fs/proc/kmsg.cstatic int kmsg_read(struct inode * inode, struct file * file,char * buf, int count)
count33fs/proc/kmsg.creturn sys_syslog(2,buf,count);
count23fs/proc/mem.cstatic int mem_read(struct inode * inode, struct file * file,char * buf, int count)
count30fs/proc/mem.cif (count < 0)
count44fs/proc/mem.cwhile (count > 0) {
count58fs/proc/mem.cif (i > count)
count59fs/proc/mem.ci = count;
count63fs/proc/mem.ccount -= i;
count71fs/proc/mem.cstatic int mem_write(struct inode * inode, struct file * file,char * buf, int count)
count78fs/proc/mem.cif (count < 0)
count92fs/proc/mem.cwhile (count > 0) {
count110fs/proc/mem.cif (i > count)
count111fs/proc/mem.ci = count;
count115fs/proc/mem.ccount -= i;
count36fs/proc/net.cchar * buf, int count);
count167fs/proc/net.cstruct dirent * dirent, int count)
count196fs/proc/net.cchar * buf, int count)
count201fs/proc/net.cint bytes=count;
count206fs/proc/net.cif (count < 0)
count134fs/proc/root.cstruct dirent * dirent, int count)
count19fs/read_write.casmlinkage int sys_readdir(unsigned int fd, struct dirent * dirent, unsigned int count)
count32fs/read_write.cerror = file->f_op->readdir(inode,file,dirent,count);
count70fs/read_write.casmlinkage int sys_read(unsigned int fd,char * buf,unsigned int count)
count82fs/read_write.cif (!count)
count84fs/read_write.cerror = verify_area(VERIFY_WRITE,buf,count);
count87fs/read_write.creturn file->f_op->read(inode,file,buf,count);
count90fs/read_write.casmlinkage int sys_write(unsigned int fd,char * buf,unsigned int count)
count102fs/read_write.cif (!count)
count104fs/read_write.cerror = verify_area(VERIFY_READ,buf,count);
count107fs/read_write.creturn file->f_op->write(inode,file,buf,count);
count87fs/select.cint count;
count118fs/select.ccount = 0;
count127fs/select.ccount++;
count132fs/select.ccount++;
count137fs/select.ccount++;
count142fs/select.cif (!count && current->timeout && !(current->signal & ~current->blocked)) {
count149fs/select.creturn count;
count32fs/sysv/balloc.cextern inline void memzero (void * s, size_t count)
count38fs/sysv/balloc.c:"a" (0),"D" (s),"c" (count/4)
count249fs/sysv/balloc.cint count, old_count;
count256fs/sysv/balloc.ccount = 0;
count265fs/sysv/balloc.ccount++;
count316fs/sysv/balloc.ccount++;
count330fs/sysv/balloc.cif (count != old_count) {
count331fs/sysv/balloc.cprintk("sysv_count_free_blocks: free block count was %d, correcting to %d\n",old_count,count);
count333fs/sysv/balloc.c*sb->sv_sb_total_free_blocks = (sb->sv_convert ? to_coh_ulong(count) : count);
count339fs/sysv/balloc.creturn count;
count341fs/sysv/balloc.cint count;
count343fs/sysv/balloc.ccount = *sb->sv_sb_total_free_blocks;
count345fs/sysv/balloc.ccount = from_coh_ulong(count);
count346fs/sysv/balloc.creturn count;
count23fs/sysv/dir.cstatic int sysv_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count65fs/sysv/dir.cstruct dirent * dirent, int count)
count109fs/sysv/file.cstatic int sysv_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count135fs/sysv/file.cif (left > count)
count136fs/sysv/file.cleft = count;
count242fs/sysv/file.cstatic int sysv_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count273fs/sysv/file.cwhile (written<count) {
count281fs/sysv/file.cif (c > count-written)
count282fs/sysv/file.cc = count-written;
count167fs/sysv/ialloc.cint j,block,count;
count170fs/sysv/ialloc.ccount = 0;
count187fs/sysv/ialloc.ccount++;
count190fs/sysv/ialloc.cif (count != *sb->sv_sb_total_free_inodes) {
count191fs/sysv/ialloc.cprintk("sysv_count_free_inodes: free inode count was %d, correcting to %d\n",(short)(*sb->sv_sb_total_free_inodes),count);
count193fs/sysv/ialloc.c*sb->sv_sb_total_free_inodes = count;
count199fs/sysv/ialloc.creturn count;
count60fs/xiafs/dir.cstruct file * filp, char * buf, int count)
count66fs/xiafs/dir.cstruct file * filp, struct dirent * dirent, int count)
count70fs/xiafs/file.cxiafs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count89fs/xiafs/file.cif (left > count)
count90fs/xiafs/file.cleft = count;
count190fs/xiafs/file.cxiafs_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count214fs/xiafs/file.cwhile (written < count) {
count222fs/xiafs/file.cif (c > count-written)
count223fs/xiafs/file.cc = count-written;
count223include/asm/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count225include/asm/dma.hcount--;
count227include/asm/dma.houtb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count228include/asm/dma.houtb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count230include/asm/dma.houtb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count231include/asm/dma.houtb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count250include/asm/dma.hunsigned short count;
count252include/asm/dma.hcount = 1 + inb(io_port);
count253include/asm/dma.hcount += inb(io_port) << 8;
count255include/asm/dma.hreturn (dmanr<=3)? count : (count<<1);
count69include/asm/io.hextern inline void ins##s(unsigned short port, void * addr, unsigned long count) \
count71include/asm/io.h: "=D" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
count74include/asm/io.hextern inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
count76include/asm/io.h: "=S" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
count41include/linux/binfmts.hchar * addr, unsigned long count);
count26include/linux/ext_fs.hunsigned long count;
count32include/linux/ext_fs.hunsigned long count;
count12include/linux/mm.hint __verify_write(unsigned long addr, unsigned long count);
count84include/linux/mm.hunsigned short count;
count165include/linux/mm.hextern int vread(char *buf, char *addr, int count);
count68include/linux/nfs_fs.hint offset, int count, char *data,
count71include/linux/nfs_fs.hint offset, int count, char *data,
count91include/linux/nfs_fs.hint cookie, int count, struct nfs_entry *entry);
count192include/linux/sched.hint count;
count204include/linux/sched.hint count;
count216include/linux/sched.hint count;
count546include/linux/sched.hif (sem->count <= 0)
count548include/linux/sched.hsem->count--;
count553include/linux/sched.hsem->count++;
count103include/linux/serial.hint      count;      /* # of fd on device */
count38include/linux/string.hextern inline char * strncpy(char * dest,const char *src,size_t count)
count51include/linux/string.h:"S" (src),"D" (dest),"c" (count):"si","di","ax","cx","memory");
count70include/linux/string.hextern inline char * strncat(char * dest,const char * src,size_t count)
count86include/linux/string.h:"S" (src),"D" (dest),"a" (0),"c" (0xffffffff),"g" (count)
count109include/linux/string.hextern inline int strncmp(const char * cs,const char * ct,size_t count)
count125include/linux/string.h:"=a" (__res):"S" (cs),"D" (ct),"c" (count):"si","di","cx");
count377include/linux/string.hextern inline int memcmp(const void * cs,const void * ct,size_t count)
count387include/linux/string.h:"=a" (__res):"0" (0),"S" (cs),"D" (ct),"c" (count)
count392include/linux/string.hextern inline void * memchr(const void * cs,char c,size_t count)
count395include/linux/string.hif (!count)
count403include/linux/string.h:"=D" (__res):"a" (c),"D" (cs),"c" (count)
count408include/linux/string.hextern inline void * memset(void * s,char c,size_t count)
count414include/linux/string.h:"a" (c),"D" (s),"c" (count)
count78include/linux/tty.hint    count;
count195include/linux/tty.hint count;
count120include/linux/tty_driver.hunsigned char *buf, int count);
count13include/linux/tty_flip.hif (tty->flip.count++ >= TTY_FLIPBUF_SIZE)
count37include/linux/tty_ldisc.hchar *fp, int count);
count15include/linux/wait.hint count;
count118include/linux/xd.hstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count);
count122include/linux/xd.hstatic u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count);
count123include/linux/xd.hstatic u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control);
count53init/main.cstatic inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
count287kernel/exit.cint err, retval = 0, count = 0;
count295kernel/exit.c++count;
count300kernel/exit.creturn(count ? retval : -ESRCH);
count37kernel/ksyms.cchar * addr, unsigned long count);
count57kernel/printk.cunsigned long i, j, count;
count110kernel/printk.ccount = len;
count111kernel/printk.cif (count > LOG_BUF_LEN)
count112kernel/printk.ccount = LOG_BUF_LEN;
count113kernel/printk.cif (count > logged_chars)
count114kernel/printk.ccount = logged_chars;
count115kernel/printk.cj = log_start + log_size - count;
count116kernel/printk.cfor (i = 0; i < count; i++) {
count328kernel/sched.cwhile (sem->count <= 0) {
count444kernel/sched.cstatic int count = LOAD_FREQ;
count446kernel/sched.cif (count-- > 0)
count448kernel/sched.ccount = LOAD_FREQ;
count172kernel/time.cint count;
count177kernel/time.ccount = inb_p(0x40);  /* read the latched count */
count178kernel/time.ccount |= inb(0x40) << 8;
count180kernel/time.cif (count > (LATCH - LATCH/100)) {
count186kernel/time.ccount = ((LATCH-1) - count) * TICK_SIZE;
count187kernel/time.ccount = (count + LATCH/2) / LATCH;
count188kernel/time.creturn offset + count;
count11lib/write.c_syscall3(int,write,int,fd,const char *,buf,off_t,count)
count172mm/kmalloc.cstatic int count = 0;
count173mm/kmalloc.cif (++count < 5) {
count597mm/swap.cstatic int count = 0;
count598mm/swap.cif (++count < 5) {
count178mm/vmalloc.cint vread(char *buf, char *addr, int count)
count187mm/vmalloc.cif (count == 0)
count189mm/vmalloc.cput_fs_byte('\0', buf++), addr++, count--;
count195mm/vmalloc.cif (count == 0)
count197mm/vmalloc.cput_fs_byte(*addr++, buf++), count--;
count824net/inet/ip.cint count, len;
count853net/inet/ip.ccount = 0;
count859net/inet/ip.cif(count+fp->len>skb->len)
count868net/inet/ip.ccount += fp->len;
count878net/inet/ip.ciph->tot_len = htons((iph->ihl * sizeof(unsigned long)) + count);
count452net/inet/skbuff.cstatic int count = 0;
count453net/inet/skbuff.cif (++count < 5) {
count55net/socket.cstruct dirent *dirent, int count);
count276net/socket.cint count)