taglinefilesource code
cmd139drivers/block/aztcd.c(CURRENT && MAJOR(CURRENT -> dev) == MAJOR_NR && CURRENT -> cmd == READ \
cmd203drivers/block/aztcd.cstatic int  aztSendCmd(int cmd);
cmd204drivers/block/aztcd.cstatic int  sendAztCmd(int cmd, struct azt_Play_msf *params);
cmd306drivers/block/aztcd.cstatic int aztSendCmd(int cmd)
cmd311drivers/block/aztcd.cprintk("aztcd: Executing command %x\n",cmd);
cmd321drivers/block/aztcd.c{ outb((unsigned char) cmd,CMD_PORT);
cmd329drivers/block/aztcd.cprintk("### Error 1 aztcd: aztSendCmd %x  Error Code %x\n",cmd,data);
cmd333drivers/block/aztcd.c{ printk("### Error 2 aztcd: aztSendCmd %x \n",cmd);
cmd342drivers/block/aztcd.cstatic int sendAztCmd(int cmd, struct azt_Play_msf *params)
cmd352drivers/block/aztcd.c{ aztSendCmd(cmd);
cmd366drivers/block/aztcd.cprintk("### Error 1 aztcd: sendAztCmd %x  Error Code %x\n",cmd,data);
cmd370drivers/block/aztcd.c{ printk("### Error 2 aztcd: sendAztCmd %x\n ",cmd);
cmd455drivers/block/aztcd.cstatic int aztcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd467drivers/block/aztcd.cprintk("aztcd: starting aztcd_ioctl - Command:%x\n",cmd);
cmd475drivers/block/aztcd.cswitch (cmd)
cmd689drivers/block/aztcd.cif (cmd==CDROMREADMODE1)
cmd26drivers/block/blk.h((s1)->cmd < (s2)->cmd || ((s1)->cmd == (s2)->cmd && \
cmd224drivers/block/cdu31a.cstatic void do_sony_cd_cmd(unsigned char cmd,
cmd501drivers/block/cdu31a.cwrite_cmd(unsigned char cmd)
cmd504drivers/block/cdu31a.coutb(cmd, sony_cd_cmd_reg);
cmd747drivers/block/cdu31a.cdo_sony_cd_cmd(unsigned char cmd,
cmd811drivers/block/cdu31a.cwrite_cmd(cmd);
cmd1440drivers/block/cdu31a.cswitch(CURRENT->cmd)
cmd2173drivers/block/cdu31a.cunsigned int  cmd,
cmd2187drivers/block/cdu31a.cswitch (cmd)
cmd190drivers/block/floppy.c#define COMMAND raw_cmd.cmd[0]
cmd191drivers/block/floppy.c#define DR_SELECT raw_cmd.cmd[1]
cmd192drivers/block/floppy.c#define TRACK raw_cmd.cmd[2]
cmd193drivers/block/floppy.c#define HEAD raw_cmd.cmd[3]
cmd194drivers/block/floppy.c#define SECTOR raw_cmd.cmd[4]
cmd195drivers/block/floppy.c#define SIZECODE raw_cmd.cmd[5]
cmd196drivers/block/floppy.c#define SECT_PER_TRACK raw_cmd.cmd[6]
cmd197drivers/block/floppy.c#define GAP raw_cmd.cmd[7]
cmd198drivers/block/floppy.c#define SIZECODE2 raw_cmd.cmd[8]
cmd202drivers/block/floppy.c#define F_SIZECODE raw_cmd.cmd[2]
cmd203drivers/block/floppy.c#define F_SECT_PER_TRACK raw_cmd.cmd[3]
cmd204drivers/block/floppy.c#define F_GAP raw_cmd.cmd[4]
cmd205drivers/block/floppy.c#define F_FILL raw_cmd.cmd[5]
cmd1229drivers/block/floppy.cr|=output_byte( raw_cmd.cmd[i] );
cmd1959drivers/block/floppy.cif(CURRENT->cmd == WRITE) {
cmd2200drivers/block/floppy.cif (CURRENT->cmd == READ){
cmd2203drivers/block/floppy.c} else if (CURRENT->cmd == WRITE){
cmd2706drivers/block/floppy.cstatic int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
cmd2720drivers/block/floppy.cswitch (cmd) {
cmd2725drivers/block/floppy.cswitch (cmd) {
cmd2763drivers/block/floppy.cswitch (cmd) {
cmd2837drivers/block/floppy.cif ( cmd != FDDEFPRM )
cmd2847drivers/block/floppy.cif (cmd == FDDEFPRM)
cmd2882drivers/block/floppy.cswitch(cmd){
cmd223drivers/block/hd.cunsigned int head,unsigned int cyl,unsigned int cmd,
cmd247drivers/block/hd.coutb_p(cmd,++port);
cmd739drivers/block/hd.cdev+'a', (CURRENT->cmd == READ)?"read":"writ",
cmd744drivers/block/hd.cif (CURRENT->cmd == READ) {
cmd745drivers/block/hd.cunsigned int cmd = mult_count[dev] > 1 ? WIN_MULTREAD : WIN_READ;
cmd746drivers/block/hd.chd_out(dev,nsect,sec,head,cyl,cmd,&read_intr);
cmd751drivers/block/hd.cif (CURRENT->cmd == WRITE) {
cmd780drivers/block/hd.cunsigned int cmd, unsigned long arg)
cmd791drivers/block/hd.cswitch (cmd) {
cmd204drivers/block/ide-cd.cif (rq->cmd == READ)
cmd243drivers/block/ide-cd.celse if (rq->cmd == PACKET_COMMAND)
cmd875drivers/block/ide-cd.creq.cmd = PACKET_COMMAND;
cmd919drivers/block/ide-cd.cif (rq -> cmd == PACKET_COMMAND)
cmd922drivers/block/ide-cd.cif (rq -> cmd != READ)
cmd924drivers/block/ide-cd.cprintk ("ide-cd: bad cmd %d\n", rq -> cmd);
cmd1315drivers/block/ide-cd.cstruct file *file, unsigned int cmd, unsigned long arg)
cmd1317drivers/block/ide-cd.cswitch (cmd)
cmd608drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {  /* never retry an explicit DRIVE_CMD */
cmd620drivers/block/ide.cif ((stat & DRQ_STAT) && rq->cmd == READ) {
cmd785drivers/block/ide.cstatic inline void ide_cmd(ide_dev_t *dev, byte cmd, byte nsect,
cmd790drivers/block/ide.cOUT_BYTE(cmd,HD_COMMAND);
cmd947drivers/block/ide.cdev->name, (rq->cmd==READ)?"read":"writ", 
cmd966drivers/block/ide.cdev->name, (rq->cmd==READ)?"read":"writ", cyl,
cmd970drivers/block/ide.cif (rq->cmd == READ) {
cmd975drivers/block/ide.cif (rq->cmd == WRITE) {
cmd992drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {
cmd1009drivers/block/ide.cprintk("%s: bad command: %d\n", dev->name, rq->cmd);
cmd1354drivers/block/ide.crq.cmd = IDE_DRIVE_CMD;
cmd1397drivers/block/ide.cunsigned int cmd, unsigned long arg)
cmd1408drivers/block/ide.cswitch (cmd) {
cmd1528drivers/block/ide.creturn ide_cdrom_ioctl(dev, inode, file, cmd, arg);
cmd1601drivers/block/ide.cstatic void do_identify (ide_dev_t *dev, byte cmd)
cmd1616drivers/block/ide.cbswap = (cmd == WIN_IDENTIFY);
cmd1624drivers/block/ide.cif (cmd == WIN_PIDENTIFY) {
cmd1728drivers/block/ide.cstatic int try_to_identify (ide_dev_t *dev, byte cmd)
cmd1754drivers/block/ide.cOUT_BYTE(cmd,HD_COMMAND);    /* ask drive for ID */
cmd1755drivers/block/ide.ctimeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
cmd1770drivers/block/ide.cdo_identify(dev, cmd);  /* drive returned ID */
cmd1797drivers/block/ide.cstatic int do_probe (ide_dev_t *dev, byte cmd)
cmd1810drivers/block/ide.cif ((dev->type == disk) ^ (cmd == WIN_IDENTIFY))
cmd1817drivers/block/ide.c(cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
cmd1827drivers/block/ide.c|| dev->present || cmd == WIN_PIDENTIFY)
cmd1829drivers/block/ide.cif ((rc = try_to_identify(dev, cmd)))  /* send cmd and wait */
cmd1830drivers/block/ide.crc = try_to_identify(dev, cmd);  /* failed: try again */
cmd292drivers/block/ll_rw_blk.creq->cmd == rw &&
cmd306drivers/block/ll_rw_blk.creq->cmd == rw &&
cmd344drivers/block/ll_rw_blk.creq->cmd = rw;
cmd377drivers/block/ll_rw_blk.creq->cmd = rw;
cmd512drivers/block/ll_rw_blk.creq->cmd = rw;
cmd88drivers/block/mcd.c(CURRENT && MAJOR(CURRENT -> dev) == MAJOR_NR && CURRENT -> cmd == READ \
cmd140drivers/block/mcd.cstatic void sendMcdCmd(int cmd, struct mcd_Play_msf *params);
cmd240drivers/block/mcd.cmcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
cmd267drivers/block/mcd.cswitch (cmd)
cmd1235drivers/block/mcd.csendMcdCmd(int cmd, struct mcd_Play_msf *params)
cmd1237drivers/block/mcd.coutb(cmd, MCDPORT(0));
cmd48drivers/block/ramdisk.cif (CURRENT-> cmd == WRITE) {
cmd52drivers/block/ramdisk.c} else if (CURRENT->cmd == READ) {
cmd3210drivers/block/sbpcd.cstatic int sbpcd_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd3216drivers/block/sbpcd.cMINOR(inode->i_rdev), cmd, arg));
cmd3235drivers/block/sbpcd.cDPRINTF((DBG_IO2,"SBPCD: ioctl: device %d, request %04X\n",i,cmd));
cmd3236drivers/block/sbpcd.cswitch (cmd)     /* Sun-compatible */
cmd3712drivers/block/sbpcd.cDPRINTF((DBG_IOC,"SBPCD: ioctl: unknown function request %04X\n", cmd));
cmd3763drivers/block/sbpcd.cif (CURRENT->cmd != READ)
cmd3765drivers/block/sbpcd.cprintk("SBPCD: bad cmd %d\n", CURRENT->cmd);
cmd223drivers/block/xd.cswitch (CURRENT->cmd) {
cmd227drivers/block/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
cmd238drivers/block/xd.cstatic int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
cmd244drivers/block/xd.cswitch (cmd) {
cmd408drivers/char/cyclades.cwrite_cy_cmd(u_char *base_addr, u_char cmd)
cmd429drivers/char/cyclades.cbase_addr[CyCCR] = cmd;
cmd1789drivers/char/cyclades.cset_modem_info(struct cyclades_port * info, unsigned int cmd,
cmd1804drivers/char/cyclades.cswitch (cmd) {
cmd1897drivers/char/cyclades.cunsigned int cmd, unsigned long arg)
cmd1904drivers/char/cyclades.cprintk("cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg); /* */
cmd1907drivers/char/cyclades.cswitch (cmd) {
cmd1926drivers/char/cyclades.cret_val = set_modem_info(info, cmd, (unsigned int *) arg);
cmd397drivers/char/lp.cunsigned int cmd, unsigned long arg)
cmd403drivers/char/lp.cprintk("lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
cmd409drivers/char/lp.cif (cmd <= OLD_IOCTL_MAX)
cmd411drivers/char/lp.cminor, cmd);
cmd412drivers/char/lp.cswitch ( cmd ) {
cmd1547drivers/char/serial.cstatic int set_modem_info(struct async_struct * info, unsigned int cmd,
cmd1557drivers/char/serial.cswitch (cmd) {
cmd1680drivers/char/serial.cunsigned int cmd, unsigned long arg)
cmd1689drivers/char/serial.cif ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
cmd1690drivers/char/serial.c(cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
cmd1691drivers/char/serial.c(cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
cmd1696drivers/char/serial.cswitch (cmd) {
cmd1734drivers/char/serial.creturn set_modem_info(info, cmd, (unsigned int *) arg);
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) {
cmd107drivers/char/tty_io.cunsigned int cmd, unsigned long arg);
cmd306drivers/char/tty_io.cunsigned int cmd, unsigned long arg)
cmd1283drivers/char/tty_io.cunsigned int cmd, unsigned long arg)
cmd1303drivers/char/tty_io.cswitch (cmd) {
cmd1505drivers/char/tty_io.ccmd, arg);
cmd1511drivers/char/tty_io.ccmd, arg);
cmd219drivers/char/tty_ioctl.cunsigned int cmd, unsigned long arg)
cmd231drivers/char/tty_ioctl.cswitch (cmd) {
cmd369drivers/char/tty_ioctl.ctty->driver.ioctl(tty, file, cmd, arg);
cmd130drivers/char/vt.cunsigned int cmd, unsigned long arg)
cmd152drivers/char/vt.cswitch (cmd) {
cmd192drivers/char/vt.creturn sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
cmd197drivers/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;
cmd747drivers/net/apricot.clp->scb.cmd = (struct i596_cmd *) I596_NULL;
cmd879drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
cmd975drivers/net/apricot.cstruct i596_cmd *cmd;
cmd981drivers/net/apricot.ccmd = (struct i596_cmd *) kmalloc(sizeof(struct i596_cmd)+2+num_addrs*6, GFP_ATOMIC);
cmd982drivers/net/apricot.cif (cmd == NULL)
cmd988drivers/net/apricot.ccmd->command = CmdMulticastList;
cmd989drivers/net/apricot.c*((unsigned short *) (cmd + 1)) = num_addrs * 6;
cmd990drivers/net/apricot.cmemcpy (((char *)(cmd + 1))+2, addrs, num_addrs * 6);
cmd991drivers/net/apricot.cprint_eth (((char *)(cmd + 1)) + 2);
cmd993drivers/net/apricot.ci596_add_cmd(dev, cmd);
cmd132drivers/net/atp.cstatic unsigned short eeprom_op(short ioaddr, unsigned int cmd);
cmd291drivers/net/atp.cstatic unsigned short eeprom_op(short ioaddr, unsigned int cmd)
cmd297drivers/net/atp.cchar outval = test_bit(num_bits, &cmd) ? EE_DATA_WRITE : 0;
cmd280drivers/net/de4x5.cstatic int  de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd1686drivers/net/de4x5.cstatic int de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1698drivers/net/de4x5.cswitch(ioc->cmd) {
cmd464drivers/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(byte cmd)
cmd250drivers/net/de620.cif (cmd == W_DUMMY)
cmd253drivers/net/de620.coutb(cmd, DATA_PORT);
cmd297drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd1609drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1620drivers/net/ewrk3.cswitch(ioc->cmd) {
cmd294drivers/net/ewrk3.hunsigned short cmd;                /* Command to run */
cmd143drivers/net/ni52.cif(!p->scb->cmd) break; \
cmd481drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
cmd507drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
cmd531drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
cmd546drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
cmd566drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
cmd624drivers/net/ni52.cp->scb->cmd = CUC_START;
cmd669drivers/net/ni52.cp->scb->cmd = CUC_START;
cmd745drivers/net/ni52.cp->scb->cmd = stat;
cmd767drivers/net/ni52.cp->scb->cmd = RUC_RESUME;
cmd777drivers/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 */
cmd138drivers/net/plip.cstatic int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd991drivers/net/plip.cplip_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd102drivers/net/ppp.cstatic int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd622drivers/net/ppp.cstatic int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd957drivers/net/slip.cslip_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
cmd968drivers/net/slip.cswitch(cmd) {
cmd1039drivers/net/slip.creturn n_tty_ioctl(tty, (struct file *) file, cmd, (unsigned long) arg);
cmd225drivers/net/wavelan.h#define PIOM(cmd,piono)    ((u_short)cmd << 10 << (piono * 2))
cmd176drivers/scsi/53c7,8xx.cstatic void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result);
cmd181drivers/scsi/53c7,8xx.c*cmd);
cmd182drivers/scsi/53c7,8xx.cstatic void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
cmd187drivers/scsi/53c7,8xx.cstatic void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd);
cmd190drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd);
cmd1235drivers/scsi/53c7,8xx.cunsigned char cmd[6];
cmd1240drivers/scsi/53c7,8xx.ccmd[0] = INQUIRY;
cmd1241drivers/scsi/53c7,8xx.ccmd[1] = cmd[2] = cmd[3] = cmd[5] = 0;
cmd1242drivers/scsi/53c7,8xx.ccmd[4] = sizeof(data); 
cmd1247drivers/scsi/53c7,8xx.cdsa[5] = (unsigned long) &cmd;
cmd1324drivers/scsi/53c7,8xx.cstatic void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd) {
cmd1325drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd->cmd;
cmd1331drivers/scsi/53c7,8xx.cmemcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
cmd1334drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(long), 
cmd1335drivers/scsi/53c7,8xx.cdsa_temp_jump_resume, ((unsigned long) cmd->dsa) + 
cmd1337drivers/scsi/53c7,8xx.cpatch_abs_rwri_data (cmd->dsa, Ent_dsa_code_template / sizeof(long),
cmd1339drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(long),
cmd1340drivers/scsi/53c7,8xx.cdsa_temp_dsa_next, ((unsigned long) cmd->dsa) + A_dsa_next);
cmd1341drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(long), 
cmd1343drivers/scsi/53c7,8xx.cpatch_abs_rwri_data (cmd->dsa, Ent_dsa_code_template / sizeof(long),
cmd1362drivers/scsi/53c7,8xx.cstatic void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result) {
cmd1363drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd->cmd;
cmd1376drivers/scsi/53c7,8xx.csearch && (search + hostdata->dsa_start) != (char *) cmd->dsa;
cmd1384drivers/scsi/53c7,8xx.cif (cmd->prev)
cmd1385drivers/scsi/53c7,8xx.ccmd->prev->next = cmd->next;
cmd1387drivers/scsi/53c7,8xx.cif (cmd->next)
cmd1388drivers/scsi/53c7,8xx.ccmd->next->prev = cmd->prev;
cmd1390drivers/scsi/53c7,8xx.cif (hostdata->running_list == cmd)
cmd1391drivers/scsi/53c7,8xx.chostdata->running_list = cmd->next;
cmd1395drivers/scsi/53c7,8xx.cscsi_free ((void *) cmd->real, cmd->size);
cmd1397drivers/scsi/53c7,8xx.ckfree_s (cmd->real, cmd->size);
cmd1423drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd) {
cmd1427drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd ? cmd->cmd : NULL;
cmd1615drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd) {
cmd1617drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd ? cmd->cmd : NULL;
cmd1631drivers/scsi/53c7,8xx.cif (cmd) 
cmd1654drivers/scsi/53c7,8xx.cif (cmd) {
cmd1656drivers/scsi/53c7,8xx.chost->host_no, c->target, (cmd->flags & CMD_FLAG_SDTR) ? "accepting" :
cmd1666drivers/scsi/53c7,8xx.cif (cmd->flags & CMD_FLAG_SDTR) {
cmd1667drivers/scsi/53c7,8xx.ccmd->flags &= ~CMD_FLAG_SDTR; 
cmd1675drivers/scsi/53c7,8xx.ccmd->flags |= CMD_FLAG_DID_SDTR;
cmd1681drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout_other, 0, 5);
cmd1682drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout_other, 1, 
cmd1766drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout, 0, 1);
cmd1773drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_cmdout, 0, 6);
cmd1788drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_dataout, 0, hostdata->E_other_transfer);
cmd1789drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_datain, 0, cmd->data_transfer_start);
cmd1790drivers/scsi/53c7,8xx.ccmd->data_transfer_start[0] = (((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I | 
cmd1792drivers/scsi/53c7,8xx.ccmd->data_transfer_start[1] = (unsigned long) c->sense_buffer;
cmd1794drivers/scsi/53c7,8xx.ccmd->data_transfer_start[2] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) 
cmd1796drivers/scsi/53c7,8xx.ccmd->data_transfer_start[3] = hostdata->E_other_transfer;
cmd1805drivers/scsi/53c7,8xx.ccmd->cmd->result = 0xffff;    
cmd1820drivers/scsi/53c7,8xx.cif (cmd)
cmd1821drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_ERROR << 16);
cmd2258drivers/scsi/53c7,8xx.cstatic struct NCR53c7x0_cmd *create_cmd (Scsi_Cmnd *cmd) {
cmd2260drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd2273drivers/scsi/53c7,8xx.cNCR53c7x0_local_setup(cmd->host);
cmd2281drivers/scsi/53c7,8xx.cswitch (cmd->cmnd[0]) {
cmd2289drivers/scsi/53c7,8xx.cdatain = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd2298drivers/scsi/53c7,8xx.cprint_command(cmd->cmnd);
cmd2302drivers/scsi/53c7,8xx.ccmd->use_sg);
cmd2305drivers/scsi/53c7,8xx.cdataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd2323drivers/scsi/53c7,8xx.cdatain = dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd2397drivers/scsi/53c7,8xx.chost->host_no, cmd->pid);
cmd2404drivers/scsi/53c7,8xx.ctmp->cmd = cmd;
cmd2433drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmnd, 0, cmd);
cmd2434drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_select, 0, hostdata->sync[cmd->target].
cmd2442drivers/scsi/53c7,8xx.ctmp->select[0] = IDENTIFY (1, cmd->lun);
cmd2444drivers/scsi/53c7,8xx.ctmp->select[0] = IDENTIFY (0, cmd->lun);
cmd2447drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmdout, 0, cmd->cmd_len);
cmd2448drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmdout, 1, cmd->cmnd);
cmd2460drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_msgin, 1, (((unsigned long) &cmd->result) + 1));
cmd2462drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_status, 1, &cmd->result);
cmd2503drivers/scsi/53c7,8xx.cfor (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; cmd_datain += 4, 
cmd2505drivers/scsi/53c7,8xx.cunsigned long buf = (unsigned long) (cmd->use_sg ? 
cmd2506drivers/scsi/53c7,8xx.c((struct scatterlist *)cmd->buffer)[i].address :
cmd2507drivers/scsi/53c7,8xx.ccmd->request_buffer);
cmd2508drivers/scsi/53c7,8xx.cunsigned long count = (unsigned long) (cmd->use_sg ?
cmd2509drivers/scsi/53c7,8xx.c((struct scatterlist *)cmd->buffer)[i].length :
cmd2510drivers/scsi/53c7,8xx.ccmd->request_bufflen);
cmd2600drivers/scsi/53c7,8xx.cint NCR53c7xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *)) {
cmd2603drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd2612drivers/scsi/53c7,8xx.c!(hostdata->debug_lun_limit[cmd->target] & (1 << cmd->lun)))) ||
cmd2613drivers/scsi/53c7,8xx.ccmd->target > 7) {
cmd2615drivers/scsi/53c7,8xx.ccmd->target, cmd->lun);
cmd2616drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd2617drivers/scsi/53c7,8xx.cdone(cmd);
cmd2624drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd2625drivers/scsi/53c7,8xx.cdone(cmd);
cmd2632drivers/scsi/53c7,8xx.cswitch (cmd->cmnd[0]) {
cmd2637drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd2638drivers/scsi/53c7,8xx.cdone(cmd);
cmd2643drivers/scsi/53c7,8xx.ccmd->scsi_done = done;
cmd2644drivers/scsi/53c7,8xx.ccmd->result = 0xffff;    /* The NCR will overwrite message
cmd2647drivers/scsi/53c7,8xx.ccmd->host_scribble = (unsigned char *) tmp = create_cmd (cmd);
cmd2683drivers/scsi/53c7,8xx.ctarget_was_busy = hostdata->busy[cmd->target][cmd->lun]
cmd2787drivers/scsi/53c7,8xx.cstatic void intr_scsi (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd2817drivers/scsi/53c7,8xx.cif (cmd) {
cmd2819drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd2820drivers/scsi/53c7,8xx.cprint_command (cmd->cmd->cmnd);
cmd2840drivers/scsi/53c7,8xx.c} else if (cmd) {
cmd2841drivers/scsi/53c7,8xx.cabnormal_finished(cmd, DID_BAD_TARGET << 16);
cmd2852drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd2853drivers/scsi/53c7,8xx.cif (cmd) {
cmd2854drivers/scsi/53c7,8xx.cabnormal_finished(cmd, DID_ERROR << 16);
cmd2864drivers/scsi/53c7,8xx.cif (cmd && cmd->cmd) {
cmd2866drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd2867drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_PARITY << 16); 
cmd2893drivers/scsi/53c7,8xx.cintr_phase_mismatch (host, cmd);
cmd2946drivers/scsi/53c7,8xx.cstruct NCR53c7x0_cmd *cmd,      /* command which halted */
cmd3017drivers/scsi/53c7,8xx.c&(hostdata->running_list), cmd = (struct NCR53c7x0_cmd *)
cmd3018drivers/scsi/53c7,8xx.chostdata->running_list; cmd ; cmd_prev_ptr = 
cmd3019drivers/scsi/53c7,8xx.c&(cmd->next), cmd = (struct NCR53c7x0_cmd *) cmd->next) {
cmd3022drivers/scsi/53c7,8xx.cif (!cmd) {
cmd3027drivers/scsi/53c7,8xx.cif (!(tmp = cmd->cmd)) {
cmd3034drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->result);
cmd3045drivers/scsi/53c7,8xx.cif (cmd->prev)
cmd3046drivers/scsi/53c7,8xx.ccmd->prev->next = cmd->next;
cmd3048drivers/scsi/53c7,8xx.c*cmd_prev_ptr = cmd->next;
cmd3059drivers/scsi/53c7,8xx.cscsi_free ((void *) cmd->real, cmd->size);
cmd3061drivers/scsi/53c7,8xx.ckfree_s ((void *) cmd->real, cmd->size);
cmd3107drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *) hostdata->current;
cmd3110drivers/scsi/53c7,8xx.cfor (cmd = (struct NCR53c7x0_cmd *) 
cmd3111drivers/scsi/53c7,8xx.chostdata->running_list; cmd &&
cmd3113drivers/scsi/53c7,8xx.ccmd->dsa;
cmd3114drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *)(cmd->next));
cmd3117drivers/scsi/53c7,8xx.cif (cmd) {
cmd3119drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->pid, (int) cmd->cmd->target,
cmd3120drivers/scsi/53c7,8xx.c(int) cmd->cmd->lun);
cmd3121drivers/scsi/53c7,8xx.cprint_command (cmd->cmd->cmnd);
cmd3130drivers/scsi/53c7,8xx.cintr_scsi (host, cmd);
cmd3136drivers/scsi/53c7,8xx.cintr_dma (host, cmd);
cmd3240drivers/scsi/53c7,8xx.c*cmd) {
cmd3249drivers/scsi/53c7,8xx.cif (!cmd) {
cmd3310drivers/scsi/53c7,8xx.cif (dsp >= cmd->data_transfer_start & dsp < cmd->data_transfer_end) {
cmd3397drivers/scsi/53c7,8xx.cstatic void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd3512drivers/scsi/53c7,8xx.c} else if (cmd) 
cmd3513drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_BAD_TARGET << 16);
cmd3566drivers/scsi/53c7,8xx.cswitch ((tmp = hostdata->dstat_sir_intr (host, cmd))) {
cmd3579drivers/scsi/53c7,8xx.cintr_break (host, cmd);
cmd3653drivers/scsi/53c7,8xx.cint NCR53c7xx_abort (Scsi_Cmnd *cmd) {
cmd3654drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd3672drivers/scsi/53c7,8xx.ccurr && curr->cmd != cmd; prev = &(curr->next), curr = curr->next);
cmd3690drivers/scsi/53c7,8xx.ccmd->result = 0;
cmd3691drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd3702drivers/scsi/53c7,8xx.ccurr && curr->cmd != cmd; prev = &(curr->next), curr = curr->next);
cmd3707drivers/scsi/53c7,8xx.ccmd->host->host_no);
cmd3717drivers/scsi/53c7,8xx.ccurr = (struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd3729drivers/scsi/53c7,8xx.cif (((cmd->result & 0xff00) == 0xff00) ||
cmd3730drivers/scsi/53c7,8xx.c((cmd->result & 0xff) == 0xff)) {
cmd3736drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd3752drivers/scsi/53c7,8xx.cint NCR53c7xx_reset (Scsi_Cmnd *cmd) {
cmd3754drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd ? cmd->host : NULL;
cmd3761drivers/scsi/53c7,8xx.ccmd->host->host_no);
cmd3773drivers/scsi/53c7,8xx.cScsi_Cmnd * cmd;
cmd935drivers/scsi/53c7,8xx.hScsi_Cmnd *cmd;      /* Associated Scsi_Cmnd 
cmd1063drivers/scsi/53c7,8xx.hvoid (* dsa_fixup)(struct NCR53c7x0_cmd *cmd);
cmd1073drivers/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) {
cmd847drivers/scsi/NCR5380.cint NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) {
cmd849drivers/scsi/NCR5380.ccmd->host->hostdata;
cmd853drivers/scsi/NCR5380.cswitch (cmd->cmnd[0]) {
cmd858drivers/scsi/NCR5380.ccmd->result = (DID_ERROR << 16);
cmd859drivers/scsi/NCR5380.cdone(cmd);
cmd870drivers/scsi/NCR5380.ccmd->host_scribble = NULL;
cmd871drivers/scsi/NCR5380.ccmd->scsi_done = done;
cmd873drivers/scsi/NCR5380.ccmd->result = 0;
cmd884drivers/scsi/NCR5380.cif (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd885drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) hostdata->issue_queue;
cmd886drivers/scsi/NCR5380.chostdata->issue_queue = cmd;
cmd890drivers/scsi/NCR5380.ctmp->host_scribble = (unsigned char *) cmd;
cmd894drivers/scsi/NCR5380.c(cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
cmd1164drivers/scsi/NCR5380.cstatic int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
cmd1278drivers/scsi/NCR5380.cNCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
cmd1317drivers/scsi/NCR5380.cprintk("scsi%d : selecting target %d\n", instance->host_no, cmd->target);
cmd1350drivers/scsi/NCR5380.cif (hostdata->targets_present & (1 << cmd->target)) {
cmd1360drivers/scsi/NCR5380.ccmd->result = DID_BAD_TARGET << 16;
cmd1361drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd1371drivers/scsi/NCR5380.chostdata->targets_present |= (1 << cmd->target);
cmd1393drivers/scsi/NCR5380.cinstance->host_no, cmd->target);
cmd1395drivers/scsi/NCR5380.ctmp[0] = IDENTIFY(((instance->irq == IRQ_NONE) ? 0 : 1), cmd->lun);
cmd1397drivers/scsi/NCR5380.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
cmd1401drivers/scsi/NCR5380.cif (cmd->device->current_tag == 0)
cmd1402drivers/scsi/NCR5380.ccmd->device->current_tag = 1;
cmd1404drivers/scsi/NCR5380.ccmd->tag = cmd->device->current_tag;
cmd1405drivers/scsi/NCR5380.ccmd->device->current_tag++;
cmd1407drivers/scsi/NCR5380.ccmd->tag = (unsigned char) tag;
cmd1409drivers/scsi/NCR5380.ctmp[2] = cmd->tag;
cmd1416drivers/scsi/NCR5380.ccmd->tag=0;
cmd1427drivers/scsi/NCR5380.chostdata->connected = cmd;
cmd1429drivers/scsi/NCR5380.cif (!cmd->device->tagged_queue)
cmd1431drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd1433drivers/scsi/NCR5380.cinitialize_SCp(cmd);
cmd1921drivers/scsi/NCR5380.cScsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
cmd1964drivers/scsi/NCR5380.cif (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
cmd1965drivers/scsi/NCR5380.c++cmd->SCp.buffer;
cmd1966drivers/scsi/NCR5380.c--cmd->SCp.buffers_residual;
cmd1967drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd1968drivers/scsi/NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd1971drivers/scsi/NCR5380.cinstance->host_no, cmd->SCp.this_residual,
cmd1972drivers/scsi/NCR5380.ccmd->SCp.buffers_residual);
cmd1988drivers/scsi/NCR5380.cif (!cmd->device->borken &&
cmd1989drivers/scsi/NCR5380.c(transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
cmd1991drivers/scsi/NCR5380.ctransfersize = cmd->transfersize;
cmd1998drivers/scsi/NCR5380.cif (!cmd->device->borken && transfersize && 
cmd1999drivers/scsi/NCR5380.ccmd->SCp.this_residual && !(cmd->SCp.this_residual % 
cmd2004drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
cmd2010drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2011drivers/scsi/NCR5380.ccmd->device->borken = 1;
cmd2018drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
cmd2022drivers/scsi/NCR5380.c(int *) &cmd->SCp.this_residual, (unsigned char **)
cmd2023drivers/scsi/NCR5380.c&cmd->SCp.ptr);
cmd2029drivers/scsi/NCR5380.ccmd->SCp.Message = tmp;
cmd2050drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2058drivers/scsi/NCR5380.cif (!cmd->next_link) {
cmd2060drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2068drivers/scsi/NCR5380.cinitialize_SCp(cmd->next_link);
cmd2070drivers/scsi/NCR5380.ccmd->next_link->tag = cmd->tag;
cmd2071drivers/scsi/NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2074drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2076drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2077drivers/scsi/NCR5380.ccmd = hostdata->connected;
cmd2087drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2089drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2107drivers/scsi/NCR5380.cif (cmd->cmnd[0] != REQUEST_SENSE) 
cmd2108drivers/scsi/NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2109drivers/scsi/NCR5380.celse if (cmd->SCp.Status != GOOD)
cmd2110drivers/scsi/NCR5380.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd2113drivers/scsi/NCR5380.cif ((cmd->cmnd[0] != REQUEST_SENSE) && 
cmd2114drivers/scsi/NCR5380.c(cmd->SCp.Status == CHECK_CONDITION)) {
cmd2119drivers/scsi/NCR5380.ccmd->cmnd[0] = REQUEST_SENSE;
cmd2120drivers/scsi/NCR5380.ccmd->cmnd[1] &= 0xe0;
cmd2121drivers/scsi/NCR5380.ccmd->cmnd[2] = 0;
cmd2122drivers/scsi/NCR5380.ccmd->cmnd[3] = 0;
cmd2123drivers/scsi/NCR5380.ccmd->cmnd[4] = sizeof(cmd->sense_buffer);
cmd2124drivers/scsi/NCR5380.ccmd->cmnd[5] = 0;
cmd2126drivers/scsi/NCR5380.ccmd->SCp.buffer = NULL;
cmd2127drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = 0;
cmd2128drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->sense_buffer;
cmd2129drivers/scsi/NCR5380.ccmd->SCp.this_residual = sizeof(cmd->sense_buffer);
cmd2132drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) 
cmd2134drivers/scsi/NCR5380.chostdata->issue_queue = (Scsi_Cmnd *) cmd;
cmd2141drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2160drivers/scsi/NCR5380.ccmd->device->tagged_queue = 0;
cmd2161drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd2169drivers/scsi/NCR5380.ccmd->device->disconnect = 1;
cmd2171drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) 
cmd2174drivers/scsi/NCR5380.chostdata->disconnected_queue = cmd;
cmd2179drivers/scsi/NCR5380.ccmd->target, cmd->lun);
cmd2285drivers/scsi/NCR5380.cinstance->host_no, tmp, cmd->target, cmd->lun);
cmd2288drivers/scsi/NCR5380.cinstance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
cmd2302drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2304drivers/scsi/NCR5380.ccmd->result = DID_ERROR << 16;
cmd2305drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2312drivers/scsi/NCR5380.clen = cmd->cmd_len;
cmd2313drivers/scsi/NCR5380.cdata = cmd->cmnd;
cmd2322drivers/scsi/NCR5380.cif (!disconnect && should_disconnect(cmd->cmnd[0])) {
cmd2337drivers/scsi/NCR5380.ccmd->SCp.Status = tmp;
cmd2572drivers/scsi/NCR5380.cint NCR5380_abort (Scsi_Cmnd *cmd) {
cmd2574drivers/scsi/NCR5380.cstruct Scsi_Host *instance = cmd->host;
cmd2582drivers/scsi/NCR5380.cprint_Scsi_Cmnd (cmd);
cmd2602drivers/scsi/NCR5380.cif (hostdata->connected == cmd) {
cmd2636drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd2695drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd2701drivers/scsi/NCR5380.cif (NCR5380_select (instance, cmd, (int) cmd->tag)) 
cmd2720drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd2759drivers/scsi/NCR5380.cint NCR5380_reset (Scsi_Cmnd *cmd) {
cmd2761drivers/scsi/NCR5380.cNCR5380_setup(cmd->host);
cmd2763drivers/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);
cmd510drivers/scsi/aha1542.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd529drivers/scsi/aha1542.cif(*cmd == REQUEST_SENSE){
cmd541drivers/scsi/aha1542.cif (*cmd == READ_10 || *cmd == WRITE_10)
cmd542drivers/scsi/aha1542.ci = xscsi2int(cmd+2);
cmd543drivers/scsi/aha1542.celse if (*cmd == READ_6 || *cmd == WRITE_6)
cmd544drivers/scsi/aha1542.ci = scsi2int(cmd+2);
cmd548drivers/scsi/aha1542.cprintk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd550drivers/scsi/aha1542.cprintk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd553drivers/scsi/aha1542.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd555drivers/scsi/aha1542.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd593drivers/scsi/aha1542.cif (*cmd == READ_10 || *cmd == READ_6)
cmd595drivers/scsi/aha1542.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd598drivers/scsi/aha1542.cmemcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
cmd695drivers/scsi/aha1542.cunchar cmd[5] = {CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
cmd705drivers/scsi/aha1542.cany2scsi((cmd+2), mb);
cmd706drivers/scsi/aha1542.caha1542_out(bse, cmd, 5);
cmd1028drivers/scsi/aha1542.cstatic unchar cmd[] = {  READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cmd1033drivers/scsi/aha1542.cif (!aha1542_command(i, cmd, buf, sizeof(buf))) {
cmd1043drivers/scsi/aha1542.cunsigned char cmd[10];
cmd1046drivers/scsi/aha1542.ccmd[0] = READ_10;
cmd1047drivers/scsi/aha1542.ccmd[1] = 0;
cmd1048drivers/scsi/aha1542.cxany2scsi(cmd+2, i);
cmd1049drivers/scsi/aha1542.ccmd[6] = 0;
cmd1050drivers/scsi/aha1542.ccmd[7] = 0;
cmd1051drivers/scsi/aha1542.ccmd[8] = 1;
cmd1052drivers/scsi/aha1542.ccmd[9] = 0;
cmd1053drivers/scsi/aha1542.caha1542_command(0, cmd, buffer, 512);
cmd248drivers/scsi/aha1740.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd257drivers/scsi/aha1740.cif(*cmd == REQUEST_SENSE)
cmd269drivers/scsi/aha1740.cif (*cmd == READ_10 || *cmd == WRITE_10)
cmd270drivers/scsi/aha1740.ci = xscsi2int(cmd+2);
cmd271drivers/scsi/aha1740.celse if (*cmd == READ_6 || *cmd == WRITE_6)
cmd272drivers/scsi/aha1740.ci = scsi2int(cmd+2);
cmd275drivers/scsi/aha1740.cprintk("aha1740_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd277drivers/scsi/aha1740.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd310drivers/scsi/aha1740.cif (*cmd == READ_10 || *cmd == READ_6)
cmd312drivers/scsi/aha1740.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd315drivers/scsi/aha1740.cmemcpy(ecb[ecbno].cdb, cmd, ecb[ecbno].cdblen);
cmd129drivers/scsi/aha274x.c#define aha274x_parity(cmd)  ((cmd)->SCp.Status)
cmd360drivers/scsi/aha274x.cunsigned aha274x_length(Scsi_Cmnd *cmd, int sg_last)
cmd366drivers/scsi/aha274x.csegments = cmd->use_sg - sg_last;
cmd367drivers/scsi/aha274x.csg = (struct scatterlist *)cmd->buffer;
cmd369drivers/scsi/aha274x.cif (cmd->use_sg) {
cmd371drivers/scsi/aha274x.ci < cmd->use_sg && i < segments;
cmd377drivers/scsi/aha274x.clength = cmd->request_bufflen;
cmd383drivers/scsi/aha274x.cvoid aha274x_sg_check(Scsi_Cmnd *cmd)
cmd386drivers/scsi/aha274x.cstruct scatterlist *sg = (struct scatterlist *)cmd->buffer;
cmd388drivers/scsi/aha274x.cif (cmd->use_sg) {
cmd389drivers/scsi/aha274x.cfor (i = 0; i < cmd->use_sg; i++)
cmd495drivers/scsi/aha274x.cScsi_Cmnd *cmd;
cmd497drivers/scsi/aha274x.ccmd = (Scsi_Cmnd *)p->SCB_array[scbptr];
cmd498drivers/scsi/aha274x.cif (!cmd) {
cmd525drivers/scsi/aha274x.ccmd->result = DID_TIME_OUT << 16;
cmd552drivers/scsi/aha274x.ccmd->scsi_done(cmd);
cmd561drivers/scsi/aha274x.ccmd->target,
cmd562drivers/scsi/aha274x.ccmd->lun);
cmd563drivers/scsi/aha274x.caha274x_parity(cmd) = DID_PARITY;
cmd591drivers/scsi/aha274x.cScsi_Cmnd *cmd;
cmd601drivers/scsi/aha274x.ccmd = (Scsi_Cmnd *)p->SCB_array[complete];
cmd602drivers/scsi/aha274x.cif (!cmd) {
cmd629drivers/scsi/aha274x.ccmd->result = scb.target_status |
cmd630drivers/scsi/aha274x.c(aha274x_parity(cmd) << 16);
cmd638drivers/scsi/aha274x.cactual = aha274x_length(cmd,
cmd645drivers/scsi/aha274x.cif (actual < cmd->underflow) {
cmd648drivers/scsi/aha274x.ccmd->target, cmd->underflow, actual);
cmd650drivers/scsi/aha274x.ccmd->result = scb.target_status |
cmd654drivers/scsi/aha274x.ccmd->scsi_done(cmd);
cmd1048drivers/scsi/aha274x.cint aha274x_command(Scsi_Cmnd *cmd)
cmd1060drivers/scsi/aha274x.cScsi_Cmnd *cmd,
cmd1071drivers/scsi/aha274x.cscb->target_channel_lun = ((cmd->target << 4) & 0xf0) |
cmd1072drivers/scsi/aha274x.c(cmd->lun & 0x7);
cmd1084drivers/scsi/aha274x.clength = aha274x_length(cmd, 0);
cmd1092drivers/scsi/aha274x.caha274x_sg_check(cmd);
cmd1102drivers/scsi/aha274x.caddr = cmd->cmnd;
cmd1103drivers/scsi/aha274x.cscb->SCSI_cmd_length = cmd->cmd_len;
cmd1106drivers/scsi/aha274x.cif (cmd->use_sg) {
cmd1109drivers/scsi/aha274x.ccmd->use_sg,
cmd1112drivers/scsi/aha274x.cscb->SG_segment_count = cmd->use_sg;
cmd1114drivers/scsi/aha274x.c&cmd->request_buffer,
cmd1119drivers/scsi/aha274x.c&cmd->request_buffer,
cmd1122drivers/scsi/aha274x.c&cmd->request_bufflen,
cmd1148drivers/scsi/aha274x.cint aha274x_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
cmd1157drivers/scsi/aha274x.ccmd->cmnd[0],
cmd1158drivers/scsi/aha274x.ccmd->cmd_len,
cmd1159drivers/scsi/aha274x.ccmd->target,
cmd1160drivers/scsi/aha274x.ccmd->lun);
cmd1163drivers/scsi/aha274x.cp = (struct aha274x_host *)cmd->host->hostdata;
cmd1169drivers/scsi/aha274x.caha274x_buildscb(p, cmd, &scb);
cmd1226drivers/scsi/aha274x.ccmd->scsi_done = fn;
cmd1227drivers/scsi/aha274x.cp->SCB_array[empty] = cmd;
cmd1228drivers/scsi/aha274x.caha274x_parity(cmd) = DID_OK;
cmd1263drivers/scsi/aha274x.cenum k_state aha274x_kill(Scsi_Cmnd *cmd, unsigned char message,
cmd1270drivers/scsi/aha274x.cp = (struct aha274x_host *)cmd->host->hostdata;
cmd1277drivers/scsi/aha274x.cif (p->SCB_array[scb] == cmd)
cmd1353drivers/scsi/aha274x.ccmd->result = result << 16;
cmd1354drivers/scsi/aha274x.ccmd->scsi_done(cmd);
cmd1358drivers/scsi/aha274x.cint aha274x_abort(Scsi_Cmnd *cmd)
cmd1366drivers/scsi/aha274x.cswitch (aha274x_kill(cmd, ABORT, DID_ABORT, !0)) {
cmd1386drivers/scsi/aha274x.cint aha274x_reset(Scsi_Cmnd *cmd)
cmd1393drivers/scsi/aha274x.cp = (struct aha274x_host *)cmd->host->hostdata;
cmd1397drivers/scsi/aha274x.cswitch (aha274x_kill(cmd, BUS_DEVICE_RESET, DID_RESET, 0)) {
cmd1406drivers/scsi/aha274x.coutb((1 << cmd->target), HA_NEEDSDTR(p->base));
cmd1447drivers/scsi/aha274x.cif (cmd == p->SCB_array[i]) {
cmd601drivers/scsi/buslogic.cunsigned char *cmd = (unsigned char *)scpnt->cmnd;
cmd620drivers/scsi/buslogic.cif (*cmd == REQUEST_SENSE) {
cmd637drivers/scsi/buslogic.cif (*cmd == READ_10 || *cmd == WRITE_10
cmd638drivers/scsi/buslogic.c|| *cmd == READ_6 || *cmd == WRITE_6)
cmd639drivers/scsi/buslogic.ci = *(int *)(cmd + 2);
cmd643drivers/scsi/buslogic.ctarget, *cmd, i, bufflen);
cmd647drivers/scsi/buslogic.cprintk(" %02X", cmd[i]);
cmd649drivers/scsi/buslogic.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd705drivers/scsi/buslogic.cif (*cmd == READ_10 || *cmd == READ_6)
cmd707drivers/scsi/buslogic.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd710drivers/scsi/buslogic.cmemcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
cmd834drivers/scsi/buslogic.cunsigned char cmd, count;
cmd836drivers/scsi/buslogic.c} cmd = { CMD_INITEXTMB, BUSLOGIC_MAILBOXES, mb };
cmd844drivers/scsi/buslogic.cif (buslogic_out(base, (unsigned char *)&cmd, sizeof cmd))
cmd1307drivers/scsi/buslogic.cunsigned char cmd[]
cmd1317drivers/scsi/buslogic.cif (!buslogic_command(i, cmd, buf, sizeof buf)) {
cmd1328drivers/scsi/buslogic.ccmd[0] = READ_10;
cmd1329drivers/scsi/buslogic.ccmd[1] = 0;
cmd1330drivers/scsi/buslogic.cxany2scsi(cmd + 2, i);
cmd1331drivers/scsi/buslogic.ccmd[6] = 0;
cmd1332drivers/scsi/buslogic.ccmd[7] = 0;
cmd1333drivers/scsi/buslogic.ccmd[8] = 1;
cmd1334drivers/scsi/buslogic.ccmd[9] = 0;
cmd1335drivers/scsi/buslogic.cbuslogic_command(0, cmd, buffer, sizeof buffer);
cmd550drivers/scsi/constants.cvoid print_Scsi_Cmnd (Scsi_Cmnd *cmd) {
cmd552drivers/scsi/constants.ccmd->host->host_no, 
cmd553drivers/scsi/constants.ccmd->target, 
cmd554drivers/scsi/constants.ccmd->lun);
cmd556drivers/scsi/constants.cprint_command (cmd->cmnd);
cmd308drivers/scsi/eata.cstatic inline unchar do_dma (ushort iobase, unsigned int addr, unchar cmd) {
cmd319drivers/scsi/eata.coutb(cmd, iobase + REG_CMD);
cmd121drivers/scsi/eata_dma.cScsi_Cmnd *cmd;
cmd143drivers/scsi/eata_dma.ccmd = cp->cmd;
cmd144drivers/scsi/eata_dma.cbase = (uint) cmd->host->base;
cmd173drivers/scsi/eata_dma.cirq, base, cmd->pid, cmd->target, cmd->lun, 
cmd179drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
cmd180drivers/scsi/eata_dma.c&& (HD(cmd)->t_state[cmd->target] == RESET))
cmd185drivers/scsi/eata_dma.cHD(cmd)->t_state[cmd->target] = FALSE;
cmd186drivers/scsi/eata_dma.cHD(cmd)->t_timeout[cmd->target] = 0;
cmd192drivers/scsi/eata_dma.cif (HD(cmd)->t_timeout[cmd->target] > 1)
cmd196drivers/scsi/eata_dma.cHD(cmd)->t_timeout[cmd->target]++;
cmd200drivers/scsi/eata_dma.cif (cmd->device->type != TYPE_TAPE)
cmd206drivers/scsi/eata_dma.cHD(cmd)->t_state[i] = RESET;
cmd221drivers/scsi/eata_dma.ccmd->result = result | scsi_stat; 
cmd223drivers/scsi/eata_dma.c(cmd->sense_buffer[2] & 0xf) == UNIT_ATTENTION) 
cmd224drivers/scsi/eata_dma.ccmd->result |= (DRIVER_SENSE << 24);
cmd230drivers/scsi/eata_dma.cscsi_stat,cmd->sense_buffer[2] & 0xf, cmd->result); 
cmd237drivers/scsi/eata_dma.cif(cmd->scsi_done != eata_scsi_done) cmd->scsi_done(cmd);
cmd263drivers/scsi/eata_dma.cint eata_queue(Scsi_Cmnd * cmd, void *(done) (Scsi_Cmnd *))
cmd282drivers/scsi/eata_dma.ccmd->result = (DID_ERROR << 16) + QUEUE_FULL;
cmd285drivers/scsi/eata_dma.chd = HD(cmd);
cmd286drivers/scsi/eata_dma.csh = cmd->host;
cmd316drivers/scsi/eata_dma.ccmd->pid, cmd->target, cmd->lun, y));
cmd319drivers/scsi/eata_dma.ccmd->scsi_done = (void *)done;
cmd321drivers/scsi/eata_dma.cswitch (cmd->cmnd[0]) {
cmd343drivers/scsi/eata_dma.cif (cmd->use_sg) {
cmd346drivers/scsi/eata_dma.ccp->cp_datalen = htonl(cmd->use_sg*8);
cmd347drivers/scsi/eata_dma.csl=(struct scatterlist *)cmd->request_buffer;
cmd349drivers/scsi/eata_dma.cfor(i = 0; i < cmd->use_sg; i++, sl++){
cmd355drivers/scsi/eata_dma.ccp->cp_datalen = htonl(cmd->request_bufflen);
cmd356drivers/scsi/eata_dma.ccp->cp_dataDMA = htonl((ulong)cmd->request_buffer);
cmd360drivers/scsi/eata_dma.ccp->cp_reqDMA = htonl((ulong) cmd->sense_buffer);
cmd361drivers/scsi/eata_dma.ccp->reqlen = sizeof(cmd->sense_buffer);
cmd363drivers/scsi/eata_dma.ccp->cp_id = cmd->target;
cmd364drivers/scsi/eata_dma.ccp->cp_lun = cmd->lun;
cmd367drivers/scsi/eata_dma.cmemcpy(cp->cp_cdb, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
cmd372drivers/scsi/eata_dma.ccp->cmd = cmd;
cmd373drivers/scsi/eata_dma.ccmd->host_scribble = (char *)&hd->ccb[y];  
cmd376drivers/scsi/eata_dma.ccmd->result = DID_ERROR << 16;
cmd378drivers/scsi/eata_dma.ccmd->target, cmd->pid);
cmd380drivers/scsi/eata_dma.cif(done != (void *)eata_scsi_done) done(cmd);
cmd384drivers/scsi/eata_dma.c(long)sh->base, cmd->pid, cmd->target, cmd->lun, y, sh->irq));
cmd393drivers/scsi/eata_dma.cstatic void internal_done(Scsi_Cmnd * cmd)
cmd395drivers/scsi/eata_dma.cinternal_done_errcode = cmd->result;
cmd399drivers/scsi/eata_dma.cint eata_command(Scsi_Cmnd * cmd)
cmd404drivers/scsi/eata_dma.ceata_queue(cmd, (void *)internal_done);
cmd411drivers/scsi/eata_dma.cint eata_abort(Scsi_Cmnd * cmd)
cmd420drivers/scsi/eata_dma.ccmd->pid, cmd->target, cmd->lun, cmd->abort_reason));
cmd424drivers/scsi/eata_dma.cwhile (inb((uint)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd431drivers/scsi/eata_dma.cif (CD(cmd)->status == FREE) {
cmd436drivers/scsi/eata_dma.cif (CD(cmd)->status == USED) {
cmd441drivers/scsi/eata_dma.cif (CD(cmd)->status == RESET) {
cmd447drivers/scsi/eata_dma.cif (CD(cmd)->status == LOCKED) {
cmd456drivers/scsi/eata_dma.cint eata_reset(Scsi_Cmnd * cmd)
cmd468drivers/scsi/eata_dma.ccmd->pid, cmd->target, cmd->lun, cmd->abort_reason));
cmd471drivers/scsi/eata_dma.cif (HD(cmd)->state == RESET) {
cmd478drivers/scsi/eata_dma.cwhile (inb((uint)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd486drivers/scsi/eata_dma.cHD(cmd)->t_state[z] = RESET;
cmd488drivers/scsi/eata_dma.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd490drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status == FREE)
cmd493drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status == LOCKED) {
cmd494drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = FREE;
cmd499drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
cmd500drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = RESET;
cmd508drivers/scsi/eata_dma.cif (sp == cmd)
cmd513drivers/scsi/eata_dma.cinb((uint) (cmd->host->base) + HA_RSTATUS);  /* This might cause trouble */
cmd514drivers/scsi/eata_dma.ceata_send_command(0, (uint) cmd->host->base, EATA_CMD_RESET);
cmd517drivers/scsi/eata_dma.cHD(cmd)->state = RESET;
cmd530drivers/scsi/eata_dma.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd533drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status != RESET)
cmd536drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
cmd540drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = LOCKED;
cmd550drivers/scsi/eata_dma.cHD(cmd)->state = FALSE;
cmd156drivers/scsi/eata_dma.h#define HD(cmd)  ((hostdata *)&(cmd->host->hostdata))
cmd157drivers/scsi/eata_dma.h#define CD(cmd)  ((struct eata_ccb *)(cmd->host_scribble))
cmd335drivers/scsi/eata_dma.hScsi_Cmnd *cmd;             /* address of cmd                 */
cmd412drivers/scsi/in2000.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd427drivers/scsi/in2000.cif ( *cmd == TEST_UNIT_READY )
cmd433drivers/scsi/in2000.cif (*cmd == READ_10 || *cmd == WRITE_10) {
cmd434drivers/scsi/in2000.ci = xscsi2int((cmd+1));
cmd435drivers/scsi/in2000.c} else if (*cmd == READ_6 || *cmd == WRITE_6) {
cmd436drivers/scsi/in2000.ci = scsi2int((cmd+1));
cmd443drivers/scsi/in2000.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd447drivers/scsi/in2000.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd510drivers/scsi/in2000.coutb(cmd[loop],INDATA);
cmd248drivers/scsi/qlogic.cstatic void  ql_icmd(Scsi_Cmnd * cmd)
cmd294drivers/scsi/qlogic.coutb(cmd->target, qbase + 4);
cmd296drivers/scsi/qlogic.cfor (i = 0; i < cmd->cmd_len; i++)
cmd297drivers/scsi/qlogic.coutb(cmd->cmnd[i], qbase + 2);
cmd298drivers/scsi/qlogic.cqlcmd = cmd;
cmd304drivers/scsi/qlogic.cstatic unsigned int  ql_pcmd(Scsi_Cmnd * cmd)
cmd340drivers/scsi/qlogic.creqlen = cmd->request_bufflen;
cmd350drivers/scsi/qlogic.cif (!cmd->use_sg)
cmd351drivers/scsi/qlogic.cql_pdma(phase, cmd->request_buffer, cmd->request_bufflen);
cmd353drivers/scsi/qlogic.csgcount = cmd->use_sg;
cmd354drivers/scsi/qlogic.csglist = cmd->request_buffer;
cmd437drivers/scsi/qlogic.cstatic void  qlidone(Scsi_Cmnd * cmd) {};    /* null function */
cmd441drivers/scsi/qlogic.cint  qlogic_command(Scsi_Cmnd * cmd)
cmd446drivers/scsi/qlogic.cqlogic_queuecommand(cmd, qlidone);
cmd448drivers/scsi/qlogic.creturn cmd->result;
cmd452drivers/scsi/qlogic.cif (cmd->target == qinitid)
cmd454drivers/scsi/qlogic.cql_icmd(cmd);
cmd457drivers/scsi/qlogic.creturn ql_pcmd(cmd);
cmd464drivers/scsi/qlogic.cint  qlogic_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd466drivers/scsi/qlogic.cif(cmd->target == qinitid) {
cmd467drivers/scsi/qlogic.ccmd->result = DID_BAD_TARGET << 16;
cmd468drivers/scsi/qlogic.cdone(cmd);
cmd472drivers/scsi/qlogic.ccmd->scsi_done = done;
cmd475drivers/scsi/qlogic.cql_icmd(cmd);
cmd479drivers/scsi/qlogic.cint  qlogic_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd587drivers/scsi/qlogic.cint  qlogic_abort(Scsi_Cmnd * cmd)
cmd596drivers/scsi/qlogic.cint  qlogic_reset(Scsi_Cmnd * cmd)
cmd2486drivers/scsi/scsi.creq->cmd,
cmd90drivers/scsi/scsi_debug.cif (SCpnt->request.cmd != RW) panic ("Wrong  operation");    \
cmd157drivers/scsi/scsi_debug.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd182drivers/scsi/scsi_debug.cswitch(*cmd){
cmd199drivers/scsi/scsi_debug.cif(cmd[4]) printk("Medium removal inhibited...");
cmd237drivers/scsi/scsi_debug.cif ((*cmd) == READ_10)
cmd238drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
cmd240drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
cmd316drivers/scsi/scsi_debug.cmemcpy(buff+sizeof(target), cmd, 24);
cmd348drivers/scsi/scsi_debug.cif ((*cmd) == WRITE_10)
cmd349drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
cmd351drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
cmd370drivers/scsi/scsi_debug.cprintk("Unknown command %d\n",*cmd);
cmd91drivers/scsi/scsi_ioctl.cstatic int ioctl_internal_command(Scsi_Device *dev, char * cmd)
cmd97drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd, NULL,  0,
cmd112drivers/scsi/scsi_ioctl.cif(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0;
cmd149drivers/scsi/scsi_ioctl.cchar cmd[12];
cmd176drivers/scsi/scsi_ioctl.cmemcpy_fromfs ((void *) cmd,  cmd_in,  cmdlen = COMMAND_SIZE (opcode));
cmd179drivers/scsi/scsi_ioctl.ccmd[1] = ( cmd[1] & 0x1f ) | (dev->lun << 5);
cmd185drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd,  buf, needed,  scsi_ioctl_done,  MAX_TIMEOUT, 
cmd224drivers/scsi/scsi_ioctl.cprintk("%02x ", cmd[i]);
cmd242drivers/scsi/scsi_ioctl.cint scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
cmd249drivers/scsi/scsi_ioctl.cswitch (cmd) {
cmd305drivers/scsi/scsi_ioctl.cint kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) {
cmd310drivers/scsi/scsi_ioctl.ctmp = scsi_ioctl (dev, cmd, arg);
cmd17drivers/scsi/scsi_ioctl.hextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd18drivers/scsi/scsi_ioctl.hextern int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd211drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
cmd223drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
cmd428drivers/scsi/sd.cunsigned char cmd[10];
cmd492drivers/scsi/sd.cswitch (SCpnt->request.cmd)
cmd500drivers/scsi/sd.ccmd[0] = WRITE_6;
cmd503drivers/scsi/sd.ccmd[0] = READ_6;
cmd506drivers/scsi/sd.cpanic ("Unknown sd command %d\n", SCpnt->request.cmd);
cmd710drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
cmd732drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
cmd738drivers/scsi/sd.c(SCpnt->request.cmd == WRITE) ? "writing" : "reading",
cmd742drivers/scsi/sd.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
cmd761drivers/scsi/sd.ccmd[0] += READ_10 - READ_6 ;
cmd762drivers/scsi/sd.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
cmd763drivers/scsi/sd.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
cmd764drivers/scsi/sd.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
cmd765drivers/scsi/sd.ccmd[5] = (unsigned char) block & 0xff;
cmd766drivers/scsi/sd.ccmd[6] = cmd[9] = 0;
cmd767drivers/scsi/sd.ccmd[7] = (unsigned char) (this_count >> 8) & 0xff;
cmd768drivers/scsi/sd.ccmd[8] = (unsigned char) this_count & 0xff;
cmd775drivers/scsi/sd.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
cmd776drivers/scsi/sd.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
cmd777drivers/scsi/sd.ccmd[3] = (unsigned char) block & 0xff;
cmd778drivers/scsi/sd.ccmd[4] = (unsigned char) this_count;
cmd779drivers/scsi/sd.ccmd[5] = 0;
cmd790drivers/scsi/sd.cscsi_do_cmd (SCpnt, (void *) cmd, buff, 
cmd846drivers/scsi/sd.cunsigned char cmd[10];
cmd864drivers/scsi/sd.ccmd[0] = TEST_UNIT_READY;
cmd865drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd866drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd873drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd888drivers/scsi/sd.ccmd[0] = START_STOP;
cmd889drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd890drivers/scsi/sd.ccmd[1] |= 1;  /* Return immediately */
cmd891drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd892drivers/scsi/sd.ccmd[4] = 1; /* Start spin cycle */
cmd899drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd924drivers/scsi/sd.ccmd[0] = READ_CAPACITY;
cmd925drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd926drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd934drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd18drivers/scsi/sd_ioctl.cint sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
cmd26drivers/scsi/sd_ioctl.cswitch (cmd) {
cmd73drivers/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg);
cmd1597drivers/scsi/seagate.cunsigned char buf[256 + sizeof(int) * 2], cmd[6], *data, *page;
cmd1612drivers/scsi/seagate.ccmd[0] = MODE_SENSE;
cmd1613drivers/scsi/seagate.ccmd[1] = (disk->device->lun << 5) & 0xe5;
cmd1614drivers/scsi/seagate.ccmd[2] = 0x04; /* Read page 4, rigid disk geometry page current values */
cmd1615drivers/scsi/seagate.ccmd[3] = 0;
cmd1616drivers/scsi/seagate.ccmd[4] = 255;
cmd1617drivers/scsi/seagate.ccmd[5] = 0;
cmd1627drivers/scsi/seagate.cmemcpy (data, cmd, 6);
cmd1639drivers/scsi/seagate.ccmd[2] = 0x03; /* Read page 3, format page current values */
cmd1640drivers/scsi/seagate.cmemcpy (data, cmd, 6);
cmd305drivers/scsi/sr.cunsigned char   *cmd;       /* the scsi-command */
cmd322drivers/scsi/sr.ccmd = rec = &buf[8];
cmd332drivers/scsi/sr.ccmd[0] = 0xde;
cmd333drivers/scsi/sr.ccmd[1] = 0x03;
cmd334drivers/scsi/sr.ccmd[2] = 0xb0;
cmd367drivers/scsi/sr.ccmd[0] = 0xc7;
cmd368drivers/scsi/sr.ccmd[1] = 3;
cmd396drivers/scsi/sr.ccmd[0] = 0x1a;
cmd397drivers/scsi/sr.ccmd[2] = 1;
cmd398drivers/scsi/sr.ccmd[4] = 12;
cmd417drivers/scsi/sr.ccmd[0] = 0x15;
cmd418drivers/scsi/sr.ccmd[1] = (1 << 4);
cmd419drivers/scsi/sr.ccmd[4] = 12;
cmd420drivers/scsi/sr.csend = &cmd[6];                 /* this is a 6-Byte command          */
cmd547drivers/scsi/sr.cunsigned char cmd[10], *buffer, tries;
cmd590drivers/scsi/sr.cswitch (SCpnt->request.cmd)
cmd597drivers/scsi/sr.ccmd[0] = READ_6;
cmd600drivers/scsi/sr.cpanic ("Unknown sr command %d\n", SCpnt->request.cmd);
cmd603drivers/scsi/sr.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
cmd777drivers/scsi/sr.ccmd[0] += READ_10 - READ_6 ;
cmd778drivers/scsi/sr.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
cmd779drivers/scsi/sr.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
cmd780drivers/scsi/sr.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
cmd781drivers/scsi/sr.ccmd[5] = (unsigned char) block & 0xff;
cmd782drivers/scsi/sr.ccmd[6] = cmd[9] = 0;
cmd783drivers/scsi/sr.ccmd[7] = (unsigned char) (realcount >> 8) & 0xff;
cmd784drivers/scsi/sr.ccmd[8] = (unsigned char) realcount & 0xff;
cmd794drivers/scsi/sr.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
cmd795drivers/scsi/sr.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
cmd796drivers/scsi/sr.ccmd[3] = (unsigned char) block & 0xff;
cmd797drivers/scsi/sr.ccmd[4] = (unsigned char) realcount;
cmd798drivers/scsi/sr.ccmd[5] = 0;
cmd807drivers/scsi/sr.cfor(i=0; i<12; i++) printk("%2.2x ", cmd[i]);
cmd826drivers/scsi/sr.cscsi_do_cmd (SCpnt, (void *) cmd, buffer, 
cmd881drivers/scsi/sr.cunsigned char cmd[10];
cmd891drivers/scsi/sr.ccmd[0] = READ_CAPACITY;
cmd892drivers/scsi/sr.ccmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
cmd893drivers/scsi/sr.cmemset ((void *) &cmd[2], 0, 8);
cmd900drivers/scsi/sr.c(void *) cmd, (void *) buffer,
cmd20drivers/scsi/sr_ioctl.cextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd92drivers/scsi/sr_ioctl.cint sr_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
cmd104drivers/scsi/sr_ioctl.cswitch (cmd) 
cmd429drivers/scsi/sr_ioctl.creturn scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
cmd240drivers/scsi/st.cunsigned char cmd[10];
cmd242drivers/scsi/st.ccmd[0] = SPACE;
cmd243drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd244drivers/scsi/st.ccmd[2] = cmd[3] = cmd[4] = 0xff;  /* -1 filemarks */
cmd245drivers/scsi/st.ccmd[5] = 0;
cmd251drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data, 0,
cmd273drivers/scsi/st.cunsigned char cmd[10];
cmd305drivers/scsi/st.cmemset(cmd, 0, 10);
cmd306drivers/scsi/st.ccmd[0] = WRITE_6;
cmd307drivers/scsi/st.ccmd[1] = 1;
cmd309drivers/scsi/st.ccmd[2] = blks >> 16;
cmd310drivers/scsi/st.ccmd[3] = blks >> 8;
cmd311drivers/scsi/st.ccmd[4] = blks;
cmd314drivers/scsi/st.c(void *) cmd, (STp->buffer)->b_data, transfer,
cmd397drivers/scsi/st.cunsigned char cmd[10];
cmd441drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd442drivers/scsi/st.ccmd[0] = TEST_UNIT_READY;
cmd445drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data,
cmd455drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd456drivers/scsi/st.ccmd[0] = TEST_UNIT_READY;
cmd459drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data,
cmd491drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd492drivers/scsi/st.ccmd[0] = READ_BLOCK_LIMITS;
cmd495drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data,
cmd520drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd521drivers/scsi/st.ccmd[0] = MODE_SENSE;
cmd522drivers/scsi/st.ccmd[4] = 12;
cmd525drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data,
cmd612drivers/scsi/st.cstatic unsigned char cmd[10];
cmd634drivers/scsi/st.cmemset(cmd, 0, 10);
cmd635drivers/scsi/st.ccmd[0] = WRITE_FILEMARKS;
cmd636drivers/scsi/st.ccmd[4] = 1 + STp->two_fm;
cmd639drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data,
cmd661drivers/scsi/st.cprintk("st%d: Buffer flushed, %d EOF(s) written\n", dev, cmd[4]);
cmd695drivers/scsi/st.cstatic unsigned char cmd[10];
cmd764drivers/scsi/st.cmemset(cmd, 0, 10);
cmd765drivers/scsi/st.ccmd[0] = WRITE_6;
cmd766drivers/scsi/st.ccmd[1] = (STp->block_size != 0);
cmd793drivers/scsi/st.ccmd[2] = blks >> 16;
cmd794drivers/scsi/st.ccmd[3] = blks >> 8;
cmd795drivers/scsi/st.ccmd[4] = blks;
cmd799drivers/scsi/st.c(void *) cmd, (STp->buffer)->b_data, transfer,
cmd904drivers/scsi/st.ccmd[2] = blks >> 16;
cmd905drivers/scsi/st.ccmd[3] = blks >> 8;
cmd906drivers/scsi/st.ccmd[4] = blks;
cmd911drivers/scsi/st.c(void *) cmd, (STp->buffer)->b_data,
cmd930drivers/scsi/st.cstatic unsigned char cmd[10];
cmd979drivers/scsi/st.cmemset(cmd, 0, 10);
cmd980drivers/scsi/st.ccmd[0] = READ_6;
cmd981drivers/scsi/st.ccmd[1] = (STp->block_size != 0);
cmd997drivers/scsi/st.ccmd[2] = blks >> 16;
cmd998drivers/scsi/st.ccmd[3] = blks >> 8;
cmd999drivers/scsi/st.ccmd[4] = blks;
cmd1004drivers/scsi/st.c(void *) cmd, (STp->buffer)->b_data,
cmd1217drivers/scsi/st.cunsigned char cmd[10];
cmd1230drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1235drivers/scsi/st.ccmd[0] = SPACE;
cmd1236drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd1237drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1238drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1239drivers/scsi/st.ccmd[4] = arg;
cmd1243drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1252drivers/scsi/st.ccmd[0] = SPACE;
cmd1253drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd1255drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1256drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1257drivers/scsi/st.ccmd[4] = ltmp;
cmd1260drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1262drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1272drivers/scsi/st.ccmd[0] = SPACE;
cmd1273drivers/scsi/st.ccmd[1] = 0x00; /* Space Blocks */
cmd1274drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1275drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1276drivers/scsi/st.ccmd[4] = arg;
cmd1280drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1287drivers/scsi/st.ccmd[0] = SPACE;
cmd1288drivers/scsi/st.ccmd[1] = 0x00; /* Space Blocks */
cmd1290drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1291drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1292drivers/scsi/st.ccmd[4] = ltmp;
cmd1295drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1297drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1306drivers/scsi/st.ccmd[0] = SPACE;
cmd1307drivers/scsi/st.ccmd[1] = 0x04; /* Space Setmarks */
cmd1308drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1309drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1310drivers/scsi/st.ccmd[4] = arg;
cmd1314drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1322drivers/scsi/st.ccmd[0] = SPACE;
cmd1323drivers/scsi/st.ccmd[1] = 0x04; /* Space Setmarks */
cmd1325drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1326drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1327drivers/scsi/st.ccmd[4] = ltmp;
cmd1330drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1332drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1345drivers/scsi/st.ccmd[0] = WRITE_FILEMARKS;
cmd1347drivers/scsi/st.ccmd[1] = 2;
cmd1348drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1349drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1350drivers/scsi/st.ccmd[4] = arg;
cmd1356drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1359drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1368drivers/scsi/st.ccmd[0] = REZERO_UNIT;
cmd1370drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1380drivers/scsi/st.ccmd[0] = START_STOP;
cmd1382drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1399drivers/scsi/st.ccmd[0] = START_STOP;
cmd1401drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1404drivers/scsi/st.ccmd[4] = 3;
cmd1425drivers/scsi/st.ccmd[0] = SPACE;
cmd1426drivers/scsi/st.ccmd[1] = 3;
cmd1437drivers/scsi/st.ccmd[0] = ERASE;
cmd1438drivers/scsi/st.ccmd[1] = 1;  /* To the end of tape */
cmd1440drivers/scsi/st.ccmd[1] |= 2;  /* Don't wait for completion */
cmd1453drivers/scsi/st.ccmd[0] = QFA_SEEK_BLOCK;
cmd1454drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1455drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1456drivers/scsi/st.ccmd[4] = arg;
cmd1457drivers/scsi/st.ccmd[5] = 0;
cmd1460drivers/scsi/st.ccmd[0] = SEEK_10;
cmd1461drivers/scsi/st.ccmd[1] = 4;
cmd1462drivers/scsi/st.ccmd[3] = (arg >> 24);
cmd1463drivers/scsi/st.ccmd[4] = (arg >> 16);
cmd1464drivers/scsi/st.ccmd[5] = (arg >> 8);
cmd1465drivers/scsi/st.ccmd[6] = arg;
cmd1468drivers/scsi/st.ccmd[1] |= 1;  /* Don't wait for completion */
cmd1490drivers/scsi/st.ccmd[0] = MODE_SELECT;
cmd1491drivers/scsi/st.ccmd[4] = datalen = 12;
cmd1537drivers/scsi/st.c(void *) cmd, (void *) (STp->buffer)->b_data, datalen,
cmd1659drivers/scsi/st.cint i, cmd, result;
cmd1675drivers/scsi/st.ccmd = cmd_in & IOCCMD_MASK;
cmd1676drivers/scsi/st.cif (cmd == (MTIOCTOP & IOCCMD_MASK)) {
cmd1703drivers/scsi/st.celse if (cmd == (MTIOCGET & IOCCMD_MASK)) {
cmd1756drivers/scsi/st.celse if (cmd == (MTIOCPOS & IOCCMD_MASK)) {
cmd567drivers/scsi/wd7000.cstatic inline int command_out(Adapter *host, unchar *cmd, int len)
cmd572drivers/scsi/wd7000.coutb(*cmd, host->iobase+ASC_COMMAND);
cmd575drivers/scsi/wd7000.ccmd++;
cmd90drivers/sound/ad1848.cstatic int      ad1848_ioctl (int dev, unsigned int cmd, unsigned int arg, int local);
cmd409drivers/sound/ad1848.cad1848_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd413drivers/sound/ad1848.cswitch (cmd)
cmd322drivers/sound/audio.cunsigned int cmd, unsigned int arg)
cmd327drivers/sound/audio.cswitch (cmd)
cmd336drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd351drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd362drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd405drivers/sound/audio.cunsigned int cmd, unsigned int arg)
cmd124drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, unsigned int arg, int local);
cmd139drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, unsigned int arg);
cmd150drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, unsigned int arg);
cmd178drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, unsigned int arg);
cmd196drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, unsigned int arg);
cmd391drivers/sound/dmabuf.cDMAbuf_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd395drivers/sound/dmabuf.cswitch (cmd)
cmd482drivers/sound/dmabuf.creturn audio_devs[dev]->ioctl (dev, cmd, arg, local);
cmd915drivers/sound/dmabuf.cDMAbuf_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd195drivers/sound/gus_midi.cgus_midi_ioctl (int dev, unsigned cmd, unsigned arg)
cmd840drivers/sound/gus_wave.cunsigned int cmd, unsigned int arg)
cmd843drivers/sound/gus_wave.cswitch (cmd)
cmd1723drivers/sound/gus_wave.cint             voice, cmd;
cmd1727drivers/sound/gus_wave.ccmd = event[2];
cmd1734drivers/sound/gus_wave.c(cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS))
cmd1737drivers/sound/gus_wave.cswitch (cmd)
cmd1907drivers/sound/gus_wave.cgus_sampling_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd1909drivers/sound/gus_wave.cswitch (cmd)
cmd2703drivers/sound/gus_wave.cgus_default_mixer_ioctl (int dev, unsigned int cmd, unsigned int arg)
cmd2707drivers/sound/gus_wave.cif (((cmd >> 8) & 0xff) == 'M')
cmd2709drivers/sound/gus_wave.cif (cmd & IOC_IN)
cmd2710drivers/sound/gus_wave.cswitch (cmd & 0xff)
cmd2781drivers/sound/gus_wave.cswitch (cmd & 0xff)  /*
cmd135drivers/sound/ics2101.cics2101_mixer_ioctl (int dev, unsigned int cmd, unsigned int arg)
cmd137drivers/sound/ics2101.cif (((cmd >> 8) & 0xff) == 'M')
cmd139drivers/sound/ics2101.cif (cmd & IOC_IN)
cmd140drivers/sound/ics2101.cswitch (cmd & 0xff)
cmd143drivers/sound/ics2101.creturn gus_default_mixer_ioctl (dev, cmd, arg);
cmd170drivers/sound/ics2101.cswitch (cmd & 0xff)  /*
cmd176drivers/sound/ics2101.creturn gus_default_mixer_ioctl (dev, cmd, arg);
cmd103drivers/sound/midi_synth.cunsigned int cmd, unsigned int arg)
cmd109drivers/sound/midi_synth.cswitch (cmd)
cmd2drivers/sound/midi_synth.hunsigned int cmd, unsigned int arg);
cmd376drivers/sound/midibuf.cunsigned int cmd, unsigned int arg)
cmd382drivers/sound/midibuf.cswitch (cmd)
cmd396drivers/sound/midibuf.creturn midi_devs[dev]->ioctl (dev, cmd, arg);
cmd88drivers/sound/mpu401.c#define write_command(base, cmd)    OUTB(cmd, COMDPORT(base))
cmd144drivers/sound/mpu401.c#define STORE(cmd) \
cmd149drivers/sound/mpu401.ccmd; \
cmd608drivers/sound/mpu401.cmpu401_command (int dev, mpu_command_rec * cmd)
cmd641drivers/sound/mpu401.cprintk ("MPU-401: Command (0x%x) timeout\n", (int) cmd->cmd);
cmd646drivers/sound/mpu401.cwrite_command (devc->base, cmd->cmd);
cmd656drivers/sound/mpu401.cprintk ("MPU: No ACK to command (0x%x)\n", (int) cmd->cmd);
cmd660drivers/sound/mpu401.cif (cmd->nr_args)
cmd661drivers/sound/mpu401.cfor (i = 0; i < cmd->nr_args; i++)
cmd665drivers/sound/mpu401.cif (!mpu401_out (dev, cmd->data[i]))
cmd668drivers/sound/mpu401.cprintk ("MPU: Command (0x%x), parm send failed.\n", (int) cmd->cmd);
cmd674drivers/sound/mpu401.ccmd->data[0] = 0;
cmd676drivers/sound/mpu401.cif (cmd->nr_returns)
cmd677drivers/sound/mpu401.cfor (i = 0; i < cmd->nr_returns; i++)
cmd683drivers/sound/mpu401.ccmd->data[i] = read_data (devc->base);
cmd690drivers/sound/mpu401.cprintk ("MPU: No response(%d) to command (0x%x)\n", i, (int) cmd->cmd);
cmd701drivers/sound/mpu401.cexec_cmd (int dev, int cmd, int data)
cmd707drivers/sound/mpu401.crec.cmd = cmd & 0xff;
cmd708drivers/sound/mpu401.crec.nr_args = ((cmd & 0xf0) == 0xE0);
cmd709drivers/sound/mpu401.crec.nr_returns = ((cmd & 0xf0) == 0xA0);
cmd762drivers/sound/mpu401.cmpu401_ioctl (int dev, unsigned cmd, unsigned arg)
cmd768drivers/sound/mpu401.cswitch (cmd)
cmd820drivers/sound/mpu401.cunsigned int cmd, unsigned int arg)
cmd832drivers/sound/mpu401.cswitch (cmd)
cmd133drivers/sound/opl3.cunsigned int cmd, unsigned int arg)
cmd135drivers/sound/opl3.cswitch (cmd)
cmd217drivers/sound/pas2_midi.cpas_midi_ioctl (int dev, unsigned cmd, unsigned arg)
cmd306drivers/sound/pas2_mixer.cpas_mixer_ioctl (int dev, unsigned int cmd, unsigned int arg)
cmd308drivers/sound/pas2_mixer.cTRACE (printk ("pas2_mixer.c: int pas_mixer_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
cmd310drivers/sound/pas2_mixer.cif (((cmd >> 8) & 0xff) == 'M')
cmd312drivers/sound/pas2_mixer.cif (cmd & IOC_IN)
cmd313drivers/sound/pas2_mixer.creturn IOCTL_OUT (arg, pas_mixer_set (cmd & 0xff, IOCTL_IN (arg)));
cmd319drivers/sound/pas2_mixer.cswitch (cmd & 0xff)
cmd363drivers/sound/pas2_mixer.creturn IOCTL_OUT (arg, levels[cmd & 0xff]);
cmd156drivers/sound/pas2_pcm.cpas_pcm_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd158drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static int pas_pcm_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
cmd160drivers/sound/pas2_pcm.cswitch (cmd)
cmd844drivers/sound/pss.cunsigned int cmd, unsigned int arg)
cmd846drivers/sound/pss.cDEB (printk ("pss_ioctl dev=%d cmd=%x\n", dev, cmd));
cmd852drivers/sound/pss.cswitch (cmd)
cmd73drivers/sound/sb16_dsp.cstatic int      sb16_dsp_ioctl (int dev, unsigned int cmd, unsigned int arg, int local);
cmd159drivers/sound/sb16_dsp.csb16_dsp_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd161drivers/sound/sb16_dsp.cswitch (cmd)
cmd45drivers/sound/sb16_midi.c#define sb16midi_cmd(cmd)    OUTB(cmd, COMDPORT)
cmd157drivers/sound/sb16_midi.csb16midi_ioctl (int dev, unsigned cmd, unsigned arg)
cmd647drivers/sound/sb_dsp.csb_dsp_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
cmd649drivers/sound/sb_dsp.cswitch (cmd)
cmd192drivers/sound/sb_midi.csb_midi_ioctl (int dev, unsigned cmd, unsigned arg)
cmd328drivers/sound/sb_mixer.csb_mixer_ioctl (int dev, unsigned int cmd, unsigned int arg)
cmd330drivers/sound/sb_mixer.cif (((cmd >> 8) & 0xff) == 'M')
cmd332drivers/sound/sb_mixer.cif (cmd & IOC_IN)
cmd333drivers/sound/sb_mixer.cswitch (cmd & 0xff)
cmd340drivers/sound/sb_mixer.creturn IOCTL_OUT (arg, sb_mixer_set (cmd & 0xff, IOCTL_IN (arg)));
cmd343drivers/sound/sb_mixer.cswitch (cmd & 0xff)  /*
cmd370drivers/sound/sb_mixer.creturn IOCTL_OUT (arg, sb_mixer_get (cmd & 0xff));
cmd472drivers/sound/sequencer.cunsigned char   cmd = event[2];
cmd490drivers/sound/sequencer.cif (cmd == MIDI_NOTEON && parm == 0)
cmd492drivers/sound/sequencer.ccmd = MIDI_NOTEOFF;
cmd497drivers/sound/sequencer.cswitch (cmd)
cmd538drivers/sound/sequencer.cunsigned char   cmd = event[2];
cmd552drivers/sound/sequencer.cswitch (cmd)
cmd617drivers/sound/sequencer.cunsigned char   cmd = event[1];
cmd641drivers/sound/sequencer.cswitch (cmd)
cmd1326drivers/sound/sequencer.cunsigned int cmd, unsigned int arg)
cmd1333drivers/sound/sequencer.cswitch (cmd)
cmd1347drivers/sound/sequencer.creturn tmr->ioctl (tmr_no, cmd, arg);
cmd1449drivers/sound/sequencer.creturn tmr->ioctl (tmr_no, cmd, arg);
cmd1468drivers/sound/sequencer.creturn synth_devs[dev]->ioctl (dev, cmd, arg);
cmd1489drivers/sound/sequencer.creturn IOCTL_OUT (arg, synth_devs[dev]->ioctl (dev, cmd, arg));
cmd1503drivers/sound/sequencer.csynth_devs[dev]->ioctl (dev, cmd, arg);
cmd1522drivers/sound/sequencer.creturn synth_devs[dev]->ioctl (dev, cmd, arg);
cmd1654drivers/sound/sequencer.creturn synth_devs[0]->ioctl (0, cmd, arg);
cmd1838drivers/sound/sequencer.cunsigned int cmd, unsigned int arg)
cmd11drivers/sound/sound_calls.hint DMAbuf_ioctl(int dev, unsigned int cmd, unsigned int arg, int local);
cmd29drivers/sound/sound_calls.hunsigned int cmd, unsigned int arg);
cmd42drivers/sound/sound_calls.hunsigned int cmd, unsigned int arg);
cmd64drivers/sound/sound_calls.hunsigned int cmd, unsigned int arg);
cmd114drivers/sound/sound_calls.hunsigned int cmd, unsigned long arg);
cmd192drivers/sound/sound_calls.hint gus_default_mixer_ioctl (int dev, unsigned int cmd, unsigned int arg);
cmd241drivers/sound/sound_calls.hunsigned int cmd, unsigned int arg);
cmd471drivers/sound/sound_switch.cunsigned int cmd, unsigned long arg)
cmd473drivers/sound/sound_switch.cDEB (printk ("sound_ioctl_sw(dev=%d, cmd=0x%x, arg=0x%x)\n", dev, cmd, arg));
cmd476drivers/sound/sound_switch.cif ((cmd >> 8) & 0xff == 'M')  /*
cmd479drivers/sound/sound_switch.creturn mixer_devs[0]->ioctl (0, cmd, arg);
cmd494drivers/sound/sound_switch.creturn mixer_devs[dev]->ioctl (dev, cmd, arg);
cmd499drivers/sound/sound_switch.creturn sequencer_ioctl (dev, file, cmd, arg);
cmd505drivers/sound/sound_switch.creturn audio_ioctl (dev, file, cmd, arg);
cmd510drivers/sound/sound_switch.creturn MIDIbuf_ioctl (dev, file, cmd, arg);
cmd516drivers/sound/sound_switch.creturn pss_ioctl (dev, file, cmd, arg);
cmd175drivers/sound/sound_timer.cunsigned char   cmd = event[1];
cmd178drivers/sound/sound_timer.cswitch (cmd)
cmd248drivers/sound/sound_timer.cunsigned int cmd, unsigned int arg)
cmd250drivers/sound/sound_timer.cswitch (cmd)
cmd127drivers/sound/soundcard.cunsigned int cmd, unsigned long arg)
cmd134drivers/sound/soundcard.creturn sound_ioctl_sw (dev, &files[dev], cmd, arg);
cmd129drivers/sound/sys_timer.cunsigned char   cmd = event[1];
cmd132drivers/sound/sys_timer.cswitch (cmd)
cmd199drivers/sound/sys_timer.cunsigned int cmd, unsigned int arg)
cmd201drivers/sound/sys_timer.cswitch (cmd)
cmd48drivers/sound/uart6850.c#define uart6850_cmd(cmd)  OUTB(cmd, COMDPORT)
cmd220drivers/sound/uart6850.cuart6850_ioctl (int dev, unsigned cmd, unsigned arg)
cmd18fs/ext2/ioctl.cint ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
cmd24fs/ext2/ioctl.cext2_debug ("cmd = %u, arg = %lu\n", cmd, arg);
cmd26fs/ext2/ioctl.cswitch (cmd) {
cmd18fs/fcntl.cextern int sock_fcntl (struct file *, unsigned int cmd, unsigned long arg);
cmd66fs/fcntl.casmlinkage int 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);
cmd88fs/locks.cint fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l)
cmd143fs/locks.cif (cmd == F_SETLKW) {
cmd135fs/pipe.cunsigned int cmd, unsigned long arg)
cmd139fs/pipe.cswitch (cmd) {
cmd29fs/umsdos/ioctl.cunsigned int cmd,
cmd38fs/umsdos/ioctl.c|| cmd == UMSDOS_GETVERSION){
cmd60fs/umsdos/ioctl.cPRINTK (("ioctl %d ",cmd));
cmd61fs/umsdos/ioctl.cif (cmd == UMSDOS_GETVERSION){
cmd75fs/umsdos/ioctl.c}else if (cmd == UMSDOS_READDIR_DOS){
cmd84fs/umsdos/ioctl.c}else if (cmd == UMSDOS_READDIR_EMD){
cmd127fs/umsdos/ioctl.c}else if (cmd == UMSDOS_INIT_EMD){
cmd150fs/umsdos/ioctl.cif (cmd == UMSDOS_CREAT_EMD){
cmd167fs/umsdos/ioctl.c}else if (cmd == UMSDOS_RENAME_DOS){
cmd182fs/umsdos/ioctl.c}else if (cmd == UMSDOS_UNLINK_EMD){
cmd200fs/umsdos/ioctl.c}else if (cmd == UMSDOS_UNLINK_DOS){
cmd211fs/umsdos/ioctl.c}else if (cmd == UMSDOS_RMDIR_DOS){
cmd222fs/umsdos/ioctl.c}else if (cmd == UMSDOS_STAT_DOS){
cmd246fs/umsdos/ioctl.c}else if (cmd == UMSDOS_DOS_SETUP){
cmd16include/linux/blkdev.hint cmd;    /* READ or WRITE */
cmd231include/linux/fd.hunsigned char cmd[9];
cmd32include/linux/ioctl.h#define IOC_SIZE(cmd)  (((cmd) & IOCSIZE_MASK) >> IOCSIZE_SHIFT)
cmd33include/linux/ioctl.h#define IOCBASECMD(cmd)  ((cmd) & ~IOCPARM_MASK)
cmd34include/linux/ioctl.h#define IOCGROUP(cmd)  (((cmd) >> 8) & 0xFF)
cmd109include/linux/net.hint  (*ioctl)  (struct socket *sock, unsigned int cmd,
cmd125include/linux/net.hint  (*fcntl)  (struct socket *sock, unsigned int cmd,
cmd159include/linux/netdevice.hint        (*do_ioctl)(struct device *dev, struct ifreq *ifr, int cmd);
cmd213include/linux/netdevice.hextern int    dev_ioctl(unsigned int cmd, void *);
cmd522include/linux/soundcard.hunsigned char cmd;
cmd311include/linux/tty.hunsigned int cmd, unsigned long arg);
cmd329include/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;\
cmd115include/linux/xd.hstatic int xd_ioctl (struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg);
cmd319ipc/msg.cint 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.cint 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.cint 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) {
cmd25ipc/util.cextern int sys_semctl (int semid, int semnum, int cmd, union semun arg);
cmd30ipc/util.cextern int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf);
cmd34ipc/util.cextern int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf);
cmd378net/inet/af_inet.cstatic int inet_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd384net/inet/af_inet.cswitch(cmd) 
cmd1228net/inet/af_inet.cstatic int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1233net/inet/af_inet.cswitch(cmd) 
cmd1259net/inet/af_inet.creturn(ip_rt_ioctl(cmd,(void *) arg));
cmd1263net/inet/af_inet.creturn(arp_ioctl(cmd,(void *) arg));
cmd1268net/inet/af_inet.creturn(rarp_ioctl(cmd,(void *) arg));
cmd1301net/inet/af_inet.creturn(dev_ioctl(cmd,(void *) arg));
cmd1304net/inet/af_inet.cif ((cmd >= SIOCDEVPRIVATE) &&
cmd1305net/inet/af_inet.c(cmd <= (SIOCDEVPRIVATE + 15)))
cmd1306net/inet/af_inet.creturn(dev_ioctl(cmd,(void *) arg));
cmd1310net/inet/af_inet.creturn(sk->prot->ioctl(sk, cmd, arg));
cmd1211net/inet/arp.cint arp_ioctl(unsigned int cmd, void *arg)
cmd1217net/inet/arp.cswitch(cmd)
cmd13net/inet/arp.hextern int  arp_ioctl(unsigned int cmd, void *arg);
cmd1337net/inet/dev.cint dev_ioctl(unsigned int cmd, void *arg)
cmd1339net/inet/dev.cswitch(cmd) 
cmd1362net/inet/dev.creturn dev_ifsioc(arg, cmd);
cmd1382net/inet/dev.creturn dev_ifsioc(arg, cmd);
cmd1392net/inet/dev.cif((cmd >= SIOCDEVPRIVATE) &&
cmd1393net/inet/dev.c(cmd <= (SIOCDEVPRIVATE + 15))) {
cmd1394net/inet/dev.creturn dev_ifsioc(arg, cmd);
cmd766net/inet/icmp.cint icmp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd768net/inet/icmp.cswitch(cmd) 
cmd35net/inet/icmp.hextern int  icmp_ioctl(struct sock *sk, int cmd,
cmd144net/inet/ip.cint ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd146net/inet/ip.cswitch(cmd)
cmd77net/inet/ip.hextern int    ip_ioctl(struct sock *sk, int cmd,
cmd796net/inet/ipx.cipxitf_ioctl(unsigned int cmd, void *arg)
cmd799net/inet/ipx.cswitch(cmd)
cmd1034net/inet/ipx.cstatic int ipxrtr_ioctl(unsigned int cmd, void *arg)
cmd1056net/inet/ipx.cswitch(cmd)
cmd1237net/inet/ipx.cstatic int ipx_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1239net/inet/ipx.cswitch(cmd)
cmd1774net/inet/ipx.cstatic int ipx_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
cmd1780net/inet/ipx.cswitch(cmd)
cmd1805net/inet/ipx.creturn(ipxrtr_ioctl(cmd,(void *)arg));
cmd1812net/inet/ipx.creturn(ipxitf_ioctl(cmd,(void *)arg));
cmd1840net/inet/ipx.creturn(dev_ioctl(cmd,(void *) arg));
cmd386net/inet/rarp.cint rarp_ioctl(unsigned int cmd, void *arg)
cmd392net/inet/rarp.cswitch(cmd)
cmd5net/inet/rarp.hextern int rarp_ioctl(unsigned int cmd, void *arg);
cmd643net/inet/route.cint ip_rt_ioctl(unsigned int cmd, void *arg)
cmd648net/inet/route.cswitch(cmd) 
cmd657net/inet/route.creturn (cmd == SIOCDELRTOLD) ? rt_kill(&rt) : rt_new(&rt);
cmd667net/inet/route.creturn (cmd == SIOCDELRT) ? rt_kill(&rt) : rt_new(&rt);
cmd51net/inet/route.hextern int    ip_rt_ioctl(unsigned int cmd, void *arg);
cmd246net/inet/sock.hint      (*ioctl)(struct sock *sk, int cmd,
cmd956net/inet/tcp.cint tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd959net/inet/tcp.cswitch(cmd) 
cmd132net/inet/tcp.hextern int  tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd412net/inet/udp.cint udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd415net/inet/udp.cswitch(cmd) 
cmd47net/inet/udp.hextern int  udp_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd76net/socket.cunsigned int cmd, unsigned long arg);
cmd381net/socket.cint sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd391net/socket.creturn(sock->ops->ioctl(sock, cmd, arg));
cmd1130net/socket.cint sock_fcntl(struct file *filp, unsigned int cmd, unsigned long arg)
cmd1136net/socket.creturn(sock->ops->fcntl(sock, cmd, arg));
cmd77net/unix/sock.cstatic int unix_proto_ioctl(struct socket *sock, unsigned int cmd,
cmd830net/unix/sock.cstatic int unix_proto_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd838net/unix/sock.cswitch(cmd)