taglinefilesource code
cmd95arch/alpha/kernel/bios32.cunsigned short cmd;
cmd99arch/alpha/kernel/bios32.cpcibios_read_config_word(bus->number, dev->devfn, PCI_COMMAND, &cmd);
cmd121arch/alpha/kernel/bios32.ccmd |= PCI_COMMAND_IO;
cmd135arch/alpha/kernel/bios32.ccmd |= PCI_COMMAND_MEMORY;
cmd223arch/alpha/kernel/bios32.ccmd |= PCI_COMMAND_IO;
cmd226arch/alpha/kernel/bios32.ccmd | PCI_COMMAND_MASTER);
cmd199drivers/block/aztcd.c(CURRENT && MAJOR(CURRENT -> rq_dev) == MAJOR_NR && CURRENT -> cmd == READ \
cmd270drivers/block/aztcd.cstatic int  aztSendCmd(int cmd);
cmd271drivers/block/aztcd.cstatic int  sendAztCmd(int cmd, struct azt_Play_msf *params);
cmd410drivers/block/aztcd.cstatic int aztSendCmd(int cmd)
cmd415drivers/block/aztcd.cprintk("aztcd: Executing command %x\n",cmd);
cmd417drivers/block/aztcd.caztCmd=cmd;
cmd426drivers/block/aztcd.c{ outb((unsigned char) cmd,CMD_PORT);
cmd434drivers/block/aztcd.cprintk("### Error 1 aztcd: aztSendCmd %x  Error Code %x\n",cmd,data);
cmd438drivers/block/aztcd.c{ printk("### Error 2 aztcd: aztSendCmd %x \n",cmd);
cmd447drivers/block/aztcd.cstatic int sendAztCmd(int cmd, struct azt_Play_msf *params)
cmd457drivers/block/aztcd.c{ aztSendCmd(cmd);
cmd471drivers/block/aztcd.cprintk("### Error 1 aztcd: sendAztCmd %x  Error Code %x\n",cmd,data);
cmd475drivers/block/aztcd.c{ printk("### Error 2 aztcd: sendAztCmd %x\n ",cmd);
cmd618drivers/block/aztcd.cstatic int aztcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd630drivers/block/aztcd.cprintk("aztcd: starting aztcd_ioctl - Command:%x   Time: %li\n",cmd, jiffies);
cmd639drivers/block/aztcd.cswitch (cmd)
cmd813drivers/block/aztcd.cprintk("aztcd: exiting aztcd_ioctl - Error 1 - Command:%x\n",cmd);
cmd820drivers/block/aztcd.cprintk("aztcd: exiting aztcd_ioctl - Error 2 - Command:%x\n",cmd);
cmd828drivers/block/aztcd.cprintk("aztcd: exiting aztcd_ioctl - Error 3 - Command:%x\n",cmd);
cmd914drivers/block/aztcd.cif (cmd==CDROMREADRAW)
cmd955drivers/block/aztcd.cprintk("aztcd: exiting aztcd_ioctl Command:%x  Time:%li\n",cmd,jiffies);
cmd21drivers/block/blk.h((s1)->cmd < (s2)->cmd || ((s1)->cmd == (s2)->cmd && \
cmd235drivers/block/cdu31a.cstatic void do_sony_cd_cmd(unsigned char cmd,
cmd511drivers/block/cdu31a.cwrite_cmd(unsigned char cmd)
cmd514drivers/block/cdu31a.coutb(cmd, sony_cd_cmd_reg);
cmd813drivers/block/cdu31a.cdo_sony_cd_cmd(unsigned char cmd,
cmd881drivers/block/cdu31a.cwrite_cmd(cmd);
cmd1567drivers/block/cdu31a.cswitch(CURRENT->cmd)
cmd2306drivers/block/cdu31a.cunsigned char cmd,
cmd2312drivers/block/cdu31a.cdo_sony_cd_cmd(cmd, params, num_params, result_buffer, result_size);
cmd2326drivers/block/cdu31a.cunsigned int  cmd,
cmd2340drivers/block/cdu31a.cswitch (cmd)
cmd653drivers/block/cm206.cif (CURRENT->cmd != READ) {
cmd654drivers/block/cm206.cdebug(("Non-read command %d on cdrom\n", CURRENT->cmd));
cmd895drivers/block/cm206.cunsigned int cmd, unsigned long arg)
cmd897drivers/block/cm206.cswitch (cmd) {
cmd936drivers/block/cm206.cswitch (cmd) {
cmd1018drivers/block/cm206.celse return -cmd;
cmd1031drivers/block/cm206.cdebug(("Unknown ioctl call 0x%x\n", cmd));
cmd194drivers/block/floppy.cunsigned char cmd[9];
cmd321drivers/block/floppy.c#define COMMAND raw_cmd->cmd[0]
cmd322drivers/block/floppy.c#define DR_SELECT raw_cmd->cmd[1]
cmd323drivers/block/floppy.c#define TRACK raw_cmd->cmd[2]
cmd324drivers/block/floppy.c#define HEAD raw_cmd->cmd[3]
cmd325drivers/block/floppy.c#define SECTOR raw_cmd->cmd[4]
cmd326drivers/block/floppy.c#define SIZECODE raw_cmd->cmd[5]
cmd327drivers/block/floppy.c#define SECT_PER_TRACK raw_cmd->cmd[6]
cmd328drivers/block/floppy.c#define GAP raw_cmd->cmd[7]
cmd329drivers/block/floppy.c#define SIZECODE2 raw_cmd->cmd[8]
cmd333drivers/block/floppy.c#define F_SIZECODE raw_cmd->cmd[2]
cmd334drivers/block/floppy.c#define F_SECT_PER_TRACK raw_cmd->cmd[3]
cmd335drivers/block/floppy.c#define F_GAP raw_cmd->cmd[4]
cmd336drivers/block/floppy.c#define F_FILL raw_cmd->cmd[5]
cmd1052drivers/block/floppy.cprintk("%x,", raw_cmd->cmd[i]);
cmd1459drivers/block/floppy.cr|=output_byte( raw_cmd->cmd[i] );
cmd2222drivers/block/floppy.cif(CURRENT->cmd == WRITE) {
cmd2463drivers/block/floppy.cif (CURRENT->cmd == READ){
cmd2466drivers/block/floppy.c} else if (CURRENT->cmd == WRITE){
cmd2949drivers/block/floppy.cstatic inline int raw_cmd_copyout(int cmd, char *param,
cmd2956drivers/block/floppy.cif(cmd == OLDFDRAWCMD) {
cmd3001drivers/block/floppy.cstatic inline int raw_cmd_copyin(int cmd, char *param,
cmd3018drivers/block/floppy.cif(cmd == OLDFDRAWCMD){
cmd3026drivers/block/floppy.cmemcpy(ptr->cmd, old_raw_cmd.cmd, 9);
cmd3067drivers/block/floppy.cstatic int raw_cmd_ioctl(int cmd, void *param)
cmd3091drivers/block/floppy.cret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
cmd3111drivers/block/floppy.cret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
cmd3127drivers/block/floppy.cstatic int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
cmd3143drivers/block/floppy.cswitch (cmd) {
cmd3148drivers/block/floppy.cswitch (cmd) {
cmd3200drivers/block/floppy.cswitch (cmd) {
cmd3216drivers/block/floppy.cCALL(i = raw_cmd_ioctl(cmd,(void *) param));
cmd3286drivers/block/floppy.cif ( cmd != FDDEFPRM )
cmd3296drivers/block/floppy.cif (cmd == FDDEFPRM)
cmd3336drivers/block/floppy.cswitch(cmd){
cmd210drivers/block/gscd.cstatic int gscd_ioctl (struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd216drivers/block/gscd.cswitch (cmd)
cmd282drivers/block/gscd.cif (CURRENT -> cmd != READ)
cmd284drivers/block/gscd.cprintk("GSCD: bad cmd %d\n", CURRENT -> cmd);
cmd325drivers/block/gscd.cchar   cmd[] = { CMD_READ, 0x80, 0,0,0, 0,1 }; /* cmd mode M-S-F secth sectl */
cmd348drivers/block/gscd.ccmd[2] = gscdcmd.start.min;
cmd349drivers/block/gscd.ccmd[3] = gscdcmd.start.sec;
cmd350drivers/block/gscd.ccmd[4] = gscdcmd.start.frame;
cmd353drivers/block/gscd.cprintk ("GSCD: read msf %d:%d:%d\n", cmd[2], cmd[3], cmd[4] ); 
cmd355drivers/block/gscd.ccmd_out ( TYPE_DATA, (char *)&cmd, (char *)&gscd_buf[0], 1 );
cmd531drivers/block/gscd.cvoid cmd_out ( int cmd_type, char * cmd, char * respo_buf, int respo_count )
cmd587drivers/block/gscd.ccmd_write_cmd (cmd);
cmd221drivers/block/hd.cunsigned int head,unsigned int cyl,unsigned int cmd,
cmd245drivers/block/hd.coutb_p(cmd,++port);
cmd738drivers/block/hd.cdev+'a', (CURRENT->cmd == READ)?"read":"writ",
cmd743drivers/block/hd.cif (CURRENT->cmd == READ) {
cmd744drivers/block/hd.cunsigned int cmd = mult_count[dev] > 1 ? WIN_MULTREAD : WIN_READ;
cmd745drivers/block/hd.chd_out(dev,nsect,sec,head,cyl,cmd,&read_intr);
cmd750drivers/block/hd.cif (CURRENT->cmd == WRITE) {
cmd779drivers/block/hd.cunsigned int cmd, unsigned long arg)
cmd790drivers/block/hd.cswitch (cmd) {
cmd552drivers/block/ide-cd.crq->cmd = REQUEST_SENSE_COMMAND;
cmd587drivers/block/ide-cd.cif (rq->cmd == REQUEST_SENSE_COMMAND && uptodate)
cmd614drivers/block/ide-cd.cint stat, err, sense_key, cmd;
cmd631drivers/block/ide-cd.ccmd = rq->cmd;
cmd633drivers/block/ide-cd.cif (cmd == REQUEST_SENSE_COMMAND)
cmd646drivers/block/ide-cd.celse if (cmd == PACKET_COMMAND)
cmd1420drivers/block/ide-cd.creq.cmd = PACKET_COMMAND;
cmd1489drivers/block/ide-cd.cif (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
cmd1492drivers/block/ide-cd.celse if (rq -> cmd == RESET_DRIVE_COMMAND)
cmd1499drivers/block/ide-cd.celse if (rq -> cmd != READ)
cmd1501drivers/block/ide-cd.cprintk ("ide-cd: bad cmd %d\n", rq -> cmd);
cmd2056drivers/block/ide-cd.cstruct file *file, unsigned int cmd, unsigned long arg)
cmd2058drivers/block/ide-cd.cswitch (cmd)
cmd2398drivers/block/ide-cd.cif (cmd == CDROMREADMODE1)
cmd2439drivers/block/ide-cd.creq.cmd = RESET_DRIVE_COMMAND;
cmd852drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {  /* never retry an explicit DRIVE_CMD */
cmd866drivers/block/ide.cif ((stat & DRQ_STAT) && rq->cmd != WRITE)
cmd1050drivers/block/ide.cstatic void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
cmd1055drivers/block/ide.cOUT_BYTE(cmd,IDE_COMMAND_REG);
cmd1211drivers/block/ide.cdrive->name, (rq->cmd==READ)?"read":"writ", 
cmd1230drivers/block/ide.cdrive->name, (rq->cmd==READ)?"read":"writ", cyl,
cmd1234drivers/block/ide.cif (rq->cmd == READ) {
cmd1243drivers/block/ide.cif (rq->cmd == WRITE) {
cmd1266drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {
cmd1286drivers/block/ide.cprintk("%s: bad command: %d\n", drive->name, rq->cmd);
cmd1607drivers/block/ide.crq.cmd = IDE_DRIVE_CMD;
cmd1747drivers/block/ide.cunsigned int cmd, unsigned long arg)
cmd1758drivers/block/ide.cswitch (cmd) {
cmd1835drivers/block/ide.cswitch (cmd) {
cmd1908drivers/block/ide.creturn ide_cdrom_ioctl(drive, inode, file, cmd, arg);
cmd1956drivers/block/ide.cstatic inline void do_identify (ide_drive_t *drive, byte cmd)
cmd1981drivers/block/ide.cif (cmd == WIN_PIDENTIFY) {
cmd1994drivers/block/ide.cif (cmd == WIN_PIDENTIFY) {
cmd2108drivers/block/ide.cstatic int try_to_identify (ide_drive_t *drive, byte cmd)
cmd2127drivers/block/ide.cOUT_BYTE(cmd,IDE_COMMAND_REG);    /* ask drive for ID */
cmd2128drivers/block/ide.ctimeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
cmd2142drivers/block/ide.cdo_identify(drive, cmd); /* drive returned ID */
cmd2172drivers/block/ide.cstatic int do_probe (ide_drive_t *drive, byte cmd)
cmd2177drivers/block/ide.cif ((drive->media == cdrom) && (cmd == WIN_IDENTIFY))
cmd2184drivers/block/ide.c(cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
cmd2198drivers/block/ide.c|| drive->present || cmd == WIN_PIDENTIFY)
cmd2200drivers/block/ide.cif ((rc = try_to_identify(drive,cmd)))   /* send cmd and wait */
cmd2201drivers/block/ide.crc = try_to_identify(drive,cmd); /* failed: try again */
cmd112drivers/block/ll_rw_blk.cplug->cmd = -1;
cmd132drivers/block/ll_rw_blk.cif (req && req->rq_status == RQ_INACTIVE && req->cmd == -1) {
cmd357drivers/block/ll_rw_blk.creq->cmd == rw &&
cmd371drivers/block/ll_rw_blk.creq->cmd == rw &&
cmd404drivers/block/ll_rw_blk.creq->cmd = rw;
cmd438drivers/block/ll_rw_blk.creq->cmd = rw;
cmd570drivers/block/ll_rw_blk.creq[j]->cmd = rw;
cmd143drivers/block/mcd.c(CURRENT && MAJOR(CURRENT -> rq_dev) == MAJOR_NR && CURRENT -> cmd == READ \
cmd194drivers/block/mcd.cstatic void sendMcdCmd(int cmd, struct mcd_Play_msf *params);
cmd294drivers/block/mcd.cmcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
cmd321drivers/block/mcd.cswitch (cmd)
cmd1330drivers/block/mcd.csendMcdCmd(int cmd, struct mcd_Play_msf *params)
cmd1332drivers/block/mcd.coutb(cmd, MCDPORT(0));
cmd245drivers/block/mcdx.cconst unsigned char* cmd, size_t, void *buffer,
cmd281drivers/block/mcdx.cunsigned int cmd, unsigned long arg)
cmd288drivers/block/mcdx.cswitch (cmd) {
cmd529drivers/block/mcdx.cWARN(("ioctl(): unknown request 0x%04x\n", cmd));
cmd567drivers/block/mcdx.cswitch (CURRENT->cmd) {
cmd850drivers/block/mcdx.cconst unsigned char *cmd, size_t cmdlen,
cmd877drivers/block/mcdx.ctries, timeout, size, (unsigned char) cmd[0]));
cmd878drivers/block/mcdx.cfor (i = 1; i < cmdlen; i++) printk(" 0x%02x", cmd[i]);
cmd890drivers/block/mcdx.coutsb((unsigned int) stuffp->wreg_data, cmd, cmdlen);
cmd896drivers/block/mcdx.ccmd[0], tries - 1, tries == 2 ? "y" : "ies"));
cmd906drivers/block/mcdx.cWARN(("command error %02x (%d)\n", cmd[0], cmdlen));
cmd926drivers/block/mcdx.ccmd[0], tries - 1, tries == 2 ? "y" : "ies"));
cmd1289drivers/block/mcdx.cstatic unsigned char cmd[] = {
cmd1295drivers/block/mcdx.ccmd[0] = stuffp->readcmd;
cmd1324drivers/block/mcdx.ccmd[1] = pending.minute;
cmd1325drivers/block/mcdx.ccmd[2] = pending.second;
cmd1326drivers/block/mcdx.ccmd[3] = pending.frame;
cmd1330drivers/block/mcdx.ccmd[6] = (unsigned char) (stuffp->off_requested - stuffp->pending) / 4;
cmd1332drivers/block/mcdx.coutsb((unsigned int) stuffp->wreg_data, cmd, sizeof cmd);
cmd1467drivers/block/mcdx.cunsigned char cmd[7] = {
cmd1471drivers/block/mcdx.ccmd[0] = stuffp->playcmd;
cmd1473drivers/block/mcdx.ccmd[1] = msf->cdmsf_min0;
cmd1474drivers/block/mcdx.ccmd[2] = msf->cdmsf_sec0;
cmd1475drivers/block/mcdx.ccmd[3] = msf->cdmsf_frame0;
cmd1476drivers/block/mcdx.ccmd[4] = msf->cdmsf_min1;
cmd1477drivers/block/mcdx.ccmd[5] = msf->cdmsf_sec1;
cmd1478drivers/block/mcdx.ccmd[6] = msf->cdmsf_frame1;
cmd1482drivers/block/mcdx.ccmd[0], cmd[1], cmd[2], cmd[3],
cmd1483drivers/block/mcdx.ccmd[4], cmd[5], cmd[6])); 
cmd1485drivers/block/mcdx.coutsb((unsigned int) stuffp->wreg_data, cmd, sizeof cmd);
cmd1616drivers/block/mcdx.cchar cmd[2];
cmd1621drivers/block/mcdx.cif (-1 == (ans = mcdx_talk(stuffp, "\xc2", 1, cmd, sizeof(cmd), 5*HZ, tries)))
cmd1625drivers/block/mcdx.ccase TOC: cmd[1] |= 0x04; break;
cmd1626drivers/block/mcdx.ccase DATA: cmd[1] &= ~0x04; break;
cmd1627drivers/block/mcdx.ccase RAW: cmd[1] |= 0x40; break;
cmd1628drivers/block/mcdx.ccase COOKED: cmd[1] &= ~0x40; break;
cmd1631drivers/block/mcdx.ccmd[0] = 0x50;
cmd1632drivers/block/mcdx.creturn mcdx_talk(stuffp, cmd, 2, NULL, 0, 5*HZ, tries);
cmd1639drivers/block/mcdx.cunsigned char cmd[2] = { 0xa0 };
cmd1642drivers/block/mcdx.ccase MODE0: cmd[1] = 0x00; break;
cmd1643drivers/block/mcdx.ccase MODE1: cmd[1] = 0x01; break;
cmd1644drivers/block/mcdx.ccase MODE2: cmd[1] = 0x02; break;
cmd1647drivers/block/mcdx.creturn mcdx_talk(stuffp, cmd, 2, NULL, 0, 5*HZ, tries);
cmd1653drivers/block/mcdx.cchar cmd[4];
cmd1657drivers/block/mcdx.ccmd[0] = 0x90;
cmd1659drivers/block/mcdx.ccmd[1] = 0x10;    /* irq enable */
cmd1660drivers/block/mcdx.ccmd[2] = 0x05;    /* pre, err irq enable */
cmd1662drivers/block/mcdx.cif (-1 == mcdx_talk(stuffp, cmd, 3, NULL, 0, 1*HZ, tries))
cmd1665drivers/block/mcdx.ccmd[1] = 0x02;    /* dma select */
cmd1666drivers/block/mcdx.ccmd[2] = 0x00;    /* no dma */
cmd1668drivers/block/mcdx.creturn mcdx_talk(stuffp, cmd, 3, NULL, 0, 1*HZ, tries);
cmd1699drivers/block/mcdx.cchar cmd[2] = { 0xfe };
cmd1701drivers/block/mcdx.ccmd[1] = lock ? 0x01 : 0x00;
cmd1702drivers/block/mcdx.creturn mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 0, 5*HZ, tries);
cmd240drivers/block/optcd.cstatic int optSendCmd(int cmd) {
cmd243drivers/block/optcd.cprintk("optcd: executing command 0x%02x\n", cmd);
cmd246drivers/block/optcd.coutb(cmd, COMIN_PORT);    /* Send command code */
cmd373drivers/block/optcd.cinline static int optCmd(int cmd) {
cmd374drivers/block/optcd.cint ack = optSendCmd(cmd);
cmd377drivers/block/optcd.cif (cmd < COMFETCH)    /* Quick response command */
cmd384drivers/block/optcd.cinline static int optPlayCmd(int cmd, struct opt_Play_msf *params) {
cmd385drivers/block/optcd.cint ack = optSendCmd(cmd);
cmd395drivers/block/optcd.cinline static int optReadCmd(int cmd, struct opt_Play_msf *params) {
cmd396drivers/block/optcd.cint ack = optSendCmd(cmd);
cmd1047drivers/block/optcd.cunsigned int cmd, unsigned long arg) {
cmd1051drivers/block/optcd.cprintk("optcd: starting opt_ioctl, command 0x%x\n", cmd);
cmd1060drivers/block/optcd.cswitch (cmd) {
cmd48drivers/block/ramdisk.cif (CURRENT-> cmd == WRITE) {
cmd52drivers/block/ramdisk.c} else if (CURRENT->cmd == READ) {
cmd3806drivers/block/sbpcd.cstatic int sbpcd_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd3812drivers/block/sbpcd.cMINOR(inode->i_rdev), cmd, arg);
cmd3833drivers/block/sbpcd.cmsg(DBG_IO2,"ioctl: device %d, request %04X\n",i,cmd);
cmd3834drivers/block/sbpcd.cswitch (cmd)     /* Sun-compatible */
cmd4349drivers/block/sbpcd.cmsg(DBG_IOC,"ioctl: unknown function request %04X\n", cmd);
cmd4390drivers/block/sbpcd.cif (CURRENT->cmd != READ)
cmd4392drivers/block/sbpcd.cmsg(DBG_INF, "bad cmd %d\n", CURRENT->cmd);
cmd245drivers/block/sjcd.cstatic void sjcd_send_cmd( unsigned char cmd ){
cmd247drivers/block/sjcd.cprintk( "sjcd: send_cmd( 0x%x )\n", cmd );
cmd249drivers/block/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd258drivers/block/sjcd.cstatic void sjcd_send_1_cmd( unsigned char cmd, unsigned char a ){
cmd260drivers/block/sjcd.cprintk( "sjcd: send_1_cmd( 0x%x, 0x%x )\n", cmd, a );
cmd262drivers/block/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd272drivers/block/sjcd.cstatic void sjcd_send_4_cmd( unsigned char cmd, unsigned char a,
cmd275drivers/block/sjcd.cprintk( "sjcd: send_4_cmd( 0x%x )\n", cmd );
cmd277drivers/block/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd290drivers/block/sjcd.cstatic void sjcd_send_6_cmd( unsigned char cmd, struct sjcd_play_msf *pms ){
cmd292drivers/block/sjcd.cprintk( "sjcd: send_long_cmd( 0x%x )\n", cmd );
cmd294drivers/block/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd638drivers/block/sjcd.cunsigned int cmd, unsigned long arg ){
cmd649drivers/block/sjcd.cswitch( cmd ){
cmd912drivers/block/sjcd.cCURRENT->cmd == READ && CURRENT->sector != -1 )
cmd207drivers/block/sonycd535.cstatic int do_sony_cmd(Byte * cmd, int nCmd, Byte status[2],
cmd443drivers/block/sonycd535.cByte cmd;
cmd503drivers/block/sonycd535.ccmd = SONY535_SPIN_UP;
cmd504drivers/block/sonycd535.cdo_sony_cmd(&cmd, 1, e_status, NULL, 0, 0);
cmd544drivers/block/sonycd535.cdo_sony_cmd(Byte * cmd, int n_cmd, Byte status[2],
cmd551drivers/block/sonycd535.coutb(cmd[i], command_reg);
cmd565drivers/block/sonycd535.c*cmd, status[0], status[1]);
cmd708drivers/block/sonycd535.cByte cmd;
cmd711drivers/block/sonycd535.ccmd = SONY535_REQUEST_DRIVE_STATUS_1;
cmd712drivers/block/sonycd535.cif (do_sony_cmd(&cmd, 1, status, NULL, 0, 0) != 0)
cmd718drivers/block/sonycd535.ccmd = SONY535_SPIN_UP;
cmd719drivers/block/sonycd535.creturn do_sony_cmd(&cmd, 1, status, NULL, 0, 0);
cmd809drivers/block/sonycd535.cByte cmd[2];
cmd830drivers/block/sonycd535.cswitch (CURRENT->cmd) {
cmd917drivers/block/sonycd535.ccmd[0] = SONY535_SPIN_UP;
cmd918drivers/block/sonycd535.cdo_sony_cmd(cmd, 1, status, NULL, 0, 0);
cmd994drivers/block/sonycd535.cByte cmd = SONY535_REQUEST_SUB_Q_DATA;
cmd1001drivers/block/sonycd535.cif ((dsc_status = do_sony_cmd(&cmd, 1, status, (Byte *) last_sony_subcode,
cmd1089drivers/block/sonycd535.cunsigned int cmd,
cmd1109drivers/block/sonycd535.cswitch (cmd) {
cmd225drivers/block/xd.cswitch (CURRENT->cmd) {
cmd229drivers/block/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
cmd240drivers/block/xd.cstatic int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
cmd246drivers/block/xd.cswitch (cmd) {
cmd476drivers/char/cyclades.cwrite_cy_cmd(u_char *base_addr, u_char cmd, int index)
cmd497drivers/char/cyclades.cbase_addr[CyCCR<<index] = cmd;
cmd1887drivers/char/cyclades.cset_modem_info(struct cyclades_port * info, unsigned int cmd,
cmd1903drivers/char/cyclades.cswitch (cmd) {
cmd2114drivers/char/cyclades.cunsigned int cmd, unsigned long arg)
cmd2121drivers/char/cyclades.cprintk("cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg); /* */
cmd2124drivers/char/cyclades.cswitch (cmd) {
cmd2200drivers/char/cyclades.cret_val = set_modem_info(info, cmd, (unsigned int *) arg);
cmd593drivers/char/istallion.cstatic int  stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
cmd609drivers/char/istallion.cstatic int  stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
cmd619drivers/char/istallion.cstatic int  stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
cmd620drivers/char/istallion.cstatic void  stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
cmd1240drivers/char/istallion.cstatic int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
cmd1245drivers/char/istallion.cprintk("stli_cmdwait(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,copyback=%d)\n", (int) brdp, (int) portp, (int) cmd, (int) arg, size, copyback);
cmd1258drivers/char/istallion.cstli_sendcmd(brdp, portp, cmd, arg, size, copyback);
cmd1796drivers/char/istallion.cstatic int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
cmd1804drivers/char/istallion.cprintk("stli_ioctl(tty=%x,file=%x,cmd=%x,arg=%x)\n", (int) tty, (int) file, cmd, (int) arg);
cmd1818drivers/char/istallion.cswitch (cmd) {
cmd2204drivers/char/istallion.cstatic void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
cmd2212drivers/char/istallion.cprintk("stli_sendcmd(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,copyback=%d)\n", (int) brdp, (int) portp, (int) cmd, (int) arg, size, copyback);
cmd2216drivers/char/istallion.cprintk("STALLION: command already busy, cmd=%x!\n", (int) cmd);
cmd2232drivers/char/istallion.ccp->cmd = cmd;
cmd2321drivers/char/istallion.cint  cmd;
cmd2325drivers/char/istallion.ccmd = A_SETSIGNALSF;
cmd2327drivers/char/istallion.ccmd = A_SETSIGNALSFTX;
cmd2329drivers/char/istallion.ccmd = A_SETSIGNALSFRX;
cmd2331drivers/char/istallion.ccmd = A_SETSIGNALS;
cmd2337drivers/char/istallion.ccp->cmd = cmd;
cmd2340drivers/char/istallion.ccmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0);
cmd2341drivers/char/istallion.ccmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
cmd2344drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &cmd, sizeof(int));
cmd2346drivers/char/istallion.ccp->cmd = A_FLUSH;
cmd2415drivers/char/istallion.cif ((cp->cmd == 0) && (rc != 0)) {
cmd3937drivers/char/istallion.cstatic int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd3943drivers/char/istallion.cprintk("stli_memioctl(ip=%x,fp=%x,cmd=%x,arg=%x)\n", (int) ip, (int) fp, cmd, (int) arg);
cmd3955drivers/char/istallion.cswitch (cmd) {
cmd398drivers/char/lp.cunsigned int cmd, unsigned long arg)
cmd404drivers/char/lp.cprintk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
cmd410drivers/char/lp.cswitch ( cmd ) {
cmd171drivers/char/scc.cstatic int scc_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
cmd1361drivers/char/scc.ckiss_set_param(struct scc_channel *scc,char cmd, unsigned int val)
cmd1367drivers/char/scc.cswitch(cmd){
cmd1833drivers/char/scc.cscc_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
cmd1854drivers/char/scc.cif (cmd == TIOCSCCINI)
cmd1870drivers/char/scc.cif (cmd == TIOCCHANINI)
cmd1919drivers/char/scc.cswitch(cmd){
cmd1941drivers/char/scc.cswitch (cmd) {
cmd1597drivers/char/serial.cstatic int set_modem_info(struct async_struct * info, unsigned int cmd,
cmd1607drivers/char/serial.cswitch (cmd) {
cmd1841drivers/char/serial.cunsigned int cmd, unsigned long arg)
cmd1850drivers/char/serial.cif ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
cmd1851drivers/char/serial.c(cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
cmd1852drivers/char/serial.c(cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
cmd1857drivers/char/serial.cswitch (cmd) {
cmd1895drivers/char/serial.creturn set_modem_info(info, cmd, (unsigned int *) arg);
cmd467drivers/char/stallion.cstatic int  stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
cmd1168drivers/char/stallion.cstatic int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
cmd1174drivers/char/stallion.cprintk("stl_ioctl(tty=%x,file=%x,cmd=%x,arg=%x)\n", (int) tty, (int) file, cmd, (int) arg);
cmd1185drivers/char/stallion.cswitch (cmd) {
cmd665drivers/char/tpqic02.cstatic int notify_cmd(char cmd, short ignore_ex)
cmd669drivers/char/tpqic02.coutb_p(cmd, QIC02_CMD_PORT);    /* output the command */
cmd805drivers/char/tpqic02.cstatic int send_qic02_cmd(int cmd, time_t timeout, int ignore_ex)
cmd824drivers/char/tpqic02.cstatus_cmd_pending = cmd;
cmd826drivers/char/tpqic02.cstat = notify_cmd(cmd, ignore_ex); /* tell drive new command was loaded, */
cmd828drivers/char/tpqic02.cif (TP_HAVE_SEEK && (cmd == AR_QCMDV_SEEK_BLK)) {
cmd973drivers/char/tpqic02.cstatic void finish_rw(int cmd);
cmd1077drivers/char/tpqic02.cstatic int ll_do_qic_cmd(int cmd, time_t timeout)
cmd1094drivers/char/tpqic02.cprintk(TPQIC02_NAME ": ll_do_qic_cmd(%x, %ld) failed\n", cmd, (long) timeout);
cmd1104drivers/char/tpqic02.cstat = send_qic02_cmd(cmd, timeout, 0);  /* (checks for exceptions) */
cmd1106drivers/char/tpqic02.cif (cmd==QCMD_RD_FM) {
cmd1112drivers/char/tpqic02.c} else if (cmd==QCMD_WRT_FM) {
cmd1115drivers/char/tpqic02.c} else if ((cmd==QCMD_REWIND) || (cmd==QCMD_ERASE) || (cmd==QCMD_RETEN)) {
cmd1130drivers/char/tpqic02.cprintk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[1](%x, %ld)", cmd, (long) timeout);
cmd1148drivers/char/tpqic02.cif (tp_sense((cmd==QCMD_SEEK_EOD ?    /*****************************/
cmd1151drivers/char/tpqic02.cprintk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[2](%x, %ld)\n", cmd, (long) timeout);
cmd1152drivers/char/tpqic02.cif (cmd!=QCMD_RD_FM)
cmd1159drivers/char/tpqic02.cprintk(TPQIC02_NAME ": ll_do_qic_cmd %x: wait failed, stat == 0x%x\n", cmd, stat);
cmd1191drivers/char/tpqic02.cstatic void terminate_read(int cmd)
cmd1195drivers/char/tpqic02.cif (cmd != QCMD_RD_FM) {
cmd1219drivers/char/tpqic02.cstatic void terminate_write(int cmd)
cmd1226drivers/char/tpqic02.cif (cmd != QCMD_WRT_FM) {
cmd1243drivers/char/tpqic02.cstatic void finish_rw(int cmd)
cmd1249drivers/char/tpqic02.cterminate_read(cmd);
cmd1250drivers/char/tpqic02.cterminate_write(cmd);
cmd1258drivers/char/tpqic02.cstatic int do_qic_cmd(int cmd, time_t timeout)
cmd1263drivers/char/tpqic02.cfinish_rw(cmd);
cmd1273drivers/char/tpqic02.cif (cmd==QCMD_REWIND)  /* don't wind beyond BOT ;-) */
cmd1277drivers/char/tpqic02.creturn ll_do_qic_cmd(cmd, timeout);
cmd1285drivers/char/tpqic02.cstatic int do_ioctl_cmd(int cmd)
cmd1295drivers/char/tpqic02.cswitch (cmd) {
cmd104drivers/char/tty_io.cunsigned int cmd, unsigned long arg);
cmd307drivers/char/tty_io.cunsigned int cmd, unsigned long arg)
cmd1332drivers/char/tty_io.cunsigned int cmd, unsigned long arg)
cmd1352drivers/char/tty_io.cswitch (cmd) {
cmd1554drivers/char/tty_io.ccmd, arg);
cmd1560drivers/char/tty_io.ccmd, arg);
cmd375drivers/char/tty_ioctl.cunsigned int cmd, unsigned long arg)
cmd387drivers/char/tty_ioctl.cswitch (cmd) {
cmd544drivers/char/tty_ioctl.ctty->driver.ioctl(tty, file, cmd, arg);
cmd186drivers/char/vt.cunsigned int cmd, unsigned long arg)
cmd208drivers/char/vt.cswitch (cmd) {
cmd248drivers/char/vt.creturn sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
cmd253drivers/char/vt.c(cmd == KDENABIO)) ? -ENXIO : 0;
cmd108drivers/net/apricot.cstruct i596_cmd cmd;
cmd116drivers/net/apricot.cunsigned short cmd;
cmd129drivers/net/apricot.cstruct i596_cmd *cmd;
cmd192drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd);
cmd221drivers/net/apricot.crfd->cmd = CMD_EOL;
cmd225drivers/net/apricot.crfd->cmd = 0x0000;
cmd276drivers/net/apricot.clp->cmd_head = lp->scb.cmd = (struct i596_cmd *) I596_NULL;
cmd378drivers/net/apricot.clp->rx_tail->cmd = 0;
cmd382drivers/net/apricot.clp->rx_tail->cmd = CMD_EOL;
cmd443drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
cmd487drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd)
cmd496drivers/net/apricot.ccmd->status = 0;
cmd497drivers/net/apricot.ccmd->command |= (CMD_EOL|CMD_INTR);
cmd498drivers/net/apricot.ccmd->next = (struct i596_cmd *) I596_NULL;
cmd503drivers/net/apricot.clp->cmd_tail->next = cmd;
cmd506drivers/net/apricot.clp->cmd_head = cmd;
cmd515drivers/net/apricot.clp->scb.cmd = cmd;
cmd519drivers/net/apricot.clp->cmd_tail = cmd;
cmd522drivers/net/apricot.clp->cmd_head = lp->scb.cmd;
cmd646drivers/net/apricot.ctx_cmd->cmd.command = CMD_FLEX|CmdTx;
cmd748drivers/net/apricot.clp->scb.cmd = (struct i596_cmd *) I596_NULL;
cmd880drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
cmd976drivers/net/apricot.cstruct i596_cmd *cmd;
cmd982drivers/net/apricot.ccmd = (struct i596_cmd *) kmalloc(sizeof(struct i596_cmd)+2+num_addrs*6, GFP_ATOMIC);
cmd983drivers/net/apricot.cif (cmd == NULL)
cmd989drivers/net/apricot.ccmd->command = CmdMulticastList;
cmd990drivers/net/apricot.c*((unsigned short *) (cmd + 1)) = num_addrs * 6;
cmd991drivers/net/apricot.cmemcpy (((char *)(cmd + 1))+2, addrs, num_addrs * 6);
cmd992drivers/net/apricot.cprint_eth (((char *)(cmd + 1)) + 2);
cmd994drivers/net/apricot.ci596_add_cmd(dev, cmd);
cmd132drivers/net/atp.cstatic unsigned short eeprom_op(short ioaddr, unsigned int cmd);
cmd293drivers/net/atp.cstatic unsigned short eeprom_op(short ioaddr, unsigned int cmd)
cmd299drivers/net/atp.cchar outval = test_bit(num_bits, &cmd) ? EE_DATA_WRITE : 0;
cmd410drivers/net/de4x5.cstatic int     de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd2496drivers/net/de4x5.cstatic int de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd2509drivers/net/de4x5.cswitch(ioc->cmd) {
cmd623drivers/net/de4x5.hunsigned short cmd;                /* Command to run */
cmd290drivers/net/de600.c#define de600_put_command(cmd) ( \
cmd293drivers/net/de600.coutb_p(((rx_page | cmd) << 4)   | COMMAND            , DATA_PORT), \
cmd294drivers/net/de600.coutb_p(((rx_page | cmd) & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT))
cmd247drivers/net/de620.cde620_send_command(struct device *dev, byte cmd)
cmd250drivers/net/de620.cif (cmd == W_DUMMY)
cmd253drivers/net/de620.coutb(cmd, DATA_PORT);
cmd371drivers/net/depca.cstatic int    depca_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd1659drivers/net/depca.cstatic int depca_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1671drivers/net/depca.cswitch(ioc->cmd) {
cmd163drivers/net/depca.hunsigned short cmd;                /* Command to run */
cmd148drivers/net/eql.cstatic int eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd); /*  */
cmd335drivers/net/eql.ceql_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd337drivers/net/eql.cif(!suser() && cmd!=EQL_GETMASTRCFG && cmd!=EQL_GETSLAVECFG)
cmd339drivers/net/eql.cswitch (cmd)
cmd297drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd1613drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1625drivers/net/ewrk3.cswitch(ioc->cmd) {
cmd294drivers/net/ewrk3.hunsigned short cmd;                /* Command to run */
cmd143drivers/net/ni52.cif(!p->scb->cmd) break; \
cmd480drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
cmd506drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
cmd530drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
cmd545drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
cmd565drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
cmd623drivers/net/ni52.cp->scb->cmd = CUC_START;
cmd668drivers/net/ni52.cp->scb->cmd = CUC_START;
cmd744drivers/net/ni52.cp->scb->cmd = stat;
cmd766drivers/net/ni52.cp->scb->cmd = RUC_RESUME;
cmd776drivers/net/ni52.cif(p->scb->cmd)   /* timed out? */
cmd848drivers/net/ni52.cp->scb->cmd = RUC_ABORT; /* usually the RU is in the 'no resource'-state .. abort it now. */
cmd918drivers/net/ni52.cp->scb->cmd = RUC_START;
cmd948drivers/net/ni52.cp->scb->cmd = CUC_ABORT;
cmd952drivers/net/ni52.cp->scb->cmd = CUC_START;
cmd998drivers/net/ni52.cp->scb->cmd = CUC_START;
cmd65drivers/net/ni52.hunsigned short cmd;           /* command word */
cmd153drivers/net/pi2.cstatic int pi_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd240drivers/net/pi2.cint cmd;
cmd249drivers/net/pi2.ccmd = lp->base + CTL;
cmd255drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
cmd271drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
cmd274drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1,
cmd344drivers/net/pi2.cint cmd;
cmd350drivers/net/pi2.ccmd = CTL + lp->base;
cmd366drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd367drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd368drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd372drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
cmd383drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
cmd399drivers/net/pi2.cint cmd;
cmd410drivers/net/pi2.ccmd = lp->base + CTL;
cmd437drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
cmd454drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
cmd457drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
cmd460drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
cmd463drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
cmd473drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd474drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd475drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd490drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
cmd506drivers/net/pi2.cint cmd;
cmd516drivers/net/pi2.ccmd = lp->base + CTL;
cmd518drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* Get special condition bits from R1 */
cmd582drivers/net/pi2.cint cmd;
cmd591drivers/net/pi2.ccmd = CTL + lp->base;
cmd593drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
cmd595drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0)) & Rx_CH_AV) {
cmd617drivers/net/pi2.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);  /* char to rcv buff */
cmd621drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd622drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
cmd676drivers/net/pi2.cint cmd;
cmd681drivers/net/pi2.ccmd = CTL + lp->base;
cmd707drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd708drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd709drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd713drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
cmd734drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
cmd740drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & 0x40)) {
cmd745drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
cmd754drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
cmd756drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
cmd758drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);  /* reset Tx Int Pend */
cmd777drivers/net/pi2.cint cmd;
cmd780drivers/net/pi2.ccmd = CTL + lp->base;
cmd783drivers/net/pi2.cst = rdscc(lp->cardbase, cmd, R0);  /* Fetch status */
cmd785drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd792drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
cmd820drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
cmd824drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
cmd826drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
cmd829drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
cmd830drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
cmd838drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
cmd840drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
cmd846drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
cmd847drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd848drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);  /* Tx/Ext ints */
cmd858drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd859drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd860drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd864drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
cmd885drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
cmd889drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
cmd891drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
cmd894drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
cmd895drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
cmd903drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
cmd905drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
cmd911drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
cmd912drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd914drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
cmd927drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd928drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd929drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1001drivers/net/pi2.cint cmd;
cmd1005drivers/net/pi2.ccmd = CTL + lp->base;
cmd1010drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
cmd1011drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Rx off */
cmd1013drivers/net/pi2.cif (cmd & 2) {    /* if channel a */
cmd1015drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
cmd1017drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);  /* No interrupts */
cmd1024drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
cmd1025drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
cmd1028drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
cmd1032drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);  /*  TX off */
cmd1038drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
cmd1042drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
cmd1043drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
cmd1045drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
cmd1047drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
cmd1051drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Make sure rx is off */
cmd1052drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
cmd1053drivers/net/pi2.cdummy = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
cmd1054drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1055drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1057drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1060drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | Rx8);
cmd1063drivers/net/pi2.cif (cmd & 2) {    /* if channel a */
cmd1069drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
cmd1071drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* allow ABORT int */
cmd1096drivers/net/pi2.cregister int cmd;
cmd1100drivers/net/pi2.ccmd = CTL + lp->base;
cmd1104drivers/net/pi2.cswitch (cmd & CHANA) {
cmd1106drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRA);  /* Reset channel A */
cmd1107drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R2, 0xff);  /* Initialize interrupt vector */
cmd1110drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRB);  /* Reset channel B */
cmd1115drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);
cmd1118drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
cmd1121drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
cmd1125drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
cmd1128drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
cmd1131drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCDPLL | RCDPLL | TRxCBR | TRxCOI);
cmd1133drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
cmd1135drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP);
cmd1139drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R6, 0);
cmd1142drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R7, FLAG);
cmd1147drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
cmd1150drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* 8 bits/char */
cmd1153drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);  /* BRG off, keep Pclk source */
cmd1164drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
cmd1165drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
cmd1172drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
cmd1175drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSRTxC);
cmd1177drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
cmd1178drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
cmd1180drivers/net/pi2.cif (!(cmd & 2))    /* if channel b */
cmd1181drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
cmd1183drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
cmd1186drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | Rx8);
cmd1594drivers/net/pi2.cstatic int pi_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd1604drivers/net/pi2.cif(cmd!=SIOCDEVPRIVATE)
cmd1609drivers/net/pi2.cswitch (rq.cmd) {
cmd73drivers/net/pi2.hint cmd;
cmd158drivers/net/plip.cstatic int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd1042drivers/net/plip.cplip_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd194drivers/net/ppp.cstatic int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
cmd2859drivers/net/ppp.cppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
cmd2866drivers/net/ppp.cswitch (cmd) {
cmd1016drivers/net/slip.cslip_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
cmd1027drivers/net/slip.cswitch(cmd) {
cmd1098drivers/net/slip.creturn n_tty_ioctl(tty, (struct file *) file, cmd, (unsigned long) arg);
cmd224drivers/net/wavelan.h#define PIOM(cmd,piono)    ((u_short)cmd << 10 << (piono * 2))
cmd679drivers/pci/pci.cunsigned char cmd, tmp, hdr_type = 0;
cmd739drivers/pci/pci.c&cmd);
cmd741drivers/pci/pci.ccmd | PCI_COMMAND_MASTER);
cmd746drivers/pci/pci.ccmd);
cmd188drivers/scsi/53c7,8xx.cstatic void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result);
cmd195drivers/scsi/53c7,8xx.c*cmd);
cmd196drivers/scsi/53c7,8xx.cstatic void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
cmd201drivers/scsi/53c7,8xx.cstatic void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd);
cmd204drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd);
cmd1313drivers/scsi/53c7,8xx.cunsigned char cmd[6];
cmd1318drivers/scsi/53c7,8xx.ccmd[0] = INQUIRY;
cmd1319drivers/scsi/53c7,8xx.ccmd[1] = cmd[2] = cmd[3] = cmd[5] = 0;
cmd1320drivers/scsi/53c7,8xx.ccmd[4] = sizeof(data); 
cmd1325drivers/scsi/53c7,8xx.cdsa[5] = virt_to_bus(&cmd);
cmd1404drivers/scsi/53c7,8xx.cstatic void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd) {
cmd1405drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd->cmd;
cmd1411drivers/scsi/53c7,8xx.cmemcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
cmd1414drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd1415drivers/scsi/53c7,8xx.cdsa_temp_jump_resume, virt_to_bus(cmd->dsa) + 
cmd1417drivers/scsi/53c7,8xx.cpatch_abs_rwri_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd1419drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd1420drivers/scsi/53c7,8xx.cdsa_temp_dsa_next, virt_to_bus(cmd->dsa) + A_dsa_next);
cmd1421drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd1423drivers/scsi/53c7,8xx.cpatch_abs_rwri_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd1442drivers/scsi/53c7,8xx.cstatic void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result) {
cmd1443drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd->cmd;
cmd1457drivers/scsi/53c7,8xx.csearch && ((char*)bus_to_virt(search) + hostdata->dsa_start) != (char *) cmd->dsa;
cmd1465drivers/scsi/53c7,8xx.cif (cmd->prev)
cmd1466drivers/scsi/53c7,8xx.ccmd->prev->next = cmd->next;
cmd1468drivers/scsi/53c7,8xx.cif (cmd->next)
cmd1469drivers/scsi/53c7,8xx.ccmd->next->prev = cmd->prev;
cmd1471drivers/scsi/53c7,8xx.cif (hostdata->running_list == cmd)
cmd1472drivers/scsi/53c7,8xx.chostdata->running_list = cmd->next;
cmd1474drivers/scsi/53c7,8xx.ccmd->next = hostdata->free;
cmd1475drivers/scsi/53c7,8xx.chostdata->free = cmd;
cmd1497drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd) {
cmd1501drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd ? cmd->cmd : NULL;
cmd1692drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd) {
cmd1694drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd ? cmd->cmd : NULL;
cmd1708drivers/scsi/53c7,8xx.cif (cmd) 
cmd1731drivers/scsi/53c7,8xx.cif (cmd) {
cmd1733drivers/scsi/53c7,8xx.chost->host_no, c->target, (cmd->flags & CMD_FLAG_SDTR) ? "accepting" :
cmd1743drivers/scsi/53c7,8xx.cif (cmd->flags & CMD_FLAG_SDTR) {
cmd1744drivers/scsi/53c7,8xx.ccmd->flags &= ~CMD_FLAG_SDTR; 
cmd1753drivers/scsi/53c7,8xx.ccmd->flags |= CMD_FLAG_DID_SDTR;
cmd1760drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout_other, 0, 5);
cmd1761drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout_other, 1, 
cmd1845drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout, 0, 1);
cmd1852drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_cmdout, 0, 6);
cmd1867drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_dataout, 0, hostdata->E_other_transfer);
cmd1868drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_datain, 0, virt_to_bus(cmd->data_transfer_start));
cmd1869drivers/scsi/53c7,8xx.ccmd->data_transfer_start[0] = (((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I | 
cmd1871drivers/scsi/53c7,8xx.ccmd->data_transfer_start[1] = virt_to_bus(c->sense_buffer);
cmd1873drivers/scsi/53c7,8xx.ccmd->data_transfer_start[2] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) 
cmd1875drivers/scsi/53c7,8xx.ccmd->data_transfer_start[3] = hostdata->E_other_transfer;
cmd1884drivers/scsi/53c7,8xx.ccmd->cmd->result = 0xffff;    
cmd1899drivers/scsi/53c7,8xx.cif (cmd)
cmd1900drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_ERROR << 16);
cmd2358drivers/scsi/53c7,8xx.ccreate_cmd (Scsi_Cmnd *cmd) {
cmd2360drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd2376drivers/scsi/53c7,8xx.cNCR53c7x0_local_setup(cmd->host);
cmd2391drivers/scsi/53c7,8xx.c!(hostdata->cmd_allocated[cmd->target] & (1 << cmd->lun))) {
cmd2439drivers/scsi/53c7,8xx.cswitch (cmd->cmnd[0]) {
cmd2447drivers/scsi/53c7,8xx.cdatain = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd2456drivers/scsi/53c7,8xx.cprint_command(cmd->cmnd);
cmd2460drivers/scsi/53c7,8xx.ccmd->use_sg);
cmd2463drivers/scsi/53c7,8xx.cdataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd2481drivers/scsi/53c7,8xx.cdatain = dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd2505drivers/scsi/53c7,8xx.ctmp->cmd = cmd;
cmd2534drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmnd, 0, virt_to_bus(cmd));
cmd2535drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_select, 0, hostdata->sync[cmd->target].
cmd2543drivers/scsi/53c7,8xx.ctmp->select[0] = IDENTIFY (1, cmd->lun);
cmd2545drivers/scsi/53c7,8xx.ctmp->select[0] = IDENTIFY (0, cmd->lun);
cmd2548drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmdout, 0, cmd->cmd_len);
cmd2549drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmdout, 1, virt_to_bus(cmd->cmnd));
cmd2559drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_msgin, 1, virt_to_bus(&cmd->result) + 1);
cmd2561drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_status, 1, virt_to_bus(&cmd->result));
cmd2602drivers/scsi/53c7,8xx.cfor (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; cmd_datain += 4, 
cmd2604drivers/scsi/53c7,8xx.cu32 buf = cmd->use_sg ?
cmd2605drivers/scsi/53c7,8xx.cvirt_to_bus(((struct scatterlist *)cmd->buffer)[i].address) :
cmd2606drivers/scsi/53c7,8xx.cvirt_to_bus(cmd->request_buffer);
cmd2607drivers/scsi/53c7,8xx.cu32 count = cmd->use_sg ?
cmd2608drivers/scsi/53c7,8xx.c((struct scatterlist *)cmd->buffer)[i].length :
cmd2609drivers/scsi/53c7,8xx.ccmd->request_bufflen;
cmd2699drivers/scsi/53c7,8xx.cint NCR53c7xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *)) {
cmd2702drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd2711drivers/scsi/53c7,8xx.c!(hostdata->debug_lun_limit[cmd->target] & (1 << cmd->lun)))) ||
cmd2712drivers/scsi/53c7,8xx.ccmd->target > 7) {
cmd2714drivers/scsi/53c7,8xx.ccmd->target, cmd->lun);
cmd2715drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd2716drivers/scsi/53c7,8xx.cdone(cmd);
cmd2723drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd2724drivers/scsi/53c7,8xx.cdone(cmd);
cmd2731drivers/scsi/53c7,8xx.cswitch (cmd->cmnd[0]) {
cmd2736drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd2737drivers/scsi/53c7,8xx.cdone(cmd);
cmd2742drivers/scsi/53c7,8xx.ccmd->scsi_done = done;
cmd2743drivers/scsi/53c7,8xx.ccmd->result = 0xffff;    /* The NCR will overwrite message
cmd2746drivers/scsi/53c7,8xx.ccmd->host_scribble = (unsigned char *) tmp = create_cmd (cmd);
cmd2783drivers/scsi/53c7,8xx.ctarget_was_busy = hostdata->busy[cmd->target][cmd->lun]
cmd2890drivers/scsi/53c7,8xx.cstatic void intr_scsi (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd2922drivers/scsi/53c7,8xx.cif (cmd) {
cmd2924drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd2925drivers/scsi/53c7,8xx.cprint_command (cmd->cmd->cmnd);
cmd2945drivers/scsi/53c7,8xx.c} else if (cmd) {
cmd2946drivers/scsi/53c7,8xx.cabnormal_finished(cmd, DID_BAD_TARGET << 16);
cmd2956drivers/scsi/53c7,8xx.cif (cmd) {
cmd2958drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd2959drivers/scsi/53c7,8xx.cabnormal_finished(cmd, DID_ERROR << 16);
cmd2969drivers/scsi/53c7,8xx.cif (cmd && cmd->cmd) {
cmd2971drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd2972drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_PARITY << 16); 
cmd2998drivers/scsi/53c7,8xx.cintr_phase_mismatch (host, cmd);
cmd3054drivers/scsi/53c7,8xx.cstruct NCR53c7x0_cmd *cmd,      /* command which halted */
cmd3129drivers/scsi/53c7,8xx.c&(hostdata->running_list), cmd = 
cmd3130drivers/scsi/53c7,8xx.c(struct NCR53c7x0_cmd *) hostdata->running_list; cmd ;
cmd3131drivers/scsi/53c7,8xx.ccmd_prev_ptr = (struct NCR53c7x0_cmd **) &(cmd->next), 
cmd3132drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *) cmd->next) {
cmd3135drivers/scsi/53c7,8xx.cif (!cmd) {
cmd3140drivers/scsi/53c7,8xx.cif (!(tmp = cmd->cmd)) {
cmd3147drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->result);
cmd3158drivers/scsi/53c7,8xx.cif (cmd->prev)
cmd3159drivers/scsi/53c7,8xx.ccmd->prev->next = cmd->next;
cmd3161drivers/scsi/53c7,8xx.c*cmd_prev_ptr = (struct NCR53c7x0_cmd *) cmd->next;
cmd3170drivers/scsi/53c7,8xx.ccmd->next = hostdata->free;
cmd3171drivers/scsi/53c7,8xx.chostdata->free = cmd;
cmd3212drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *) hostdata->current_cmd;
cmd3215drivers/scsi/53c7,8xx.cfor (cmd = (struct NCR53c7x0_cmd *) 
cmd3216drivers/scsi/53c7,8xx.chostdata->running_list; cmd &&
cmd3218drivers/scsi/53c7,8xx.ccmd->dsa;
cmd3219drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *)(cmd->next));
cmd3222drivers/scsi/53c7,8xx.cif (cmd) {
cmd3224drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->pid, (int) cmd->cmd->target,
cmd3225drivers/scsi/53c7,8xx.c(int) cmd->cmd->lun);
cmd3226drivers/scsi/53c7,8xx.cprint_command (cmd->cmd->cmnd);
cmd3235drivers/scsi/53c7,8xx.cintr_scsi (host, cmd);
cmd3241drivers/scsi/53c7,8xx.cintr_dma (host, cmd);
cmd3349drivers/scsi/53c7,8xx.c*cmd) {
cmd3358drivers/scsi/53c7,8xx.cif (!cmd) {
cmd3419drivers/scsi/53c7,8xx.cif (dsp >= cmd->data_transfer_start && dsp < cmd->data_transfer_end) {
cmd3507drivers/scsi/53c7,8xx.cstatic void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd3622drivers/scsi/53c7,8xx.c} else if (cmd) 
cmd3623drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_BAD_TARGET << 16);
cmd3676drivers/scsi/53c7,8xx.cswitch ((tmp = hostdata->dstat_sir_intr (host, cmd))) {
cmd3689drivers/scsi/53c7,8xx.cintr_break (host, cmd);
cmd3764drivers/scsi/53c7,8xx.cint NCR53c7xx_abort (Scsi_Cmnd *cmd) {
cmd3765drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd3785drivers/scsi/53c7,8xx.ccurr && curr->cmd != cmd; prev = (volatile struct NCR53c7x0_cmd **)
cmd3797drivers/scsi/53c7,8xx.ccmd->result = 0;
cmd3798drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd3810drivers/scsi/53c7,8xx.ccurr && curr->cmd != cmd; prev = (volatile struct NCR53c7x0_cmd **) 
cmd3816drivers/scsi/53c7,8xx.ccmd->host->host_no);
cmd3826drivers/scsi/53c7,8xx.ccurr = (struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd3830drivers/scsi/53c7,8xx.cif (((cmd->result & 0xff00) == 0xff00) ||
cmd3831drivers/scsi/53c7,8xx.c((cmd->result & 0xff) == 0xff)) {
cmd3837drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd3854drivers/scsi/53c7,8xx.cNCR53c7xx_reset (Scsi_Cmnd *cmd) {
cmd3860drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd3874drivers/scsi/53c7,8xx.ctmp = c->cmd;
cmd3878drivers/scsi/53c7,8xx.cif (tmp == cmd)
cmd3884drivers/scsi/53c7,8xx.cc = (struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd3889drivers/scsi/53c7,8xx.ccmd->result = DID_RESET << 16;
cmd3890drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd966drivers/scsi/53c7,8xx.hScsi_Cmnd *cmd;      /* Associated Scsi_Cmnd 
cmd1101drivers/scsi/53c7,8xx.hvoid (* dsa_fixup)(struct NCR53c7x0_cmd *cmd);
cmd1111drivers/scsi/53c7,8xx.hint (* dstat_sir_intr)(struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
cmd299drivers/scsi/NCR5380.cstatic __inline__ void initialize_SCp(Scsi_Cmnd *cmd) {
cmd305drivers/scsi/NCR5380.cif (cmd->use_sg) {
cmd306drivers/scsi/NCR5380.ccmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
cmd307drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd308drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
cmd309drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd311drivers/scsi/NCR5380.ccmd->SCp.buffer = NULL;
cmd312drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = 0;
cmd313drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->request_buffer;
cmd314drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd499drivers/scsi/NCR5380.cstatic int should_disconnect (unsigned char cmd) {
cmd500drivers/scsi/NCR5380.cswitch (cmd) {
cmd848drivers/scsi/NCR5380.cint NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) {
cmd850drivers/scsi/NCR5380.ccmd->host->hostdata;
cmd854drivers/scsi/NCR5380.cswitch (cmd->cmnd[0]) {
cmd859drivers/scsi/NCR5380.ccmd->result = (DID_ERROR << 16);
cmd860drivers/scsi/NCR5380.cdone(cmd);
cmd871drivers/scsi/NCR5380.ccmd->host_scribble = NULL;
cmd872drivers/scsi/NCR5380.ccmd->scsi_done = done;
cmd874drivers/scsi/NCR5380.ccmd->result = 0;
cmd885drivers/scsi/NCR5380.cif (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd886drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) hostdata->issue_queue;
cmd887drivers/scsi/NCR5380.chostdata->issue_queue = cmd;
cmd891drivers/scsi/NCR5380.ctmp->host_scribble = (unsigned char *) cmd;
cmd895drivers/scsi/NCR5380.c(cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
cmd1165drivers/scsi/NCR5380.cstatic int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
cmd1279drivers/scsi/NCR5380.cNCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
cmd1318drivers/scsi/NCR5380.cprintk("scsi%d : selecting target %d\n", instance->host_no, cmd->target);
cmd1351drivers/scsi/NCR5380.cif (hostdata->targets_present & (1 << cmd->target)) {
cmd1361drivers/scsi/NCR5380.ccmd->result = DID_BAD_TARGET << 16;
cmd1362drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd1372drivers/scsi/NCR5380.chostdata->targets_present |= (1 << cmd->target);
cmd1394drivers/scsi/NCR5380.cinstance->host_no, cmd->target);
cmd1396drivers/scsi/NCR5380.ctmp[0] = IDENTIFY(((instance->irq == IRQ_NONE) ? 0 : 1), cmd->lun);
cmd1398drivers/scsi/NCR5380.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
cmd1402drivers/scsi/NCR5380.cif (cmd->device->current_tag == 0)
cmd1403drivers/scsi/NCR5380.ccmd->device->current_tag = 1;
cmd1405drivers/scsi/NCR5380.ccmd->tag = cmd->device->current_tag;
cmd1406drivers/scsi/NCR5380.ccmd->device->current_tag++;
cmd1408drivers/scsi/NCR5380.ccmd->tag = (unsigned char) tag;
cmd1410drivers/scsi/NCR5380.ctmp[2] = cmd->tag;
cmd1417drivers/scsi/NCR5380.ccmd->tag=0;
cmd1428drivers/scsi/NCR5380.chostdata->connected = cmd;
cmd1430drivers/scsi/NCR5380.cif (!cmd->device->tagged_queue)
cmd1432drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd1434drivers/scsi/NCR5380.cinitialize_SCp(cmd);
cmd1922drivers/scsi/NCR5380.cScsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
cmd1965drivers/scsi/NCR5380.cif (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
cmd1966drivers/scsi/NCR5380.c++cmd->SCp.buffer;
cmd1967drivers/scsi/NCR5380.c--cmd->SCp.buffers_residual;
cmd1968drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd1969drivers/scsi/NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd1972drivers/scsi/NCR5380.cinstance->host_no, cmd->SCp.this_residual,
cmd1973drivers/scsi/NCR5380.ccmd->SCp.buffers_residual);
cmd1989drivers/scsi/NCR5380.cif (!cmd->device->borken &&
cmd1990drivers/scsi/NCR5380.c(transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
cmd1992drivers/scsi/NCR5380.ctransfersize = cmd->transfersize;
cmd1999drivers/scsi/NCR5380.cif (!cmd->device->borken && transfersize && 
cmd2000drivers/scsi/NCR5380.ccmd->SCp.this_residual && !(cmd->SCp.this_residual % 
cmd2005drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
cmd2011drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2012drivers/scsi/NCR5380.ccmd->device->borken = 1;
cmd2019drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
cmd2023drivers/scsi/NCR5380.c(int *) &cmd->SCp.this_residual, (unsigned char **)
cmd2024drivers/scsi/NCR5380.c&cmd->SCp.ptr);
cmd2030drivers/scsi/NCR5380.ccmd->SCp.Message = tmp;
cmd2051drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2059drivers/scsi/NCR5380.cif (!cmd->next_link) {
cmd2061drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2069drivers/scsi/NCR5380.cinitialize_SCp(cmd->next_link);
cmd2071drivers/scsi/NCR5380.ccmd->next_link->tag = cmd->tag;
cmd2072drivers/scsi/NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2075drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2077drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2078drivers/scsi/NCR5380.ccmd = hostdata->connected;
cmd2088drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2090drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2108drivers/scsi/NCR5380.cif (cmd->cmnd[0] != REQUEST_SENSE) 
cmd2109drivers/scsi/NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2110drivers/scsi/NCR5380.celse if (cmd->SCp.Status != GOOD)
cmd2111drivers/scsi/NCR5380.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd2114drivers/scsi/NCR5380.cif ((cmd->cmnd[0] != REQUEST_SENSE) && 
cmd2115drivers/scsi/NCR5380.c(cmd->SCp.Status == CHECK_CONDITION)) {
cmd2120drivers/scsi/NCR5380.ccmd->cmnd[0] = REQUEST_SENSE;
cmd2121drivers/scsi/NCR5380.ccmd->cmnd[1] &= 0xe0;
cmd2122drivers/scsi/NCR5380.ccmd->cmnd[2] = 0;
cmd2123drivers/scsi/NCR5380.ccmd->cmnd[3] = 0;
cmd2124drivers/scsi/NCR5380.ccmd->cmnd[4] = sizeof(cmd->sense_buffer);
cmd2125drivers/scsi/NCR5380.ccmd->cmnd[5] = 0;
cmd2127drivers/scsi/NCR5380.ccmd->SCp.buffer = NULL;
cmd2128drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = 0;
cmd2129drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->sense_buffer;
cmd2130drivers/scsi/NCR5380.ccmd->SCp.this_residual = sizeof(cmd->sense_buffer);
cmd2133drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) 
cmd2135drivers/scsi/NCR5380.chostdata->issue_queue = (Scsi_Cmnd *) cmd;
cmd2142drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2161drivers/scsi/NCR5380.ccmd->device->tagged_queue = 0;
cmd2162drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd2170drivers/scsi/NCR5380.ccmd->device->disconnect = 1;
cmd2172drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) 
cmd2175drivers/scsi/NCR5380.chostdata->disconnected_queue = cmd;
cmd2180drivers/scsi/NCR5380.ccmd->target, cmd->lun);
cmd2286drivers/scsi/NCR5380.cinstance->host_no, tmp, cmd->target, cmd->lun);
cmd2289drivers/scsi/NCR5380.cinstance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
cmd2303drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2305drivers/scsi/NCR5380.ccmd->result = DID_ERROR << 16;
cmd2306drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2313drivers/scsi/NCR5380.clen = cmd->cmd_len;
cmd2314drivers/scsi/NCR5380.cdata = cmd->cmnd;
cmd2323drivers/scsi/NCR5380.cif (!disconnect && should_disconnect(cmd->cmnd[0])) {
cmd2338drivers/scsi/NCR5380.ccmd->SCp.Status = tmp;
cmd2573drivers/scsi/NCR5380.cint NCR5380_abort (Scsi_Cmnd *cmd) {
cmd2575drivers/scsi/NCR5380.cstruct Scsi_Host *instance = cmd->host;
cmd2583drivers/scsi/NCR5380.cprint_Scsi_Cmnd (cmd);
cmd2603drivers/scsi/NCR5380.cif (hostdata->connected == cmd) {
cmd2637drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd2696drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd2702drivers/scsi/NCR5380.cif (NCR5380_select (instance, cmd, (int) cmd->tag)) 
cmd2721drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd2760drivers/scsi/NCR5380.cint NCR5380_reset (Scsi_Cmnd *cmd) {
cmd2762drivers/scsi/NCR5380.cNCR5380_setup(cmd->host);
cmd2764drivers/scsi/NCR5380.cNCR5380_print_status (cmd->host);
cmd281drivers/scsi/NCR5380.hint NCR5380_abort (Scsi_Cmnd *cmd);
cmd285drivers/scsi/NCR5380.hint NCR5380_reset (Scsi_Cmnd *cmd);
cmd289drivers/scsi/NCR5380.hint NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *));
cmd293drivers/scsi/NCR5380.hstatic int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag);
cmd517drivers/scsi/aha1542.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd536drivers/scsi/aha1542.cif(*cmd == REQUEST_SENSE){
cmd548drivers/scsi/aha1542.cif (*cmd == READ_10 || *cmd == WRITE_10)
cmd549drivers/scsi/aha1542.ci = xscsi2int(cmd+2);
cmd550drivers/scsi/aha1542.celse if (*cmd == READ_6 || *cmd == WRITE_6)
cmd551drivers/scsi/aha1542.ci = scsi2int(cmd+2);
cmd555drivers/scsi/aha1542.cprintk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd557drivers/scsi/aha1542.cprintk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd560drivers/scsi/aha1542.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd562drivers/scsi/aha1542.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd600drivers/scsi/aha1542.cif (*cmd == READ_10 || *cmd == READ_6)
cmd602drivers/scsi/aha1542.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd605drivers/scsi/aha1542.cmemcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
cmd703drivers/scsi/aha1542.cunchar cmd[5] = {CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
cmd713drivers/scsi/aha1542.cany2scsi((cmd+2), mb);
cmd714drivers/scsi/aha1542.caha1542_out(bse, cmd, 5);
cmd1042drivers/scsi/aha1542.cstatic unchar cmd[] = {  READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cmd1047drivers/scsi/aha1542.cif (!aha1542_command(i, cmd, buf, sizeof(buf))) {
cmd1057drivers/scsi/aha1542.cunsigned char cmd[10];
cmd1060drivers/scsi/aha1542.ccmd[0] = READ_10;
cmd1061drivers/scsi/aha1542.ccmd[1] = 0;
cmd1062drivers/scsi/aha1542.cxany2scsi(cmd+2, i);
cmd1063drivers/scsi/aha1542.ccmd[6] = 0;
cmd1064drivers/scsi/aha1542.ccmd[7] = 0;
cmd1065drivers/scsi/aha1542.ccmd[8] = 1;
cmd1066drivers/scsi/aha1542.ccmd[9] = 0;
cmd1067drivers/scsi/aha1542.caha1542_command(0, cmd, buffer, 512);
cmd255drivers/scsi/aha1740.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd264drivers/scsi/aha1740.cif(*cmd == REQUEST_SENSE)
cmd276drivers/scsi/aha1740.cif (*cmd == READ_10 || *cmd == WRITE_10)
cmd277drivers/scsi/aha1740.ci = xscsi2int(cmd+2);
cmd278drivers/scsi/aha1740.celse if (*cmd == READ_6 || *cmd == WRITE_6)
cmd279drivers/scsi/aha1740.ci = scsi2int(cmd+2);
cmd282drivers/scsi/aha1740.cprintk("aha1740_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd284drivers/scsi/aha1740.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd317drivers/scsi/aha1740.cif (*cmd == READ_10 || *cmd == READ_6)
cmd319drivers/scsi/aha1740.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd322drivers/scsi/aha1740.cmemcpy(ecb[ecbno].cdb, cmd, ecb[ecbno].cdblen);
cmd719drivers/scsi/aic7xxx.c#define aic7xxx_error(cmd)  ((cmd)->SCp.Status)
cmd724drivers/scsi/aic7xxx.c#define aic7xxx_status(cmd)  ((cmd)->SCp.sent_command)
cmd729drivers/scsi/aic7xxx.c#define aic7xxx_position(cmd)  ((cmd)->SCp.have_data_in)
cmd844drivers/scsi/aic7xxx.cScsi_Cmnd          *cmd;  /* Scsi_Cmnd for this scb */
cmd1366drivers/scsi/aic7xxx.caic7xxx_length(Scsi_Cmnd *cmd, int sg_last)
cmd1372drivers/scsi/aic7xxx.csegments = cmd->use_sg - sg_last;
cmd1373drivers/scsi/aic7xxx.csg = (struct scatterlist *) cmd->buffer;
cmd1375drivers/scsi/aic7xxx.cif (cmd->use_sg)
cmd1377drivers/scsi/aic7xxx.cfor (i = length = 0; i < cmd->use_sg && i < segments; i++)
cmd1384drivers/scsi/aic7xxx.clength = cmd->request_bufflen;
cmd1448drivers/scsi/aic7xxx.cScsi_Cmnd *cmd;
cmd1557drivers/scsi/aic7xxx.cscb->cmd->device->tagged_supported = 0;
cmd1558drivers/scsi/aic7xxx.cscb->cmd->device->tagged_queue = 0;
cmd1803drivers/scsi/aic7xxx.cif ((scb->state != SCB_ACTIVE) || (scb->cmd == NULL))
cmd1807drivers/scsi/aic7xxx.cintstat, scbptr, scb->state, (unsigned int) scb->cmd);
cmd1811drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd1813drivers/scsi/aic7xxx.caic7xxx_status(cmd) = scb->target_status;
cmd1815drivers/scsi/aic7xxx.ccmd->result = cmd->result | scb->target_status;
cmd1827drivers/scsi/aic7xxx.cif ((aic7xxx_error(cmd) == 0) && !(cmd->flags & WAS_SENSE))
cmd1838drivers/scsi/aic7xxx.ccmd->flags = cmd->flags | WAS_SENSE;
cmd1842drivers/scsi/aic7xxx.cscb->sense_cmd[1] = cmd->lun << 5;
cmd1843drivers/scsi/aic7xxx.cscb->sense_cmd[4] = sizeof(cmd->sense_buffer);
cmd1846drivers/scsi/aic7xxx.cscb->sense_sg.address = (char *) &cmd->sense_buffer;
cmd1847drivers/scsi/aic7xxx.cscb->sense_sg.length = sizeof(cmd->sense_buffer);
cmd1850drivers/scsi/aic7xxx.creq_buf = &cmd->sense_buffer;
cmd1851drivers/scsi/aic7xxx.creq_buflen = sizeof(cmd->sense_buffer);
cmd1853drivers/scsi/aic7xxx.ccmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
cmd1855drivers/scsi/aic7xxx.cscb->target_channel_lun = ((cmd->target << 4) & 0xF0) |
cmd1856drivers/scsi/aic7xxx.c((cmd->channel & 0x01) << 3) | (cmd->lun & 0x07);
cmd1918drivers/scsi/aic7xxx.ccmd->flags = cmd->flags | ASKED_FOR_SENSE;
cmd1924drivers/scsi/aic7xxx.cif (!aic7xxx_error(cmd))
cmd1926drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_BUS_BUSY;
cmd1932drivers/scsi/aic7xxx.cif (!aic7xxx_error(cmd))
cmd1934drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd1941drivers/scsi/aic7xxx.cif (!aic7xxx_error(cmd))
cmd1943drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd1953drivers/scsi/aic7xxx.cif ((scb->state != SCB_ACTIVE) || (scb->cmd == NULL))
cmd1957drivers/scsi/aic7xxx.cintstat, scbptr, scb->state, (unsigned int) scb->cmd);
cmd1961drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd1966drivers/scsi/aic7xxx.cif (!(cmd->flags & WAS_SENSE))
cmd1974drivers/scsi/aic7xxx.cactual = aic7xxx_length(cmd, scb->residual_SG_segment_count);
cmd1980drivers/scsi/aic7xxx.cif (actual < cmd->underflow)
cmd1984drivers/scsi/aic7xxx.ccmd->target, cmd->underflow, actual);
cmd1986drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd1987drivers/scsi/aic7xxx.caic7xxx_status(cmd) = scb->target_status;
cmd1996drivers/scsi/aic7xxx.cif ((scb->state != SCB_ACTIVE) || (scb->cmd == NULL))
cmd2000drivers/scsi/aic7xxx.cintstat, scbptr, scb->state, (unsigned int) scb->cmd);
cmd2004drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2011drivers/scsi/aic7xxx.c(cmd->channel & 0x01) ? 'B':'A',
cmd2012drivers/scsi/aic7xxx.ccmd->target, cmd->lun & 0x07);
cmd2025drivers/scsi/aic7xxx.cscb->cmd = NULL;
cmd2030drivers/scsi/aic7xxx.ccmd->result = (DID_RETRY_COMMAND << 16);
cmd2031drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd2038drivers/scsi/aic7xxx.cif ((scb->state != SCB_ACTIVE) || (scb->cmd == NULL))
cmd2042drivers/scsi/aic7xxx.cintstat, scbptr, scb->state, (unsigned int) scb->cmd);
cmd2079drivers/scsi/aic7xxx.cif ((scb->state != SCB_ACTIVE) || (scb->cmd == NULL))
cmd2095drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2106drivers/scsi/aic7xxx.cunsigned char target_mask = (1 << (cmd->target & 0x07));
cmd2114drivers/scsi/aic7xxx.ccmd->result = (DID_TIME_OUT << 16);
cmd2177drivers/scsi/aic7xxx.cscb->cmd = NULL;
cmd2183drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd2186drivers/scsi/aic7xxx.cscb->position, scb->state, (unsigned int) scb->cmd);
cmd2199drivers/scsi/aic7xxx.ccmd->target,
cmd2200drivers/scsi/aic7xxx.ccmd->channel & 0x01,
cmd2201drivers/scsi/aic7xxx.ccmd->lun & 0x07);
cmd2202drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_PARITY;
cmd2245drivers/scsi/aic7xxx.cif ((scb->state != SCB_ACTIVE) || (scb->cmd == NULL))
cmd2251drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd);
cmd2255drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2257drivers/scsi/aic7xxx.ccmd->result = (aic7xxx_error(cmd) << 16) | aic7xxx_status(cmd);
cmd2258drivers/scsi/aic7xxx.cif ((cmd->flags & WAS_SENSE) && !(cmd->flags & ASKED_FOR_SENSE))
cmd2260drivers/scsi/aic7xxx.ccmd->flags = cmd->flags & ASKED_FOR_SENSE;
cmd2264drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, (unsigned int) p->free_scb);
cmd2275drivers/scsi/aic7xxx.cscb->cmd = NULL;
cmd2285drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, (unsigned int) p->free_scb);
cmd2288drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd2966drivers/scsi/aic7xxx.cp->scb_array[i].cmd = NULL;
cmd3413drivers/scsi/aic7xxx.cScsi_Cmnd *cmd,
cmd3425drivers/scsi/aic7xxx.cif (cmd->device->tagged_supported)
cmd3427drivers/scsi/aic7xxx.cif (cmd->device->tagged_queue == 0)
cmd3430drivers/scsi/aic7xxx.c"channel %d\n", cmd->target, cmd->channel);
cmd3431drivers/scsi/aic7xxx.ccmd->device->tagged_queue = 1;
cmd3432drivers/scsi/aic7xxx.ccmd->device->current_tag = 1;  /* enable tagging */
cmd3434drivers/scsi/aic7xxx.ccmd->tag = cmd->device->current_tag;
cmd3435drivers/scsi/aic7xxx.ccmd->device->current_tag = cmd->device->current_tag + 1;
cmd3439drivers/scsi/aic7xxx.cmask = (0x01 << cmd->target);
cmd3445drivers/scsi/aic7xxx.cprintk("Sending WDTR request to target %d.\n", cmd->target);
cmd3455drivers/scsi/aic7xxx.cprintk("Sending SDTR request to target %d.\n", cmd->target);
cmd3462drivers/scsi/aic7xxx.ccmd->target, cmd->cmnd[0], cmd->cmd_len, p->needwdtr, mask);
cmd3464drivers/scsi/aic7xxx.cscb->target_channel_lun = ((cmd->target << 4) & 0xF0) |
cmd3465drivers/scsi/aic7xxx.c((cmd->channel & 0x01) << 3) | (cmd->lun & 0x07);
cmd3477drivers/scsi/aic7xxx.clength = aic7xxx_length(cmd, 0);
cmd3488drivers/scsi/aic7xxx.caddr = cmd->cmnd;
cmd3489drivers/scsi/aic7xxx.cscb->SCSI_cmd_length = cmd->cmd_len;
cmd3492drivers/scsi/aic7xxx.cif (cmd->use_sg)
cmd3496drivers/scsi/aic7xxx.ccmd->use_sg, length);
cmd3498drivers/scsi/aic7xxx.cscb->SG_segment_count = cmd->use_sg;
cmd3499drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &cmd->request_buffer,
cmd3506drivers/scsi/aic7xxx.c(unsigned long) cmd->request_buffer, cmd->request_bufflen);
cmd3510drivers/scsi/aic7xxx.cscb->sg.address = (char *) cmd->request_buffer;
cmd3511drivers/scsi/aic7xxx.cscb->sg.length = cmd->request_bufflen;
cmd3516drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &cmd->request_buffer, sizeof(scb->data_pointer));
cmd3517drivers/scsi/aic7xxx.cmemcpy(scb->data_count, &cmd->request_bufflen, 3);
cmd3530drivers/scsi/aic7xxx.caic7xxx_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
cmd3540drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
cmd3543drivers/scsi/aic7xxx.cif (!p->a_scanned && (cmd->channel == 0))
cmd3550drivers/scsi/aic7xxx.cif (!p->b_scanned && (cmd->channel == 1))
cmd3559drivers/scsi/aic7xxx.ccmd->cmnd[0], cmd->cmd_len, cmd->target, cmd->channel,
cmd3560drivers/scsi/aic7xxx.ccmd->lun & 0x07);
cmd3631drivers/scsi/aic7xxx.cscb->cmd = cmd;
cmd3632drivers/scsi/aic7xxx.caic7xxx_position(cmd) = scb->position;
cmd3638drivers/scsi/aic7xxx.caic7xxx_buildscb(p, cmd, scb);
cmd3646drivers/scsi/aic7xxx.cscb->position, (unsigned int) scb->cmd,
cmd3680drivers/scsi/aic7xxx.ccmd->scsi_done = fn;
cmd3681drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_OK;
cmd3682drivers/scsi/aic7xxx.caic7xxx_status(cmd) = 0;
cmd3684drivers/scsi/aic7xxx.ccmd->result = 0;
cmd3685drivers/scsi/aic7xxx.cmemset(&cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
cmd3721drivers/scsi/aic7xxx.caic7xxx_kill(Scsi_Cmnd *cmd, unsigned char message,
cmd3732drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
cmd3733drivers/scsi/aic7xxx.cscb = &p->scb_array[aic7xxx_position(cmd)];
cmd3813drivers/scsi/aic7xxx.cif (cmd->channel & 0x01)
cmd3876drivers/scsi/aic7xxx.cscb->cmd = NULL;                /* clear the command pointer */
cmd3879drivers/scsi/aic7xxx.ccmd->result = cmd->result << 16;
cmd3880drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd3892drivers/scsi/aic7xxx.caic7xxx_abort(Scsi_Cmnd *cmd)
cmd3900drivers/scsi/aic7xxx.cswitch (aic7xxx_kill(cmd, ABORT, DID_ABORT, !0))
cmd3924drivers/scsi/aic7xxx.caic7xxx_reset(Scsi_Cmnd *cmd)
cmd3929drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
cmd3933drivers/scsi/aic7xxx.cswitch (aic7xxx_kill(cmd, BUS_DEVICE_RESET, DID_RESET, 0))
cmd3942drivers/scsi/aic7xxx.cp->needsdtr = p->needsdtr & (1 << cmd->target);
cmd3955drivers/scsi/aic7xxx.ccmd->result = DID_RESET << 16;  /* return reset code */
cmd3956drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd3986drivers/scsi/aic7xxx.ccmd->result = DID_RESET << 16;  /* return reset code */
cmd3987drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd579drivers/scsi/buslogic.cunsigned char *cmd = (unsigned char *)scpnt->cmnd;
cmd599drivers/scsi/buslogic.cif (*cmd == REQUEST_SENSE) {
cmd616drivers/scsi/buslogic.cif (*cmd == READ_10 || *cmd == WRITE_10
cmd617drivers/scsi/buslogic.c|| *cmd == READ_6 || *cmd == WRITE_6)
cmd618drivers/scsi/buslogic.ci = *(int *)(cmd + 2);
cmd622drivers/scsi/buslogic.ctarget, *cmd, i, bufflen);
cmd626drivers/scsi/buslogic.cprintk(" %02X", cmd[i]);
cmd628drivers/scsi/buslogic.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd683drivers/scsi/buslogic.cif (*cmd == READ_10 || *cmd == READ_6)
cmd685drivers/scsi/buslogic.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd688drivers/scsi/buslogic.cmemcpy(ccb->cdb, cmd, ccb->cdblen);
cmd811drivers/scsi/buslogic.cunsigned char cmd, count;
cmd813drivers/scsi/buslogic.c} cmd = { CMD_INITEXTMB, BUSLOGIC_MAILBOXES, mb };
cmd821drivers/scsi/buslogic.cif (buslogic_out(base, (unsigned char *)&cmd, sizeof cmd))
cmd1286drivers/scsi/buslogic.cunsigned char cmd[]
cmd1296drivers/scsi/buslogic.cif (!buslogic_command(i, cmd, buf, sizeof buf)) {
cmd1307drivers/scsi/buslogic.ccmd[0] = READ_10;
cmd1308drivers/scsi/buslogic.ccmd[1] = 0;
cmd1309drivers/scsi/buslogic.cxany2scsi(cmd + 2, i);
cmd1310drivers/scsi/buslogic.ccmd[6] = 0;
cmd1311drivers/scsi/buslogic.ccmd[7] = 0;
cmd1312drivers/scsi/buslogic.ccmd[8] = 1;
cmd1313drivers/scsi/buslogic.ccmd[9] = 0;
cmd1314drivers/scsi/buslogic.cbuslogic_command(0, cmd, buffer, sizeof buffer);
cmd568drivers/scsi/constants.cvoid print_Scsi_Cmnd (Scsi_Cmnd *cmd) {
cmd570drivers/scsi/constants.ccmd->host->host_no, 
cmd571drivers/scsi/constants.ccmd->target, 
cmd572drivers/scsi/constants.ccmd->lun);
cmd574drivers/scsi/constants.cprint_command (cmd->cmnd);
cmd337drivers/scsi/eata.cstatic inline unchar do_dma (ushort iobase, unsigned int addr, unchar cmd) {
cmd348drivers/scsi/eata.coutb(cmd, iobase + REG_CMD);
cmd160drivers/scsi/eata_dma.cScsi_Cmnd *cmd;
cmd182drivers/scsi/eata_dma.ccmd = cp->cmd;
cmd183drivers/scsi/eata_dma.cbase = (uint) cmd->host->base;
cmd212drivers/scsi/eata_dma.cirq, base, cmd->pid, cmd->target, cmd->lun, 
cmd218drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
cmd219drivers/scsi/eata_dma.c&& (HD(cmd)->t_state[cp->cp_channel][cp->cp_id] == RESET))
cmd222drivers/scsi/eata_dma.cHD(cmd)->t_state[cp->cp_channel][cp->cp_id] = OK;
cmd223drivers/scsi/eata_dma.cif(HD(cmd)->do_latency == TRUE && cp->timestamp) {
cmd227drivers/scsi/eata_dma.cif(HD(cmd)->writes_lat[cp->sizeindex][1] > time)
cmd228drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][1] = time;
cmd229drivers/scsi/eata_dma.cif(HD(cmd)->writes_lat[cp->sizeindex][2] < time)
cmd230drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][2] = time;
cmd231drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][3] += time;
cmd232drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][0]++;
cmd234drivers/scsi/eata_dma.cif(HD(cmd)->reads_lat[cp->sizeindex][1] > time)
cmd235drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][1] = time;
cmd236drivers/scsi/eata_dma.cif(HD(cmd)->reads_lat[cp->sizeindex][2] < time)
cmd237drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][2] = time;
cmd238drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][3] += time;
cmd239drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][0]++;
cmd244drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
cmd245drivers/scsi/eata_dma.c&& (cmd->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
cmd249drivers/scsi/eata_dma.cHD(cmd)->t_timeout[cp->cp_channel][cp->cp_id] = OK;
cmd255drivers/scsi/eata_dma.cif (HD(cmd)->t_timeout[cp->cp_channel][cp->cp_id] > 1)
cmd259drivers/scsi/eata_dma.cHD(cmd)->t_timeout[cp->cp_channel][cp->cp_id]++;
cmd264drivers/scsi/eata_dma.cif (cmd->device->type != TYPE_TAPE)
cmd270drivers/scsi/eata_dma.cHD(cmd)->t_state[cp->cp_channel][i] = RESET;
cmd284drivers/scsi/eata_dma.ccmd->result = result | (scsi_stat << 1); 
cmd288drivers/scsi/eata_dma.c|| cmd->scsi_done == NULL || cmd->device->id == 7) 
cmd292drivers/scsi/eata_dma.cx, cmd->device->channel, cmd->device->id, cmd->device->lun,
cmd293drivers/scsi/eata_dma.ccmd->pid, eata_stat, hba_stat, scsi_stat, 
cmd294drivers/scsi/eata_dma.ccmd->sense_buffer[2] & 0xf, cmd->result); 
cmd299drivers/scsi/eata_dma.ccmd->scsi_done(cmd);
cmd343drivers/scsi/eata_dma.cint eata_queue(Scsi_Cmnd * cmd, void (* done) (Scsi_Cmnd *))
cmd357drivers/scsi/eata_dma.chd = HD(cmd);
cmd358drivers/scsi/eata_dma.csh = cmd->host;
cmd401drivers/scsi/eata_dma.ccmd->pid, cmd->target, cmd->lun, y));
cmd409drivers/scsi/eata_dma.cif (cmd->cmnd[0] == WRITE_6 || cmd->cmnd[0] == WRITE_10 || 
cmd410drivers/scsi/eata_dma.ccmd->cmnd[0] == WRITE_12 || cmd->cmnd[0] == READ_6 || 
cmd411drivers/scsi/eata_dma.ccmd->cmnd[0] == READ_10 || cmd->cmnd[0] == READ_12) {
cmd414drivers/scsi/eata_dma.cswitch(cmd->cmnd[0]) {
cmd417drivers/scsi/eata_dma.cx = cmd->cmnd[4]/2; 
cmd421drivers/scsi/eata_dma.csho = (short *) &cmd->cmnd[7];
cmd426drivers/scsi/eata_dma.clon = (long *) &cmd->cmnd[6];
cmd434drivers/scsi/eata_dma.cif (cmd->cmnd[0] ==  WRITE_6 || cmd->cmnd[0] == WRITE_10 || 
cmd435drivers/scsi/eata_dma.ccmd->cmnd[0] ==  WRITE_12){
cmd440drivers/scsi/eata_dma.ccmd->scsi_done = (void *)done;
cmd442drivers/scsi/eata_dma.cswitch (cmd->cmnd[0]) {
cmd464drivers/scsi/eata_dma.cif (cmd->target == sh->this_id) 
cmd467drivers/scsi/eata_dma.cif (cmd->use_sg) {
cmd477drivers/scsi/eata_dma.ccp->cp_datalen = htonl(cmd->use_sg * sizeof(struct eata_sg_list));
cmd478drivers/scsi/eata_dma.csl=(struct scatterlist *)cmd->request_buffer;
cmd479drivers/scsi/eata_dma.cfor(i = 0; i < cmd->use_sg; i++, sl++){
cmd485drivers/scsi/eata_dma.ccp->cp_datalen = htonl(cmd->request_bufflen);
cmd486drivers/scsi/eata_dma.ccp->cp_dataDMA = htonl(virt_to_bus(cmd->request_buffer));
cmd490drivers/scsi/eata_dma.ccp->cp_reqDMA = htonl(virt_to_bus(cmd->sense_buffer));
cmd491drivers/scsi/eata_dma.ccp->reqlen = sizeof(cmd->sense_buffer);
cmd493drivers/scsi/eata_dma.ccp->cp_id = cmd->target;
cmd494drivers/scsi/eata_dma.ccp->cp_channel = cmd->channel;
cmd495drivers/scsi/eata_dma.ccp->cp_lun = cmd->lun;
cmd498drivers/scsi/eata_dma.cmemcpy(cp->cp_cdb, cmd->cmnd, cmd->cmd_len);
cmd503drivers/scsi/eata_dma.ccp->cmd = cmd;
cmd504drivers/scsi/eata_dma.ccmd->host_scribble = (char *)&hd->ccb[y];  
cmd507drivers/scsi/eata_dma.ccmd->result = DID_BUS_BUSY << 16;
cmd509drivers/scsi/eata_dma.ccmd->target, cmd->pid);
cmd510drivers/scsi/eata_dma.cdone(cmd);
cmd516drivers/scsi/eata_dma.c"slot %d irq %d\n", (s32)sh->base, cmd->pid, 
cmd517drivers/scsi/eata_dma.ccmd->target, cmd->lun, y, sh->irq));
cmd524drivers/scsi/eata_dma.cint eata_abort(Scsi_Cmnd * cmd)
cmd533drivers/scsi/eata_dma.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
cmd534drivers/scsi/eata_dma.ccmd->abort_reason));
cmd538drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd545drivers/scsi/eata_dma.cif (CD(cmd)->status == USED) {
cmd550drivers/scsi/eata_dma.cif (CD(cmd)->status == FREE) {
cmd555drivers/scsi/eata_dma.cif (CD(cmd)->status == RESET) {
cmd561drivers/scsi/eata_dma.cif (CD(cmd)->status == LOCKED) {
cmd571drivers/scsi/eata_dma.cint eata_reset(Scsi_Cmnd * cmd)
cmd584drivers/scsi/eata_dma.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
cmd585drivers/scsi/eata_dma.ccmd->abort_reason));
cmd587drivers/scsi/eata_dma.cif (HD(cmd)->state == RESET) {
cmd594drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd604drivers/scsi/eata_dma.cHD(cmd)->t_state[x][z] = RESET;
cmd605drivers/scsi/eata_dma.cHD(cmd)->t_timeout[x][z] = NO_TIMEOUT;
cmd609drivers/scsi/eata_dma.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd610drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status == FREE)
cmd613drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status == LOCKED) {
cmd614drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = FREE;
cmd619drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
cmd620drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = RESET;
cmd628drivers/scsi/eata_dma.cif (sp == cmd)
cmd633drivers/scsi/eata_dma.cinb((u32) (cmd->host->base) + HA_RSTATUS);  /* This might cause trouble */
cmd634drivers/scsi/eata_dma.ceata_send_command(0, (u32) cmd->host->base, EATA_CMD_RESET);
cmd637drivers/scsi/eata_dma.cHD(cmd)->state = RESET;
cmd652drivers/scsi/eata_dma.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd655drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status != RESET)
cmd658drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
cmd662drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = LOCKED;
cmd672drivers/scsi/eata_dma.cHD(cmd)->state = FALSE;
cmd79drivers/scsi/eata_generic.h#define HD(cmd)   ((hostdata *)&(cmd->host->hostdata))
cmd80drivers/scsi/eata_generic.h#define CD(cmd)   ((struct eata_ccb *)(cmd->host_scribble))
cmd303drivers/scsi/eata_generic.hScsi_Cmnd *cmd;        /* address of cmd        */
cmd131drivers/scsi/eata_pio.cScsi_Cmnd *cmd;
cmd155drivers/scsi/eata_pio.ccmd = cp->cmd;
cmd156drivers/scsi/eata_pio.cbase = (uint) cmd->host->base;
cmd165drivers/scsi/eata_pio.cwhile ((cmd->SCp.Status)&&((z>0)||(odd)))
cmd169drivers/scsi/eata_pio.c*(cmd->SCp.ptr)=zwickel>>8; 
cmd170drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1);
cmd173drivers/scsi/eata_pio.cx=min(z,cmd->SCp.this_residual/2);
cmd174drivers/scsi/eata_pio.cinsw(base+HA_RDATA,cmd->SCp.ptr,x);
cmd176drivers/scsi/eata_pio.cIncStat(&cmd->SCp,2*x);
cmd177drivers/scsi/eata_pio.cif ((z>0)&&(cmd->SCp.this_residual==1))
cmd180drivers/scsi/eata_pio.c*(cmd->SCp.ptr)=zwickel&0xff;
cmd181drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1); z--; 
cmd193drivers/scsi/eata_pio.cwhile ((cmd->SCp.Status)&&((z>0)||(odd)))
cmd197drivers/scsi/eata_pio.czwickel+=*(cmd->SCp.ptr)<<8; 
cmd198drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1);
cmd203drivers/scsi/eata_pio.cx=min(z,cmd->SCp.this_residual/2);
cmd204drivers/scsi/eata_pio.coutsw(base+HA_RDATA,cmd->SCp.ptr,x);
cmd206drivers/scsi/eata_pio.cIncStat(&cmd->SCp,2*x);
cmd207drivers/scsi/eata_pio.cif ((z>0)&&(cmd->SCp.this_residual==1))
cmd209drivers/scsi/eata_pio.czwickel=*(cmd->SCp.ptr); 
cmd211drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1); 
cmd234drivers/scsi/eata_pio.ccmd->result=(DID_OK<<16); 
cmd238drivers/scsi/eata_pio.ccmd->result=(DID_OK<<16)+0x02;
cmd239drivers/scsi/eata_pio.celse cmd->result=(DID_NO_CONNECT<<16);
cmd252drivers/scsi/eata_pio.cprintk("stat: %#.2x, result: %#.8x\n", stat, cmd->result); 
cmd259drivers/scsi/eata_pio.ccmd->scsi_done(cmd);
cmd280drivers/scsi/eata_pio.cint eata_pio_queue(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd295drivers/scsi/eata_pio.chd = HD(cmd);
cmd296drivers/scsi/eata_pio.csh = cmd->host;
cmd317drivers/scsi/eata_pio.cmemset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
cmd322drivers/scsi/eata_pio.ccmd->pid, cmd->target, cmd->lun, y));
cmd325drivers/scsi/eata_pio.ccmd->scsi_done = (void *)done;
cmd327drivers/scsi/eata_pio.cswitch (cmd->cmnd[0]) {
cmd346drivers/scsi/eata_pio.ccp->Interpret = (cmd->target == hd->hostid);
cmd347drivers/scsi/eata_pio.ccp->cp_datalen = htonl((ulong)cmd->request_bufflen);
cmd352drivers/scsi/eata_pio.ccp->cp_id = cmd->target;
cmd353drivers/scsi/eata_pio.ccp->cp_lun = cmd->lun;
cmd356drivers/scsi/eata_pio.cmemcpy(cp->cp_cdb, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
cmd361drivers/scsi/eata_pio.ccp->cmd = cmd;
cmd362drivers/scsi/eata_pio.ccmd->host_scribble = (char *)&hd->ccb[y];   
cmd364drivers/scsi/eata_pio.cif (cmd->use_sg == 0)
cmd366drivers/scsi/eata_pio.ccmd->SCp.buffers_residual=1;
cmd367drivers/scsi/eata_pio.ccmd->SCp.ptr = cmd->request_buffer;
cmd368drivers/scsi/eata_pio.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd369drivers/scsi/eata_pio.ccmd->SCp.buffer = NULL;
cmd371drivers/scsi/eata_pio.ccmd->SCp.buffer = cmd->request_buffer;
cmd372drivers/scsi/eata_pio.ccmd->SCp.buffers_residual = cmd->use_sg;
cmd373drivers/scsi/eata_pio.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd374drivers/scsi/eata_pio.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd376drivers/scsi/eata_pio.ccmd->SCp.Status = (cmd->SCp.this_residual != 0);  /* TRUE as long as bytes 
cmd381drivers/scsi/eata_pio.ccmd->result = DID_BUS_BUSY << 16;
cmd383drivers/scsi/eata_pio.c"DID_BUS_BUSY, done.\n", cmd->target, cmd->pid);
cmd384drivers/scsi/eata_pio.cdone(cmd);
cmd395drivers/scsi/eata_pio.c"slot %d irq %d\n", (long)sh->base, cmd->pid, 
cmd396drivers/scsi/eata_pio.ccmd->target, cmd->lun, y, sh->irq));
cmd403drivers/scsi/eata_pio.cint eata_pio_abort(Scsi_Cmnd * cmd)
cmd412drivers/scsi/eata_pio.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
cmd413drivers/scsi/eata_pio.ccmd->abort_reason));
cmd417drivers/scsi/eata_pio.cwhile (inb((uint)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd424drivers/scsi/eata_pio.cif (CD(cmd)->status == FREE) {
cmd429drivers/scsi/eata_pio.cif (CD(cmd)->status == USED) {
cmd434drivers/scsi/eata_pio.cif (CD(cmd)->status == RESET) {
cmd440drivers/scsi/eata_pio.cif (CD(cmd)->status == LOCKED) {
cmd450drivers/scsi/eata_pio.cint eata_pio_reset(Scsi_Cmnd * cmd)
cmd461drivers/scsi/eata_pio.c"reason %x\n", cmd->pid, cmd->target, cmd->lun, 
cmd462drivers/scsi/eata_pio.ccmd->abort_reason));
cmd464drivers/scsi/eata_pio.cif (HD(cmd)->state == RESET) {
cmd472drivers/scsi/eata_pio.cHD(cmd)->t_state[0][z] = RESET;
cmd473drivers/scsi/eata_pio.cHD(cmd)->t_timeout[0][z] = NO_TIMEOUT;
cmd478drivers/scsi/eata_pio.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd480drivers/scsi/eata_pio.cif (HD(cmd)->ccb[x].status == FREE) 
cmd483drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
cmd484drivers/scsi/eata_pio.cHD(cmd)->ccb[x].status = RESET;
cmd494drivers/scsi/eata_pio.coutb((uint) cmd->host->base+HA_WCOMMAND, EATA_CMD_RESET);
cmd497drivers/scsi/eata_pio.cHD(cmd)->state = RESET;
cmd505drivers/scsi/eata_pio.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd508drivers/scsi/eata_pio.cif (HD(cmd)->ccb[x].status != RESET)
cmd511drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
cmd516drivers/scsi/eata_pio.cHD(cmd)->ccb[x].status = FREE;
cmd523drivers/scsi/eata_pio.cHD(cmd)->state = FALSE;
cmd421drivers/scsi/in2000.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd436drivers/scsi/in2000.cif ( *cmd == TEST_UNIT_READY )
cmd442drivers/scsi/in2000.cif (*cmd == READ_10 || *cmd == WRITE_10) {
cmd443drivers/scsi/in2000.ci = xscsi2int((cmd+1));
cmd444drivers/scsi/in2000.c} else if (*cmd == READ_6 || *cmd == WRITE_6) {
cmd445drivers/scsi/in2000.ci = scsi2int((cmd+1));
cmd452drivers/scsi/in2000.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd456drivers/scsi/in2000.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd520drivers/scsi/in2000.coutb(cmd[loop],INDATA);
cmd298drivers/scsi/qlogic.cstatic void  ql_icmd(Scsi_Cmnd * cmd)
cmd332drivers/scsi/qlogic.coutb(cmd->target, qbase + 4);
cmd334drivers/scsi/qlogic.cfor (i = 0; i < cmd->cmd_len; i++)
cmd335drivers/scsi/qlogic.coutb(cmd->cmnd[i], qbase + 2);
cmd336drivers/scsi/qlogic.cqlcmd = cmd;
cmd342drivers/scsi/qlogic.cstatic unsigned int  ql_pcmd(Scsi_Cmnd * cmd)
cmd379drivers/scsi/qlogic.creqlen = cmd->request_bufflen;
cmd389drivers/scsi/qlogic.cif (!cmd->use_sg)
cmd390drivers/scsi/qlogic.cql_pdma(phase, cmd->request_buffer, cmd->request_bufflen);
cmd392drivers/scsi/qlogic.csgcount = cmd->use_sg;
cmd393drivers/scsi/qlogic.csglist = cmd->request_buffer;
cmd477drivers/scsi/qlogic.cstatic void  qlidone(Scsi_Cmnd * cmd) {};    /* null function */
cmd481drivers/scsi/qlogic.cint  qlogic_command(Scsi_Cmnd * cmd)
cmd486drivers/scsi/qlogic.cqlogic_queuecommand(cmd, qlidone);
cmd488drivers/scsi/qlogic.creturn cmd->result;
cmd492drivers/scsi/qlogic.cif (cmd->target == qinitid)
cmd494drivers/scsi/qlogic.cql_icmd(cmd);
cmd497drivers/scsi/qlogic.creturn ql_pcmd(cmd);
cmd504drivers/scsi/qlogic.cint  qlogic_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd506drivers/scsi/qlogic.cif(cmd->target == qinitid) {
cmd507drivers/scsi/qlogic.ccmd->result = DID_BAD_TARGET << 16;
cmd508drivers/scsi/qlogic.cdone(cmd);
cmd512drivers/scsi/qlogic.ccmd->scsi_done = done;
cmd516drivers/scsi/qlogic.cql_icmd(cmd);
cmd520drivers/scsi/qlogic.cint  qlogic_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd653drivers/scsi/qlogic.cint  qlogic_abort(Scsi_Cmnd * cmd)
cmd662drivers/scsi/qlogic.cint  qlogic_reset(Scsi_Cmnd * cmd)
cmd3104drivers/scsi/scsi.creq->cmd,
cmd103drivers/scsi/scsi_debug.cif (SCpnt->request.cmd != RW) panic ("Wrong  operation");       \
cmd178drivers/scsi/scsi_debug.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd212drivers/scsi/scsi_debug.cswitch(*cmd){
cmd230drivers/scsi/scsi_debug.cif(cmd[4]) printk("Medium removal inhibited...");
cmd268drivers/scsi/scsi_debug.cif ((*cmd) == READ_10)
cmd269drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
cmd271drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
cmd349drivers/scsi/scsi_debug.cmemcpy(buff+sizeof(target), cmd, 24);
cmd381drivers/scsi/scsi_debug.cif ((*cmd) == WRITE_10)
cmd382drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
cmd384drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
cmd403drivers/scsi/scsi_debug.cprintk("Unknown command %d\n",*cmd);
cmd110drivers/scsi/scsi_ioctl.cstatic int ioctl_internal_command(Scsi_Device *dev, char * cmd)
cmd116drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd, NULL,  0,
cmd132drivers/scsi/scsi_ioctl.cif(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0;
cmd174drivers/scsi/scsi_ioctl.cchar cmd[12];
cmd234drivers/scsi/scsi_ioctl.cmemcpy_fromfs ((void *) cmd,  cmd_in,  cmdlen);
cmd246drivers/scsi/scsi_ioctl.ccmd[1] = ( cmd[1] & 0x1f ) | (dev->lun << 5);
cmd252drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd,  buf, needed,  scsi_ioctl_done,  MAX_TIMEOUT, 
cmd297drivers/scsi/scsi_ioctl.cprintk("%02x ", cmd[i]);
cmd315drivers/scsi/scsi_ioctl.cint scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
cmd323drivers/scsi/scsi_ioctl.cswitch (cmd) {
cmd385drivers/scsi/scsi_ioctl.cint kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) {
cmd390drivers/scsi/scsi_ioctl.ctmp = scsi_ioctl (dev, cmd, arg);
cmd16drivers/scsi/scsi_ioctl.hextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd17drivers/scsi/scsi_ioctl.hextern int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd235drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
cmd250drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
cmd495drivers/scsi/sd.cunsigned char cmd[10];
cmd562drivers/scsi/sd.cswitch (SCpnt->request.cmd)
cmd570drivers/scsi/sd.ccmd[0] = WRITE_6;
cmd573drivers/scsi/sd.ccmd[0] = READ_6;
cmd576drivers/scsi/sd.cpanic ("Unknown sd command %d\n", SCpnt->request.cmd);
cmd794drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
cmd816drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
cmd823drivers/scsi/sd.c(SCpnt->request.cmd == WRITE) ? "writing" : "reading",
cmd827drivers/scsi/sd.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
cmd846drivers/scsi/sd.ccmd[0] += READ_10 - READ_6 ;
cmd847drivers/scsi/sd.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
cmd848drivers/scsi/sd.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
cmd849drivers/scsi/sd.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
cmd850drivers/scsi/sd.ccmd[5] = (unsigned char) block & 0xff;
cmd851drivers/scsi/sd.ccmd[6] = cmd[9] = 0;
cmd852drivers/scsi/sd.ccmd[7] = (unsigned char) (this_count >> 8) & 0xff;
cmd853drivers/scsi/sd.ccmd[8] = (unsigned char) this_count & 0xff;
cmd860drivers/scsi/sd.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
cmd861drivers/scsi/sd.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
cmd862drivers/scsi/sd.ccmd[3] = (unsigned char) block & 0xff;
cmd863drivers/scsi/sd.ccmd[4] = (unsigned char) this_count;
cmd864drivers/scsi/sd.ccmd[5] = 0;
cmd875drivers/scsi/sd.cscsi_do_cmd (SCpnt, (void *) cmd, buff, 
cmd931drivers/scsi/sd.cunsigned char cmd[10];
cmd953drivers/scsi/sd.ccmd[0] = TEST_UNIT_READY;
cmd954drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd955drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd962drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd982drivers/scsi/sd.ccmd[0] = START_STOP;
cmd983drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd984drivers/scsi/sd.ccmd[1] |= 1;  /* Return immediately */
cmd985drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd986drivers/scsi/sd.ccmd[4] = 1; /* Start spin cycle */
cmd994drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd1020drivers/scsi/sd.ccmd[0] = READ_CAPACITY;
cmd1021drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd1022drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd1030drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd22drivers/scsi/sd_ioctl.cint sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
cmd30drivers/scsi/sd_ioctl.cswitch (cmd) {
cmd73drivers/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg);
cmd1611drivers/scsi/seagate.cunsigned char buf[256 + sizeof(int) * 2], cmd[6], *data, *page;
cmd1626drivers/scsi/seagate.ccmd[0] = MODE_SENSE;
cmd1627drivers/scsi/seagate.ccmd[1] = (disk->device->lun << 5) & 0xe5;
cmd1628drivers/scsi/seagate.ccmd[2] = 0x04; /* Read page 4, rigid disk geometry page current values */
cmd1629drivers/scsi/seagate.ccmd[3] = 0;
cmd1630drivers/scsi/seagate.ccmd[4] = 255;
cmd1631drivers/scsi/seagate.ccmd[5] = 0;
cmd1641drivers/scsi/seagate.cmemcpy (data, cmd, 6);
cmd1653drivers/scsi/seagate.ccmd[2] = 0x03; /* Read page 3, format page current values */
cmd1654drivers/scsi/seagate.cmemcpy (data, cmd, 6);
cmd325drivers/scsi/sr.cunsigned char   *cmd;       /* the scsi-command */
cmd354drivers/scsi/sr.ccmd = rec = &buf[8];
cmd365drivers/scsi/sr.ccmd[0] = 0xde;
cmd366drivers/scsi/sr.ccmd[1] = 0x03;
cmd367drivers/scsi/sr.ccmd[2] = 0xb0;
cmd401drivers/scsi/sr.ccmd[0] = 0xc7;
cmd402drivers/scsi/sr.ccmd[1] = 3;
cmd437drivers/scsi/sr.ccmd[0] = 0x1a;
cmd438drivers/scsi/sr.ccmd[2] = 1;
cmd439drivers/scsi/sr.ccmd[4] = 12;
cmd458drivers/scsi/sr.ccmd[0] = 0x15;
cmd459drivers/scsi/sr.ccmd[1] = (1 << 4);
cmd460drivers/scsi/sr.ccmd[4] = 12;
cmd461drivers/scsi/sr.csend = &cmd[6];                 /* this is a 6-Byte command          */
cmd483drivers/scsi/sr.ccmd[0] = 0x43; /* Read TOC */
cmd484drivers/scsi/sr.ccmd[8] = 0x0c;
cmd485drivers/scsi/sr.ccmd[9] = 0x40;
cmd642drivers/scsi/sr.cunsigned char cmd[10], *buffer, tries;
cmd683drivers/scsi/sr.cswitch (SCpnt->request.cmd)
cmd690drivers/scsi/sr.ccmd[0] = READ_6;
cmd693drivers/scsi/sr.cpanic ("Unknown sr command %d\n", SCpnt->request.cmd);
cmd696drivers/scsi/sr.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
cmd871drivers/scsi/sr.ccmd[0] += READ_10 - READ_6 ;
cmd872drivers/scsi/sr.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
cmd873drivers/scsi/sr.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
cmd874drivers/scsi/sr.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
cmd875drivers/scsi/sr.ccmd[5] = (unsigned char) block & 0xff;
cmd876drivers/scsi/sr.ccmd[6] = cmd[9] = 0;
cmd877drivers/scsi/sr.ccmd[7] = (unsigned char) (realcount >> 8) & 0xff;
cmd878drivers/scsi/sr.ccmd[8] = (unsigned char) realcount & 0xff;
cmd888drivers/scsi/sr.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
cmd889drivers/scsi/sr.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
cmd890drivers/scsi/sr.ccmd[3] = (unsigned char) block & 0xff;
cmd891drivers/scsi/sr.ccmd[4] = (unsigned char) realcount;
cmd892drivers/scsi/sr.ccmd[5] = 0;
cmd901drivers/scsi/sr.cfor(i=0; i<12; i++) printk("%2.2x ", cmd[i]);
cmd920drivers/scsi/sr.cscsi_do_cmd (SCpnt, (void *) cmd, buffer, 
cmd975drivers/scsi/sr.cunsigned char cmd[10];
cmd985drivers/scsi/sr.ccmd[0] = READ_CAPACITY;
cmd986drivers/scsi/sr.ccmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
cmd987drivers/scsi/sr.cmemset ((void *) &cmd[2], 0, 8);
cmd994drivers/scsi/sr.c(void *) cmd, (void *) buffer,
cmd98drivers/scsi/sr_ioctl.cint sr_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
cmd110drivers/scsi/sr_ioctl.cswitch (cmd) 
cmd479drivers/scsi/sr_ioctl.creturn scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
cmd218drivers/scsi/st.cst_do_scsi(Scsi_Cmnd *SCpnt, Scsi_Tape *STp, unsigned char *cmd, int bytes,
cmd229drivers/scsi/st.ccmd[1] |= (SCpnt->lun << 5) & 0xe0;
cmd233drivers/scsi/st.cscsi_do_cmd(SCpnt, (void *)cmd, (STp->buffer)->b_data, bytes,
cmd296drivers/scsi/st.cunsigned char cmd[10];
cmd298drivers/scsi/st.ccmd[0] = SPACE;
cmd299drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd300drivers/scsi/st.ccmd[2] = cmd[3] = cmd[4] = 0xff;  /* -1 filemarks */
cmd301drivers/scsi/st.ccmd[5] = 0;
cmd303drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_RETRIES);
cmd325drivers/scsi/st.cunsigned char cmd[10];
cmd357drivers/scsi/st.cmemset(cmd, 0, 10);
cmd358drivers/scsi/st.ccmd[0] = WRITE_6;
cmd359drivers/scsi/st.ccmd[1] = 1;
cmd361drivers/scsi/st.ccmd[2] = blks >> 16;
cmd362drivers/scsi/st.ccmd[3] = blks >> 8;
cmd363drivers/scsi/st.ccmd[4] = blks;
cmd365drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
cmd452drivers/scsi/st.cunsigned char cmd[10];
cmd497drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd498drivers/scsi/st.ccmd[0] = TEST_UNIT_READY;
cmd500drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
cmd507drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd508drivers/scsi/st.ccmd[0] = TEST_UNIT_READY;
cmd510drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
cmd540drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd541drivers/scsi/st.ccmd[0] = READ_BLOCK_LIMITS;
cmd543drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 6, ST_TIMEOUT, MAX_READY_RETRIES);
cmd564drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd565drivers/scsi/st.ccmd[0] = MODE_SENSE;
cmd566drivers/scsi/st.ccmd[4] = 12;
cmd568drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 12, ST_TIMEOUT, MAX_READY_RETRIES);
cmd654drivers/scsi/st.cstatic unsigned char cmd[10];
cmd679drivers/scsi/st.cmemset(cmd, 0, 10);
cmd680drivers/scsi/st.ccmd[0] = WRITE_FILEMARKS;
cmd681drivers/scsi/st.ccmd[4] = 1 + STp->two_fm;
cmd683drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_WRITE_RETRIES);
cmd702drivers/scsi/st.cprintk("st%d: Buffer flushed, %d EOF(s) written\n", dev, cmd[4]);
cmd741drivers/scsi/st.cstatic unsigned char cmd[10];
cmd822drivers/scsi/st.cmemset(cmd, 0, 10);
cmd823drivers/scsi/st.ccmd[0] = WRITE_6;
cmd824drivers/scsi/st.ccmd[1] = (STp->block_size != 0);
cmd852drivers/scsi/st.ccmd[2] = blks >> 16;
cmd853drivers/scsi/st.ccmd[3] = blks >> 8;
cmd854drivers/scsi/st.ccmd[4] = blks;
cmd856drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
cmd965drivers/scsi/st.ccmd[2] = blks >> 16;
cmd966drivers/scsi/st.ccmd[3] = blks >> 8;
cmd967drivers/scsi/st.ccmd[4] = blks;
cmd972drivers/scsi/st.c(void *) cmd, (STp->buffer)->b_data,
cmd990drivers/scsi/st.cstatic unsigned char cmd[10];
cmd1043drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1044drivers/scsi/st.ccmd[0] = READ_6;
cmd1045drivers/scsi/st.ccmd[1] = (STp->block_size != 0);
cmd1061drivers/scsi/st.ccmd[2] = blks >> 16;
cmd1062drivers/scsi/st.ccmd[3] = blks >> 8;
cmd1063drivers/scsi/st.ccmd[4] = blks;
cmd1065drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, bytes, ST_TIMEOUT, MAX_RETRIES);
cmd1278drivers/scsi/st.cunsigned char cmd[10];
cmd1291drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1296drivers/scsi/st.ccmd[0] = SPACE;
cmd1297drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd1298drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1299drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1300drivers/scsi/st.ccmd[4] = arg;
cmd1304drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1313drivers/scsi/st.ccmd[0] = SPACE;
cmd1314drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd1316drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1317drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1318drivers/scsi/st.ccmd[4] = ltmp;
cmd1321drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1323drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1333drivers/scsi/st.ccmd[0] = SPACE;
cmd1334drivers/scsi/st.ccmd[1] = 0x00; /* Space Blocks */
cmd1335drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1336drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1337drivers/scsi/st.ccmd[4] = arg;
cmd1341drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1348drivers/scsi/st.ccmd[0] = SPACE;
cmd1349drivers/scsi/st.ccmd[1] = 0x00; /* Space Blocks */
cmd1351drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1352drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1353drivers/scsi/st.ccmd[4] = ltmp;
cmd1356drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1358drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1367drivers/scsi/st.ccmd[0] = SPACE;
cmd1368drivers/scsi/st.ccmd[1] = 0x04; /* Space Setmarks */
cmd1369drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1370drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1371drivers/scsi/st.ccmd[4] = arg;
cmd1375drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1383drivers/scsi/st.ccmd[0] = SPACE;
cmd1384drivers/scsi/st.ccmd[1] = 0x04; /* Space Setmarks */
cmd1386drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1387drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1388drivers/scsi/st.ccmd[4] = ltmp;
cmd1391drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1393drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1406drivers/scsi/st.ccmd[0] = WRITE_FILEMARKS;
cmd1408drivers/scsi/st.ccmd[1] = 2;
cmd1409drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1410drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1411drivers/scsi/st.ccmd[4] = arg;
cmd1417drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1420drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1429drivers/scsi/st.ccmd[0] = REZERO_UNIT;
cmd1431drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1441drivers/scsi/st.ccmd[0] = START_STOP;
cmd1443drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1460drivers/scsi/st.ccmd[0] = START_STOP;
cmd1462drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1465drivers/scsi/st.ccmd[4] = 3;
cmd1486drivers/scsi/st.ccmd[0] = SPACE;
cmd1487drivers/scsi/st.ccmd[1] = 3;
cmd1498drivers/scsi/st.ccmd[0] = ERASE;
cmd1499drivers/scsi/st.ccmd[1] = 1;  /* To the end of tape */
cmd1501drivers/scsi/st.ccmd[1] |= 2;  /* Don't wait for completion */
cmd1513drivers/scsi/st.ccmd[0] = ALLOW_MEDIUM_REMOVAL;
cmd1514drivers/scsi/st.ccmd[4] = SCSI_REMOVAL_PREVENT;
cmd1521drivers/scsi/st.ccmd[0] = ALLOW_MEDIUM_REMOVAL;
cmd1522drivers/scsi/st.ccmd[4] = SCSI_REMOVAL_ALLOW;
cmd1530drivers/scsi/st.ccmd[0] = START_STOP;
cmd1532drivers/scsi/st.ccmd[4] |= 1;
cmd1534drivers/scsi/st.ccmd[1] |= 2;  /* Don't wait for completion */
cmd1542drivers/scsi/st.ccmd[0] = QFA_SEEK_BLOCK;
cmd1543drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1544drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1545drivers/scsi/st.ccmd[4] = arg;
cmd1546drivers/scsi/st.ccmd[5] = 0;
cmd1549drivers/scsi/st.ccmd[0] = SEEK_10;
cmd1550drivers/scsi/st.ccmd[1] = 4;
cmd1551drivers/scsi/st.ccmd[3] = (arg >> 24);
cmd1552drivers/scsi/st.ccmd[4] = (arg >> 16);
cmd1553drivers/scsi/st.ccmd[5] = (arg >> 8);
cmd1554drivers/scsi/st.ccmd[6] = arg;
cmd1557drivers/scsi/st.ccmd[1] |= 1;  /* Don't wait for completion */
cmd1579drivers/scsi/st.ccmd[0] = MODE_SELECT;
cmd1580drivers/scsi/st.ccmd[4] = datalen = 12;
cmd1622drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, datalen, timeout, MAX_RETRIES);
cmd578drivers/scsi/wd7000.cstatic inline int command_out(Adapter *host, unchar *cmd, int len)
cmd583drivers/scsi/wd7000.coutb(*cmd, host->iobase+ASC_COMMAND);
cmd586drivers/scsi/wd7000.ccmd++;
cmd118drivers/sound/ad1848.cstatic int      ad1848_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local);
cmd454drivers/sound/ad1848.cad1848_mixer_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
cmd467drivers/sound/ad1848.cif (((cmd >> 8) & 0xff) == 'M')
cmd469drivers/sound/ad1848.cif (cmd & IOC_IN)
cmd470drivers/sound/ad1848.cswitch (cmd & 0xff)
cmd477drivers/sound/ad1848.creturn snd_ioctl_return ((int *) arg, ad1848_mixer_set (devc, cmd & 0xff, get_fs_long ((long *) arg)));
cmd480drivers/sound/ad1848.cswitch (cmd & 0xff)  /*
cmd506drivers/sound/ad1848.creturn snd_ioctl_return ((int *) arg, ad1848_mixer_get (devc, cmd & 0xff));
cmd772drivers/sound/ad1848.cad1848_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd776drivers/sound/ad1848.cswitch (cmd)
cmd414drivers/sound/aedsp16.cWriteDSPCommand (int port, int cmd)
cmd427drivers/sound/aedsp16.coutb (cmd, port + DSP_COMMAND);
cmd433drivers/sound/aedsp16.cprintk ("[aedsp16] DSP Command (0x%x) timeout.\n", cmd);
cmd359drivers/sound/audio.cunsigned int cmd, ioctl_arg arg)
cmd364drivers/sound/audio.cif (((cmd >> 8) & 0xff) == 'C')
cmd367drivers/sound/audio.creturn audio_devs[dev]->coproc->ioctl (audio_devs[dev]->coproc->devc, cmd, arg, 0);
cmd374drivers/sound/audio.cswitch (cmd)
cmd383drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd399drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd416drivers/sound/audio.cint             err = DMAbuf_ioctl (dev, cmd, (ioctl_arg) & info, 1);
cmd432drivers/sound/audio.cint             err = DMAbuf_ioctl (dev, cmd, (ioctl_arg) & info, 1);
cmd471drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd547drivers/sound/audio.cunsigned int cmd, unsigned int arg)
cmd130drivers/sound/dev_table.hint (*ioctl) (void *devc, unsigned int cmd, ioctl_arg arg, int local);
cmd151drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, ioctl_arg arg, int local);
cmd174drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, ioctl_arg arg);
cmd185drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, ioctl_arg arg);
cmd229drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, ioctl_arg arg);
cmd255drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, ioctl_arg arg);
cmd694drivers/sound/dmabuf.cDMAbuf_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd699drivers/sound/dmabuf.cswitch (cmd)
cmd761drivers/sound/dmabuf.cif (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
cmd772drivers/sound/dmabuf.cif (cmd == SNDCTL_DSP_GETISPACE)
cmd802drivers/sound/dmabuf.cif (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
cmd898drivers/sound/dmabuf.creturn audio_devs[dev]->ioctl (dev, cmd, arg, local);
cmd1558drivers/sound/dmabuf.cDMAbuf_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd199drivers/sound/gus_midi.cgus_midi_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd892drivers/sound/gus_wave.cunsigned int cmd, ioctl_arg arg)
cmd895drivers/sound/gus_wave.cswitch (cmd)
cmd1777drivers/sound/gus_wave.cint             voice, cmd;
cmd1781drivers/sound/gus_wave.ccmd = event[2];
cmd1788drivers/sound/gus_wave.c(cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS))
cmd1791drivers/sound/gus_wave.cswitch (cmd)
cmd1989drivers/sound/gus_wave.cgus_sampling_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd1991drivers/sound/gus_wave.cswitch (cmd)
cmd2827drivers/sound/gus_wave.cgus_default_mixer_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
cmd2831drivers/sound/gus_wave.cif (((cmd >> 8) & 0xff) == 'M')
cmd2833drivers/sound/gus_wave.cif (cmd & IOC_IN)
cmd2834drivers/sound/gus_wave.cswitch (cmd & 0xff)
cmd2905drivers/sound/gus_wave.cswitch (cmd & 0xff)  /*
cmd132drivers/sound/ics2101.cics2101_mixer_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
cmd134drivers/sound/ics2101.cif (((cmd >> 8) & 0xff) == 'M')
cmd136drivers/sound/ics2101.cif (cmd & IOC_IN)
cmd137drivers/sound/ics2101.cswitch (cmd & 0xff)
cmd140drivers/sound/ics2101.creturn gus_default_mixer_ioctl (dev, cmd, arg);
cmd167drivers/sound/ics2101.cswitch (cmd & 0xff)  /*
cmd173drivers/sound/ics2101.creturn gus_default_mixer_ioctl (dev, cmd, arg);
cmd294drivers/sound/mad16_sb_midi.cmad16_sb_midi_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd50drivers/sound/midi_synth.c#define STORE(cmd) \
cmd54drivers/sound/midi_synth.ccmd; \
cmd277drivers/sound/midi_synth.cunsigned int cmd, ioctl_arg arg)
cmd283drivers/sound/midi_synth.cswitch (cmd)
cmd2drivers/sound/midi_synth.hunsigned int cmd, ioctl_arg arg);
cmd497drivers/sound/midibuf.cunsigned int cmd, ioctl_arg arg)
cmd503drivers/sound/midibuf.cif (((cmd >> 8) & 0xff) == 'C')
cmd506drivers/sound/midibuf.creturn midi_devs[dev]->coproc->ioctl (midi_devs[dev]->coproc->devc, cmd, arg, 0);
cmd513drivers/sound/midibuf.cswitch (cmd)
cmd527drivers/sound/midibuf.creturn midi_devs[dev]->ioctl (dev, cmd, arg);
cmd93drivers/sound/mpu401.c#define write_command(devc, cmd)  outb( cmd,  COMDPORT(devc->base))
cmd151drivers/sound/mpu401.c#define STORE(cmd) \
cmd155drivers/sound/mpu401.ccmd; \
cmd590drivers/sound/mpu401.cmpu401_command (int dev, mpu_command_rec * cmd)
cmd622drivers/sound/mpu401.cprintk ("MPU-401: Command (0x%x) timeout\n", (int) cmd->cmd);
cmd635drivers/sound/mpu401.cwrite_command (devc, cmd->cmd);
cmd657drivers/sound/mpu401.cif (cmd->nr_args)
cmd658drivers/sound/mpu401.cfor (i = 0; i < cmd->nr_args; i++)
cmd662drivers/sound/mpu401.cif (!mpu401_out (dev, cmd->data[i]))
cmd665drivers/sound/mpu401.cprintk ("MPU: Command (0x%x), parm send failed.\n", (int) cmd->cmd);
cmd671drivers/sound/mpu401.ccmd->data[0] = 0;
cmd673drivers/sound/mpu401.cif (cmd->nr_returns)
cmd674drivers/sound/mpu401.cfor (i = 0; i < cmd->nr_returns; i++)
cmd680drivers/sound/mpu401.ccmd->data[i] = read_data (devc);
cmd698drivers/sound/mpu401.cmpu_cmd (int dev, int cmd, int data)
cmd704drivers/sound/mpu401.crec.cmd = cmd & 0xff;
cmd705drivers/sound/mpu401.crec.nr_args = ((cmd & 0xf0) == 0xE0);
cmd706drivers/sound/mpu401.crec.nr_returns = ((cmd & 0xf0) == 0xA0);
cmd764drivers/sound/mpu401.cmpu401_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd770drivers/sound/mpu401.cswitch (cmd)
cmd822drivers/sound/mpu401.cunsigned int cmd, ioctl_arg arg)
cmd834drivers/sound/mpu401.cswitch (cmd)
cmd124drivers/sound/opl3.cunsigned int cmd, ioctl_arg arg)
cmd126drivers/sound/opl3.cswitch (cmd)
cmd220drivers/sound/pas2_midi.cpas_midi_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd261drivers/sound/pas2_mixer.cpas_mixer_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
cmd263drivers/sound/pas2_mixer.cTRACE (printk ("pas2_mixer.c: int pas_mixer_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
cmd265drivers/sound/pas2_mixer.cif (((cmd >> 8) & 0xff) == 'M')
cmd267drivers/sound/pas2_mixer.cif (cmd & IOC_IN)
cmd268drivers/sound/pas2_mixer.creturn snd_ioctl_return ((int *) arg, pas_mixer_set (cmd & 0xff, get_fs_long ((long *) arg)));
cmd274drivers/sound/pas2_mixer.cswitch (cmd & 0xff)
cmd314drivers/sound/pas2_mixer.creturn snd_ioctl_return ((int *) arg, levels[cmd & 0xff]);
cmd157drivers/sound/pas2_pcm.cpas_pcm_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd159drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static int pas_pcm_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
cmd161drivers/sound/pas2_pcm.cswitch (cmd)
cmd497drivers/sound/pss.cpss_coproc_ioctl (void *dev_info, unsigned int cmd, ioctl_arg arg, int local)
cmd501drivers/sound/pss.cswitch (cmd)
cmd63drivers/sound/sb16_dsp.cstatic int      sb16_dsp_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local);
cmd153drivers/sound/sb16_dsp.csb16_dsp_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd155drivers/sound/sb16_dsp.cswitch (cmd)
cmd47drivers/sound/sb16_midi.c#define sb16midi_cmd(cmd)    outb( cmd,  COMDPORT)
cmd160drivers/sound/sb16_midi.csb16midi_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd723drivers/sound/sb_dsp.csb_dsp_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd725drivers/sound/sb_dsp.cswitch (cmd)
cmd195drivers/sound/sb_midi.csb_midi_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd448drivers/sound/sb_mixer.csb_mixer_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
cmd450drivers/sound/sb_mixer.cif (((cmd >> 8) & 0xff) == 'M')
cmd452drivers/sound/sb_mixer.cif (cmd & IOC_IN)
cmd453drivers/sound/sb_mixer.cswitch (cmd & 0xff)
cmd461drivers/sound/sb_mixer.creturn snd_ioctl_return ((int *) arg, sb_mixer_set (cmd & 0xff, get_fs_long ((long *) arg)));
cmd464drivers/sound/sb_mixer.cswitch (cmd & 0xff)  /*
cmd493drivers/sound/sb_mixer.creturn snd_ioctl_return ((int *) arg, sb_mixer_get (cmd & 0xff));
cmd537drivers/sound/sequencer.cunsigned char   cmd = event[2];
cmd555drivers/sound/sequencer.cif (cmd == MIDI_NOTEON && parm == 0)
cmd557drivers/sound/sequencer.ccmd = MIDI_NOTEOFF;
cmd562drivers/sound/sequencer.cswitch (cmd)
cmd619drivers/sound/sequencer.cunsigned char   cmd = event[2];
cmd633drivers/sound/sequencer.cswitch (cmd)
cmd716drivers/sound/sequencer.cunsigned char   cmd = event[1];
cmd744drivers/sound/sequencer.cswitch (cmd)
cmd819drivers/sound/sequencer.cunsigned char   cmd = event[1];
cmd822drivers/sound/sequencer.cswitch (cmd)
cmd1570drivers/sound/sequencer.cunsigned int cmd, ioctl_arg arg)
cmd1577drivers/sound/sequencer.cswitch (cmd)
cmd1591drivers/sound/sequencer.creturn tmr->ioctl (tmr_no, cmd, arg);
cmd1693drivers/sound/sequencer.creturn tmr->ioctl (tmr_no, cmd, arg);
cmd1719drivers/sound/sequencer.cerr = synth_devs[dev]->ioctl (dev, cmd, arg);
cmd1742drivers/sound/sequencer.creturn snd_ioctl_return ((int *) arg, synth_devs[dev]->ioctl (dev, cmd, arg));
cmd1756drivers/sound/sequencer.csynth_devs[dev]->ioctl (dev, cmd, arg);
cmd1775drivers/sound/sequencer.creturn synth_devs[dev]->ioctl (dev, cmd, arg);
cmd1939drivers/sound/sequencer.creturn synth_devs[0]->ioctl (0, cmd, arg);
cmd2139drivers/sound/sequencer.cunsigned int cmd, unsigned int arg)
cmd11drivers/sound/sound_calls.hint DMAbuf_ioctl(int dev, unsigned int cmd, ioctl_arg arg, int local);
cmd31drivers/sound/sound_calls.hunsigned int cmd, ioctl_arg arg);
cmd46drivers/sound/sound_calls.hunsigned int cmd, ioctl_arg arg);
cmd66drivers/sound/sound_calls.hunsigned int cmd, ioctl_arg arg);
cmd95drivers/sound/sound_calls.hunsigned int cmd, ioctl_arg arg);
cmd175drivers/sound/sound_calls.hint gus_default_mixer_ioctl (int dev, unsigned int cmd, ioctl_arg arg);
cmd244drivers/sound/sound_calls.hunsigned int cmd, ioctl_arg arg);
cmd498drivers/sound/sound_switch.cunsigned int cmd, ioctl_arg arg)
cmd500drivers/sound/sound_switch.cDEB (printk ("sound_ioctl_sw(dev=%d, cmd=0x%x, arg=0x%x)\n", dev, cmd, arg));
cmd502drivers/sound/sound_switch.cif (((cmd >> 8) & 0xff) == 'M' && num_mixers > 0)  /* Mixer ioctl */
cmd516drivers/sound/sound_switch.creturn mixer_devs[mixdev]->ioctl (mixdev, cmd, arg);
cmd520drivers/sound/sound_switch.creturn mixer_devs[0]->ioctl (0, cmd, arg);
cmd537drivers/sound/sound_switch.creturn mixer_devs[dev]->ioctl (dev, cmd, arg);
cmd542drivers/sound/sound_switch.creturn sequencer_ioctl (dev, file, cmd, arg);
cmd548drivers/sound/sound_switch.creturn audio_ioctl (dev, file, cmd, arg);
cmd553drivers/sound/sound_switch.creturn MIDIbuf_ioctl (dev, file, cmd, arg);
cmd134drivers/sound/sound_timer.cunsigned char   cmd = event[1];
cmd137drivers/sound/sound_timer.cswitch (cmd)
cmd207drivers/sound/sound_timer.cunsigned int cmd, ioctl_arg arg)
cmd209drivers/sound/sound_timer.cswitch (cmd)
cmd152drivers/sound/soundcard.cunsigned int cmd, unsigned long arg)
cmd159drivers/sound/soundcard.cif (cmd == 1)
cmd179drivers/sound/soundcard.cif (cmd & IOC_INOUT)
cmd186drivers/sound/soundcard.clen = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
cmd188drivers/sound/soundcard.cif (cmd & IOC_IN)
cmd194drivers/sound/soundcard.cif (cmd & IOC_OUT)
cmd202drivers/sound/soundcard.cerr = sound_ioctl_sw (dev, &files[dev], cmd, (caddr_t) arg);
cmd230drivers/sound/sscape.chost_command1 (struct sscape_info *devc, int cmd)
cmd234drivers/sound/sscape.cbuf[0] = (unsigned char) (cmd & 0xff);
cmd240drivers/sound/sscape.chost_command2 (struct sscape_info *devc, int cmd, int parm1)
cmd244drivers/sound/sscape.cbuf[0] = (unsigned char) (cmd & 0xff);
cmd251drivers/sound/sscape.chost_command3 (struct sscape_info *devc, int cmd, int parm1, int parm2)
cmd255drivers/sound/sscape.cbuf[0] = (unsigned char) (cmd & 0xff);
cmd681drivers/sound/sscape.csscape_coproc_ioctl (void *dev_info, unsigned int cmd, ioctl_arg arg, int local)
cmd684drivers/sound/sscape.cswitch (cmd)
cmd794drivers/sound/sscape.csscape_audio_ioctl (int dev, unsigned int cmd, ioctl_arg arg, int local)
cmd798drivers/sound/sscape.cswitch (cmd)
cmd135drivers/sound/sys_timer.cunsigned char   cmd = event[1];
cmd138drivers/sound/sys_timer.cswitch (cmd)
cmd205drivers/sound/sys_timer.cunsigned int cmd, ioctl_arg arg)
cmd207drivers/sound/sys_timer.cswitch (cmd)
cmd48drivers/sound/uart6850.c#define uart6850_cmd(cmd)  outb( cmd,  COMDPORT)
cmd231drivers/sound/uart6850.cuart6850_ioctl (int dev, unsigned cmd, ioctl_arg arg)
cmd19fs/ext2/ioctl.cint ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
cmd25fs/ext2/ioctl.cext2_debug ("cmd = %u, arg = %lu\n", cmd, arg);
cmd27fs/ext2/ioctl.cswitch (cmd) {
cmd18fs/fcntl.cextern int sock_fcntl (struct file *, unsigned int cmd, unsigned long arg);
cmd66fs/fcntl.casmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
cmd74fs/fcntl.cswitch (cmd) {
cmd107fs/fcntl.creturn fcntl_setlk(fd, cmd, (struct flock *) arg);
cmd109fs/fcntl.creturn fcntl_setlk(fd, cmd, (struct flock *) arg);
cmd168fs/fcntl.creturn (sock_fcntl (filp, cmd, arg));
cmd17fs/ioctl.cstatic int file_ioctl(struct file *filp,unsigned int cmd,unsigned long arg)
cmd22fs/ioctl.cswitch (cmd) {
cmd53fs/ioctl.creturn filp->f_op->ioctl(filp->f_inode, filp, cmd, arg);
cmd58fs/ioctl.casmlinkage int sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
cmd65fs/ioctl.cswitch (cmd) {
cmd93fs/ioctl.creturn file_ioctl(filp, cmd, arg);
cmd96fs/ioctl.creturn filp->f_op->ioctl(filp->f_inode, filp, cmd, arg);
cmd72fs/locks.cunsigned int cmd);
cmd98fs/locks.casmlinkage int sys_flock(unsigned int fd, unsigned int cmd)
cmd106fs/locks.cif (!flock_make_lock(filp, &file_lock, cmd))
cmd112fs/locks.creturn (flock_lock_file(filp, &file_lock, cmd & LOCK_UN ? 0 : cmd & LOCK_NB ? 0 : 1));
cmd161fs/locks.cint fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l)
cmd201fs/locks.creturn (posix_lock_file(filp, &file_lock, cmd == F_SETLKW));
cmd287fs/locks.cunsigned int cmd)
cmd292fs/locks.cswitch (cmd & ~LOCK_NB) {
cmd135fs/pipe.cunsigned int cmd, unsigned long arg)
cmd139fs/pipe.cswitch (cmd) {
cmd26fs/smbfs/ioctl.cunsigned int cmd, unsigned long arg)
cmd30fs/smbfs/ioctl.cswitch (cmd) {
cmd61fs/umsdos/ioctl.cunsigned int cmd,
cmd76fs/umsdos/ioctl.c|| cmd == UMSDOS_GETVERSION){
cmd98fs/umsdos/ioctl.cPRINTK (("ioctl %d ",cmd));
cmd99fs/umsdos/ioctl.cif (cmd == UMSDOS_GETVERSION){
cmd113fs/umsdos/ioctl.c}else if (cmd == UMSDOS_READDIR_DOS){
cmd126fs/umsdos/ioctl.c}else if (cmd == UMSDOS_READDIR_EMD){
cmd169fs/umsdos/ioctl.c}else if (cmd == UMSDOS_INIT_EMD){
cmd192fs/umsdos/ioctl.cif (cmd == UMSDOS_CREAT_EMD){
cmd209fs/umsdos/ioctl.c}else if (cmd == UMSDOS_RENAME_DOS){
cmd224fs/umsdos/ioctl.c}else if (cmd == UMSDOS_UNLINK_EMD){
cmd242fs/umsdos/ioctl.c}else if (cmd == UMSDOS_UNLINK_DOS){
cmd253fs/umsdos/ioctl.c}else if (cmd == UMSDOS_RMDIR_DOS){
cmd264fs/umsdos/ioctl.c}else if (cmd == UMSDOS_STAT_DOS){
cmd288fs/umsdos/ioctl.c}else if (cmd == UMSDOS_DOS_SETUP){
cmd33include/asm-i386/ioctl.h#define IOC_SIZE(cmd)  (((cmd) & IOCSIZE_MASK) >> IOCSIZE_SHIFT)
cmd34include/asm-i386/ioctl.h#define IOCBASECMD(cmd)  ((cmd) & ~IOCPARM_MASK)
cmd35include/asm-i386/ioctl.h#define IOCGROUP(cmd)  (((cmd) >> 8) & 0xFF)
cmd23include/linux/blkdev.hint cmd;    /* READ or WRITE */
cmd421include/linux/cdk.hunsigned long  cmd;
cmd285include/linux/fd.hunsigned char cmd[16];
cmd119include/linux/mroute.hextern int ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd74include/linux/msg.hasmlinkage int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf);
cmd111include/linux/net.hint  (*ioctl)  (struct socket *sock, unsigned int cmd,
cmd127include/linux/net.hint  (*fcntl)  (struct socket *sock, unsigned int cmd,
cmd165include/linux/netdevice.hint        (*do_ioctl)(struct device *dev, struct ifreq *ifr, int cmd);
cmd220include/linux/netdevice.hextern int    dev_ioctl(unsigned int cmd, void *);
cmd174include/linux/optcd.h&& CURRENT -> cmd == READ && CURRENT -> sector != -1)
cmd108include/linux/sem.hasmlinkage int sys_semctl (int semid, int semnum, int cmd, union semun arg);
cmd65include/linux/shm.hasmlinkage int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf);
cmd116include/linux/smb_fs.hunsigned int cmd, unsigned long arg);
cmd542include/linux/soundcard.hunsigned char cmd;
cmd321include/linux/tty.hunsigned int cmd, unsigned long arg);
cmd339include/linux/tty.hunsigned int cmd, unsigned long arg);
cmd133include/linux/tty_driver.hunsigned int cmd, unsigned long arg);
cmd27include/linux/tty_ldisc.hunsigned int cmd, unsigned long arg);
cmd93include/linux/ultrasound.h#define _GUS_CMD(chn, voice, cmd, p1, p2) \
cmd95include/linux/ultrasound.h_seqbuf[_seqbufptr+1] = (chn); _seqbuf[_seqbufptr+2] = cmd;\
cmd114include/linux/xd.hstatic int xd_ioctl (struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg);
cmd14include/net/arp.hextern int  arp_ioctl(unsigned int cmd, void *arg);
cmd32include/net/icmp.hextern int  icmp_ioctl(struct sock *sk, int cmd,
cmd77include/net/ip.hextern int    ip_ioctl(struct sock *sk, int cmd,
cmd5include/net/rarp.hextern int rarp_ioctl(unsigned int cmd, void *arg);
cmd52include/net/route.hextern int    ip_rt_ioctl(unsigned int cmd, void *arg);
cmd284include/net/sock.hint      (*ioctl)(struct sock *sk, int cmd,
cmd134include/net/tcp.hextern int  tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd49include/net/udp.hextern int  udp_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd319ipc/msg.casmlinkage int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf)
cmd326ipc/msg.cif (msqid < 0 || cmd < 0)
cmd328ipc/msg.cswitch (cmd) {
cmd343ipc/msg.cif (cmd == MSG_INFO) {
cmd404ipc/msg.cswitch (cmd) {
cmd360ipc/sem.casmlinkage int sys_semctl (int semid, int semnum, int cmd, union semun arg)
cmd373ipc/sem.cif (semid < 0 || semnum < 0 || cmd < 0)
cmd376ipc/sem.cswitch (cmd) {
cmd391ipc/sem.cif (cmd == SEM_INFO) {
cmd432ipc/sem.cswitch (cmd) {
cmd444ipc/sem.cswitch (cmd) {
cmd452ipc/sem.cswitch (cmd) {
cmd502ipc/sem.cswitch (cmd) {
cmd202ipc/shm.casmlinkage int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf)
cmd209ipc/shm.cif (cmd < 0 || shmid < 0)
cmd211ipc/shm.cif (cmd == IPC_SET) {
cmd220ipc/shm.cswitch (cmd) { /* replace with proc interface ? */
cmd287ipc/shm.cswitch (cmd) {
cmd75ipc/util.casmlinkage int sys_semctl (int semid, int semnum, int cmd, union semun arg)
cmd96ipc/util.casmlinkage int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf)
cmd116ipc/util.casmlinkage int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf)
cmd6net/802/llc.cint llc_rx_adm(struct sock *sk,struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd10net/802/llc.cif(cmd==DISC)
cmd12net/802/llc.celse if(cmd==SABM)
cmd36net/802/llc.cint llc_rx_setup(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd40net/802/llc.cif(cmd==SABM)
cmd46net/802/llc.cif(cmd==DISC)
cmd55net/802/llc.cif(cmd==UA && pf==sk->llc.p_flag)
cmd62net/802/llc.cif(cmd==DM)
cmd70net/802/llc.cint llc_rx_reset(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd74net/802/llc.cif(cmd==SABM)
cmd80net/802/llc.celse if(cmd==DISC)
cmd92net/802/llc.cif(cmd==UA)
cmd105net/802/llc.cif(cmd==DM)
cmd114net/802/llc.cint llc_rx_d_conn(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd118net/802/llc.cif(cmd==SABM)
cmd123net/802/llc.celse if(cmd==DISC)
cmd133net/802/llc.cif(cmd==UA && pf==sk->llc.p_flag)
cmd139net/802/llc.cif(cmd==DM)
cmd150net/802/llc.cint llc_rx_error(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd154net/802/llc.cif(cmd==SABM)
cmd164net/802/llc.celse if(cmd==DISC)
cmd175net/802/llc.cif(cmd==DM)
cmd181net/802/llc.cif(cmd==FRMR)
cmd199net/802/llc.cint llc_rx_nr_shared(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd203net/802/llc.cif(cmd==SABM)
cmd212net/802/llc.celse if(cmd==DISC)
cmd222net/802/llc.celse if(cmd==ILLEGAL)
cmd239net/802/llc.cif(cmd==FRMR)
cmd248net/802/llc.celse if(cmd==DM)
cmd258net/802/llc.celse if(cmd==UA)
cmd270net/802/llc.celse if(cmd==ILLEGAL)
cmd288net/802/llc.cint llc_rx_normal(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
cmd290net/802/llc.cif(llc_rx_nr_shared(sk, skb, type, cmd, pf, nr, ns))
cmd292net/802/llc.cif(cmd==I)
cmd368net/802/llc.celse if(cmd==RR||cmd==RNR)
cmd378net/802/llc.cif(cmd==RR)
cmd386net/802/llc.celse if(type==cmd && pf)
cmd388net/802/llc.cif(cmd==RR)
cmd401net/802/llc.cif(cmd==RR)
cmd407net/802/llc.celse if(cmd==REJ)
cmd668net/appletalk/ddp.cint atif_ioctl(int cmd, void *arg)
cmd676net/appletalk/ddp.cint ro=(cmd==SIOCSIFADDR);
cmd693net/appletalk/ddp.cswitch(cmd)
cmd795net/appletalk/ddp.cstatic int atrtr_ioctl(unsigned int cmd, void *arg)
cmd805net/appletalk/ddp.cswitch(cmd)
cmd931net/appletalk/ddp.cstatic int atalk_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd934net/appletalk/ddp.cswitch(cmd)
cmd1773net/appletalk/ddp.cstatic int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
cmd1779net/appletalk/ddp.cswitch(cmd)
cmd1816net/appletalk/ddp.creturn(atrtr_ioctl(cmd,(void *)arg));
cmd1823net/appletalk/ddp.creturn atif_ioctl(cmd,(void *)arg);
cmd1838net/appletalk/ddp.creturn(dev_ioctl(cmd,(void *) arg));
cmd465net/ax25/af_ax25.cstatic int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
cmd469net/ax25/af_ax25.cswitch (cmd) {
cmd680net/ax25/af_ax25.cstatic int ax25_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd682net/ax25/af_ax25.cswitch(cmd)
cmd1958net/ax25/af_ax25.cstatic int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1964net/ax25/af_ax25.cswitch (cmd) {
cmd2005net/ax25/af_ax25.creturn ax25_uid_ioctl(cmd, &sax25);
cmd2021net/ax25/af_ax25.creturn ax25_dev_ioctl(cmd, (void *)arg);
cmd2027net/ax25/af_ax25.creturn ax25_rt_ioctl(cmd, (void *)arg);
cmd2042net/ax25/af_ax25.creturn(dev_ioctl(cmd, (void *)arg));
cmd167net/ax25/ax25_route.cint ax25_rt_ioctl(unsigned int cmd, void *arg)
cmd175net/ax25/ax25_route.cswitch (cmd) {
cmd515net/ax25/ax25_route.cint ax25_dev_ioctl(unsigned int cmd, void *arg)
cmd522net/ax25/ax25_route.cswitch (cmd) {
cmd1241net/core/dev.cint dev_ioctl(unsigned int cmd, void *arg)
cmd1243net/core/dev.cswitch(cmd) 
cmd1266net/core/dev.creturn dev_ifsioc(arg, cmd);
cmd1286net/core/dev.creturn dev_ifsioc(arg, cmd);
cmd1296net/core/dev.cif((cmd >= SIOCDEVPRIVATE) &&
cmd1297net/core/dev.c(cmd <= (SIOCDEVPRIVATE + 15))) {
cmd1298net/core/dev.creturn dev_ifsioc(arg, cmd);
cmd410net/ipv4/af_inet.cstatic int inet_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd416net/ipv4/af_inet.cswitch(cmd) 
cmd1289net/ipv4/af_inet.cstatic int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1295net/ipv4/af_inet.cswitch(cmd) 
cmd1325net/ipv4/af_inet.creturn(ip_rt_ioctl(cmd,(void *) arg));
cmd1329net/ipv4/af_inet.creturn(arp_ioctl(cmd,(void *) arg));
cmd1334net/ipv4/af_inet.creturn(rarp_ioctl_hook(cmd,(void *) arg));
cmd1362net/ipv4/af_inet.creturn(dev_ioctl(cmd,(void *) arg));
cmd1365net/ipv4/af_inet.cif ((cmd >= SIOCDEVPRIVATE) &&
cmd1366net/ipv4/af_inet.c(cmd <= (SIOCDEVPRIVATE + 15)))
cmd1367net/ipv4/af_inet.creturn(dev_ioctl(cmd,(void *) arg));
cmd1371net/ipv4/af_inet.creturn(sk->prot->ioctl(sk, cmd, arg));
cmd1404net/ipv4/arp.cint arp_ioctl(unsigned int cmd, void *arg)
cmd1410net/ipv4/arp.cswitch(cmd)
cmd576net/ipv4/ip.cint ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd578net/ipv4/ip.cswitch(cmd)
cmd596net/ipv4/ipmr.cint ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd603net/ipv4/ipmr.cswitch(cmd)
cmd441net/ipv4/rarp.cint rarp_ioctl(unsigned int cmd, void *arg)
cmd447net/ipv4/rarp.cswitch(cmd)
cmd710net/ipv4/route.cint ip_rt_ioctl(unsigned int cmd, void *arg)
cmd715net/ipv4/route.cswitch(cmd) 
cmd725net/ipv4/route.creturn (cmd == SIOCDELRT) ? rt_kill(&rt) : rt_new(&rt);
cmd1243net/ipv4/tcp.cint tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd1246net/ipv4/tcp.cswitch(cmd) 
cmd418net/ipv4/udp.cint udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd421net/ipv4/udp.cswitch(cmd) 
cmd832net/ipx/af_ipx.cipxitf_ioctl(unsigned int cmd, void *arg)
cmd835net/ipx/af_ipx.cswitch(cmd)
cmd1070net/ipx/af_ipx.cstatic int ipxrtr_ioctl(unsigned int cmd, void *arg)
cmd1092net/ipx/af_ipx.cswitch(cmd)
cmd1274net/ipx/af_ipx.cstatic int ipx_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1276net/ipx/af_ipx.cswitch(cmd)
cmd1820net/ipx/af_ipx.cstatic int ipx_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
cmd1826net/ipx/af_ipx.cswitch(cmd)
cmd1853net/ipx/af_ipx.creturn(ipxrtr_ioctl(cmd,(void *)arg));
cmd1860net/ipx/af_ipx.creturn(ipxitf_ioctl(cmd,(void *)arg));
cmd1888net/ipx/af_ipx.creturn(dev_ioctl(cmd,(void *) arg));
cmd151net/netlink.cunsigned int cmd, unsigned long arg)
cmd158net/netlink.cswitch ( cmd ) {
cmd285net/netrom/af_netrom.cstatic int nr_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd287net/netrom/af_netrom.cswitch(cmd)
cmd1261net/netrom/af_netrom.cstatic int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1267net/netrom/af_netrom.cswitch (cmd) {
cmd1317net/netrom/af_netrom.creturn nr_rt_ioctl(cmd, (void *)arg);
cmd1342net/netrom/af_netrom.creturn dev_ioctl(cmd, (void *)arg);
cmd563net/netrom/nr_route.cint nr_rt_ioctl(unsigned int cmd, void *arg)
cmd570net/netrom/nr_route.cswitch (cmd) {
cmd82net/socket.cunsigned int cmd, unsigned long arg);
cmd369net/socket.cint sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd374net/socket.creturn(sock->ops->ioctl(sock, cmd, arg));
cmd1104net/socket.cint sock_fcntl(struct file *filp, unsigned int cmd, unsigned long arg)
cmd1110net/socket.creturn(sock->ops->fcntl(sock, cmd, arg));
cmd197net/unix/af_unix.cstatic int unix_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd931net/unix/af_unix.cstatic int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd937net/unix/af_unix.cswitch(cmd)