taglinefilesource code
cmd117arch/alpha/kernel/bios32.cunsigned short cmd;
cmd120arch/alpha/kernel/bios32.cpcibios_read_config_word(bus->number, dev->devfn, PCI_COMMAND, &cmd);
cmd123arch/alpha/kernel/bios32.ccmd &= (~PCI_COMMAND_IO & ~PCI_COMMAND_MEMORY & ~PCI_COMMAND_MASTER);
cmd124arch/alpha/kernel/bios32.cpcibios_write_config_word(bus->number, dev->devfn, PCI_COMMAND, cmd);
cmd136arch/alpha/kernel/bios32.cunsigned short cmd;
cmd141arch/alpha/kernel/bios32.cpcibios_read_config_word(bus->number, dev->devfn, PCI_COMMAND, &cmd);
cmd164arch/alpha/kernel/bios32.ccmd |= PCI_COMMAND_IO;
cmd180arch/alpha/kernel/bios32.ccmd |= PCI_COMMAND_MEMORY;
cmd269arch/alpha/kernel/bios32.ccmd |= PCI_COMMAND_IO;
cmd273arch/alpha/kernel/bios32.ccmd | PCI_COMMAND_MASTER);
cmd374arch/alpha/kernel/lca.cunsigned cmd  = (stat0 & IOC_CMD)  >> IOC_CMD_SHIFT;
cmd377arch/alpha/kernel/lca.ccode > 3 ? "PCI" : "CPU", pci_cmd[cmd], stat1, err_name[code]);
cmd1020arch/m68k/amiga/amifb.cstatic int amiga_fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd2688arch/m68k/amiga/amifb.cstatic int mono_amiga_fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd4587arch/m68k/amiga/amifb.cu_int cmd, u_long arg, int con)
cmd4594arch/m68k/amiga/amifb.cswitch (cmd) {
cmd2688arch/m68k/atari/atafb.catari_fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd2693arch/m68k/atari/atafb.cswitch (cmd) {
cmd327arch/m68k/atari/ataints.cextern void atari_microwire_cmd( int cmd );
cmd540arch/m68k/atari/atakeyb.cstatic const char cmd[2] = { 0x80, 0x01 };
cmd542arch/m68k/atari/atakeyb.cikbd_write(cmd, 2);
cmd551arch/m68k/atari/atakeyb.cchar cmd[2] = { 0x07, mode };
cmd553arch/m68k/atari/atakeyb.cikbd_write(cmd, 2);
cmd559arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x08 };
cmd561arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd567arch/m68k/atari/atakeyb.cchar cmd[5] = { 0x09, xmax>>8, xmax&0xFF, ymax>>8, ymax&0xFF };
cmd569arch/m68k/atari/atakeyb.cikbd_write(cmd, 5);
cmd575arch/m68k/atari/atakeyb.cchar cmd[3] = { 0x0A, dx, dy };
cmd577arch/m68k/atari/atakeyb.cikbd_write(cmd, 3);
cmd583arch/m68k/atari/atakeyb.cchar cmd[3] = { 0x0B, x, y };
cmd585arch/m68k/atari/atakeyb.cikbd_write(cmd, 3);
cmd591arch/m68k/atari/atakeyb.cchar cmd[3] = { 0x0C, x, y };
cmd593arch/m68k/atari/atakeyb.cikbd_write(cmd, 3);
cmd599arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x0D };
cmd601arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd609arch/m68k/atari/atakeyb.cchar cmd[6] = { 0x0E, 0x00, x>>8, x&0xFF, y>>8, y&0xFF };
cmd611arch/m68k/atari/atakeyb.cikbd_write(cmd, 6);
cmd617arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x0F };
cmd619arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd625arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x10 };
cmd627arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd633arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x11 };
cmd635arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd641arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x12 };
cmd643arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd649arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x13 };
cmd651arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd657arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x14 };
cmd659arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd665arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x15 };
cmd667arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd673arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x16 };
cmd675arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd683arch/m68k/atari/atakeyb.cstatic const char cmd[2] = { 0x17, rate };
cmd685arch/m68k/atari/atakeyb.cikbd_write(cmd, 2);
cmd696arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x1A };
cmd698arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd704arch/m68k/atari/atakeyb.cchar cmd[7] = { 0x1B, year, month, day, hour, minute, second };
cmd706arch/m68k/atari/atakeyb.cikbd_write(cmd, 7);
cmd712arch/m68k/atari/atakeyb.cstatic const char cmd[1] = { 0x1C };
cmd714arch/m68k/atari/atakeyb.cikbd_write(cmd, 1);
cmd726arch/m68k/atari/atakeyb.cchar cmd[3] = { 0x21, address>>8, address&0xFF };
cmd728arch/m68k/atari/atakeyb.cikbd_write(cmd, 3);
cmd736arch/m68k/atari/atakeyb.cchar cmd[3] = { 0x22, address>>8, address&0xFF };
cmd738arch/m68k/atari/atakeyb.cikbd_write(cmd, 3);
cmd746arch/m68k/atari/atakeyb.cchar cmd[6] = {32, 0, 4, 1, 254 + ((leds & 4) != 0), 0};
cmd747arch/m68k/atari/atakeyb.cikbd_write(cmd, 6);
cmd53arch/m68k/atari/atasound.cvoid atari_microwire_cmd (int cmd)
cmd56arch/m68k/atari/atasound.ctt_microwire.data = MW_LM1992_ADDR | cmd;
cmd142arch/m68k/fpsp040/fpsp.h.set  CMDREG2B,LV-52    | cmd reg for machine 2
cmd143arch/m68k/fpsp040/fpsp.h.set  CMDREG3B,LV-48    | cmd reg for E3 exceptions (2 bytes)
cmd173arch/m68k/fpsp040/fpsp.h.set  CMDREG1B,LV-36    | cmd reg for E1 exceptions (2 bytes)
cmd51arch/mips/kernel/sysmips.csys_sysmips(int cmd, int arg1, int arg2, int arg3)
cmd57arch/mips/kernel/sysmips.cswitch(cmd)
cmd32arch/sparc/kernel/sunos_ioctl.casmlinkage int sunos_ioctl (int fd, unsigned long cmd, unsigned long arg)
cmd41arch/sparc/kernel/sunos_ioctl.cif(cmd == TIOCSETD) {
cmd50arch/sparc/kernel/sunos_ioctl.cfoo = sys_ioctl(fd, cmd, (int) &ntty);
cmd57arch/sparc/kernel/sunos_ioctl.cif(cmd == TIOCNOTTY)
cmd61arch/sparc/kernel/sunos_ioctl.cswitch (cmd) {
cmd145arch/sparc/kernel/sunos_ioctl.ccmd = TIOCSPGRP;
cmd151arch/sparc/kernel/sunos_ioctl.cfoo = sys_ioctl(fd, cmd, arg);
cmd164arch/sparc/kernel/sunos_ioctl.ccmd = TIOCGPGRP;
cmd170arch/sparc/kernel/sunos_ioctl.cfoo = sys_ioctl(fd, cmd, arg);
cmd182arch/sparc/kernel/sunos_ioctl.cif (cmd & 0xff00 == ('k' << 8)){
cmd183arch/sparc/kernel/sunos_ioctl.cprintk ("[[KBIO: %8.8x\n", (unsigned int) cmd);
cmd187arch/sparc/kernel/sunos_ioctl.cfoo = sys_ioctl(fd, cmd, arg);
cmd1017arch/sparc/kernel/sys_sunos.cextern asmlinkage int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf);
cmd1325drivers/block/amiflop.cswitch (CURRENT->cmd) {
cmd1402drivers/block/amiflop.cunsigned int cmd, unsigned long param)
cmd1408drivers/block/amiflop.cswitch(cmd)
cmd1478drivers/block/amiflop.cprintk("fd_ioctl: unknown cmd %d for drive %d.",cmd,drive);
cmd384drivers/block/ataflop.ccmd, unsigned long param);
cmd1488drivers/block/ataflop.cReqCmd = CURRENT->cmd;
cmd1530drivers/block/ataflop.cunsigned int cmd, unsigned long param)
cmd1544drivers/block/ataflop.cswitch (cmd) {
cmd1550drivers/block/ataflop.cswitch (cmd) {
cmd1581drivers/block/ataflop.cswitch (cmd) {
cmd144drivers/block/floppy.cunsigned char cmd[9];
cmd265drivers/block/floppy.c#define COMMAND raw_cmd->cmd[0]
cmd266drivers/block/floppy.c#define DR_SELECT raw_cmd->cmd[1]
cmd267drivers/block/floppy.c#define TRACK raw_cmd->cmd[2]
cmd268drivers/block/floppy.c#define HEAD raw_cmd->cmd[3]
cmd269drivers/block/floppy.c#define SECTOR raw_cmd->cmd[4]
cmd270drivers/block/floppy.c#define SIZECODE raw_cmd->cmd[5]
cmd271drivers/block/floppy.c#define SECT_PER_TRACK raw_cmd->cmd[6]
cmd272drivers/block/floppy.c#define GAP raw_cmd->cmd[7]
cmd273drivers/block/floppy.c#define SIZECODE2 raw_cmd->cmd[8]
cmd277drivers/block/floppy.c#define F_SIZECODE raw_cmd->cmd[2]
cmd278drivers/block/floppy.c#define F_SECT_PER_TRACK raw_cmd->cmd[3]
cmd279drivers/block/floppy.c#define F_GAP raw_cmd->cmd[4]
cmd280drivers/block/floppy.c#define F_FILL raw_cmd->cmd[5]
cmd1018drivers/block/floppy.cprintk("%x,", raw_cmd->cmd[i]);
cmd1447drivers/block/floppy.cr|=output_byte(raw_cmd->cmd[i]);
cmd2218drivers/block/floppy.cif (CURRENT->cmd == WRITE) {
cmd2459drivers/block/floppy.cif (CURRENT->cmd == READ){
cmd2462drivers/block/floppy.c} else if (CURRENT->cmd == WRITE){
cmd2946drivers/block/floppy.cstatic inline int raw_cmd_copyout(int cmd, char *param,
cmd2953drivers/block/floppy.cif (cmd == OLDFDRAWCMD) {
cmd2999drivers/block/floppy.cstatic inline int raw_cmd_copyin(int cmd, char *param,
cmd3014drivers/block/floppy.cif (cmd == OLDFDRAWCMD){
cmd3025drivers/block/floppy.cmemcpy(ptr->cmd, old_raw_cmd.cmd, 9);
cmd3073drivers/block/floppy.cstatic int raw_cmd_ioctl(int cmd, void *param)
cmd3097drivers/block/floppy.cret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
cmd3117drivers/block/floppy.cret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
cmd3139drivers/block/floppy.cstatic inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
cmd3176drivers/block/floppy.cif (cmd != FDDEFPRM)
cmd3185drivers/block/floppy.cif (cmd == FDDEFPRM)
cmd3236drivers/block/floppy.cstatic inline int normalize_0x02xx_ioctl(int *cmd, int *size)
cmd3241drivers/block/floppy.cif ((*cmd & 0xffff) == (translation_table[i].newcmd & 0xffff)){
cmd3242drivers/block/floppy.c*size = _IOC_SIZE(*cmd);
cmd3243drivers/block/floppy.c*cmd = translation_table[i].newcmd;
cmd3244drivers/block/floppy.cif (*size > _IOC_SIZE(*cmd)) {
cmd3254drivers/block/floppy.cstatic inline int xlate_0x00xx_ioctl(int *cmd, int *size)
cmd3263drivers/block/floppy.cprintk("obsolete floppy ioctl %x\n", *cmd);
cmd3270drivers/block/floppy.cif (*cmd == translation_table[i].oldcmd) {
cmd3272drivers/block/floppy.c*cmd = translation_table[i].newcmd;
cmd3279drivers/block/floppy.cstatic int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
cmd3301drivers/block/floppy.cswitch (cmd) {
cmd3310drivers/block/floppy.cif(cmd == CDROMEJECT || /* CD-ROM eject */
cmd3311drivers/block/floppy.ccmd == 0x6470 /* SunOS floppy eject */) {
cmd3314drivers/block/floppy.ccmd = FDEJECT;
cmd3318drivers/block/floppy.cif ((cmd & 0xff00) == 0x0200) {
cmd3319drivers/block/floppy.cECALL(normalize_0x02xx_ioctl(&cmd, &size));
cmd3320drivers/block/floppy.c} else if ((cmd & 0xff00) == 0x0000) {
cmd3321drivers/block/floppy.cECALL(xlate_0x00xx_ioctl(&cmd, &size));
cmd3326drivers/block/floppy.cif (((cmd & 0x80) && !suser()) ||
cmd3327drivers/block/floppy.c((cmd & 0x40) && !IOCTL_ALLOWED))
cmd3331drivers/block/floppy.cif (_IOC_DIR(cmd) & _IOC_READ)
cmd3336drivers/block/floppy.cif (_IOC_DIR(cmd) & _IOC_WRITE)
cmd3339drivers/block/floppy.cswitch (cmd) {
cmd3362drivers/block/floppy.creturn set_geometry(cmd, & inparam.g,
cmd3437drivers/block/floppy.cCALL(i = raw_cmd_ioctl(cmd,(void *) param));
cmd3451drivers/block/floppy.cif (_IOC_DIR(cmd) & _IOC_READ)
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) {
cmd583drivers/block/ide-cd.crq->cmd = REQUEST_SENSE_COMMAND;
cmd602drivers/block/ide-cd.cif (rq->cmd == REQUEST_SENSE_COMMAND && uptodate) {
cmd632drivers/block/ide-cd.cint stat, err, sense_key, cmd;
cmd649drivers/block/ide-cd.ccmd = rq->cmd;
cmd651drivers/block/ide-cd.cif (cmd == REQUEST_SENSE_COMMAND) {
cmd663drivers/block/ide-cd.c} else if (cmd == PACKET_COMMAND) {
cmd1362drivers/block/ide-cd.creq.cmd = PACKET_COMMAND;
cmd1419drivers/block/ide-cd.cif (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
cmd1421drivers/block/ide-cd.celse if (rq -> cmd == RESET_DRIVE_COMMAND) {
cmd1425drivers/block/ide-cd.c} else if (rq -> cmd != READ) {
cmd1426drivers/block/ide-cd.cprintk ("ide-cd: bad cmd %d\n", rq -> cmd);
cmd1961drivers/block/ide-cd.cstruct file *file, unsigned int cmd, unsigned long arg)
cmd1963drivers/block/ide-cd.cswitch (cmd) {
cmd2315drivers/block/ide-cd.cif (cmd == CDROMREADMODE1) {
cmd2377drivers/block/ide-cd.creq.cmd = RESET_DRIVE_COMMAND;
cmd424drivers/block/ide-tape.c#define IDETAPE_REQUEST_CMD(cmd)   ((cmd >= IDETAPE_FIRST_REQUEST) && (cmd <= IDETAPE_LAST_REQUEST))
cmd857drivers/block/ide-tape.cvoid idetape_create_load_unload_cmd (idetape_packet_command_t *pc,int cmd);
cmd858drivers/block/ide-tape.cvoid idetape_create_space_cmd (idetape_packet_command_t *pc,long count,byte cmd);
cmd883drivers/block/ide-tape.cint idetape_chrdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
cmd924drivers/block/ide-tape.cint idetape_queue_rw_tail (ide_drive_t *drive,int cmd,int blocks,char *buffer);
cmd1921drivers/block/ide-tape.cif (tape->postponed_rq->cmd != IDETAPE_PACKET_COMMAND_REQUEST_TYPE1) {
cmd1961drivers/block/ide-tape.cif (tape->postponed_rq->cmd == IDETAPE_PACKET_COMMAND_REQUEST_TYPE1) {
cmd2584drivers/block/ide-tape.cvoid idetape_create_load_unload_cmd (idetape_packet_command_t *pc,int cmd)
cmd2588drivers/block/ide-tape.cprintk ("Creating LOAD UNLOAD packet command, cmd=%d\n",cmd);
cmd2600drivers/block/ide-tape.cpc->c [4]=cmd;
cmd2661drivers/block/ide-tape.cvoid idetape_create_space_cmd (idetape_packet_command_t *pc,long count,byte cmd)
cmd2690drivers/block/ide-tape.cpc->c [1]=cmd;
cmd2806drivers/block/ide-tape.cunsigned int cmd, unsigned long arg)
cmd2817drivers/block/ide-tape.cswitch (cmd) {
cmd2853drivers/block/ide-tape.cif (rq->cmd == IDETAPE_READ_REQUEST) {
cmd2865drivers/block/ide-tape.cif (rq->cmd == IDETAPE_WRITE_REQUEST) {
cmd2911drivers/block/ide-tape.cprintk ("rq_status: %d, rq_dev: %u, cmd: %d, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->cmd,rq->errors);
cmd2915drivers/block/ide-tape.cif (!IDETAPE_REQUEST_CMD (rq->cmd)) {
cmd2972drivers/block/ide-tape.cif (rq->cmd == IDETAPE_PACKET_COMMAND_REQUEST_TYPE1) {
cmd3003drivers/block/ide-tape.cswitch (rq->cmd) {
cmd3059drivers/block/ide-tape.crq->cmd=IDETAPE_PACKET_COMMAND_REQUEST_TYPE2;  /* Note that we are waiting for DSC *before* we */
cmd3065drivers/block/ide-tape.crq->cmd=IDETAPE_PACKET_COMMAND_REQUEST_TYPE1;
cmd3104drivers/block/ide-tape.crq.cmd = IDETAPE_PACKET_COMMAND_REQUEST_TYPE1;
cmd3138drivers/block/ide-tape.crq->cmd = IDETAPE_PACKET_COMMAND_REQUEST_TYPE1;
cmd3156drivers/block/ide-tape.cif (rq == NULL || !IDETAPE_REQUEST_CMD (rq->cmd)) {
cmd3171drivers/block/ide-tape.cint idetape_queue_rw_tail (ide_drive_t *drive,int cmd,int blocks,char *buffer)
cmd3178drivers/block/ide-tape.cprintk ("idetape_queue_rw_tail: cmd=%d\n",cmd);
cmd3189drivers/block/ide-tape.crq.cmd = cmd;
cmd3216drivers/block/ide-tape.crq.cmd = IDETAPE_READ_REQUEST;
cmd3318drivers/block/ide-tape.crq->cmd = IDETAPE_WRITE_REQUEST;
cmd3818drivers/block/ide-tape.cint idetape_chrdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
cmd3830drivers/block/ide-tape.cprintk ("Reached idetape_chrdev_ioctl, cmd=%u\n",cmd);
cmd3838drivers/block/ide-tape.cif (tape->chrdev_direction == idetape_direction_read && cmd != MTIOCTOP)
cmd3845drivers/block/ide-tape.cswitch (cmd) {
cmd3867drivers/block/ide-tape.creturn (idetape_blkdev_ioctl (drive,inode,file,cmd,arg));
cmd4581drivers/block/ide-tape.cif (rq->cmd == IDETAPE_WRITE_REQUEST)
cmd784drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {
cmd902drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {
cmd917drivers/block/ide.cif ((stat & DRQ_STAT) && rq->cmd != WRITE)
cmd1091drivers/block/ide.cstatic void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
cmd1096drivers/block/ide.cOUT_BYTE(cmd,IDE_COMMAND_REG);
cmd1264drivers/block/ide.cif (hwif->is_promise2 || rq->cmd == READ) {
cmd1274drivers/block/ide.cdrive->name, (rq->cmd==READ)?"read":"writ",
cmd1293drivers/block/ide.cdrive->name, (rq->cmd==READ)?"read":"writ", cyl,
cmd1303drivers/block/ide.cif (rq->cmd == READ) {
cmd1312drivers/block/ide.cif (rq->cmd == WRITE) {
cmd1335drivers/block/ide.cprintk("%s: bad command: %d\n", drive->name, rq->cmd);
cmd1422drivers/block/ide.cif (rq->cmd == IDE_DRIVE_CMD) {
cmd1692drivers/block/ide.crq->cmd = IDE_DRIVE_CMD;
cmd1913drivers/block/ide.cunsigned int cmd, unsigned long arg)
cmd1925drivers/block/ide.cswitch (cmd) {
cmd2007drivers/block/ide.cswitch (cmd) {
cmd2106drivers/block/ide.creturn ide_cdrom_ioctl(drive, inode, file, cmd, arg);
cmd2110drivers/block/ide.creturn idetape_blkdev_ioctl(drive, inode, file, cmd, arg);
cmd2158drivers/block/ide.cstatic inline void do_identify (ide_drive_t *drive, byte cmd)
cmd2183drivers/block/ide.cif (cmd == WIN_PIDENTIFY) {
cmd2197drivers/block/ide.cif (cmd == WIN_PIDENTIFY) {
cmd2358drivers/block/ide.cstatic int try_to_identify (ide_drive_t *drive, byte cmd)
cmd2383drivers/block/ide.cOUT_BYTE(cmd,IDE_COMMAND_REG);    /* ask drive for ID */
cmd2384drivers/block/ide.ctimeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
cmd2400drivers/block/ide.cdo_identify(drive, cmd); /* drive returned ID */
cmd2446drivers/block/ide.cstatic int do_probe (ide_drive_t *drive, byte cmd)
cmd2452drivers/block/ide.cif ((drive->media != ide_disk) && (cmd == WIN_IDENTIFY))
cmd2459drivers/block/ide.c(cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
cmd2471drivers/block/ide.c|| drive->present || cmd == WIN_PIDENTIFY)
cmd2473drivers/block/ide.cif ((rc = try_to_identify(drive,cmd)))   /* send cmd and wait */
cmd2474drivers/block/ide.crc = try_to_identify(drive,cmd); /* failed: try again */
cmd661drivers/block/ide.hunsigned int cmd, unsigned long arg);
cmd209drivers/block/ll_rw_blk.cstatic inline void drive_stat_acct(int cmd, unsigned long nr_sectors, short disk_index)
cmd212drivers/block/ll_rw_blk.cif (cmd == READ) {
cmd216drivers/block/ll_rw_blk.celse if (cmd == WRITE) {
cmd241drivers/block/ll_rw_blk.cdrive_stat_acct(req->cmd, req->nr_sectors, disk_index);
cmd246drivers/block/ll_rw_blk.cdrive_stat_acct(req->cmd, req->nr_sectors, disk_index);
cmd250drivers/block/ll_rw_blk.cdrive_stat_acct(req->cmd, req->nr_sectors, disk_index);
cmd375drivers/block/ll_rw_blk.cif (req->cmd != rw)
cmd416drivers/block/ll_rw_blk.creq->cmd = rw;
cmd564drivers/block/ll_rw_blk.creq[j]->cmd = rw;
cmd592drivers/block/ll_rw_blk.cdev->plug.cmd        = -1;
cmd48drivers/block/loop.cstatic int transfer_none(struct loop_device *lo, int cmd, char *raw_buf,
cmd51drivers/block/loop.cif (cmd == READ)
cmd58drivers/block/loop.cstatic int transfer_xor(struct loop_device *lo, int cmd, char *raw_buf,
cmd64drivers/block/loop.cif (cmd == READ) {
cmd79drivers/block/loop.cstatic int transfer_des(struct loop_device *lo, int cmd, char *raw_buf,
cmd90drivers/block/loop.cif (cmd == READ) {
cmd186drivers/block/loop.cif (CURRENT->cmd == WRITE) {
cmd189drivers/block/loop.c} else if (CURRENT->cmd != READ) {
cmd190drivers/block/loop.cprintk("unknown loop device command (%d)?!?", CURRENT->cmd);
cmd209drivers/block/loop.cif (!buffer_uptodate(bh) && ((CURRENT->cmd == READ) ||
cmd222drivers/block/loop.cif ((lo->transfer)(lo, CURRENT->cmd, bh->b_data + offset,
cmd228drivers/block/loop.cif (CURRENT->cmd == WRITE)
cmd376drivers/block/loop.cunsigned int cmd, unsigned long arg)
cmd391drivers/block/loop.cswitch (cmd) {
cmd124drivers/block/md.cunsigned int cmd, unsigned long arg)
cmd138drivers/block/md.creturn (pers[minor & 0x7f]->ioctl (inode, file, cmd, arg));
cmd143drivers/block/md.cswitch (cmd)
cmd327drivers/block/md.cprintk ("Unknown md_ioctl %d\n", cmd);
cmd84drivers/block/promise.cint promise_cmd(ide_drive_t *drive, byte cmd)
cmd91drivers/block/promise.cOUT_BYTE(cmd,IDE_SELECT_REG);
cmd315drivers/block/promise.cif (rq->cmd == READ) {
cmd347drivers/block/promise.cif (rq->cmd == WRITE) {
cmd359drivers/block/promise.cprintk("%s: bad command: %d\n", drive->name, rq->cmd);
cmd142drivers/block/rd.cif (CURRENT->cmd == READ) 
cmd151drivers/block/rd.cstatic int rd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
cmd158drivers/block/rd.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) {
cmd211drivers/cdrom/aztcd.c(CURRENT && MAJOR(CURRENT -> rq_dev) == MAJOR_NR && CURRENT -> cmd == READ \
cmd302drivers/cdrom/aztcd.cstatic int  aztSendCmd(int cmd);
cmd303drivers/cdrom/aztcd.cstatic int  sendAztCmd(int cmd, struct azt_Play_msf *params);
cmd324drivers/cdrom/aztcd.cstatic int  aztcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
cmd452drivers/cdrom/aztcd.cstatic int aztSendCmd(int cmd)
cmd457drivers/cdrom/aztcd.cprintk("aztcd: Executing command %x\n",cmd);
cmd463drivers/cdrom/aztcd.caztCmd=cmd;
cmd472drivers/cdrom/aztcd.c{ outb((unsigned char) cmd,CMD_PORT);
cmd480drivers/cdrom/aztcd.cprintk("### Error 1 aztcd: aztSendCmd %x  Error Code %x\n",cmd,data);
cmd484drivers/cdrom/aztcd.c{ printk("### Error 2 aztcd: aztSendCmd %x \n",cmd);
cmd493drivers/cdrom/aztcd.cstatic int sendAztCmd(int cmd, struct azt_Play_msf *params)
cmd503drivers/cdrom/aztcd.c{ aztSendCmd(cmd);
cmd517drivers/cdrom/aztcd.cprintk("### Error 1 aztcd: sendAztCmd %x  Error Code %x\n",cmd,data);
cmd521drivers/cdrom/aztcd.c{ printk("### Error 2 aztcd: sendAztCmd %x\n ",cmd);
cmd1065drivers/cdrom/aztcd.cstatic int aztcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd1077drivers/cdrom/aztcd.cprintk("aztcd: starting aztcd_ioctl - Command:%x   Time: %li\n",cmd, jiffies);
cmd1086drivers/cdrom/aztcd.cswitch (cmd)
cmd1260drivers/cdrom/aztcd.cprintk("aztcd: exiting aztcd_ioctl - Error 1 - Command:%x\n",cmd);
cmd1267drivers/cdrom/aztcd.cprintk("aztcd: exiting aztcd_ioctl - Error 2 - Command:%x\n",cmd);
cmd1275drivers/cdrom/aztcd.cprintk("aztcd: exiting aztcd_ioctl - Error 3 - Command:%x\n",cmd);
cmd1361drivers/cdrom/aztcd.cif (cmd==CDROMREADRAW)
cmd1402drivers/cdrom/aztcd.cprintk("aztcd: exiting aztcd_ioctl Command:%x  Time:%li\n",cmd,jiffies);
cmd237drivers/cdrom/cdu31a.cstatic void do_sony_cd_cmd(unsigned char cmd,
cmd517drivers/cdrom/cdu31a.cwrite_cmd(unsigned char cmd)
cmd520drivers/cdrom/cdu31a.coutb(cmd, sony_cd_cmd_reg);
cmd819drivers/cdrom/cdu31a.cdo_sony_cd_cmd(unsigned char cmd,
cmd887drivers/cdrom/cdu31a.cwrite_cmd(cmd);
cmd1579drivers/cdrom/cdu31a.cswitch(CURRENT->cmd)
cmd2360drivers/cdrom/cdu31a.cunsigned char cmd,
cmd2366drivers/cdrom/cdu31a.cdo_sony_cd_cmd(cmd, params, num_params, result_buffer, result_size);
cmd2380drivers/cdrom/cdu31a.cunsigned int  cmd,
cmd2394drivers/cdrom/cdu31a.cswitch (cmd)
cmd644drivers/cdrom/cm206.cif (CURRENT->cmd != READ) {
cmd645drivers/cdrom/cm206.cdebug(("Non-read command %d on cdrom\n", CURRENT->cmd));
cmd886drivers/cdrom/cm206.cunsigned int cmd, unsigned long arg)
cmd888drivers/cdrom/cm206.cswitch (cmd) {
cmd927drivers/cdrom/cm206.cswitch (cmd) {
cmd1009drivers/cdrom/cm206.celse return -cmd;
cmd1022drivers/cdrom/cm206.cdebug(("Unknown ioctl call 0x%x\n", cmd));
cmd202drivers/cdrom/gscd.cstatic int gscd_ioctl (struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd208drivers/cdrom/gscd.cswitch (cmd)
cmd274drivers/cdrom/gscd.cif (CURRENT -> cmd != READ)
cmd276drivers/cdrom/gscd.cprintk("GSCD: bad cmd %d\n", CURRENT -> cmd);
cmd317drivers/cdrom/gscd.cchar   cmd[] = { CMD_READ, 0x80, 0,0,0, 0,1 }; /* cmd mode M-S-F secth sectl */
cmd340drivers/cdrom/gscd.ccmd[2] = gscdcmd.start.min;
cmd341drivers/cdrom/gscd.ccmd[3] = gscdcmd.start.sec;
cmd342drivers/cdrom/gscd.ccmd[4] = gscdcmd.start.frame;
cmd345drivers/cdrom/gscd.cprintk ("GSCD: read msf %d:%d:%d\n", cmd[2], cmd[3], cmd[4] ); 
cmd347drivers/cdrom/gscd.ccmd_out ( TYPE_DATA, (char *)&cmd, (char *)&gscd_buf[0], 1 );
cmd519drivers/cdrom/gscd.cvoid cmd_out ( int cmd_type, char * cmd, char * respo_buf, int respo_count )
cmd575drivers/cdrom/gscd.ccmd_write_cmd (cmd);
cmd134drivers/cdrom/mcd.c(CURRENT && MAJOR(CURRENT -> rq_dev) == MAJOR_NR && CURRENT -> cmd == READ \
cmd186drivers/cdrom/mcd.cstatic void sendMcdCmd(int cmd, struct mcd_Play_msf *params);
cmd286drivers/cdrom/mcd.cmcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
cmd313drivers/cdrom/mcd.cswitch (cmd)
cmd1328drivers/cdrom/mcd.csendMcdCmd(int cmd, struct mcd_Play_msf *params)
cmd1330drivers/cdrom/mcd.coutb(cmd, MCDPORT(0));
cmd241drivers/cdrom/mcdx.cconst unsigned char* cmd, size_t, 
cmd279drivers/cdrom/mcdx.cunsigned int cmd, unsigned long arg)
cmd286drivers/cdrom/mcdx.cswitch (cmd) {
cmd540drivers/cdrom/mcdx.cWARN(("ioctl(): unknown request 0x%04x\n", cmd));
cmd578drivers/cdrom/mcdx.cswitch (CURRENT->cmd) {
cmd916drivers/cdrom/mcdx.cconst unsigned char *cmd, size_t cmdlen,
cmd945drivers/cdrom/mcdx.ctries, timeout, size, (unsigned char) cmd[0]));
cmd946drivers/cdrom/mcdx.cfor (i = 1; i < cmdlen; i++) printk(" 0x%02x", cmd[i]);
cmd958drivers/cdrom/mcdx.coutsb((unsigned int) stuffp->wreg_data, cmd, cmdlen);
cmd964drivers/cdrom/mcdx.ccmd[0], tries - 1, tries == 2 ? "y" : "ies"));
cmd976drivers/cdrom/mcdx.ccmd[0], cmdlen > 1 ? "..." : ""));
cmd999drivers/cdrom/mcdx.ccmd[0], tries - 1, tries == 2 ? "y" : "ies"));
cmd1395drivers/cdrom/mcdx.cstatic unsigned char cmd[] = {
cmd1401drivers/cdrom/mcdx.ccmd[0] = stuffp->readcmd;
cmd1431drivers/cdrom/mcdx.ccmd[1] = pending.minute;
cmd1432drivers/cdrom/mcdx.ccmd[2] = pending.second;
cmd1433drivers/cdrom/mcdx.ccmd[3] = pending.frame;
cmd1437drivers/cdrom/mcdx.ccmd[6] = (unsigned char) (stuffp->off_requested - stuffp->pending) / 4;
cmd1439drivers/cdrom/mcdx.coutsb((unsigned int) stuffp->wreg_data, cmd, sizeof cmd);
cmd1574drivers/cdrom/mcdx.cunsigned char cmd[7] = {
cmd1578drivers/cdrom/mcdx.ccmd[0] = stuffp->playcmd;
cmd1580drivers/cdrom/mcdx.ccmd[1] = msf->cdmsf_min0;
cmd1581drivers/cdrom/mcdx.ccmd[2] = msf->cdmsf_sec0;
cmd1582drivers/cdrom/mcdx.ccmd[3] = msf->cdmsf_frame0;
cmd1583drivers/cdrom/mcdx.ccmd[4] = msf->cdmsf_min1;
cmd1584drivers/cdrom/mcdx.ccmd[5] = msf->cdmsf_sec1;
cmd1585drivers/cdrom/mcdx.ccmd[6] = msf->cdmsf_frame1;
cmd1589drivers/cdrom/mcdx.ccmd[0], cmd[1], cmd[2], cmd[3],
cmd1590drivers/cdrom/mcdx.ccmd[4], cmd[5], cmd[6])); 
cmd1592drivers/cdrom/mcdx.coutsb((unsigned int) stuffp->wreg_data, cmd, sizeof cmd);
cmd1728drivers/cdrom/mcdx.cchar cmd[2];
cmd1733drivers/cdrom/mcdx.cif (-1 == (ans = mcdx_talk(stuffp, "\xc2", 1, cmd, sizeof(cmd), 5 * HZ, tries)))
cmd1737drivers/cdrom/mcdx.ccase TOC: cmd[1] |= 0x04; break;
cmd1738drivers/cdrom/mcdx.ccase DATA: cmd[1] &= ~0x04; break;
cmd1739drivers/cdrom/mcdx.ccase RAW: cmd[1] |= 0x40; break;
cmd1740drivers/cdrom/mcdx.ccase COOKED: cmd[1] &= ~0x40; break;
cmd1743drivers/cdrom/mcdx.ccmd[0] = 0x50;
cmd1744drivers/cdrom/mcdx.creturn mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
cmd1750drivers/cdrom/mcdx.cunsigned char cmd[2] = { 0xa0 };
cmd1753drivers/cdrom/mcdx.ccase MODE0: cmd[1] = 0x00; break;
cmd1754drivers/cdrom/mcdx.ccase MODE1: cmd[1] = 0x01; break;
cmd1755drivers/cdrom/mcdx.ccase MODE2: cmd[1] = 0x02; break;
cmd1758drivers/cdrom/mcdx.creturn mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
cmd1764drivers/cdrom/mcdx.cchar cmd[4];
cmd1768drivers/cdrom/mcdx.ccmd[0] = 0x90;
cmd1770drivers/cdrom/mcdx.ccmd[1] = 0x10;    /* irq enable */
cmd1771drivers/cdrom/mcdx.ccmd[2] = 0x05;    /* pre, err irq enable */
cmd1773drivers/cdrom/mcdx.cif (-1 == mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries))
cmd1776drivers/cdrom/mcdx.ccmd[1] = 0x02;    /* dma select */
cmd1777drivers/cdrom/mcdx.ccmd[2] = 0x00;    /* no dma */
cmd1779drivers/cdrom/mcdx.creturn mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries);
cmd1811drivers/cdrom/mcdx.cchar cmd[2] = { 0xfe };
cmd1813drivers/cdrom/mcdx.ccmd[1] = lock ? 0x01 : 0x00;
cmd1814drivers/cdrom/mcdx.creturn mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 1, 5 * HZ, tries);
cmd1846drivers/cdrom/mcdx.cchar cmd[5];
cmd1847drivers/cdrom/mcdx.ccmd[0] = 0xae;
cmd1848drivers/cdrom/mcdx.ccmd[1] = vol->channel0;
cmd1849drivers/cdrom/mcdx.ccmd[2] = 0;
cmd1850drivers/cdrom/mcdx.ccmd[3] = vol->channel1;
cmd1851drivers/cdrom/mcdx.ccmd[4] = 0;
cmd1853drivers/cdrom/mcdx.creturn mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 5, 200, tries);
cmd305drivers/cdrom/optcd.cstatic int send_cmd(int cmd)
cmd309drivers/cdrom/optcd.cDEBUG((DEBUG_DRIVE_IF, "sending command 0x%02x\n", cmd));
cmd312drivers/cdrom/optcd.coutb(cmd, COMIN_PORT);    /* Send command code */
cmd473drivers/cdrom/optcd.cinline static int exec_cmd(int cmd)
cmd475drivers/cdrom/optcd.cint ack = send_cmd(cmd);
cmd478drivers/cdrom/optcd.creturn get_exec_status(cmd < COMFETCH);
cmd484drivers/cdrom/optcd.cinline static int exec_read_cmd(int cmd, struct cdrom_msf *params)
cmd486drivers/cdrom/optcd.cint ack = send_cmd(cmd);
cmd494drivers/cdrom/optcd.cinline static int exec_seek_cmd(int cmd, struct cdrom_msf *params)
cmd496drivers/cdrom/optcd.cint ack = send_cmd(cmd);
cmd507drivers/cdrom/optcd.cinline static int exec_long_cmd(int cmd, struct cdrom_msf *params)
cmd509drivers/cdrom/optcd.cint ack = exec_read_cmd(cmd, params);
cmd968drivers/cdrom/optcd.c&& CURRENT -> cmd == READ && CURRENT -> sector != -1)
cmd1612drivers/cdrom/optcd.cstatic int cdromread(unsigned long arg, int blocksize, int cmd)
cmd1630drivers/cdrom/optcd.cstatus = exec_read_cmd(cmd, &msf);
cmd1735drivers/cdrom/optcd.cunsigned int cmd, unsigned long arg)
cmd1744drivers/cdrom/optcd.cif (cmd == CDROMRESET)
cmd1761drivers/cdrom/optcd.cswitch (cmd) {  /* Actions that can be taken with door open */
cmd1783drivers/cdrom/optcd.cDEBUG((DEBUG_VFS, "ioctl cmd 0x%x", cmd));
cmd1785drivers/cdrom/optcd.cswitch (cmd) {
cmd3831drivers/cdrom/sbpcd.cstatic int sbpcd_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd3837drivers/cdrom/sbpcd.cMINOR(inode->i_rdev), cmd, arg);
cmd3858drivers/cdrom/sbpcd.cmsg(DBG_IO2,"ioctl: device %d, request %04X\n",i,cmd);
cmd3859drivers/cdrom/sbpcd.cswitch (cmd)     /* Sun-compatible */
cmd4383drivers/cdrom/sbpcd.cmsg(DBG_IOC,"ioctl: unknown function request %04X\n", cmd);
cmd4424drivers/cdrom/sbpcd.cif (CURRENT->cmd != READ)
cmd4426drivers/cdrom/sbpcd.cmsg(DBG_INF, "bad cmd %d\n", CURRENT->cmd);
cmd194drivers/cdrom/sjcd.cstatic void sjcd_send_cmd( unsigned char cmd ){
cmd196drivers/cdrom/sjcd.cprintk( "SJCD: send_cmd( 0x%x )\n", cmd );
cmd198drivers/cdrom/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd207drivers/cdrom/sjcd.cstatic void sjcd_send_1_cmd( unsigned char cmd, unsigned char a ){
cmd209drivers/cdrom/sjcd.cprintk( "SJCD: send_1_cmd( 0x%x, 0x%x )\n", cmd, a );
cmd211drivers/cdrom/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd221drivers/cdrom/sjcd.cstatic void sjcd_send_4_cmd( unsigned char cmd, unsigned char a,
cmd224drivers/cdrom/sjcd.cprintk( "SJCD: send_4_cmd( 0x%x )\n", cmd );
cmd226drivers/cdrom/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd239drivers/cdrom/sjcd.cstatic void sjcd_send_6_cmd( unsigned char cmd, struct sjcd_play_msf *pms ){
cmd241drivers/cdrom/sjcd.cprintk( "SJCD: send_long_cmd( 0x%x )\n", cmd );
cmd243drivers/cdrom/sjcd.coutb( cmd, SJCDPORT( 0 ) );
cmd654drivers/cdrom/sjcd.cunsigned int cmd, unsigned long arg ){
cmd665drivers/cdrom/sjcd.cswitch( cmd ){
cmd921drivers/cdrom/sjcd.cCURRENT->cmd == READ && CURRENT->sector != -1 )
cmd195drivers/cdrom/sonycd535.cstatic int do_sony_cmd(Byte * cmd, int nCmd, Byte status[2],
cmd427drivers/cdrom/sonycd535.cByte cmd;
cmd487drivers/cdrom/sonycd535.ccmd = SONY535_SPIN_UP;
cmd488drivers/cdrom/sonycd535.cdo_sony_cmd(&cmd, 1, e_status, NULL, 0, 0);
cmd528drivers/cdrom/sonycd535.cdo_sony_cmd(Byte * cmd, int n_cmd, Byte status[2],
cmd535drivers/cdrom/sonycd535.coutb(cmd[i], command_reg);
cmd549drivers/cdrom/sonycd535.c*cmd, status[0], status[1]);
cmd692drivers/cdrom/sonycd535.cByte cmd;
cmd695drivers/cdrom/sonycd535.ccmd = SONY535_REQUEST_DRIVE_STATUS_1;
cmd696drivers/cdrom/sonycd535.cif (do_sony_cmd(&cmd, 1, status, NULL, 0, 0) != 0)
cmd702drivers/cdrom/sonycd535.ccmd = SONY535_SPIN_UP;
cmd703drivers/cdrom/sonycd535.creturn do_sony_cmd(&cmd, 1, status, NULL, 0, 0);
cmd793drivers/cdrom/sonycd535.cByte cmd[2];
cmd814drivers/cdrom/sonycd535.cswitch (CURRENT->cmd) {
cmd901drivers/cdrom/sonycd535.ccmd[0] = SONY535_SPIN_UP;
cmd902drivers/cdrom/sonycd535.cdo_sony_cmd(cmd, 1, status, NULL, 0, 0);
cmd978drivers/cdrom/sonycd535.cByte cmd = SONY535_REQUEST_SUB_Q_DATA;
cmd985drivers/cdrom/sonycd535.cif ((dsc_status = do_sony_cmd(&cmd, 1, status, (Byte *) last_sony_subcode,
cmd1073drivers/cdrom/sonycd535.cunsigned int cmd,
cmd1093drivers/cdrom/sonycd535.cswitch (cmd) {
cmd882drivers/char/apm_bios.cu_int cmd, u_long arg)
cmd891drivers/char/apm_bios.cswitch (cmd) {
cmd512drivers/char/cyclades.cwrite_cy_cmd(u_char *base_addr, u_char cmd, int index)
cmd533drivers/char/cyclades.cbase_addr[CyCCR<<index] = cmd;
cmd1929drivers/char/cyclades.cset_modem_info(struct cyclades_port * info, unsigned int cmd,
cmd1945drivers/char/cyclades.cswitch (cmd) {
cmd2152drivers/char/cyclades.cunsigned int cmd, unsigned long arg)
cmd2159drivers/char/cyclades.cprintk("cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg); /* */
cmd2162drivers/char/cyclades.cswitch (cmd) {
cmd2238drivers/char/cyclades.cret_val = set_modem_info(info, cmd, (unsigned int *) arg);
cmd99drivers/char/fbmem.cfb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd111drivers/char/fbmem.cswitch (cmd) {
cmd184drivers/char/fbmem.creturn (fb->fb_ioctl(inode, file, cmd, arg, PROC_CONSOLE()));
cmd455drivers/char/ftape/fdc-io.cbyte cmd[] =
cmd461drivers/char/ftape/fdc-io.ccmd[1] = (fdc_drv_spec[0] & 0x1f) | 0x00;
cmd462drivers/char/ftape/fdc-io.ccmd[2] = (fdc_drv_spec[1] & 0x1f) | 0x20;
cmd463drivers/char/ftape/fdc-io.ccmd[3] = (fdc_drv_spec[2] & 0x1f) | 0x40;
cmd464drivers/char/ftape/fdc-io.ccmd[4] = (fdc_drv_spec[3] & 0x1f) | 0x60;
cmd465drivers/char/ftape/fdc-io.cresult = fdc_command(cmd, NR_ITEMS(cmd));
cmd971drivers/char/ftape/fdc-io.cbyte cmd[1];
cmd983drivers/char/ftape/fdc-io.ccmd[0] = FDC_DUMPREGS;
cmd984drivers/char/ftape/fdc-io.cresult = fdc_issue_command(cmd, 1, stat, 1);
cmd995drivers/char/ftape/fdc-io.ccmd[0] = FDC_VERSION;
cmd996drivers/char/ftape/fdc-io.cresult = fdc_issue_command(cmd, 1, stat, 1);
cmd1001drivers/char/ftape/fdc-io.ccmd[0] = FDC_UNLOCK;
cmd1002drivers/char/ftape/fdc-io.cresult = fdc_issue_command(cmd, 1, stat, 1);
cmd1010drivers/char/ftape/fdc-io.ccmd[0] = FDC_LOCK; /* restore lock */
cmd1011drivers/char/ftape/fdc-io.cresult = fdc_issue_command(cmd, 1, stat, 1);
cmd1015drivers/char/ftape/fdc-io.ccmd[0] = FDC_PARTID;
cmd1016drivers/char/ftape/fdc-io.cresult = fdc_issue_command(cmd, 1, stat, 1);
cmd1044drivers/char/ftape/fdc-io.ccmd[0] = FDC_SAVE;
cmd1045drivers/char/ftape/fdc-io.cresult = fdc_issue_command(cmd, 1, stat, 16);
cmd306drivers/char/ftape/fdc-isr.cstatic int calc_steps(int cmd)
cmd308drivers/char/ftape/fdc-isr.cif (current_cylinder > cmd) {
cmd309drivers/char/ftape/fdc-isr.creturn current_cylinder - cmd;
cmd311drivers/char/ftape/fdc-isr.creturn current_cylinder + cmd;
cmd233drivers/char/ftape/ftape-io.cint cmd;
cmd237drivers/char/ftape/ftape-io.cftape_report_error(&err, &cmd, 1);
cmd524drivers/char/istallion.cstatic int  stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
cmd543drivers/char/istallion.cstatic int  stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
cmd553drivers/char/istallion.cstatic int  stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
cmd554drivers/char/istallion.cstatic void  stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
cmd1171drivers/char/istallion.cstatic int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
cmd1176drivers/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);
cmd1189drivers/char/istallion.cstli_sendcmd(brdp, portp, cmd, arg, size, copyback);
cmd1750drivers/char/istallion.cstatic int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
cmd1758drivers/char/istallion.cprintk("stli_ioctl(tty=%x,file=%x,cmd=%x,arg=%x)\n", (int) tty, (int) file, cmd, (int) arg);
cmd1774drivers/char/istallion.cswitch (cmd) {
cmd2188drivers/char/istallion.cstatic void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
cmd2196drivers/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);
cmd2203drivers/char/istallion.cprintk("STALLION: command already busy, cmd=%x!\n", (int) cmd);
cmd2218drivers/char/istallion.ccp->cmd = cmd;
cmd2307drivers/char/istallion.cint  cmd;
cmd2311drivers/char/istallion.ccmd = A_SETSIGNALSF;
cmd2313drivers/char/istallion.ccmd = A_SETSIGNALSFTX;
cmd2315drivers/char/istallion.ccmd = A_SETSIGNALSFRX;
cmd2317drivers/char/istallion.ccmd = A_SETSIGNALS;
cmd2323drivers/char/istallion.ccp->cmd = cmd;
cmd2326drivers/char/istallion.ccmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0);
cmd2327drivers/char/istallion.ccmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
cmd2330drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &cmd, sizeof(int));
cmd2332drivers/char/istallion.ccp->cmd = A_FLUSH;
cmd2401drivers/char/istallion.cif ((cp->cmd == 0) && (rc != 0)) {
cmd4362drivers/char/istallion.cstatic int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd4368drivers/char/istallion.cprintk("stli_memioctl(ip=%x,fp=%x,cmd=%x,arg=%x)\n", (int) ip, (int) fp, cmd, (int) arg);
cmd4377drivers/char/istallion.cswitch (cmd) {
cmd4423drivers/char/istallion.cswitch (cmd) {
cmd393drivers/char/lp.cunsigned int cmd, unsigned long arg)
cmd399drivers/char/lp.cprintk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
cmd405drivers/char/lp.cswitch ( cmd ) {
cmd384drivers/char/lp_m68k.cunsigned int cmd, unsigned long arg)
cmd390drivers/char/lp_m68k.cprintk("lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
cmd396drivers/char/lp_m68k.cswitch (cmd) {
cmd1535drivers/char/pcxx.cfepcmd(struct channel *ch, int cmd, int word_or_byte, int byte2, int ncmds,
cmd1552drivers/char/pcxx.cprintk("line %d: Out of range, cmd=%x, head=%x\n", __LINE__, cmd, head);
cmd1557drivers/char/pcxx.c*(unchar *)(memaddr+head+CSTART+0) = cmd;
cmd1564drivers/char/pcxx.c*(unchar *)(memaddr+head+CSTART+0) = cmd;
cmd1822drivers/char/pcxx.cunsigned int cmd, unsigned long arg)
cmd1842drivers/char/pcxx.cswitch(cmd) {
cmd1916drivers/char/pcxx.cswitch(cmd) {
cmd1968drivers/char/pcxx.cif(cmd == DIGI_SETAW) {
cmd2007drivers/char/pcxx.cif(cmd == DIGI_GETFLOW) {
cmd2025drivers/char/pcxx.cif(cmd == DIGI_SETFLOW) {
cmd2042drivers/char/pcxx.cif(cmd == DIGI_SETFLOW) {
cmd316drivers/char/random.cunsigned int cmd, unsigned long arg);
cmd1027drivers/char/random.cunsigned int cmd, unsigned long arg)
cmd1032drivers/char/random.cswitch (cmd) {
cmd1361drivers/char/riscom8.cstatic int rc_set_modem_info(struct riscom_port * port, unsigned int cmd,
cmd1373drivers/char/riscom8.cswitch (cmd) {
cmd1497drivers/char/riscom8.cunsigned int cmd, unsigned long arg)
cmd1507drivers/char/riscom8.cswitch (cmd) {
cmd1545drivers/char/riscom8.creturn rc_set_modem_info(port, cmd, (unsigned int *) arg);
cmd79drivers/char/rtc.cunsigned int cmd, unsigned long arg);
cmd190drivers/char/rtc.cstatic int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd196drivers/char/rtc.cswitch (cmd) {
cmd222drivers/char/scc.cstatic int scc_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
cmd1593drivers/char/scc.ckiss_set_param(struct scc_channel *scc,char cmd, unsigned int val)
cmd1599drivers/char/scc.cswitch(cmd){
cmd2092drivers/char/scc.cscc_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
cmd2115drivers/char/scc.cif (cmd == TIOCSCCCFG)
cmd2203drivers/char/scc.cif (cmd == TIOCSCCINI)
cmd2223drivers/char/scc.cif (cmd == TIOCCHANINI)
cmd2272drivers/char/scc.cswitch(cmd){
cmd2294drivers/char/scc.cswitch (cmd) {
cmd1648drivers/char/serial.cstatic int set_modem_info(struct async_struct * info, unsigned int cmd,
cmd1658drivers/char/serial.cswitch (cmd) {
cmd1892drivers/char/serial.cunsigned int cmd, unsigned long arg)
cmd1903drivers/char/serial.cif ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
cmd1904drivers/char/serial.c(cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
cmd1905drivers/char/serial.c(cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT) &&
cmd1906drivers/char/serial.c(cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
cmd1911drivers/char/serial.cswitch (cmd) {
cmd1949drivers/char/serial.creturn set_modem_info(info, cmd, (unsigned int *) arg);
cmd388drivers/char/stallion.cstatic int  stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
cmd396drivers/char/stallion.cstatic int  stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
cmd1122drivers/char/stallion.cstatic int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
cmd1129drivers/char/stallion.cprintk("stl_ioctl(tty=%x,file=%x,cmd=%x,arg=%x)\n", (int) tty, (int) file, cmd, (int) arg);
cmd1140drivers/char/stallion.cswitch (cmd) {
cmd3066drivers/char/stallion.cstatic int stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
cmd3071drivers/char/stallion.cprintk("stl_memioctl(ip=%x,fp=%x,cmd=%x,arg=%x)\n", (int) ip, (int) fp, cmd, (int) arg);
cmd3079drivers/char/stallion.cswitch (cmd) {
cmd666drivers/char/tpqic02.cstatic int notify_cmd(char cmd, short ignore_ex)
cmd670drivers/char/tpqic02.coutb_p(cmd, QIC02_CMD_PORT);    /* output the command */
cmd806drivers/char/tpqic02.cstatic int send_qic02_cmd(int cmd, time_t timeout, int ignore_ex)
cmd825drivers/char/tpqic02.cstatus_cmd_pending = cmd;
cmd827drivers/char/tpqic02.cstat = notify_cmd(cmd, ignore_ex); /* tell drive new command was loaded, */
cmd829drivers/char/tpqic02.cif (TP_HAVE_SEEK && (cmd == AR_QCMDV_SEEK_BLK)) {
cmd974drivers/char/tpqic02.cstatic void finish_rw(int cmd);
cmd1078drivers/char/tpqic02.cstatic int ll_do_qic_cmd(int cmd, time_t timeout)
cmd1095drivers/char/tpqic02.cprintk(TPQIC02_NAME ": ll_do_qic_cmd(%x, %ld) failed\n", cmd, (long) timeout);
cmd1105drivers/char/tpqic02.cstat = send_qic02_cmd(cmd, timeout, 0);  /* (checks for exceptions) */
cmd1107drivers/char/tpqic02.cif (cmd==QCMD_RD_FM) {
cmd1113drivers/char/tpqic02.c} else if (cmd==QCMD_WRT_FM) {
cmd1116drivers/char/tpqic02.c} else if ((cmd==QCMD_REWIND) || (cmd==QCMD_ERASE) || (cmd==QCMD_RETEN)) {
cmd1131drivers/char/tpqic02.cprintk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[1](%x, %ld)", cmd, (long) timeout);
cmd1149drivers/char/tpqic02.cif (tp_sense((cmd==QCMD_SEEK_EOD ?    /*****************************/
cmd1152drivers/char/tpqic02.cprintk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[2](%x, %ld)\n", cmd, (long) timeout);
cmd1153drivers/char/tpqic02.cif (cmd!=QCMD_RD_FM)
cmd1160drivers/char/tpqic02.cprintk(TPQIC02_NAME ": ll_do_qic_cmd %x: wait failed, stat == 0x%x\n", cmd, stat);
cmd1192drivers/char/tpqic02.cstatic void terminate_read(int cmd)
cmd1196drivers/char/tpqic02.cif (cmd != QCMD_RD_FM) {
cmd1220drivers/char/tpqic02.cstatic void terminate_write(int cmd)
cmd1227drivers/char/tpqic02.cif (cmd != QCMD_WRT_FM) {
cmd1244drivers/char/tpqic02.cstatic void finish_rw(int cmd)
cmd1250drivers/char/tpqic02.cterminate_read(cmd);
cmd1251drivers/char/tpqic02.cterminate_write(cmd);
cmd1259drivers/char/tpqic02.cstatic int do_qic_cmd(int cmd, time_t timeout)
cmd1264drivers/char/tpqic02.cfinish_rw(cmd);
cmd1274drivers/char/tpqic02.cif (cmd==QCMD_REWIND)  /* don't wind beyond BOT ;-) */
cmd1278drivers/char/tpqic02.creturn ll_do_qic_cmd(cmd, timeout);
cmd1286drivers/char/tpqic02.cstatic int do_ioctl_cmd(int cmd)
cmd1296drivers/char/tpqic02.cswitch (cmd) {
cmd119drivers/char/tty_io.cunsigned int cmd, unsigned long arg);
cmd331drivers/char/tty_io.cunsigned int cmd, unsigned long arg)
cmd1362drivers/char/tty_io.cunsigned int cmd, unsigned long arg)
cmd1382drivers/char/tty_io.cswitch (cmd) {
cmd1595drivers/char/tty_io.ccmd, arg);
cmd1601drivers/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);
cmd197drivers/char/vt.cunsigned int cmd, unsigned long arg)
cmd219drivers/char/vt.cswitch (cmd) {
cmd266drivers/char/vt.creturn sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
cmd271drivers/char/vt.c(cmd == KDENABIO)) ? -ENXIO : 0;
cmd150drivers/char/wdt.cstatic int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd363drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd387drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_BSENT;
cmd388drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd389drivers/isdn/icn/icn.ccmd.arg = channel;
cmd390drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd464drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd496drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_BCONN;
cmd497drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd498drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd499drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd503drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_RUN;
cmd504drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd505drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd506drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd520drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_BHUP;
cmd521drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd522drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd523drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd527drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_DCONN;
cmd528drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd529drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd530drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd534drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_DHUP;
cmd535drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd536drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd537drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd541drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_BHUP;
cmd542drivers/isdn/icn/icn.ccmd.arg = 0;
cmd543drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd544drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd545drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_DHUP;
cmd546drivers/isdn/icn/icn.ccmd.arg = 0;
cmd547drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd548drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd552drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_CINF;
cmd553drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd554drivers/isdn/icn/icn.cstrncpy(cmd.num, p + 3, sizeof(cmd.num) - 1);
cmd555drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd556drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd560drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_CAUSE;
cmd561drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd562drivers/isdn/icn/icn.cstrncpy(cmd.num, p + 3, sizeof(cmd.num) - 1);
cmd563drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd564drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd568drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_ICALL;
cmd569drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd570drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd571drivers/isdn/icn/icn.cstrncpy(cmd.num, p + 6, sizeof(cmd.num) - 1);
cmd572drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd576drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_ICALL;
cmd577drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd578drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd579drivers/isdn/icn/icn.cstrcpy(cmd.num, "LEASED,07,00,1");
cmd580drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd584drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_ICALL;
cmd585drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd586drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd587drivers/isdn/icn/icn.cstrncpy(cmd.num, p + 6, sizeof(cmd.num) - 1);
cmd588drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd592drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_NODCH;
cmd593drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd594drivers/isdn/icn/icn.ccmd.arg = ch - 1;
cmd595drivers/isdn/icn/icn.cstrncpy(cmd.num, p + 6, sizeof(cmd.num) - 1);
cmd596drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd626drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_STAVAIL;
cmd627drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd628drivers/isdn/icn/icn.ccmd.arg = avail;
cmd629drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd980drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd1012drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_STAVAIL;
cmd1013drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd1014drivers/isdn/icn/icn.ccmd.arg = ocount;
cmd1015drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd1032drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd1038drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_STOP;
cmd1039drivers/isdn/icn/icn.ccmd.driver = ldev->myid;
cmd1040drivers/isdn/icn/icn.cldev->interface.statcallb(&cmd);
cmd1062drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd1158drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_RUN;
cmd1159drivers/isdn/icn/icn.ccmd.driver = ldev->myid;
cmd1160drivers/isdn/icn/icn.ccmd.arg = 0;
cmd1161drivers/isdn/icn/icn.cldev->interface.statcallb(&cmd);
cmd1169drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_RUN;
cmd1170drivers/isdn/icn/icn.ccmd.driver = ldev->myid;
cmd1171drivers/isdn/icn/icn.ccmd.arg = 0;
cmd1172drivers/isdn/icn/icn.cldev->interface.statcallb(&cmd);
cmd1384drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd1446drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_UNLOAD;
cmd1447drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd1448drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd1482drivers/isdn/icn/icn.cisdn_ctrl cmd;
cmd1486drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_UNLOAD;
cmd1487drivers/isdn/icn/icn.ccmd.driver = dev->myid;
cmd1488drivers/isdn/icn/icn.cdev->interface.statcallb(&cmd);
cmd1491drivers/isdn/icn/icn.ccmd.command = ISDN_STAT_UNLOAD;
cmd1492drivers/isdn/icn/icn.ccmd.driver = dev2->myid;
cmd1493drivers/isdn/icn/icn.cdev2->interface.statcallb(&cmd);
cmd298drivers/isdn/isdn_common.cisdn_ctrl cmd;
cmd300drivers/isdn/isdn_common.ccmd.driver = di;
cmd301drivers/isdn/isdn_common.ccmd.arg = ch;
cmd302drivers/isdn/isdn_common.ccmd.command = ISDN_CMD_SETEAZ;
cmd303drivers/isdn/isdn_common.ccmd.num[0] = '\0';
cmd304drivers/isdn/isdn_common.c(void) dev->drv[di]->interface->command(&cmd);
cmd314drivers/isdn/isdn_common.cisdn_ctrl cmd;
cmd354drivers/isdn/isdn_common.ccmd.driver = di;
cmd355drivers/isdn/isdn_common.ccmd.arg = c->arg;
cmd356drivers/isdn/isdn_common.ccmd.command = ISDN_CMD_HANGUP;
cmd357drivers/isdn/isdn_common.cdev->drv[di]->interface->command(&cmd);
cmd373drivers/isdn/isdn_common.ccmd.driver = di;
cmd374drivers/isdn/isdn_common.ccmd.arg = c->arg;
cmd375drivers/isdn/isdn_common.ccmd.command = ISDN_CMD_HANGUP;
cmd376drivers/isdn/isdn_common.cdev->drv[di]->interface->command(&cmd);
cmd382drivers/isdn/isdn_common.ccmd.driver = di;
cmd383drivers/isdn/isdn_common.ccmd.arg = c->arg;
cmd384drivers/isdn/isdn_common.ccmd.command = ISDN_CMD_ACCEPTD;
cmd385drivers/isdn/isdn_common.cdev->drv[di]->interface->command(&cmd);
cmd390drivers/isdn/isdn_common.ccmd.driver = di;
cmd391drivers/isdn/isdn_common.ccmd.arg = c->arg;
cmd392drivers/isdn/isdn_common.ccmd.command = ISDN_CMD_HANGUP;
cmd393drivers/isdn/isdn_common.cdev->drv[di]->interface->command(&cmd);
cmd437drivers/isdn/isdn_common.ccmd.driver = di;
cmd438drivers/isdn/isdn_common.ccmd.arg = c->arg;
cmd439drivers/isdn/isdn_common.ccmd.command = ISDN_CMD_ACCEPTB;
cmd440drivers/isdn/isdn_common.cdev->drv[di]->interface->command(&cmd);
cmd1021drivers/isdn/isdn_common.cstatic int isdn_ioctl(struct inode *inode, struct file *file, uint cmd, ulong arg)
cmd1036drivers/isdn/isdn_common.cswitch (cmd) {
cmd1068drivers/isdn/isdn_common.cswitch (cmd) {
cmd1316drivers/isdn/isdn_common.cif (cmd == IIOCSETMAP) {
cmd1353drivers/isdn/isdn_common.cif ((cmd&IIOCDRVCTL)==IIOCDRVCTL)
cmd1354drivers/isdn/isdn_common.ccmd = ((cmd>>_IOC_NRSHIFT)&_IOC_NRMASK)& ISDN_DRVIOCTL_MASK;
cmd1382drivers/isdn/isdn_common.cc.arg = cmd;
cmd1394drivers/isdn/isdn_common.creturn (isdn_ppp_ioctl(minor - ISDN_MINOR_PPP, file, cmd, arg));
cmd202drivers/isdn/isdn_net.cisdn_net_stat_callback(int idx, int cmd)
cmd208drivers/isdn/isdn_net.cswitch (cmd) {
cmd337drivers/isdn/isdn_net.cisdn_ctrl cmd;
cmd358drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd359drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel;
cmd360drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_CLREAZ;
cmd361drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd362drivers/isdn/isdn_net.csprintf(cmd.num, "%s", isdn_map_eaz2msn(p->local.msn, cmd.driver));
cmd363drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_SETEAZ;
cmd364drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd374drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd375drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_SETL2;
cmd376drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel + (p->local.l2_proto << 8);
cmd377drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd378drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd379drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_SETL3;
cmd380drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel + (p->local.l3_proto << 8);
cmd381drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd382drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd383drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel;
cmd392drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_DIAL;
cmd393drivers/isdn/isdn_net.csprintf(cmd.num, "%s,%s,7,0", p->local.dial->num,
cmd394drivers/isdn/isdn_net.cisdn_map_eaz2msn(p->local.msn, cmd.driver));
cmd414drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd435drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd436drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel;
cmd437drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_ACCEPTB;
cmd441drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd461drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd462drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_SETL2;
cmd463drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel + (p->local.l2_proto << 8);
cmd464drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd465drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd466drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_SETL3;
cmd467drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel + (p->local.l3_proto << 8);
cmd468drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd478drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd479drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel;
cmd480drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_ACCEPTB;
cmd481drivers/isdn/isdn_net.cdev->drv[p->local.isdn_device]->interface->command(&cmd);
cmd511drivers/isdn/isdn_net.ccmd.driver = p->local.isdn_device;
cmd512drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_HANGUP;
cmd513drivers/isdn/isdn_net.ccmd.arg = p->local.isdn_channel;
cmd514drivers/isdn/isdn_net.c(void) dev->drv[cmd.driver]->interface->command(&cmd);
cmd535drivers/isdn/isdn_net.cisdn_ctrl cmd;
cmd554drivers/isdn/isdn_net.ccmd.driver = lp->isdn_device;
cmd555drivers/isdn/isdn_net.ccmd.command = ISDN_CMD_HANGUP;
cmd556drivers/isdn/isdn_net.ccmd.arg = lp->isdn_channel;
cmd557drivers/isdn/isdn_net.c(void) dev->drv[cmd.driver]->interface->command(&cmd);
cmd279drivers/isdn/isdn_ppp.cint isdn_ppp_ioctl(int minor, struct file *file, unsigned int cmd, unsigned long arg)
cmd285drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x",minor,cmd);
cmd292drivers/isdn/isdn_ppp.cswitch (cmd) {
cmd1164drivers/isdn/isdn_ppp.cint isdn_ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd1174drivers/isdn/isdn_ppp.cswitch (cmd) {
cmd149drivers/isdn/isdn_tty.cisdn_ctrl cmd;
cmd168drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd169drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel;
cmd170drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_CLREAZ;
cmd171drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd172drivers/isdn/isdn_tty.cstrcpy(cmd.num, isdn_map_eaz2msn(m->msn, info->isdn_driver));
cmd173drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd174drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_SETEAZ;
cmd175drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd176drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd177drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_SETL2;
cmd178drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel + (m->mdmreg[14] << 8);
cmd179drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd180drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd181drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_SETL3;
cmd182drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel + (m->mdmreg[15] << 8);
cmd183drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd184drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd185drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel;
cmd186drivers/isdn/isdn_tty.csprintf(cmd.num, "%s,%s,%d,%d", n, isdn_map_eaz2msn(m->msn, info->isdn_driver),
cmd188drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_DIAL;
cmd192drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd200drivers/isdn/isdn_tty.cisdn_ctrl cmd;
cmd207drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd208drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_HANGUP;
cmd209drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel;
cmd210drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd596drivers/isdn/isdn_tty.cstatic int isdn_tty_set_modem_info(modem_info * info, uint cmd, uint * value)
cmd600drivers/isdn/isdn_tty.cswitch (cmd) {
cmd645drivers/isdn/isdn_tty.cuint cmd, ulong arg)
cmd653drivers/isdn/isdn_tty.cswitch (cmd) {
cmd686drivers/isdn/isdn_tty.creturn isdn_tty_set_modem_info(info, cmd, (uint *) arg);
cmd749drivers/isdn/isdn_tty.cprintk(KERN_DEBUG "unsupp. ioctl 0x%08x on ttyi%d\n", cmd, info->line);
cmd1449drivers/isdn/isdn_tty.cisdn_ctrl cmd;
cmd1452drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd1453drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel;
cmd1454drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_ACCEPTD;
cmd1455drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd1564drivers/isdn/isdn_tty.cisdn_ctrl cmd;
cmd1587drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd1588drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_SETL2;
cmd1589drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel + (m->mdmreg[14] << 8);
cmd1590drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd1591drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd1592drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_SETL3;
cmd1593drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel + (m->mdmreg[15] << 8);
cmd1594drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd1595drivers/isdn/isdn_tty.ccmd.driver = info->isdn_driver;
cmd1596drivers/isdn/isdn_tty.ccmd.arg = info->isdn_channel;
cmd1597drivers/isdn/isdn_tty.ccmd.command = ISDN_CMD_ACCEPTD;
cmd1604drivers/isdn/isdn_tty.cfido_command(&cmd);
cmd1606drivers/isdn/isdn_tty.cdev->drv[info->isdn_driver]->interface->command(&cmd);
cmd738drivers/isdn/pcbit/drv.cfmsg->cmd, fmsg->scmd);
cmd927drivers/isdn/pcbit/drv.cstruct pcbit_ioctl *cmd;
cmd937drivers/isdn/pcbit/drv.ccmd = (struct pcbit_ioctl *) ctl->num;
cmd941drivers/isdn/pcbit/drv.ccmd->info.l2_status = dev->l2_state;
cmd981drivers/isdn/pcbit/drv.cif (cmd->info.rdp_byte.addr > BANK4)
cmd984drivers/isdn/pcbit/drv.cwriteb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
cmd992drivers/isdn/pcbit/drv.cif (cmd->info.rdp_byte.addr > BANK4)
cmd994drivers/isdn/pcbit/drv.cprintk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
cmd998drivers/isdn/pcbit/drv.ccmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr); 
cmd260drivers/isdn/pcbit/layer2.cpcbit_writeb(dev, msg->cmd);
cmd348drivers/isdn/pcbit/layer2.cmsg.cmd = frame->skb->data[2];
cmd90drivers/isdn/pcbit/layer2.hu_char cmd;
cmd97drivers/isdn/pcbit/layer2.hu_char cmd;
cmd105drivers/net/apricot.cstruct i596_cmd cmd;
cmd113drivers/net/apricot.cunsigned short cmd;
cmd126drivers/net/apricot.cstruct i596_cmd *cmd;
cmd189drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd);
cmd216drivers/net/apricot.crfd->cmd = CMD_EOL;
cmd220drivers/net/apricot.crfd->cmd = 0x0000;
cmd271drivers/net/apricot.clp->cmd_head = lp->scb.cmd = (struct i596_cmd *) I596_NULL;
cmd373drivers/net/apricot.clp->rx_tail->cmd = 0;
cmd377drivers/net/apricot.clp->rx_tail->cmd = CMD_EOL;
cmd438drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
cmd482drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd)
cmd491drivers/net/apricot.ccmd->status = 0;
cmd492drivers/net/apricot.ccmd->command |= (CMD_EOL|CMD_INTR);
cmd493drivers/net/apricot.ccmd->next = (struct i596_cmd *) I596_NULL;
cmd498drivers/net/apricot.clp->cmd_tail->next = cmd;
cmd501drivers/net/apricot.clp->cmd_head = cmd;
cmd510drivers/net/apricot.clp->scb.cmd = cmd;
cmd514drivers/net/apricot.clp->cmd_tail = cmd;
cmd517drivers/net/apricot.clp->cmd_head = lp->scb.cmd;
cmd639drivers/net/apricot.ctx_cmd->cmd.command = CMD_FLEX|CmdTx;
cmd739drivers/net/apricot.clp->scb.cmd = (struct i596_cmd *) I596_NULL;
cmd871drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
cmd960drivers/net/apricot.cstruct i596_cmd *cmd;
cmd969drivers/net/apricot.ccmd = (struct i596_cmd *) kmalloc(sizeof(struct i596_cmd)+2+dev->mc_count*6, GFP_ATOMIC);
cmd970drivers/net/apricot.cif (cmd == NULL)
cmd975drivers/net/apricot.ccmd->command = CmdMulticastList;
cmd976drivers/net/apricot.c*((unsigned short *) (cmd + 1)) = dev->mc_count * 6;
cmd977drivers/net/apricot.ccp=((char *)(cmd + 1))+2;
cmd983drivers/net/apricot.cprint_eth (((char *)(cmd + 1)) + 2);
cmd984drivers/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;
cmd561drivers/net/de4x5.cstatic int     de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd3768drivers/net/de4x5.cde4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd3781drivers/net/de4x5.cswitch(ioc->cmd) {
cmd802drivers/net/de4x5.hunsigned short cmd;                /* Command to run */
cmd287drivers/net/de600.c#define de600_put_command(cmd) ( \
cmd290drivers/net/de600.coutb_p(((rx_page | cmd) << 4)   | COMMAND            , DATA_PORT), \
cmd291drivers/net/de600.coutb_p(((rx_page | cmd) & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT))
cmd272drivers/net/de620.cde620_send_command(struct device *dev, byte cmd)
cmd275drivers/net/de620.cif (cmd == W_DUMMY)
cmd278drivers/net/de620.coutb(cmd, DATA_PORT);
cmd388drivers/net/depca.cstatic int    depca_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd1701drivers/net/depca.cstatic int depca_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1713drivers/net/depca.cswitch(ioc->cmd) {
cmd163drivers/net/depca.hunsigned short cmd;                /* Command to run */
cmd564drivers/net/dgrs.cif (priv->rfdp->cmd & I596_RFD_EL)
cmd686drivers/net/dgrs.cdgrs_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd694drivers/net/dgrs.cif (cmd != DGRSIOCTL) return -EINVAL;
cmd698drivers/net/dgrs.cswitch (ioc.cmd)
cmd754drivers/net/dgrs.cint    cmd;
cmd763drivers/net/dgrs.ccmd = priv->scbp->cmd;
cmd768drivers/net/dgrs.cif ( (cmd & I596_SCB_RUC) == I596_SCB_RUC_START)
cmd782drivers/net/dgrs.cif ( (cmd & I596_SCB_CUC) != I596_SCB_CUC_START)
cmd784drivers/net/dgrs.cpriv->scbp->cmd = 0;  /* Ignore all other commands */
cmd793drivers/net/dgrs.cpriv->scbp->cmd = 0;  /* Safe to clear the command */
cmd796drivers/net/dgrs.cswitch (cbp->nop.cmd & I596_CB_CMD)
cmd805drivers/net/dgrs.cif (cbp->nop.cmd & I596_CB_CMD_EL)
cmd27drivers/net/dgrs.hunsigned short cmd;  /* Command to run */
cmd564drivers/net/dgrs_driver.cif (priv->rfdp->cmd & I596_RFD_EL)
cmd686drivers/net/dgrs_driver.cdgrs_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd694drivers/net/dgrs_driver.cif (cmd != DGRSIOCTL) return -EINVAL;
cmd698drivers/net/dgrs_driver.cswitch (ioc.cmd)
cmd754drivers/net/dgrs_driver.cint    cmd;
cmd763drivers/net/dgrs_driver.ccmd = priv->scbp->cmd;
cmd768drivers/net/dgrs_driver.cif ( (cmd & I596_SCB_RUC) == I596_SCB_RUC_START)
cmd782drivers/net/dgrs_driver.cif ( (cmd & I596_SCB_CUC) != I596_SCB_CUC_START)
cmd784drivers/net/dgrs_driver.cpriv->scbp->cmd = 0;  /* Ignore all other commands */
cmd793drivers/net/dgrs_driver.cpriv->scbp->cmd = 0;  /* Safe to clear the command */
cmd796drivers/net/dgrs_driver.cswitch (cbp->nop.cmd & I596_CB_CMD)
cmd805drivers/net/dgrs_driver.cif (cbp->nop.cmd & I596_CB_CMD_EL)
cmd72drivers/net/dgrs_i82596.hushort      cmd;
cmd127drivers/net/dgrs_i82596.hushort      cmd;
cmd193drivers/net/dgrs_i82596.hushort      cmd;
cmd214drivers/net/dgrs_i82596.hushort      cmd;
cmd225drivers/net/dgrs_i82596.hushort      cmd;
cmd289drivers/net/dgrs_i82596.hushort      cmd;
cmd316drivers/net/dgrs_i82596.hushort      cmd;
cmd327drivers/net/dgrs_i82596.hushort      cmd;
cmd338drivers/net/dgrs_i82596.hushort      cmd;
cmd368drivers/net/dgrs_i82596.hvolatile ushort    cmd;    /* Command word */
cmd453drivers/net/dlci.cint dlci_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd462drivers/net/dlci.cswitch(cmd)
cmd495drivers/net/dlci.creturn(dlci_config(dev, (struct dlci_conf *) ifr->ifr_data, cmd == DLCI_GET_CONF));
cmd802drivers/net/eexpress.cunsigned short cmd = 0x180|(location&0x7f);
cmd809drivers/net/eexpress.cif (cmd&i) 
cmd154drivers/net/eql.cstatic int eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd); /*  */
cmd345drivers/net/eql.cstatic int eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd347drivers/net/eql.cif(!suser() && cmd!=EQL_GETMASTRCFG && cmd!=EQL_GETSLAVECFG)
cmd349drivers/net/eql.cswitch (cmd)
cmd780drivers/net/eth16i.cshort cmd = ( (command & (1 << i)) ? DI_1 : DI_0 );
cmd781drivers/net/eth16i.coutb(cmd, ioaddr + EEPROM_DATA_REG);
cmd296drivers/net/ewrk3.cstatic int    ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
cmd1673drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1685drivers/net/ewrk3.cswitch(ioc->cmd) {
cmd297drivers/net/ewrk3.hunsigned short cmd;                /* Command to run */
cmd154drivers/net/pi2.cstatic int pi_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd241drivers/net/pi2.cint cmd;
cmd250drivers/net/pi2.ccmd = lp->base + CTL;
cmd256drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
cmd272drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
cmd275drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1,
cmd345drivers/net/pi2.cint cmd;
cmd351drivers/net/pi2.ccmd = CTL + lp->base;
cmd367drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd368drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd369drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd373drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
cmd384drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
cmd400drivers/net/pi2.cint cmd;
cmd411drivers/net/pi2.ccmd = lp->base + CTL;
cmd438drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
cmd455drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
cmd458drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
cmd461drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
cmd464drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
cmd474drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd475drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd476drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd491drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
cmd507drivers/net/pi2.cint cmd;
cmd517drivers/net/pi2.ccmd = lp->base + CTL;
cmd519drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* Get special condition bits from R1 */
cmd583drivers/net/pi2.cint cmd;
cmd592drivers/net/pi2.ccmd = CTL + lp->base;
cmd594drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
cmd596drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0)) & Rx_CH_AV) {
cmd618drivers/net/pi2.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);  /* char to rcv buff */
cmd622drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd623drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
cmd677drivers/net/pi2.cint cmd;
cmd682drivers/net/pi2.ccmd = CTL + lp->base;
cmd708drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd709drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd710drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd714drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
cmd735drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
cmd741drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & 0x40)) {
cmd746drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
cmd755drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
cmd757drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
cmd759drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);  /* reset Tx Int Pend */
cmd778drivers/net/pi2.cint cmd;
cmd781drivers/net/pi2.ccmd = CTL + lp->base;
cmd784drivers/net/pi2.cst = rdscc(lp->cardbase, cmd, R0);  /* Fetch status */
cmd786drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd793drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
cmd821drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
cmd825drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
cmd827drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
cmd830drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
cmd831drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
cmd839drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
cmd841drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
cmd847drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
cmd848drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd849drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);  /* Tx/Ext ints */
cmd859drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd860drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd861drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
cmd865drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
cmd886drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
cmd890drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
cmd892drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
cmd895drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
cmd896drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
cmd904drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
cmd906drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
cmd912drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
cmd913drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd915drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
cmd928drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd929drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd930drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1002drivers/net/pi2.cint cmd;
cmd1006drivers/net/pi2.ccmd = CTL + lp->base;
cmd1011drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
cmd1012drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Rx off */
cmd1014drivers/net/pi2.cif (cmd & 2) {    /* if channel a */
cmd1016drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
cmd1018drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);  /* No interrupts */
cmd1025drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
cmd1026drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
cmd1029drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
cmd1033drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);  /*  TX off */
cmd1039drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
cmd1043drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
cmd1044drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
cmd1046drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
cmd1048drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
cmd1052drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Make sure rx is off */
cmd1053drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
cmd1054drivers/net/pi2.cdummy = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
cmd1055drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1056drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1058drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1061drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | Rx8);
cmd1064drivers/net/pi2.cif (cmd & 2) {    /* if channel a */
cmd1070drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
cmd1072drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* allow ABORT int */
cmd1097drivers/net/pi2.cregister int cmd;
cmd1101drivers/net/pi2.ccmd = CTL + lp->base;
cmd1105drivers/net/pi2.cswitch (cmd & CHANA) {
cmd1107drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRA);  /* Reset channel A */
cmd1108drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R2, 0xff);  /* Initialize interrupt vector */
cmd1111drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRB);  /* Reset channel B */
cmd1116drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);
cmd1119drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
cmd1122drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
cmd1126drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
cmd1129drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
cmd1132drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCDPLL | RCDPLL | TRxCBR | TRxCOI);
cmd1134drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
cmd1136drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP);
cmd1140drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R6, 0);
cmd1143drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R7, FLAG);
cmd1148drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
cmd1151drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* 8 bits/char */
cmd1154drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);  /* BRG off, keep Pclk source */
cmd1165drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
cmd1166drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
cmd1173drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
cmd1176drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSRTxC);
cmd1178drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
cmd1179drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
cmd1181drivers/net/pi2.cif (!(cmd & 2))    /* if channel b */
cmd1182drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
cmd1184drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
cmd1187drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | Rx8);
cmd1595drivers/net/pi2.cstatic int pi_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd1605drivers/net/pi2.cif(cmd!=SIOCDEVPRIVATE)
cmd1610drivers/net/pi2.cswitch (rq.cmd) {
cmd73drivers/net/pi2.hint cmd;
cmd153drivers/net/plip.cstatic int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd1038drivers/net/plip.cplip_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd179drivers/net/ppp.cstatic int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
cmd2812drivers/net/ppp.cppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
cmd2819drivers/net/ppp.cswitch (cmd) {
cmd125drivers/net/pt.cstatic int pt_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd250drivers/net/pt.cint cmd;
cmd259drivers/net/pt.ccmd = lp->base + CTL;
cmd265drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
cmd281drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
cmd284drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1,
cmd365drivers/net/pt.cregister int cmd = lp->base + CTL;
cmd376drivers/net/pt.cif (cmd & CHANA)
cmd378drivers/net/pt.cwrtscc(lp->cardbase, cmd, R9, CHRA);    /* Reset channel A */
cmd379drivers/net/pt.cwrtscc(lp->cardbase, cmd, R2, 0xff);    /* Initialise interrupt vector */
cmd381drivers/net/pt.cwrtscc(lp->cardbase, cmd, R9, CHRB);    /* Reset channel B */
cmd385drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, 0);
cmd388drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, 0);
cmd391drivers/net/pt.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
cmd397drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);    
cmd400drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS);    
cmd407drivers/net/pt.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
cmd411drivers/net/pt.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP | RCRTxCP | TRxCBR);
cmd412drivers/net/pt.cwrtscc(lp->cardbase,cmd, R14, 0);  /* wiz1 */
cmd416drivers/net/pt.cwrtscc(lp->cardbase, cmd, R6, 0);
cmd419drivers/net/pt.cwrtscc(lp->cardbase, cmd, R7, FLAG);
cmd422drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
cmd425drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, AUTO_ENAB | Rx8);
cmd428drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
cmd435drivers/net/pt.cwrtscc(lp->cardbase, cmd, R12, tc & 0xff);    /* lower byte */
cmd436drivers/net/pt.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xff);  /* upper byte */      
cmd446drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
cmd447drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
cmd448drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
cmd466drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
cmd468drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
cmd477drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | AUTO_ENAB | Rx8 );
cmd642drivers/net/pt.cint cmd = lp->base + CTL;
cmd648drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, 0);
cmd649drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, AUTO_ENAB | Rx8);  /* Rx off */
cmd655drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
cmd658drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, 0);
cmd667drivers/net/pt.cwrtscc(lp->cardbase, cmd, R12, tc & 0xff);
cmd668drivers/net/pt.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xff);
cmd672drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
cmd678drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
cmd685drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
cmd688drivers/net/pt.cwrtscc(lp->cardbase, cmd, R12, tc & 0xff);
cmd689drivers/net/pt.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xff);
cmd692drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
cmd694drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
cmd699drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, AUTO_ENAB | Rx8);
cmd702drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);
cmd705drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R1);
cmd708drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd709drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd710drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd713drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | AUTO_ENAB | Rx8 );
cmd725drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, INT_ALL_Rx | EXT_INT_ENAB);
cmd728drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, BRKIE );
cmd1000drivers/net/pt.cint cmd;
cmd1002drivers/net/pt.ccmd = lp->base + CTL;
cmd1029drivers/net/pt.cstatic int pt_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd1039drivers/net/pt.cif (cmd != SIOCDEVPRIVATE)
cmd1044drivers/net/pt.cswitch (rq.cmd) {
cmd1148drivers/net/pt.cint cmd;
cmd1153drivers/net/pt.ccmd = lp->base + CTL;
cmd1190drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd1191drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd1192drivers/net/pt.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0)
cmd1197drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, DCDIE);
cmd1210drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
cmd1225drivers/net/pt.cwrtscc(lp->cardbase, cmd, R8, c);
cmd1231drivers/net/pt.cif ((rdscc(lp->cardbase, cmd, R0) & TxEOM))
cmd1236drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
cmd1246drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
cmd1248drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZ);
cmd1251drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);
cmd1256drivers/net/pt.cprintk("PT: pt_txisr(): Invalid tstate (%d) for chan %s.\n", lp->tstate, (cmd & CHANA? "A": "B") );
cmd1267drivers/net/pt.cint cmd = lp->base + CTL;
cmd1280drivers/net/pt.crse = rdscc(lp->cardbase, cmd, R1);
cmd1289drivers/net/pt.cif (rdscc(lp->cardbase, cmd, R0) & Rx_CH_AV && !lp->dmachan) 
cmd1315drivers/net/pt.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);
cmd1319drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1320drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1321drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1324drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);
cmd1328drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);
cmd1370drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);      
cmd1427drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);
cmd1564drivers/net/pt.cint cmd = lp->base + CTL;
cmd1573drivers/net/pt.cst = rdscc(lp->cardbase, cmd, R0);
cmd1579drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd1597drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
cmd1635drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
cmd1646drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
cmd1649drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
cmd1652drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
cmd1655drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
cmd1664drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);
cmd1669drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
cmd1671drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZ | ABUNDER);
cmd1674drivers/net/pt.cwrtscc(lp->cardbase, cmd, R8, c);
cmd1677drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
cmd1689drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
cmd1692drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd1695drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
cmd1706drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd1707drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
cmd1708drivers/net/pt.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0)
cmd1713drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, DCDIE);
cmd1725drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
cmd1752drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1753drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
cmd1754drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);      
cmd1760drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);      
cmd1785drivers/net/pt.c(void)rdscc(lp->cardbase, cmd, R8);
cmd1786drivers/net/pt.c(void)rdscc(lp->cardbase, cmd, R8);
cmd1787drivers/net/pt.c(void)rdscc(lp->cardbase, cmd, R8);
cmd1794drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);      
cmd102drivers/net/pt.hint cmd;
cmd325drivers/net/sdla.cstatic void sdla_errors(struct device *dev, int cmd, int dlci, int ret, int len, void *data) 
cmd398drivers/net/sdla.cif (cmd == SDLA_INFORMATION_WRITE)
cmd402drivers/net/sdla.cprintk(KERN_DEBUG "%s: Cmd 0x%2.2X generated return code 0x%2.2X\n", dev->name, cmd, ret);
cmd408drivers/net/sdla.cstatic int sdla_cmd(struct device *dev, int cmd, short dlci, short flags, 
cmd427drivers/net/sdla.ccmd_buf->cmd = cmd;
cmd478drivers/net/sdla.csdla_errors(dev, cmd, dlci, ret, len, &status);
cmd740drivers/net/sdla.cstruct sdla_cmd   *cmd;
cmd754drivers/net/sdla.ccmd = NULL;
cmd765drivers/net/sdla.ccmd = (void *) (dev->mem_start + (SDLA_502_RCV_BUF & SDLA_ADDR_MASK));
cmd767drivers/net/sdla.csuccess = cmd->opp_flag;
cmd771drivers/net/sdla.cdlci = cmd->dlci;
cmd772drivers/net/sdla.clen = cmd->length;
cmd829drivers/net/sdla.ccmd->opp_flag = 0;
cmd1265drivers/net/sdla.cstatic int sdla_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
cmd1274drivers/net/sdla.cswitch (cmd)
cmd1278drivers/net/sdla.creturn(sdla_config(dev, (struct frad_conf *)ifr->ifr_data, cmd == FRAD_GET_CONF));
cmd1315drivers/net/sdla.creturn(sdla_xfer(dev, (struct sdla_mem *)ifr->ifr_data, cmd == SDLA_READMEM));
cmd1042drivers/net/slip.cslip_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
cmd1053drivers/net/slip.cswitch(cmd) {
cmd1178drivers/net/slip.creturn n_tty_ioctl(tty, (struct file *) file, cmd, (unsigned long) arg);
cmd1386drivers/net/strip.cunsigned int cmd, unsigned long arg)
cmd1398drivers/net/strip.cswitch(cmd) 
cmd1417drivers/net/strip.creturn n_tty_ioctl(tty, (struct file *) file, cmd, 
cmd224drivers/net/wavelan.h#define PIOM(cmd,piono)    ((u_short)cmd << 10 << (piono * 2))
cmd86drivers/net/wic.cint wic_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
cmd87drivers/net/wic.cint send_cmd(struct device *dev, unsigned char *cmd, char len);
cmd88drivers/net/wic.cint recv_cmd_resp(struct device *dev, unsigned char *cmd);
cmd1092drivers/net/wic.cwic_ioctl(struct device *dev, struct ifreq *rq, int cmd)
cmd1342drivers/net/wic.csend_cmd(struct device *dev, unsigned char *cmd, char len)
cmd1365drivers/net/wic.cerr = send_byte(dev, *cmd);  
cmd1369drivers/net/wic.ccksum += *cmd;
cmd1370drivers/net/wic.ccmd++;
cmd763drivers/pci/pci.cunsigned char cmd, tmp, hdr_type = 0;
cmd823drivers/pci/pci.c&cmd);
cmd825drivers/pci/pci.ccmd | PCI_COMMAND_MASTER);
cmd830drivers/pci/pci.ccmd);
cmd548drivers/sbus/char/suncons.cfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
cmd559drivers/sbus/char/suncons.cswitch (cmd){
cmd634drivers/sbus/char/suncons.ci = fb->ioctl (inode, file, cmd, arg, fb);
cmd636drivers/sbus/char/suncons.cprintk ("[[FBIO: %8.8x]]\n", cmd);
cmd639drivers/sbus/char/suncons.cprintk ("[[FBIO: %8.8x]]\n", cmd);
cmd986drivers/sbus/char/suncons.ccg6_ioctl (struct inode *inode, struct file *file, unsigned cmd, unsigned long arg, fbinfo_t *fb)
cmd990drivers/sbus/char/suncons.cswitch (cmd){
cmd1177drivers/sbus/char/sunkbd.ckbd_ioctl (struct inode *i, struct file *f, unsigned int cmd, unsigned long arg)
cmd1179drivers/sbus/char/sunkbd.cswitch (cmd){
cmd1226drivers/sbus/char/sunkbd.cprintk ("Unknown Keyboard ioctl: %8.8x\n", cmd);
cmd354drivers/sbus/char/sunmouse.csun_mouse_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
cmd358drivers/sbus/char/sunmouse.cswitch (cmd){
cmd379drivers/sbus/char/sunmouse.cprintk ("[MOUSE-ioctl: %8.8x]\n", cmd);
cmd1335drivers/sbus/char/sunserial.cunsigned int cmd, unsigned long arg)
cmd1344drivers/sbus/char/sunserial.cif ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
cmd1345drivers/sbus/char/sunserial.c(cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
cmd1346drivers/sbus/char/sunserial.c(cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
cmd1351drivers/sbus/char/sunserial.cswitch (cmd) {
cmd287drivers/scsi/53c7,8xx.cstatic void print_progress (Scsi_Cmnd *cmd);
cmd291drivers/scsi/53c7,8xx.cstatic void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result);
cmd299drivers/scsi/53c7,8xx.c*cmd);
cmd300drivers/scsi/53c7,8xx.cstatic void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
cmd306drivers/scsi/53c7,8xx.cstatic void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd);
cmd309drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd);
cmd1919drivers/scsi/53c7,8xx.cunsigned char cmd[6];
cmd1924drivers/scsi/53c7,8xx.ccmd[0] = INQUIRY;
cmd1925drivers/scsi/53c7,8xx.ccmd[1] = cmd[2] = cmd[3] = cmd[5] = 0;
cmd1926drivers/scsi/53c7,8xx.ccmd[4] = sizeof(data); 
cmd1931drivers/scsi/53c7,8xx.cdsa[5] = virt_to_bus(&cmd);
cmd2004drivers/scsi/53c7,8xx.cNCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd) {
cmd2005drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd->cmd;
cmd2011drivers/scsi/53c7,8xx.cmemcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
cmd2030drivers/scsi/53c7,8xx.cpatch_abs_tci_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2032drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2033drivers/scsi/53c7,8xx.cdsa_temp_addr_next, virt_to_bus(&cmd->dsa_next_addr));
cmd2034drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2035drivers/scsi/53c7,8xx.cdsa_temp_next, virt_to_bus(cmd->dsa) + Ent_dsa_zero -
cmd2037drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32), 
cmd2039drivers/scsi/53c7,8xx.cpatch_abs_tci_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2042drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2043drivers/scsi/53c7,8xx.cdsa_temp_addr_saved_pointer, virt_to_bus(&cmd->saved_data_pointer));
cmd2044drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2045drivers/scsi/53c7,8xx.cdsa_temp_addr_saved_residual, virt_to_bus(&cmd->saved_residual));
cmd2046drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2047drivers/scsi/53c7,8xx.cdsa_temp_addr_residual, virt_to_bus(&cmd->residual));
cmd2050drivers/scsi/53c7,8xx.cpatch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
cmd2051drivers/scsi/53c7,8xx.cdsa_temp_addr_dsa_value, virt_to_bus(&cmd->dsa_addr));
cmd2100drivers/scsi/53c7,8xx.cabnormal_finished (struct NCR53c7x0_cmd *cmd, int result) {
cmd2101drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd->cmd;
cmd2128drivers/scsi/53c7,8xx.cif (issue_to_cmd (host, hostdata, (u32 *) current) == cmd) 
cmd2150drivers/scsi/53c7,8xx.c!= (char *) cmd->dsa;
cmd2177drivers/scsi/53c7,8xx.cleft >= 0 && linux_search && linux_search != cmd;
cmd2190drivers/scsi/53c7,8xx.ccmd->next = hostdata->free;
cmd2191drivers/scsi/53c7,8xx.chostdata->free = cmd;
cmd2216drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd) {
cmd2220drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd ? cmd->cmd : NULL;
cmd2486drivers/scsi/53c7,8xx.cNCR53c7x0_cmd *cmd) {
cmd2489drivers/scsi/53c7,8xx.cScsi_Cmnd *c = cmd ? cmd->cmd : NULL;
cmd2512drivers/scsi/53c7,8xx.cif (cmd && (cmd->flags & CMD_FLAG_SDTR)) {
cmd2515drivers/scsi/53c7,8xx.ccmd->flags &= ~CMD_FLAG_SDTR;
cmd2556drivers/scsi/53c7,8xx.cif (cmd) {
cmd2559drivers/scsi/53c7,8xx.c(cmd->flags & CMD_FLAG_SDTR) ? "accepting" : "requesting");
cmd2570drivers/scsi/53c7,8xx.cif (cmd->flags & CMD_FLAG_SDTR) {
cmd2571drivers/scsi/53c7,8xx.ccmd->flags &= ~CMD_FLAG_SDTR; 
cmd2583drivers/scsi/53c7,8xx.ccmd->flags |= CMD_FLAG_DID_SDTR;
cmd2590drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout_other, 0, 5);
cmd2591drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout_other, 1, (u32) 
cmd2655drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_msgout, 0, 1);
cmd2662drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_cmdout, 0, 6);
cmd2677drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_dataout, 0, 
cmd2679drivers/scsi/53c7,8xx.cpatch_dsa_32 (cmd->dsa, dsa_datain, 0, 
cmd2680drivers/scsi/53c7,8xx.cvirt_to_bus(cmd->data_transfer_start));
cmd2681drivers/scsi/53c7,8xx.ccmd->data_transfer_start[0] = (((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I | 
cmd2683drivers/scsi/53c7,8xx.ccmd->data_transfer_start[1] = (u32) virt_to_bus(c->sense_buffer);
cmd2685drivers/scsi/53c7,8xx.ccmd->data_transfer_start[2] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) 
cmd2687drivers/scsi/53c7,8xx.ccmd->data_transfer_start[3] = (u32) virt_to_bus(hostdata->script) + 
cmd2697drivers/scsi/53c7,8xx.ccmd->cmd->result = 0xffff;    
cmd2711drivers/scsi/53c7,8xx.cif (cmd)
cmd2712drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_ERROR << 16);
cmd2737drivers/scsi/53c7,8xx.chost->host_no, cmd->saved_data_pointer,
cmd2738drivers/scsi/53c7,8xx.cbus_to_virt(cmd->saved_data_pointer));
cmd2770drivers/scsi/53c7,8xx.chost->host_no, cmd->saved_data_pointer,
cmd2771drivers/scsi/53c7,8xx.cbus_to_virt (cmd->saved_data_pointer));
cmd2799drivers/scsi/53c7,8xx.chost->host_no, cmd->saved_data_pointer,
cmd2800drivers/scsi/53c7,8xx.cbus_to_virt (cmd->saved_data_pointer),
cmd2893drivers/scsi/53c7,8xx.chost->host_no, cmd->saved_data_pointer,
cmd2894drivers/scsi/53c7,8xx.cbus_to_virt (cmd->saved_data_pointer));
cmd2903drivers/scsi/53c7,8xx.cif (cmd) {
cmd2906drivers/scsi/53c7,8xx.chost->host_no, cmd->saved_data_pointer, bus_to_virt (
cmd2907drivers/scsi/53c7,8xx.ccmd->saved_data_pointer));
cmd2909drivers/scsi/53c7,8xx.cbus_to_virt(cmd->saved_data_pointer), "", 1);
cmd2911drivers/scsi/53c7,8xx.cbus_to_virt(cmd->saved_data_pointer) + size, "", 1);
cmd3417drivers/scsi/53c7,8xx.callocate_cmd (Scsi_Cmnd *cmd) {
cmd3418drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd3430drivers/scsi/53c7,8xx.ccmd->target, cmd->lun, (hostdata->cmd_allocated[cmd->target] &
cmd3431drivers/scsi/53c7,8xx.c(1 << cmd->lun)) ? "already allocated" : "not allocated");
cmd3439drivers/scsi/53c7,8xx.cif (!(hostdata->cmd_allocated[cmd->target] & (1 << cmd->lun)) &&
cmd3443drivers/scsi/53c7,8xx.ccmd->device && cmd->device->has_cmdblocks
cmd3448drivers/scsi/53c7,8xx.chostdata->cmd_allocated[cmd->target] |= (1 << cmd->lun);
cmd3487drivers/scsi/53c7,8xx.chost->host_no, cmd->target, cmd->lun);
cmd3506drivers/scsi/53c7,8xx.ccreate_cmd (Scsi_Cmnd *cmd) {
cmd3508drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd3523drivers/scsi/53c7,8xx.cNCR53c7x0_local_setup(cmd->host);
cmd3525drivers/scsi/53c7,8xx.cif (!(tmp = allocate_cmd (cmd)))
cmd3534drivers/scsi/53c7,8xx.cswitch (cmd->cmnd[0]) {
cmd3542drivers/scsi/53c7,8xx.cdatain = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd3551drivers/scsi/53c7,8xx.cprint_command(cmd->cmnd);
cmd3555drivers/scsi/53c7,8xx.ccmd->use_sg);
cmd3558drivers/scsi/53c7,8xx.cdataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd3576drivers/scsi/53c7,8xx.cdatain = dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
cmd3625drivers/scsi/53c7,8xx.ctmp->cmd = cmd;
cmd3657drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmnd, 0, virt_to_bus(cmd));
cmd3660drivers/scsi/53c7,8xx.cif (hostdata->sync[cmd->target].select_indirect != 
cmd3661drivers/scsi/53c7,8xx.c((hostdata->sync[cmd->target].scntl3_sanity << 24) | 
cmd3662drivers/scsi/53c7,8xx.c(cmd->target << 16) | 
cmd3663drivers/scsi/53c7,8xx.c(hostdata->sync[cmd->target].sxfer_sanity << 8))) {
cmd3665drivers/scsi/53c7,8xx.chost->host_no, hostdata->sync[cmd->target].select_indirect);
cmd3670drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_select, 0, hostdata->sync[cmd->target].
cmd3677drivers/scsi/53c7,8xx.cif (hostdata->initiate_wdtr & (1 << cmd->target)) {
cmd3683drivers/scsi/53c7,8xx.chostdata->initiate_wdtr &= ~(1 << cmd->target);
cmd3685drivers/scsi/53c7,8xx.c} else if (hostdata->initiate_sdtr & (1 << cmd->target)) {
cmd3692drivers/scsi/53c7,8xx.chostdata->initiate_sdtr &= ~(1 << cmd->target);
cmd3697drivers/scsi/53c7,8xx.celse if (!(hostdata->talked_to & (1 << cmd->target)) && 
cmd3707drivers/scsi/53c7,8xx.chostdata->talked_to |= (1 << cmd->target);
cmd3709drivers/scsi/53c7,8xx.cIDENTIFY (1, cmd->lun) : IDENTIFY (0, cmd->lun);
cmd3711drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmdout, 0, cmd->cmd_len);
cmd3712drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_cmdout, 1, virt_to_bus(cmd->cmnd));
cmd3729drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_msgin, 1, virt_to_bus(&cmd->result) + 1);
cmd3731drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_status, 1, virt_to_bus(&cmd->result));
cmd3774drivers/scsi/53c7,8xx.cfor (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; cmd_datain += 4, 
cmd3776drivers/scsi/53c7,8xx.cu32 buf = cmd->use_sg ? 
cmd3777drivers/scsi/53c7,8xx.cvirt_to_bus(((struct scatterlist *)cmd->buffer)[i].address) :
cmd3778drivers/scsi/53c7,8xx.cvirt_to_bus(cmd->request_buffer);
cmd3779drivers/scsi/53c7,8xx.cu32 count = cmd->use_sg ?
cmd3780drivers/scsi/53c7,8xx.c((struct scatterlist *)cmd->buffer)[i].length :
cmd3781drivers/scsi/53c7,8xx.ccmd->request_bufflen;
cmd3874drivers/scsi/53c7,8xx.cNCR53c7xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *)) {
cmd3875drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd3881drivers/scsi/53c7,8xx.ccmd->scsi_done = done;
cmd3882drivers/scsi/53c7,8xx.ccmd->host_scribble = NULL;
cmd3883drivers/scsi/53c7,8xx.ccmd->SCp.ptr = NULL;
cmd3884drivers/scsi/53c7,8xx.ccmd->SCp.buffer = NULL;
cmd3890drivers/scsi/53c7,8xx.c!(hostdata->debug_lun_limit[cmd->target] & (1 << cmd->lun))) 
cmd3892drivers/scsi/53c7,8xx.c|| cmd->target > 7
cmd3894drivers/scsi/53c7,8xx.c|| cmd->target > host->max_id
cmd3896drivers/scsi/53c7,8xx.c|| cmd->target == host->this_id
cmd3899drivers/scsi/53c7,8xx.ccmd->target, cmd->lun);
cmd3900drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd3904drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd3905drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd3907drivers/scsi/53c7,8xx.cswitch (cmd->cmnd[0]) {
cmd3912drivers/scsi/53c7,8xx.ccmd->result = (DID_BAD_TARGET << 16);
cmd3919drivers/scsi/53c7,8xx.ccmd->result = 0xffff;  /* The NCR will overwrite message
cmd3921drivers/scsi/53c7,8xx.ccmd->host_scribble = (unsigned char *) tmp = create_cmd (cmd);
cmd3930drivers/scsi/53c7,8xx.cif (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd3931drivers/scsi/53c7,8xx.ccmd->SCp.ptr = (unsigned char *) hostdata->issue_queue;
cmd3932drivers/scsi/53c7,8xx.chostdata->issue_queue = cmd;
cmd3936drivers/scsi/53c7,8xx.ctmp->SCp.ptr = (unsigned char *) cmd;
cmd3964drivers/scsi/53c7,8xx.cstruct NCR53c7x0_cmd *cmd) {
cmd3966drivers/scsi/53c7,8xx.cScsi_Cmnd *tmp = cmd->cmd;
cmd3989drivers/scsi/53c7,8xx.ccmd->next = (struct NCR53c7x0_cmd *) hostdata->free;
cmd3990drivers/scsi/53c7,8xx.chostdata->free = cmd;
cmd4002drivers/scsi/53c7,8xx.ccmd->next = hostdata->running_list;
cmd4003drivers/scsi/53c7,8xx.chostdata->running_list = cmd;
cmd4006drivers/scsi/53c7,8xx.ccmd->dsa [(hostdata->dsa_jump_dest - hostdata->dsa_start) / 
cmd4010drivers/scsi/53c7,8xx.cvirt_to_bus ((void *) cmd->dsa) + hostdata->E_dsa_code_begin -
cmd4019drivers/scsi/53c7,8xx.ccmd->next = (struct NCR53c7x0_cmd *) hostdata->free;
cmd4020drivers/scsi/53c7,8xx.chostdata->free = cmd;
cmd4054drivers/scsi/53c7,8xx.cScsi_Cmnd *cmd) {
cmd4058drivers/scsi/53c7,8xx.creturn hostdata->busy[cmd->target][cmd->lun];
cmd4170drivers/scsi/53c7,8xx.cintr_scsi (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd4203drivers/scsi/53c7,8xx.cif (cmd) {
cmd4205drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd4206drivers/scsi/53c7,8xx.cprint_command (cmd->cmd->cmnd);
cmd4227drivers/scsi/53c7,8xx.c} else if (cmd) {
cmd4228drivers/scsi/53c7,8xx.cabnormal_finished(cmd, DID_BAD_TARGET << 16);
cmd4241drivers/scsi/53c7,8xx.cif (cmd) {
cmd4243drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd4245drivers/scsi/53c7,8xx.cabnormal_finished(cmd, DID_ERROR << 16);
cmd4257drivers/scsi/53c7,8xx.cif (cmd && cmd->cmd) {
cmd4259drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
cmd4260drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_PARITY << 16); 
cmd4306drivers/scsi/53c7,8xx.cintr_phase_mismatch (host, cmd);
cmd4360drivers/scsi/53c7,8xx.cstruct NCR53c7x0_cmd *cmd,      /* command which halted */
cmd4435drivers/scsi/53c7,8xx.c&(hostdata->running_list), cmd = 
cmd4436drivers/scsi/53c7,8xx.c(struct NCR53c7x0_cmd *) hostdata->running_list; cmd ;
cmd4437drivers/scsi/53c7,8xx.ccmd_prev_ptr = (struct NCR53c7x0_cmd **) &(cmd->next), 
cmd4438drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *) cmd->next) {
cmd4441drivers/scsi/53c7,8xx.cif (!cmd) {
cmd4446drivers/scsi/53c7,8xx.cif (!(tmp = cmd->cmd)) {
cmd4453drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->result);
cmd4464drivers/scsi/53c7,8xx.c*cmd_prev_ptr = (struct NCR53c7x0_cmd *) cmd->next;
cmd4467drivers/scsi/53c7,8xx.ccmd->next = hostdata->free;
cmd4468drivers/scsi/53c7,8xx.chostdata->free = cmd;
cmd4524drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *) hostdata->current;
cmd4527drivers/scsi/53c7,8xx.cfor (cmd = (struct NCR53c7x0_cmd *) 
cmd4528drivers/scsi/53c7,8xx.chostdata->running_list; cmd &&
cmd4530drivers/scsi/53c7,8xx.ccmd->dsa;
cmd4531drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *)(cmd->next));
cmd4534drivers/scsi/53c7,8xx.cif (cmd) {
cmd4536drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->pid, (int) cmd->cmd->target,
cmd4537drivers/scsi/53c7,8xx.c(int) cmd->cmd->lun);
cmd4538drivers/scsi/53c7,8xx.cprint_command (cmd->cmd->cmnd);
cmd4547drivers/scsi/53c7,8xx.cintr_scsi (host, cmd);
cmd4553drivers/scsi/53c7,8xx.cintr_dma (host, cmd);
cmd4801drivers/scsi/53c7,8xx.cintr_phase_mismatch (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd4840drivers/scsi/53c7,8xx.cif (!cmd) {
cmd4861drivers/scsi/53c7,8xx.c} else if (((dsp >= cmd->data_transfer_start && 
cmd4862drivers/scsi/53c7,8xx.cdsp < cmd->data_transfer_end)) || dsp == (cmd->residual + 2)) {
cmd4877drivers/scsi/53c7,8xx.cif (dsp != cmd->residual + 2) {
cmd4878drivers/scsi/53c7,8xx.ccmd->residual[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL |
cmd4881drivers/scsi/53c7,8xx.ccmd->residual[1] = virt_to_bus(hostdata->script)
cmd4891drivers/scsi/53c7,8xx.ccmd->residual[2] = dbc_dcmd + residual;
cmd4892drivers/scsi/53c7,8xx.ccmd->residual[3] = NCR53c7x0_read32(DNAD_REG) - residual;
cmd4898drivers/scsi/53c7,8xx.cif (dsp != cmd->residual + 2) {
cmd4899drivers/scsi/53c7,8xx.ccmd->residual[4] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) 
cmd4901drivers/scsi/53c7,8xx.ccmd->residual[5] = virt_to_bus(dsp_next);
cmd4908drivers/scsi/53c7,8xx.chostdata->dsp = cmd->residual;
cmd4929drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target);
cmd4930drivers/scsi/53c7,8xx.ccmd->flags &= ~CMD_FLAG_SDTR;
cmd5019drivers/scsi/53c7,8xx.cintr_bf (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd5120drivers/scsi/53c7,8xx.cintr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
cmd5235drivers/scsi/53c7,8xx.c} else if (cmd) 
cmd5236drivers/scsi/53c7,8xx.cabnormal_finished (cmd, DID_BAD_TARGET << 16);
cmd5277drivers/scsi/53c7,8xx.cintr_bf (host, cmd);
cmd5292drivers/scsi/53c7,8xx.cswitch ((tmp = hostdata->dstat_sir_intr (host, cmd))) {
cmd5306drivers/scsi/53c7,8xx.cintr_break (host, cmd);
cmd5439drivers/scsi/53c7,8xx.cNCR53c7xx_abort (Scsi_Cmnd *cmd) {
cmd5441drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd5454drivers/scsi/53c7,8xx.ccmd->pid);
cmd5479drivers/scsi/53c7,8xx.ccmd->pid);
cmd5487drivers/scsi/53c7,8xx.cif (cache_pid == cmd->pid) 
cmd5488drivers/scsi/53c7,8xx.cpanic ("scsi%d : bloody fetus %d\n", host->host_no, cmd->pid);
cmd5490drivers/scsi/53c7,8xx.ccache_pid = cmd->pid;
cmd5506drivers/scsi/53c7,8xx.cme && me != cmd;  last = (Scsi_Cmnd **)&(me->SCp.ptr), 
cmd5516drivers/scsi/53c7,8xx.ccmd->result = DID_ABORT << 16;
cmd5517drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd5532drivers/scsi/53c7,8xx.ccurr && curr->cmd != cmd; prev = (struct NCR53c7x0_cmd **) 
cmd5536drivers/scsi/53c7,8xx.cif ((cmd->result & 0xff) != 0xff && (cmd->result & 0xff00) != 0xff00) {
cmd5540drivers/scsi/53c7,8xx.ccmd->host_scribble = NULL;
cmd5542drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd5544drivers/scsi/53c7,8xx.chost->host_no, cmd->pid);
cmd5549drivers/scsi/53c7,8xx.ccmd->host->host_no);
cmd5560drivers/scsi/53c7,8xx.ccurr = (struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd5564drivers/scsi/53c7,8xx.ccmd->host_scribble = NULL;
cmd5567drivers/scsi/53c7,8xx.cif (((cmd->result & 0xff00) == 0xff00) ||
cmd5568drivers/scsi/53c7,8xx.c((cmd->result & 0xff) == 0xff)) {
cmd5570drivers/scsi/53c7,8xx.ccmd->result = DID_ABORT << 16;
cmd5579drivers/scsi/53c7,8xx.c--hostdata->busy[cmd->target][cmd->lun];
cmd5582drivers/scsi/53c7,8xx.ccmd->scsi_done(cmd);
cmd5603drivers/scsi/53c7,8xx.cNCR53c7xx_reset (Scsi_Cmnd *cmd) {
cmd5624drivers/scsi/53c7,8xx.cstruct Scsi_Host *host = cmd->host;
cmd5637drivers/scsi/53c7,8xx.cif (tmp == cmd) {
cmd5647drivers/scsi/53c7,8xx.cc = (struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd5649drivers/scsi/53c7,8xx.ccmd->host_scribble = NULL;
cmd5653drivers/scsi/53c7,8xx.cprintk ("scsi%d: lost command %ld\n", host->host_no, cmd->pid);
cmd5654drivers/scsi/53c7,8xx.ccmd->SCp.buffer = (struct scatterlist *) nuke_list;
cmd5655drivers/scsi/53c7,8xx.cnuke_list = cmd;
cmd5693drivers/scsi/53c7,8xx.cinsn_to_offset (Scsi_Cmnd *cmd, u32 *insn) {
cmd5695drivers/scsi/53c7,8xx.c(struct NCR53c7x0_hostdata *) cmd->host->hostdata;
cmd5697drivers/scsi/53c7,8xx.c(struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd5717drivers/scsi/53c7,8xx.cif ((buffers = cmd->use_sg)) {
cmd5719drivers/scsi/53c7,8xx.csegment = (struct scatterlist *) cmd->buffer;
cmd5725drivers/scsi/53c7,8xx.ccmd->host->host_no, saved, segment->address);
cmd5732drivers/scsi/53c7,8xx.coffset = ptr - (char *) (cmd->request_buffer);
cmd5756drivers/scsi/53c7,8xx.cprint_progress (Scsi_Cmnd *cmd) {
cmd5759drivers/scsi/53c7,8xx.c(struct NCR53c7x0_cmd *) cmd->host_scribble;
cmd5763drivers/scsi/53c7,8xx.cNCR53c7x0_local_setup (cmd->host);
cmd5777drivers/scsi/53c7,8xx.coffset = insn_to_offset (cmd, ptr);
cmd5781drivers/scsi/53c7,8xx.ccmd->host->host_no, where, offset);
cmd5785drivers/scsi/53c7,8xx.ccmd->host->host_no, where);
cmd5787drivers/scsi/53c7,8xx.csize = print_insn (cmd->host, 
cmd5789drivers/scsi/53c7,8xx.cprint_insn (cmd->host, 
cmd5804drivers/scsi/53c7,8xx.cScsi_Cmnd *cmd;
cmd5840drivers/scsi/53c7,8xx.ccmd = (Scsi_Cmnd *) bus_to_virt(dsa[hostdata->dsa_cmnd / sizeof(u32)]);
cmd5842drivers/scsi/53c7,8xx.c(u32) virt_to_bus(cmd));
cmd5843drivers/scsi/53c7,8xx.cif (cmd) {
cmd5845drivers/scsi/53c7,8xx.ccmd->result, cmd->target, cmd->lun);
cmd5846drivers/scsi/53c7,8xx.cprint_command(cmd->cmnd);
cmd5851drivers/scsi/53c7,8xx.cif (cmd) { 
cmd5854drivers/scsi/53c7,8xx.chost->host_no, cmd->target,
cmd5855drivers/scsi/53c7,8xx.chostdata->sync[cmd->target].sxfer_sanity,
cmd5856drivers/scsi/53c7,8xx.chostdata->sync[cmd->target].scntl3_sanity);
cmd5857drivers/scsi/53c7,8xx.cfor (i = 0; i < (sizeof(hostdata->sync[cmd->target].script) / 4); ++i)
cmd5858drivers/scsi/53c7,8xx.cprintk ("0x%x ", hostdata->sync[cmd->target].script[i]);
cmd5860drivers/scsi/53c7,8xx.cprint_progress (cmd);
cmd5879drivers/scsi/53c7,8xx.cScsi_Cmnd *cmd, *next_cmd;
cmd5884drivers/scsi/53c7,8xx.cfor (left = host->can_queue, cmd = (Scsi_Cmnd *) hostdata->issue_queue; 
cmd5885drivers/scsi/53c7,8xx.cleft >= 0 && cmd; 
cmd5886drivers/scsi/53c7,8xx.ccmd = next_cmd) {
cmd5887drivers/scsi/53c7,8xx.cnext_cmd = (Scsi_Cmnd *) cmd->SCp.ptr;
cmd5890drivers/scsi/53c7,8xx.cif (cmd->host_scribble) {
cmd5891drivers/scsi/53c7,8xx.cif (check_address ((unsigned long) (cmd->host_scribble), 
cmd5892drivers/scsi/53c7,8xx.csizeof (cmd->host_scribble)) == -1)
cmd5894drivers/scsi/53c7,8xx.chost->host_no, cmd->pid);
cmd5897drivers/scsi/53c7,8xx.cprint_dsa (host, ((struct NCR53c7x0_cmd *) cmd->host_scribble)
cmd5901drivers/scsi/53c7,8xx.chost->host_no, cmd->pid, cmd->target, cmd->lun);
cmd6117drivers/scsi/53c7,8xx.cif (c->cmd->SCp.buffer) {
cmd6125drivers/scsi/53c7,8xx.cc->cmd->SCp.buffer = (struct scatterlist *) list;
cmd6126drivers/scsi/53c7,8xx.clist = c->cmd;
cmd6364drivers/scsi/53c7,8xx.cstruct NCR53c7x0_cmd *cmd, *tmp;
cmd6381drivers/scsi/53c7,8xx.cfor (cmd = (struct NCR53c7x0_cmd *) hostdata->free; cmd; cmd = tmp, 
cmd6383drivers/scsi/53c7,8xx.ctmp = (struct NCR53c7x0_cmd *) cmd->next;
cmd6388drivers/scsi/53c7,8xx.ccmd->next = NULL;
cmd6389drivers/scsi/53c7,8xx.cif (cmd->free)
cmd6390drivers/scsi/53c7,8xx.ccmd->free ((void *) cmd->real, cmd->size);
cmd1086drivers/scsi/53c7,8xx.hScsi_Cmnd *cmd;      /* Associated Scsi_Cmnd 
cmd1250drivers/scsi/53c7,8xx.hvoid (* dsa_fixup)(struct NCR53c7x0_cmd *cmd);
cmd1260drivers/scsi/53c7,8xx.hint (* dstat_sir_intr)(struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
cmd131drivers/scsi/AM53C974.cstatic __inline__ void initialize_SCp(Scsi_Cmnd *cmd);
cmd143drivers/scsi/AM53C974.cstatic int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd, unsigned char msg);
cmd144drivers/scsi/AM53C974.cstatic void AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag);
cmd757drivers/scsi/AM53C974.cstatic __inline__ void initialize_SCp(Scsi_Cmnd *cmd)
cmd759drivers/scsi/AM53C974.cif (cmd->use_sg) {
cmd760drivers/scsi/AM53C974.ccmd->SCp.buffer = (struct scatterlist *)cmd->buffer;
cmd761drivers/scsi/AM53C974.ccmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd762drivers/scsi/AM53C974.ccmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
cmd763drivers/scsi/AM53C974.ccmd->SCp.this_residual = cmd->SCp.buffer->length; }
cmd765drivers/scsi/AM53C974.ccmd->SCp.buffer = NULL;
cmd766drivers/scsi/AM53C974.ccmd->SCp.buffers_residual = 0;
cmd767drivers/scsi/AM53C974.ccmd->SCp.ptr = (char *)cmd->request_buffer;
cmd768drivers/scsi/AM53C974.ccmd->SCp.this_residual = cmd->request_bufflen; }
cmd812drivers/scsi/AM53C974.cint AM53C974_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
cmd814drivers/scsi/AM53C974.cstruct Scsi_Host         *instance = cmd->host;
cmd822drivers/scsi/AM53C974.ccmd->cmnd[0], cmd->target, cmd->lun, cmd->request_bufflen, cmd->use_sg));
cmd825drivers/scsi/AM53C974.ccmd->host_scribble = NULL;
cmd826drivers/scsi/AM53C974.ccmd->scsi_done = done;
cmd827drivers/scsi/AM53C974.ccmd->result = 0;
cmd828drivers/scsi/AM53C974.ccmd->device->disconnect = 0;
cmd834drivers/scsi/AM53C974.cif (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd835drivers/scsi/AM53C974.cLIST(cmd, hostdata->issue_queue);
cmd836drivers/scsi/AM53C974.ccmd->host_scribble = (unsigned char *)hostdata->issue_queue;
cmd837drivers/scsi/AM53C974.chostdata->issue_queue = cmd; }
cmd841drivers/scsi/AM53C974.cLIST(cmd, tmp);
cmd842drivers/scsi/AM53C974.ctmp->host_scribble = (unsigned char *)cmd; }
cmd845drivers/scsi/AM53C974.c(cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"));
cmd1169drivers/scsi/AM53C974.cScsi_Cmnd                *cmd;
cmd1174drivers/scsi/AM53C974.ccmd = (Scsi_Cmnd *)hostdata->sel_cmd;
cmd1176drivers/scsi/AM53C974.ccmd->result = DID_BAD_TARGET << 16;
cmd1187drivers/scsi/AM53C974.ccmd = (Scsi_Cmnd *)hostdata->connected;
cmd1188drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
cmd1190drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
cmd1191drivers/scsi/AM53C974.cif (cmd->device->disconnect) {
cmd1194drivers/scsi/AM53C974.cLIST(cmd,hostdata->disconnected_queue);
cmd1195drivers/scsi/AM53C974.ccmd->host_scribble = (unsigned char *)hostdata->disconnected_queue;
cmd1196drivers/scsi/AM53C974.chostdata->disconnected_queue = cmd;
cmd1198drivers/scsi/AM53C974.c"  the disconnected_queue\n", instance->host_no, cmd->target,
cmd1199drivers/scsi/AM53C974.ccmd->lun, hostdata->disconnected_queue->SCp.this_residual));
cmd1205drivers/scsi/AM53C974.cif (cmd->cmnd[0] == REQUEST_SENSE) {
cmd1208drivers/scsi/AM53C974.cfor (i = 0; i < cmd->request_bufflen; i++) {
cmd1209drivers/scsi/AM53C974.cprintk("%02x ", *((char *)(cmd->request_buffer) + i));
cmd1217drivers/scsi/AM53C974.ccmd = (Scsi_Cmnd *)hostdata->connected;
cmd1218drivers/scsi/AM53C974.cif (cmd) {
cmd1222drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
cmd1224drivers/scsi/AM53C974.cinstance->host_no, cmd->SCp.phase, cmd->target, cmd->SCp.this_residual, cmd->SCp.buffers_residual,
cmd1225drivers/scsi/AM53C974.ccmd->SCp.Message);
cmd1233drivers/scsi/AM53C974.chostdata->sync_off[cmd->target] = 0; }
cmd1235drivers/scsi/AM53C974.ccmd->result = DID_ABORT << 16;
cmd1237drivers/scsi/AM53C974.ccmd->result = DID_ERROR << 16;
cmd1248drivers/scsi/AM53C974.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1252drivers/scsi/AM53C974.ccmd->scsi_done(cmd);
cmd1255drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target); 
cmd1270drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target); 
cmd1392drivers/scsi/AM53C974.cScsi_Cmnd                *cmd = (Scsi_Cmnd *)hostdata->connected;
cmd1400drivers/scsi/AM53C974.c(long)hostdata->connected, (long)hostdata->sel_cmd, cmd->SCp.this_residual, cmd->SCp.buffers_residual));
cmd1401drivers/scsi/AM53C974.ccmd->SCp.phase = PHASE_DATAOUT;
cmd1406drivers/scsi/AM53C974.c(long)hostdata->connected, (long)hostdata->sel_cmd, cmd->SCp.this_residual, cmd->SCp.buffers_residual));
cmd1407drivers/scsi/AM53C974.ccmd->SCp.phase = PHASE_DATAIN;
cmd1414drivers/scsi/AM53C974.cif ((!cmd->SCp.this_residual) && cmd->SCp.buffers_residual) {
cmd1415drivers/scsi/AM53C974.ccmd->SCp.buffer++;
cmd1416drivers/scsi/AM53C974.ccmd->SCp.buffers_residual--;
cmd1417drivers/scsi/AM53C974.ccmd->SCp.ptr = (unsigned char *)cmd->SCp.buffer->address;
cmd1418drivers/scsi/AM53C974.ccmd->SCp.this_residual = cmd->SCp.buffer->length; }
cmd1419drivers/scsi/AM53C974.cif (cmd->SCp.this_residual) {
cmd1423drivers/scsi/AM53C974.c(unsigned long)cmd->SCp.this_residual,
cmd1424drivers/scsi/AM53C974.ccmd->SCp.ptr); }
cmd1433drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
cmd1434drivers/scsi/AM53C974.cif (cmd->SCp.phase == PHASE_DATAIN)
cmd1436drivers/scsi/AM53C974.cif ((cmd->SCp.phase == PHASE_DATAOUT) && (AM53C974_read_8(DMACMD) & DMACMD_START)) {
cmd1440drivers/scsi/AM53C974.ccmd->SCp.ptr += cmd->SCp.this_residual - residual;
cmd1441drivers/scsi/AM53C974.ccmd->SCp.this_residual = residual;
cmd1444drivers/scsi/AM53C974.cif (cmd->SCp.phase == PHASE_STATIN) {
cmd1446drivers/scsi/AM53C974.ccmd->SCp.Status = AM53C974_read_8(FFREG);
cmd1447drivers/scsi/AM53C974.ccmd->SCp.Message = AM53C974_read_8(FFREG); 
cmd1449drivers/scsi/AM53C974.ccmd->SCp.Status, cmd->SCp.Message));
cmd1450drivers/scsi/AM53C974.cret = AM53C974_message(instance, cmd, cmd->SCp.Message); }
cmd1455drivers/scsi/AM53C974.ccmd->SCp.Message = AM53C974_read_8(FFREG);
cmd1457drivers/scsi/AM53C974.cret = AM53C974_message(instance, cmd, cmd->SCp.Message);
cmd1459drivers/scsi/AM53C974.ccmd->SCp.phase = PHASE_MSGIN;
cmd1460drivers/scsi/AM53C974.cAM53C974_set_sync(instance, cmd->target);
cmd1466drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
cmd1487drivers/scsi/AM53C974.ccmd->SCp.phase = PHASE_MSGOUT;
cmd1489drivers/scsi/AM53C974.cAM53C974_set_sync(instance, cmd->target);
cmd1494drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
cmd1495drivers/scsi/AM53C974.cfor (i = 0; i < cmd->cmd_len; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]);
cmd1497drivers/scsi/AM53C974.ccmd->SCp.phase = PHASE_CMDOUT;
cmd1498drivers/scsi/AM53C974.cAM53C974_set_sync(instance, cmd->target);
cmd1503drivers/scsi/AM53C974.cif (cmd->SCp.phase == PHASE_DATAIN)
cmd1505drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
cmd1506drivers/scsi/AM53C974.cif (cmd->SCp.phase == PHASE_DATAOUT) {
cmd1513drivers/scsi/AM53C974.ccmd->SCp.ptr += cmd->SCp.this_residual - residual;
cmd1514drivers/scsi/AM53C974.ccmd->SCp.this_residual = residual; }
cmd1517drivers/scsi/AM53C974.ccmd->SCp.phase = PHASE_STATIN;
cmd1544drivers/scsi/AM53C974.cstatic int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd,
cmd1573drivers/scsi/AM53C974.cinstance->host_no, cmd->target, cmd->lun));
cmd1576drivers/scsi/AM53C974.cif (!cmd->next_link) {
cmd1578drivers/scsi/AM53C974.cinstance->host_no, cmd->target, cmd->lun);
cmd1585drivers/scsi/AM53C974.c"LINKED_FLG_CMD_COMPLETE message\n", cmd->cmnd[0]));
cmd1589drivers/scsi/AM53C974.cinitialize_SCp(cmd->next_link);
cmd1591drivers/scsi/AM53C974.ccmd->next_link->tag = cmd->tag;
cmd1592drivers/scsi/AM53C974.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd1594drivers/scsi/AM53C974.cinstance->host_no, cmd->target, cmd->lun));
cmd1595drivers/scsi/AM53C974.ccmd->scsi_done(cmd);
cmd1596drivers/scsi/AM53C974.ccmd = hostdata->connected;
cmd1604drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
cmd1606drivers/scsi/AM53C974.ccmd->device->disconnect = 0;
cmd1620drivers/scsi/AM53C974.cif (cmd->cmnd[0] != REQUEST_SENSE) 
cmd1621drivers/scsi/AM53C974.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd1622drivers/scsi/AM53C974.celse if (cmd->SCp.Status != GOOD)
cmd1623drivers/scsi/AM53C974.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);        
cmd1628drivers/scsi/AM53C974.c"COMMAND_COMPLETE message\n", cmd->cmnd[0]));
cmd1630drivers/scsi/AM53C974.cif ((cmd->cmnd[0] != REQUEST_SENSE) && (cmd->SCp.Status == CHECK_CONDITION)) {
cmd1632drivers/scsi/AM53C974.ccmd->cmnd[0] = REQUEST_SENSE;
cmd1633drivers/scsi/AM53C974.ccmd->cmnd[1] &= 0xe0;
cmd1634drivers/scsi/AM53C974.ccmd->cmnd[2] = 0;
cmd1635drivers/scsi/AM53C974.ccmd->cmnd[3] = 0;
cmd1636drivers/scsi/AM53C974.ccmd->cmnd[4] = sizeof(cmd->sense_buffer);
cmd1637drivers/scsi/AM53C974.ccmd->cmnd[5] = 0;
cmd1638drivers/scsi/AM53C974.ccmd->SCp.buffer = NULL;
cmd1639drivers/scsi/AM53C974.ccmd->SCp.buffers_residual = 0;
cmd1640drivers/scsi/AM53C974.ccmd->SCp.ptr = (char *)cmd->sense_buffer;
cmd1641drivers/scsi/AM53C974.ccmd->SCp.this_residual = sizeof(cmd->sense_buffer);
cmd1642drivers/scsi/AM53C974.cLIST(cmd,hostdata->issue_queue);
cmd1643drivers/scsi/AM53C974.ccmd->host_scribble = (unsigned char *)hostdata->issue_queue;
cmd1644drivers/scsi/AM53C974.chostdata->issue_queue = (Scsi_Cmnd *)cmd;
cmd1654drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
cmd1660drivers/scsi/AM53C974.ccmd->target,  DEF_CLK / DEF_STP);
cmd1661drivers/scsi/AM53C974.chostdata->sync_off[cmd->target] = 0;
cmd1662drivers/scsi/AM53C974.chostdata->sync_per[cmd->target] = DEF_STP; }
cmd1667drivers/scsi/AM53C974.ccmd->device->tagged_queue = 0;
cmd1668drivers/scsi/AM53C974.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd1679drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
cmd1680drivers/scsi/AM53C974.ccmd->device->disconnect = 1;
cmd1688drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
cmd1699drivers/scsi/AM53C974.ccmd->cmnd[0]));
cmd1706drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
cmd1746drivers/scsi/AM53C974.cret = AM53C974_sync_neg(instance, cmd->target, extended_msg);
cmd1786drivers/scsi/AM53C974.cstatic void AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
cmd1791drivers/scsi/AM53C974.cunsigned int             i, len, cmd_size = COMMAND_SIZE(cmd->cmnd[0]);
cmd1800drivers/scsi/AM53C974.ctmp[0] = IDENTIFY(1, cmd->lun);
cmd1803drivers/scsi/AM53C974.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
cmd1807drivers/scsi/AM53C974.cif (cmd->device->current_tag == 0) cmd->device->current_tag = 1;
cmd1808drivers/scsi/AM53C974.ccmd->tag = cmd->device->current_tag;
cmd1809drivers/scsi/AM53C974.ccmd->device->current_tag++; }
cmd1811drivers/scsi/AM53C974.ccmd->tag = (unsigned char)tag;
cmd1812drivers/scsi/AM53C974.ctmp[2] = cmd->tag;
cmd1824drivers/scsi/AM53C974.ccmd->tag = 0; }
cmd1828drivers/scsi/AM53C974.cif (((cmd->cmnd[0] == INQUIRY) || (cmd->cmnd[0] == REQUEST_SENSE)) &&
cmd1829drivers/scsi/AM53C974.c!(hostdata->sync_neg[cmd->target]) && hostdata->sync_en[cmd->target]) {
cmd1830drivers/scsi/AM53C974.chostdata->sync_neg[cmd->target] = 1;
cmd1834drivers/scsi/AM53C974.chostdata->msgout[3] = 250 / (int)hostdata->max_rate[cmd->target];
cmd1835drivers/scsi/AM53C974.chostdata->msgout[4] = hostdata->max_offset[cmd->target];
cmd1838drivers/scsi/AM53C974.cAM53C974_write_8(SDIDREG, SDIREG_MASK & cmd->target);       /* setup dest. id  */
cmd1842drivers/scsi/AM53C974.cfor (i = 0; i < cmd_size; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]);
cmd1847drivers/scsi/AM53C974.cfor (i = 0; i < cmd_size; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]);
cmd2096drivers/scsi/AM53C974.cint AM53C974_abort(Scsi_Cmnd *cmd)
cmd2099drivers/scsi/AM53C974.cstruct Scsi_Host         *instance = cmd->host;
cmd2117drivers/scsi/AM53C974.cif ((hostdata->connected == cmd) || (hostdata->sel_cmd == cmd)) {
cmd2130drivers/scsi/AM53C974.cif (cmd == tmp) {
cmd2166drivers/scsi/AM53C974.cif (cmd == tmp) {
cmd2198drivers/scsi/AM53C974.cint AM53C974_reset(Scsi_Cmnd *cmd)
cmd2202drivers/scsi/AM53C974.cstruct Scsi_Host         *instance = cmd->host;
cmd2240drivers/scsi/AM53C974.ccmd->result = DID_RESET << 16;
cmd2241drivers/scsi/AM53C974.ccmd->scsi_done(cmd);
cmd291drivers/scsi/AM53C974.hint AM53C974_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *));
cmd292drivers/scsi/AM53C974.hint AM53C974_abort(Scsi_Cmnd *cmd);
cmd293drivers/scsi/AM53C974.hint AM53C974_reset (Scsi_Cmnd *cmd);
cmd321drivers/scsi/NCR5380.cstatic __inline__ void initialize_SCp(Scsi_Cmnd *cmd) {
cmd327drivers/scsi/NCR5380.cif (cmd->use_sg) {
cmd328drivers/scsi/NCR5380.ccmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
cmd329drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd330drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
cmd331drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd333drivers/scsi/NCR5380.ccmd->SCp.buffer = NULL;
cmd334drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = 0;
cmd335drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->request_buffer;
cmd336drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd525drivers/scsi/NCR5380.cstatic int should_disconnect (unsigned char cmd) {
cmd526drivers/scsi/NCR5380.cswitch (cmd) {
cmd772drivers/scsi/NCR5380.cchar *lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length);
cmd774drivers/scsi/NCR5380.cchar *lprint_command (unsigned char *cmd, char *pos, char *buffer, int len);
cmd864drivers/scsi/NCR5380.cchar *lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length) {
cmd866drivers/scsi/NCR5380.ccmd->host->host_no, cmd->target, cmd->lun);
cmd868drivers/scsi/NCR5380.cpos = lprint_command (cmd->cmnd, pos, buffer, length);
cmd1047drivers/scsi/NCR5380.cint NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) {
cmd1048drivers/scsi/NCR5380.cstruct Scsi_Host *instance = cmd->host;
cmd1054drivers/scsi/NCR5380.cswitch (cmd->cmnd[0]) {
cmd1059drivers/scsi/NCR5380.ccmd->result = (DID_ERROR << 16);
cmd1060drivers/scsi/NCR5380.cdone(cmd);
cmd1073drivers/scsi/NCR5380.cif (cmd->request_bufflen > NCR5380_STAT_LIMIT)
cmd1075drivers/scsi/NCR5380.cswitch (cmd->cmnd[0])
cmd1080drivers/scsi/NCR5380.chostdata->time_write[cmd->target] -= (jiffies - hostdata->timebase);
cmd1081drivers/scsi/NCR5380.chostdata->bytes_write[cmd->target] += cmd->request_bufflen;
cmd1087drivers/scsi/NCR5380.chostdata->time_read[cmd->target] -= (jiffies - hostdata->timebase);
cmd1088drivers/scsi/NCR5380.chostdata->bytes_read[cmd->target] += cmd->request_bufflen;
cmd1099drivers/scsi/NCR5380.ccmd->host_scribble = NULL;
cmd1100drivers/scsi/NCR5380.ccmd->scsi_done = done;
cmd1102drivers/scsi/NCR5380.ccmd->result = 0;
cmd1113drivers/scsi/NCR5380.cif (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd1114drivers/scsi/NCR5380.cLIST(cmd, hostdata->issue_queue);
cmd1115drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) hostdata->issue_queue;
cmd1116drivers/scsi/NCR5380.chostdata->issue_queue = cmd;
cmd1120drivers/scsi/NCR5380.cLIST(cmd, tmp);
cmd1121drivers/scsi/NCR5380.ctmp->host_scribble = (unsigned char *) cmd;
cmd1125drivers/scsi/NCR5380.c(cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
cmd1395drivers/scsi/NCR5380.cstatic void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd* cmd)
cmd1398drivers/scsi/NCR5380.cif (cmd->request_bufflen > NCR5380_STAT_LIMIT)
cmd1400drivers/scsi/NCR5380.cswitch (cmd->cmnd[0])
cmd1405drivers/scsi/NCR5380.chostdata->time_write[cmd->target] += (jiffies - hostdata->timebase);
cmd1412drivers/scsi/NCR5380.chostdata->time_read[cmd->target] += (jiffies - hostdata->timebase);
cmd1451drivers/scsi/NCR5380.cstatic int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
cmd1565drivers/scsi/NCR5380.cNCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
cmd1613drivers/scsi/NCR5380.cprintk("scsi%d : selecting target %d\n", instance->host_no, cmd->target);
cmd1654drivers/scsi/NCR5380.cif (hostdata->targets_present & (1 << cmd->target)) {
cmd1664drivers/scsi/NCR5380.ccmd->result = DID_BAD_TARGET << 16;
cmd1666drivers/scsi/NCR5380.ccollect_stats(hostdata, cmd);
cmd1668drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd1678drivers/scsi/NCR5380.chostdata->targets_present |= (1 << cmd->target);
cmd1714drivers/scsi/NCR5380.cinstance->host_no, cmd->target);
cmd1716drivers/scsi/NCR5380.ctmp[0] = IDENTIFY(((instance->irq == IRQ_NONE) ? 0 : 1), cmd->lun);
cmd1718drivers/scsi/NCR5380.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
cmd1722drivers/scsi/NCR5380.cif (cmd->device->current_tag == 0)
cmd1723drivers/scsi/NCR5380.ccmd->device->current_tag = 1;
cmd1725drivers/scsi/NCR5380.ccmd->tag = cmd->device->current_tag;
cmd1726drivers/scsi/NCR5380.ccmd->device->current_tag++;
cmd1728drivers/scsi/NCR5380.ccmd->tag = (unsigned char) tag;
cmd1730drivers/scsi/NCR5380.ctmp[2] = cmd->tag;
cmd1737drivers/scsi/NCR5380.ccmd->tag=0;
cmd1748drivers/scsi/NCR5380.chostdata->connected = cmd;
cmd1750drivers/scsi/NCR5380.cif (!cmd->device->tagged_queue)
cmd1752drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd1754drivers/scsi/NCR5380.cinitialize_SCp(cmd);
cmd2364drivers/scsi/NCR5380.cScsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
cmd2399drivers/scsi/NCR5380.ccmd->result = DID_ERROR  << 16;
cmd2400drivers/scsi/NCR5380.ccmd->done(cmd);
cmd2408drivers/scsi/NCR5380.cif (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
cmd2409drivers/scsi/NCR5380.c++cmd->SCp.buffer;
cmd2410drivers/scsi/NCR5380.c--cmd->SCp.buffers_residual;
cmd2411drivers/scsi/NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd2412drivers/scsi/NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd2415drivers/scsi/NCR5380.cinstance->host_no, cmd->SCp.this_residual,
cmd2416drivers/scsi/NCR5380.ccmd->SCp.buffers_residual);
cmd2439drivers/scsi/NCR5380.cif (!cmd->device->borken &&
cmd2441drivers/scsi/NCR5380.c(transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
cmd2443drivers/scsi/NCR5380.ctransfersize = cmd->transfersize;
cmd2450drivers/scsi/NCR5380.cif (!cmd->device->borken && transfersize && 
cmd2452drivers/scsi/NCR5380.ccmd->SCp.this_residual && !(cmd->SCp.this_residual % 
cmd2461drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
cmd2467drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2468drivers/scsi/NCR5380.ccmd->device->borken = 1;
cmd2473drivers/scsi/NCR5380.ccmd->result = DID_ERROR  << 16;
cmd2474drivers/scsi/NCR5380.ccmd->done(cmd);
cmd2477drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
cmd2481drivers/scsi/NCR5380.c(int *) &cmd->SCp.this_residual, (unsigned char **)
cmd2482drivers/scsi/NCR5380.c&cmd->SCp.ptr);
cmd2488drivers/scsi/NCR5380.ccmd->SCp.Message = tmp;
cmd2509drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2517drivers/scsi/NCR5380.cif (!cmd->next_link) {
cmd2519drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2525drivers/scsi/NCR5380.cinitialize_SCp(cmd->next_link);
cmd2527drivers/scsi/NCR5380.ccmd->next_link->tag = cmd->tag;
cmd2528drivers/scsi/NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2531drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2534drivers/scsi/NCR5380.ccollect_stats(hostdata, cmd);
cmd2536drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2537drivers/scsi/NCR5380.ccmd = hostdata->connected;
cmd2548drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
cmd2550drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2568drivers/scsi/NCR5380.cif (cmd->cmnd[0] != REQUEST_SENSE) 
cmd2569drivers/scsi/NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2570drivers/scsi/NCR5380.celse if (cmd->SCp.Status != GOOD)
cmd2571drivers/scsi/NCR5380.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd2574drivers/scsi/NCR5380.cif ((cmd->cmnd[0] != REQUEST_SENSE) && 
cmd2575drivers/scsi/NCR5380.c(cmd->SCp.Status == CHECK_CONDITION)) {
cmd2580drivers/scsi/NCR5380.ccmd->cmnd[0] = REQUEST_SENSE;
cmd2581drivers/scsi/NCR5380.ccmd->cmnd[1] &= 0xe0;
cmd2582drivers/scsi/NCR5380.ccmd->cmnd[2] = 0;
cmd2583drivers/scsi/NCR5380.ccmd->cmnd[3] = 0;
cmd2584drivers/scsi/NCR5380.ccmd->cmnd[4] = sizeof(cmd->sense_buffer);
cmd2585drivers/scsi/NCR5380.ccmd->cmnd[5] = 0;
cmd2587drivers/scsi/NCR5380.ccmd->SCp.buffer = NULL;
cmd2588drivers/scsi/NCR5380.ccmd->SCp.buffers_residual = 0;
cmd2589drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->sense_buffer;
cmd2590drivers/scsi/NCR5380.ccmd->SCp.this_residual = sizeof(cmd->sense_buffer);
cmd2593drivers/scsi/NCR5380.cLIST(cmd,hostdata->issue_queue);
cmd2594drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) 
cmd2596drivers/scsi/NCR5380.chostdata->issue_queue = (Scsi_Cmnd *) cmd;
cmd2604drivers/scsi/NCR5380.ccollect_stats(hostdata, cmd);
cmd2606drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2626drivers/scsi/NCR5380.ccmd->device->tagged_queue = 0;
cmd2627drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd2635drivers/scsi/NCR5380.ccmd->device->disconnect = 1;
cmd2637drivers/scsi/NCR5380.cLIST(cmd,hostdata->disconnected_queue);
cmd2638drivers/scsi/NCR5380.ccmd->host_scribble = (unsigned char *) 
cmd2641drivers/scsi/NCR5380.chostdata->disconnected_queue = cmd;
cmd2646drivers/scsi/NCR5380.ccmd->target, cmd->lun);
cmd2755drivers/scsi/NCR5380.cinstance->host_no, tmp, cmd->target, cmd->lun);
cmd2758drivers/scsi/NCR5380.cinstance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
cmd2772drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2774drivers/scsi/NCR5380.ccmd->result = DID_ERROR << 16;
cmd2776drivers/scsi/NCR5380.ccollect_stats(hostdata, cmd);
cmd2778drivers/scsi/NCR5380.ccmd->scsi_done(cmd);
cmd2785drivers/scsi/NCR5380.clen = cmd->cmd_len;
cmd2786drivers/scsi/NCR5380.cdata = cmd->cmnd;
cmd2795drivers/scsi/NCR5380.cif (!disconnect && should_disconnect(cmd->cmnd[0])) {
cmd2810drivers/scsi/NCR5380.ccmd->SCp.Status = tmp;
cmd3043drivers/scsi/NCR5380.cint NCR5380_abort (Scsi_Cmnd *cmd) {
cmd3045drivers/scsi/NCR5380.cstruct Scsi_Host *instance = cmd->host;
cmd3051drivers/scsi/NCR5380.cprint_Scsi_Cmnd (cmd);
cmd3056drivers/scsi/NCR5380.cprint_Scsi_Cmnd (cmd);
cmd3076drivers/scsi/NCR5380.cif (hostdata->connected == cmd) {
cmd3114drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd3178drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd3184drivers/scsi/NCR5380.cif (NCR5380_select (instance, cmd, (int) cmd->tag)) 
cmd3198drivers/scsi/NCR5380.cif (cmd == tmp) {
cmd3238drivers/scsi/NCR5380.cint NCR5380_reset (Scsi_Cmnd *cmd, unsigned int dummy) {
cmd3240drivers/scsi/NCR5380.cNCR5380_setup(cmd->host);
cmd3242drivers/scsi/NCR5380.cNCR5380_print_status (cmd->host);
cmd3243drivers/scsi/NCR5380.cdo_reset (cmd->host);
cmd297drivers/scsi/NCR5380.hint NCR5380_abort (Scsi_Cmnd *cmd);
cmd301drivers/scsi/NCR5380.hint NCR5380_reset (Scsi_Cmnd *cmd, unsigned int reset_flags);
cmd305drivers/scsi/NCR5380.hint NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *));
cmd309drivers/scsi/NCR5380.hstatic int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag);
cmd55drivers/scsi/a2091.cstatic int dma_setup (Scsi_Cmnd *cmd, int dir_in)
cmd58drivers/scsi/a2091.cunsigned long addr = VTOP(cmd->SCp.ptr);
cmd59drivers/scsi/a2091.cstruct Scsi_Host *instance = cmd->host;
cmd63drivers/scsi/a2091.c(!dir_in && mm_end_of_chunk (addr, cmd->SCp.this_residual)))
cmd65drivers/scsi/a2091.cHDATA(instance)->dma_bounce_len = (cmd->SCp.this_residual + 511)
cmd91drivers/scsi/a2091.cif (cmd->use_sg)
cmd97drivers/scsi/a2091.ccmd->SCp.ptr, cmd->SCp.this_residual);
cmd101drivers/scsi/a2091.ccmd->request_buffer, cmd->request_bufflen);
cmd110drivers/scsi/a2091.cHDATA(cmd->host)->dma_dir = dir_in;
cmd112drivers/scsi/a2091.cDMA(cmd->host)->CNTR = cntr;
cmd115drivers/scsi/a2091.cDMA(cmd->host)->ACR = addr;
cmd119drivers/scsi/a2091.ccache_clear (addr, cmd->SCp.this_residual);
cmd122drivers/scsi/a2091.ccache_push (addr, cmd->SCp.this_residual);
cmd125drivers/scsi/a2091.cDMA(cmd->host)->ST_DMA = 1;
cmd49drivers/scsi/a3000.cstatic int dma_setup (Scsi_Cmnd *cmd, int dir_in)
cmd52drivers/scsi/a3000.cunsigned long addr = VTOP(cmd->SCp.ptr);
cmd61drivers/scsi/a3000.c(!dir_in && mm_end_of_chunk (addr, cmd->SCp.this_residual)))
cmd63drivers/scsi/a3000.cHDATA(a3000_host)->dma_bounce_len = (cmd->SCp.this_residual + 511)
cmd76drivers/scsi/a3000.cif (cmd->use_sg) {
cmd78drivers/scsi/a3000.ccmd->SCp.ptr, cmd->SCp.this_residual);
cmd81drivers/scsi/a3000.ccmd->request_buffer, cmd->request_bufflen);
cmd111drivers/scsi/a3000.ccache_push (addr, cmd->SCp.this_residual);
cmd113drivers/scsi/a3000.ccache_clear (addr, cmd->SCp.this_residual);
cmd117drivers/scsi/a3000.ccache_push (addr, cmd->SCp.this_residual);
cmd514drivers/scsi/aha1542.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd533drivers/scsi/aha1542.cif(*cmd == REQUEST_SENSE){
cmd545drivers/scsi/aha1542.cif (*cmd == READ_10 || *cmd == WRITE_10)
cmd546drivers/scsi/aha1542.ci = xscsi2int(cmd+2);
cmd547drivers/scsi/aha1542.celse if (*cmd == READ_6 || *cmd == WRITE_6)
cmd548drivers/scsi/aha1542.ci = scsi2int(cmd+2);
cmd552drivers/scsi/aha1542.cprintk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd554drivers/scsi/aha1542.cprintk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
cmd557drivers/scsi/aha1542.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
cmd559drivers/scsi/aha1542.cif (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd597drivers/scsi/aha1542.cif (*cmd == READ_10 || *cmd == READ_6)
cmd599drivers/scsi/aha1542.celse if (*cmd == WRITE_10 || *cmd == WRITE_6)
cmd602drivers/scsi/aha1542.cmemcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
cmd700drivers/scsi/aha1542.cunchar cmd[5] = {CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
cmd710drivers/scsi/aha1542.cany2scsi((cmd+2), mb);
cmd711drivers/scsi/aha1542.caha1542_out(bse, cmd, 5);
cmd1039drivers/scsi/aha1542.cstatic unchar cmd[] = {  READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cmd1044drivers/scsi/aha1542.cif (!aha1542_command(i, cmd, buf, sizeof(buf))) {
cmd1054drivers/scsi/aha1542.cunsigned char cmd[10];
cmd1057drivers/scsi/aha1542.ccmd[0] = READ_10;
cmd1058drivers/scsi/aha1542.ccmd[1] = 0;
cmd1059drivers/scsi/aha1542.cxany2scsi(cmd+2, i);
cmd1060drivers/scsi/aha1542.ccmd[6] = 0;
cmd1061drivers/scsi/aha1542.ccmd[7] = 0;
cmd1062drivers/scsi/aha1542.ccmd[8] = 1;
cmd1063drivers/scsi/aha1542.ccmd[9] = 0;
cmd1064drivers/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);
cmd431drivers/scsi/aic7xxx.c#define aic7xxx_error(cmd)  ((cmd)->SCp.Status)
cmd436drivers/scsi/aic7xxx.c#define aic7xxx_status(cmd)  ((cmd)->SCp.sent_command)
cmd441drivers/scsi/aic7xxx.c#define aic7xxx_position(cmd)  ((cmd)->SCp.have_data_in)
cmd527drivers/scsi/aic7xxx.cScsi_Cmnd          *cmd;  /* Scsi_Cmnd for this scb */
cmd816drivers/scsi/aic7xxx.c(unsigned long) scb->next, (unsigned long) scb->cmd, scb->state,
cmd1039drivers/scsi/aic7xxx.caic7xxx_length(Scsi_Cmnd *cmd, int sg_last)
cmd1045drivers/scsi/aic7xxx.csegments = cmd->use_sg - sg_last;
cmd1046drivers/scsi/aic7xxx.csg = (struct scatterlist *) cmd->buffer;
cmd1048drivers/scsi/aic7xxx.cif (cmd->use_sg)
cmd1050drivers/scsi/aic7xxx.cfor (i = length = 0; (i < cmd->use_sg) && (i < segments); i++)
cmd1057drivers/scsi/aic7xxx.clength = cmd->request_bufflen;
cmd1282drivers/scsi/aic7xxx.cScsi_Cmnd *cmd = scb->cmd;
cmd1286drivers/scsi/aic7xxx.ccmd->target, cmd->channel);
cmd1302drivers/scsi/aic7xxx.cscb->cmd = NULL;
cmd1305drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd1319drivers/scsi/aic7xxx.cScsi_Cmnd *cmd;
cmd1351drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd1352drivers/scsi/aic7xxx.cscb->cmd = NULL;
cmd1353drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);  /* call the done function */
cmd1441drivers/scsi/aic7xxx.cscb->cmd->result = (DID_RESET << 16);
cmd1501drivers/scsi/aic7xxx.cscb->cmd->result = (DID_RESET << 16);
cmd1569drivers/scsi/aic7xxx.cscb->cmd->result = (DID_RESET << 16);
cmd1758drivers/scsi/aic7xxx.cScsi_Cmnd *cmd;
cmd1871drivers/scsi/aic7xxx.cscb->cmd->device->tagged_supported = 0;
cmd1872drivers/scsi/aic7xxx.cscb->cmd->device->tagged_queue = 0;
cmd2079drivers/scsi/aic7xxx.cif (!(scb->state & SCB_ACTIVE) || (scb->cmd == NULL))
cmd2083drivers/scsi/aic7xxx.cintstat, scb_index, scb->state, (unsigned int) scb->cmd);
cmd2087drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2089drivers/scsi/aic7xxx.caic7xxx_status(cmd) = scb->target_status;
cmd2091drivers/scsi/aic7xxx.ccmd->result |= scb->target_status;
cmd2100drivers/scsi/aic7xxx.cif ((aic7xxx_error(cmd) == 0) && !(cmd->flags & WAS_SENSE))
cmd2111drivers/scsi/aic7xxx.ccmd->flags |= WAS_SENSE;
cmd2115drivers/scsi/aic7xxx.cscb->sense_cmd[1] = (cmd->lun << 5);
cmd2116drivers/scsi/aic7xxx.cscb->sense_cmd[4] = sizeof(cmd->sense_buffer);
cmd2118drivers/scsi/aic7xxx.cscb->sense_sg.address = (char *) &cmd->sense_buffer;
cmd2119drivers/scsi/aic7xxx.cscb->sense_sg.length = sizeof(cmd->sense_buffer);
cmd2121drivers/scsi/aic7xxx.ccmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
cmd2150drivers/scsi/aic7xxx.ccmd->flags &= ~ASKED_FOR_SENSE;
cmd2151drivers/scsi/aic7xxx.cif (aic7xxx_error(cmd) == 0)
cmd2153drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd2160drivers/scsi/aic7xxx.cif (!aic7xxx_error(cmd))
cmd2162drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_BUS_BUSY;
cmd2168drivers/scsi/aic7xxx.cif (!aic7xxx_error(cmd))
cmd2170drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd2177drivers/scsi/aic7xxx.cif (!aic7xxx_error(cmd))
cmd2179drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd2189drivers/scsi/aic7xxx.cif (!(scb->state & SCB_ACTIVE) || (scb->cmd == NULL))
cmd2193drivers/scsi/aic7xxx.cintstat, scb_index, scb->state, (unsigned int) scb->cmd);
cmd2197drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2202drivers/scsi/aic7xxx.cif (!(cmd->flags & WAS_SENSE))
cmd2210drivers/scsi/aic7xxx.cactual = aic7xxx_length(cmd, scb->residual_SG_segment_count);
cmd2216drivers/scsi/aic7xxx.cif (actual < cmd->underflow)
cmd2220drivers/scsi/aic7xxx.ccmd->target, cmd->underflow, actual,
cmd2222drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_RETRY_COMMAND;
cmd2223drivers/scsi/aic7xxx.caic7xxx_status(cmd) = scb->target_status;
cmd2232drivers/scsi/aic7xxx.cif (!(scb->state & SCB_ACTIVE) || (scb->cmd == NULL))
cmd2236drivers/scsi/aic7xxx.cintstat, scb_index, scb->state, (unsigned int) scb->cmd);
cmd2240drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2247drivers/scsi/aic7xxx.cscsi_id, channel, cmd->lun & 0x07);
cmd2249drivers/scsi/aic7xxx.ccmd->result = (DID_RETRY_COMMAND << 16);
cmd2257drivers/scsi/aic7xxx.cif (!(scb->state & SCB_ACTIVE) || (scb->cmd == NULL))
cmd2261drivers/scsi/aic7xxx.cintstat, scb_index, scb->state, (unsigned int) scb->cmd);
cmd2351drivers/scsi/aic7xxx.cif (!(scb->state & SCB_ACTIVE) || (scb->cmd == NULL))
cmd2379drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2414drivers/scsi/aic7xxx.ccmd->target, cmd->channel & 0x01, cmd->lun & 0x07);
cmd2426drivers/scsi/aic7xxx.ccmd->result = DID_PARITY << 16;
cmd2433drivers/scsi/aic7xxx.ccmd->result = DID_RETRY_COMMAND << 16;
cmd2441drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2448drivers/scsi/aic7xxx.ccmd->result = (DID_TIME_OUT << 16);
cmd2490drivers/scsi/aic7xxx.cscb->position, scb->state, (unsigned int) scb->cmd);
cmd2519drivers/scsi/aic7xxx.cif (!(scb->state & SCB_ACTIVE) || (scb->cmd == NULL))
cmd2525drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, scb->position);
cmd2529drivers/scsi/aic7xxx.ccmd = scb->cmd;
cmd2530drivers/scsi/aic7xxx.ccmd->result |= (aic7xxx_error(cmd) << 16);
cmd2531drivers/scsi/aic7xxx.cif ((cmd->flags & WAS_SENSE) && !(cmd->flags & ASKED_FOR_SENSE))
cmd2536drivers/scsi/aic7xxx.ccmd->flags &= ASKED_FOR_SENSE;
cmd2540drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, (unsigned int) p->free_scb);
cmd2560drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, (unsigned int) p->free_scb);
cmd2568drivers/scsi/aic7xxx.cactual = aic7xxx_length(cmd, 0);
cmd2569drivers/scsi/aic7xxx.cif (!(cmd->flags & WAS_SENSE) && (actual > 0))
cmd2575drivers/scsi/aic7xxx.csp = &p->stats[cmd->channel & 0x01][cmd->target & 0x0F][cmd->lun & 0x07];
cmd2578drivers/scsi/aic7xxx.cif (cmd->request.cmd == WRITE)
cmd4119drivers/scsi/aic7xxx.cScsi_Cmnd *cmd,
cmd4131drivers/scsi/aic7xxx.cif (cmd->device->tagged_supported)
cmd4133drivers/scsi/aic7xxx.cif (cmd->device->tagged_queue == 0)
cmd4136drivers/scsi/aic7xxx.c"channel %d.\n", cmd->target, cmd->channel);
cmd4137drivers/scsi/aic7xxx.ccmd->device->tagged_queue = 1;
cmd4138drivers/scsi/aic7xxx.ccmd->device->current_tag = 1;  /* enable tagging */
cmd4140drivers/scsi/aic7xxx.ccmd->tag = cmd->device->current_tag;
cmd4141drivers/scsi/aic7xxx.ccmd->device->current_tag++;
cmd4145drivers/scsi/aic7xxx.cmask = (0x01 << (cmd->target | (cmd->channel << 3)));
cmd4155drivers/scsi/aic7xxx.cprintk("aic7xxx: Sending WDTR request to target %d.\n", cmd->target);
cmd4165drivers/scsi/aic7xxx.cprintk("aic7xxx: Sending SDTR request to target %d.\n", cmd->target);
cmd4173drivers/scsi/aic7xxx.ccmd->target, cmd->cmnd[0], cmd->cmd_len, p->needwdtr, mask);
cmd4175drivers/scsi/aic7xxx.cscb->target_channel_lun = ((cmd->target << 4) & 0xF0) |
cmd4176drivers/scsi/aic7xxx.c((cmd->channel & 0x01) << 3) | (cmd->lun & 0x07);
cmd4189drivers/scsi/aic7xxx.caddr = cmd->cmnd;
cmd4190drivers/scsi/aic7xxx.cscb->SCSI_cmd_length = cmd->cmd_len;
cmd4193drivers/scsi/aic7xxx.cif (cmd->use_sg)
cmd4195drivers/scsi/aic7xxx.cscb->SG_segment_count = cmd->use_sg;
cmd4196drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &cmd->request_buffer,
cmd4198drivers/scsi/aic7xxx.cmemcpy(&sg, &cmd->request_buffer, sizeof(sg));
cmd4203drivers/scsi/aic7xxx.ccmd->use_sg, aic7xxx_length(cmd, 0), scb->data_count);
cmd4210drivers/scsi/aic7xxx.c(unsigned long) cmd->request_buffer, cmd->request_bufflen);
cmd4212drivers/scsi/aic7xxx.cif (cmd->request_bufflen == 0)
cmd4227drivers/scsi/aic7xxx.cscb->sg.address = (char *) cmd->request_buffer;
cmd4228drivers/scsi/aic7xxx.cscb->sg.length = cmd->request_bufflen;
cmd4232drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &cmd->request_buffer, sizeof(scb->data_pointer));
cmd4245drivers/scsi/aic7xxx.caic7xxx_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
cmd4251drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
cmd4256drivers/scsi/aic7xxx.cif (!p->a_scanned && (cmd->channel == 0))
cmd4263drivers/scsi/aic7xxx.cif (!p->b_scanned && (cmd->channel == 1))
cmd4272drivers/scsi/aic7xxx.ccmd->cmnd[0], cmd->cmd_len, cmd->target, cmd->channel,
cmd4273drivers/scsi/aic7xxx.ccmd->lun & 0x07);
cmd4332drivers/scsi/aic7xxx.cscb->cmd = cmd;
cmd4333drivers/scsi/aic7xxx.caic7xxx_position(cmd) = scb->position;
cmd4342drivers/scsi/aic7xxx.caic7xxx_buildscb(p, cmd, scb);
cmd4351drivers/scsi/aic7xxx.cscb->position, (unsigned int) scb->cmd,
cmd4360drivers/scsi/aic7xxx.ccmd->scsi_done = fn;
cmd4361drivers/scsi/aic7xxx.caic7xxx_error(cmd) = DID_OK;
cmd4362drivers/scsi/aic7xxx.caic7xxx_status(cmd) = 0;
cmd4363drivers/scsi/aic7xxx.ccmd->result = 0;
cmd4364drivers/scsi/aic7xxx.cmemset(&cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
cmd4386drivers/scsi/aic7xxx.c(long) cmd, (long) scb->cmd, scb->position);
cmd4404drivers/scsi/aic7xxx.caic7xxx_abort_reset(Scsi_Cmnd *cmd, unsigned char errcode)
cmd4414drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
cmd4415drivers/scsi/aic7xxx.cscb = &(p->scb_array[aic7xxx_position(cmd)]);
cmd4515drivers/scsi/aic7xxx.caic7xxx_error(scb->cmd) = errcode;
cmd4548drivers/scsi/aic7xxx.caic7xxx_error(scb->cmd) = errcode;
cmd4592drivers/scsi/aic7xxx.ccmd->result = errcode << 16;
cmd4593drivers/scsi/aic7xxx.ccmd->scsi_done(cmd);
cmd4609drivers/scsi/aic7xxx.caic7xxx_abort(Scsi_Cmnd *cmd)
cmd4612drivers/scsi/aic7xxx.cprintk ("aic7xxx: (abort) target/channel %d/%d\n", cmd->target, cmd->channel);
cmd4615drivers/scsi/aic7xxx.cswitch (aic7xxx_abort_reset(cmd, DID_ABORT))
cmd4641drivers/scsi/aic7xxx.caic7xxx_reset(Scsi_Cmnd *cmd)
cmd4644drivers/scsi/aic7xxx.cprintk ("aic7xxx: (reset) target/channel %d/%d\n", cmd->target, cmd->channel);
cmd4647drivers/scsi/aic7xxx.cswitch (aic7xxx_abort_reset(cmd, DID_RESET))
cmd305drivers/scsi/atari_NCR5380.c#define  NEXT(cmd)  ((Scsi_Cmnd *)((cmd)->host_scribble))
cmd306drivers/scsi/atari_NCR5380.c#define  NEXTADDR(cmd)  ((Scsi_Cmnd **)&((cmd)->host_scribble))
cmd309drivers/scsi/atari_NCR5380.c#define  H_NO(cmd)  (cmd)->host->host_no
cmd396drivers/scsi/atari_NCR5380.cstatic int is_lun_busy( Scsi_Cmnd *cmd, int should_be_tagged )
cmd398drivers/scsi/atari_NCR5380.cSETUP_HOSTDATA(cmd->host);
cmd400drivers/scsi/atari_NCR5380.cif (hostdata->busy[cmd->target] & (1 << cmd->lun))
cmd403drivers/scsi/atari_NCR5380.c!setup_use_tagged_queuing || !cmd->device->tagged_supported)
cmd405drivers/scsi/atari_NCR5380.cif (TagAlloc[cmd->target][cmd->lun].nr_allocated >=
cmd406drivers/scsi/atari_NCR5380.cTagAlloc[cmd->target][cmd->lun].queue_size ) {
cmd409drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->target, cmd->lun );
cmd422drivers/scsi/atari_NCR5380.cstatic void cmd_get_tag( Scsi_Cmnd *cmd, int should_be_tagged )
cmd424drivers/scsi/atari_NCR5380.cSETUP_HOSTDATA(cmd->host);
cmd430drivers/scsi/atari_NCR5380.c!setup_use_tagged_queuing || !cmd->device->tagged_supported) {
cmd431drivers/scsi/atari_NCR5380.ccmd->tag = TAG_NONE;
cmd432drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd435drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->target, cmd->lun );
cmd439drivers/scsi/atari_NCR5380.cTAG_ALLOC *ta = &TagAlloc[cmd->target][cmd->lun];
cmd441drivers/scsi/atari_NCR5380.ccmd->tag = find_first_zero_bit( &ta->allocated, MAX_TAGS );
cmd442drivers/scsi/atari_NCR5380.cset_bit( cmd->tag, &ta->allocated );
cmd447drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->tag, cmd->target, cmd->lun,
cmd458drivers/scsi/atari_NCR5380.cstatic void cmd_free_tag( Scsi_Cmnd *cmd )
cmd460drivers/scsi/atari_NCR5380.cSETUP_HOSTDATA(cmd->host);
cmd462drivers/scsi/atari_NCR5380.cif (cmd->tag == TAG_NONE) {
cmd463drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd466drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->target, cmd->lun );
cmd469drivers/scsi/atari_NCR5380.celse if (cmd->tag >= MAX_TAGS) {
cmd471drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->tag );
cmd474drivers/scsi/atari_NCR5380.cTAG_ALLOC *ta = &TagAlloc[cmd->target][cmd->lun];
cmd475drivers/scsi/atari_NCR5380.cclear_bit( cmd->tag, &ta->allocated );
cmd479drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->tag, cmd->target, cmd->lun );
cmd528drivers/scsi/atari_NCR5380.cstatic void merge_consecutive_buffers( Scsi_Cmnd *cmd )
cmd532drivers/scsi/atari_NCR5380.cunsigned long oldlen = cmd->SCp.this_residual;
cmd536drivers/scsi/atari_NCR5380.cfor( endadr = VTOP(cmd->SCp.ptr + cmd->SCp.this_residual - 1);
cmd537drivers/scsi/atari_NCR5380.ccmd->SCp.buffers_residual &&
cmd538drivers/scsi/atari_NCR5380.cVTOP( (cmd->SCp.buffer+1)->address ) == endadr + 1; ) {
cmd542drivers/scsi/atari_NCR5380.cVTOP( (cmd->SCp.buffer+1)->address ), endadr );
cmd545drivers/scsi/atari_NCR5380.c++cmd->SCp.buffer;
cmd546drivers/scsi/atari_NCR5380.c--cmd->SCp.buffers_residual;
cmd547drivers/scsi/atari_NCR5380.ccmd->SCp.this_residual += cmd->SCp.buffer->length;
cmd548drivers/scsi/atari_NCR5380.cendadr += cmd->SCp.buffer->length;
cmd551drivers/scsi/atari_NCR5380.cif (oldlen != cmd->SCp.this_residual)
cmd553drivers/scsi/atari_NCR5380.ccnt, (long)(cmd->SCp.ptr), cmd->SCp.this_residual );
cmd566drivers/scsi/atari_NCR5380.cstatic __inline__ void initialize_SCp(Scsi_Cmnd *cmd)
cmd573drivers/scsi/atari_NCR5380.cif (cmd->use_sg) {
cmd574drivers/scsi/atari_NCR5380.ccmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
cmd575drivers/scsi/atari_NCR5380.ccmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd576drivers/scsi/atari_NCR5380.ccmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
cmd577drivers/scsi/atari_NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd581drivers/scsi/atari_NCR5380.cmerge_consecutive_buffers( cmd );
cmd583drivers/scsi/atari_NCR5380.ccmd->SCp.buffer = NULL;
cmd584drivers/scsi/atari_NCR5380.ccmd->SCp.buffers_residual = 0;
cmd585drivers/scsi/atari_NCR5380.ccmd->SCp.ptr = (char *) cmd->request_buffer;
cmd586drivers/scsi/atari_NCR5380.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd820drivers/scsi/atari_NCR5380.cchar *lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length);
cmd822drivers/scsi/atari_NCR5380.cchar *lprint_command (unsigned char *cmd, char *pos, char *buffer, int len);
cmd876drivers/scsi/atari_NCR5380.clprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length)
cmd879drivers/scsi/atari_NCR5380.cH_NO(cmd), cmd->target, cmd->lun);
cmd881drivers/scsi/atari_NCR5380.cpos = lprint_command (cmd->cmnd, pos, buffer, length);
cmd984drivers/scsi/atari_NCR5380.cint NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
cmd986drivers/scsi/atari_NCR5380.cSETUP_HOSTDATA(cmd->host);
cmd993drivers/scsi/atari_NCR5380.cswitch (cmd->cmnd[0]) {
cmd997drivers/scsi/atari_NCR5380.cH_NO(cmd));
cmd998drivers/scsi/atari_NCR5380.ccmd->result = (DID_ERROR << 16);
cmd999drivers/scsi/atari_NCR5380.cdone(cmd);
cmd1013drivers/scsi/atari_NCR5380.cif (cmd->request_bufflen > NCR5380_STAT_LIMIT)
cmd1015drivers/scsi/atari_NCR5380.cswitch (cmd->cmnd[0])
cmd1020drivers/scsi/atari_NCR5380.chostdata->time_write[cmd->target] -= (jiffies - hostdata->timebase);
cmd1021drivers/scsi/atari_NCR5380.chostdata->bytes_write[cmd->target] += cmd->request_bufflen;
cmd1027drivers/scsi/atari_NCR5380.chostdata->time_read[cmd->target] -= (jiffies - hostdata->timebase);
cmd1028drivers/scsi/atari_NCR5380.chostdata->bytes_read[cmd->target] += cmd->request_bufflen;
cmd1039drivers/scsi/atari_NCR5380.cNEXT(cmd) = NULL;
cmd1040drivers/scsi/atari_NCR5380.ccmd->scsi_done = done;
cmd1042drivers/scsi/atari_NCR5380.ccmd->result = 0;
cmd1067drivers/scsi/atari_NCR5380.coldto = scsi_update_timeout(cmd, 0);
cmd1069drivers/scsi/atari_NCR5380.cscsi_update_timeout(cmd, oldto);
cmd1071drivers/scsi/atari_NCR5380.cif (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd1072drivers/scsi/atari_NCR5380.cLIST(cmd, hostdata->issue_queue);
cmd1073drivers/scsi/atari_NCR5380.cNEXT(cmd) = hostdata->issue_queue;
cmd1074drivers/scsi/atari_NCR5380.chostdata->issue_queue = cmd;
cmd1079drivers/scsi/atari_NCR5380.cLIST(cmd, tmp);
cmd1080drivers/scsi/atari_NCR5380.cNEXT(tmp) = cmd;
cmd1085drivers/scsi/atari_NCR5380.cprintk("scsi%d: command added to %s of queue\n", H_NO(cmd),
cmd1086drivers/scsi/atari_NCR5380.c(cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
cmd1448drivers/scsi/atari_NCR5380.cstatic void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd* cmd)
cmd1451drivers/scsi/atari_NCR5380.cif (cmd->request_bufflen > NCR5380_STAT_LIMIT)
cmd1453drivers/scsi/atari_NCR5380.cswitch (cmd->cmnd[0])
cmd1458drivers/scsi/atari_NCR5380.chostdata->time_write[cmd->target] += (jiffies - hostdata->timebase);
cmd1465drivers/scsi/atari_NCR5380.chostdata->time_read[cmd->target] += (jiffies - hostdata->timebase);
cmd1504drivers/scsi/atari_NCR5380.cstatic int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
cmd1639drivers/scsi/atari_NCR5380.cNCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
cmd1693drivers/scsi/atari_NCR5380.cprintk("scsi%d: selecting target %d\n", HOSTNO, cmd->target);
cmd1744drivers/scsi/atari_NCR5380.cif (hostdata->targets_present & (1 << cmd->target)) {
cmd1754drivers/scsi/atari_NCR5380.ccmd->result = DID_BAD_TARGET << 16;
cmd1756drivers/scsi/atari_NCR5380.ccollect_stats(hostdata, cmd);
cmd1759drivers/scsi/atari_NCR5380.ccmd_free_tag( cmd );
cmd1761drivers/scsi/atari_NCR5380.ccmd->scsi_done(cmd);
cmd1770drivers/scsi/atari_NCR5380.chostdata->targets_present |= (1 << cmd->target);
cmd1792drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target);
cmd1794drivers/scsi/atari_NCR5380.ctmp[0] = IDENTIFY(1, cmd->lun);
cmd1797drivers/scsi/atari_NCR5380.cif (cmd->tag != TAG_NONE) {
cmd1799drivers/scsi/atari_NCR5380.ctmp[2] = cmd->tag;
cmd1805drivers/scsi/atari_NCR5380.ccmd->tag=0;
cmd1816drivers/scsi/atari_NCR5380.chostdata->connected = cmd;
cmd1818drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd1821drivers/scsi/atari_NCR5380.cinitialize_SCp(cmd);
cmd2142drivers/scsi/atari_NCR5380.cScsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
cmd2175drivers/scsi/atari_NCR5380.ccmd->result = DID_ERROR  << 16;
cmd2176drivers/scsi/atari_NCR5380.ccmd->done(cmd);
cmd2185drivers/scsi/atari_NCR5380.cif (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
cmd2186drivers/scsi/atari_NCR5380.c++cmd->SCp.buffer;
cmd2187drivers/scsi/atari_NCR5380.c--cmd->SCp.buffers_residual;
cmd2188drivers/scsi/atari_NCR5380.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd2189drivers/scsi/atari_NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd2193drivers/scsi/atari_NCR5380.cmerge_consecutive_buffers( cmd );
cmd2196drivers/scsi/atari_NCR5380.cHOSTNO, cmd->SCp.this_residual,
cmd2197drivers/scsi/atari_NCR5380.ccmd->SCp.buffers_residual);
cmd2217drivers/scsi/atari_NCR5380.cif (!cmd->device->borken &&
cmd2218drivers/scsi/atari_NCR5380.c(transfersize = NCR5380_dma_xfer_len(instance,cmd,phase)) > 31) {
cmd2220drivers/scsi/atari_NCR5380.ccmd->SCp.phase = phase;
cmd2222drivers/scsi/atari_NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
cmd2228drivers/scsi/atari_NCR5380.c"handshake\n", HOSTNO, cmd->target, cmd->lun);
cmd2229drivers/scsi/atari_NCR5380.ccmd->device->borken = 1;
cmd2234drivers/scsi/atari_NCR5380.ccmd->result = DID_ERROR  << 16;
cmd2235drivers/scsi/atari_NCR5380.ccmd->done(cmd);
cmd2246drivers/scsi/atari_NCR5380.ccmd->SCp.this_residual -= transfersize - len;
cmd2252drivers/scsi/atari_NCR5380.c(int *) &cmd->SCp.this_residual, (unsigned char **)
cmd2253drivers/scsi/atari_NCR5380.c&cmd->SCp.ptr);
cmd2260drivers/scsi/atari_NCR5380.ccmd->SCp.Message = tmp;
cmd2281drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target, cmd->lun);
cmd2291drivers/scsi/atari_NCR5380.cif (!cmd->next_link) {
cmd2294drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target, cmd->lun);
cmd2300drivers/scsi/atari_NCR5380.cinitialize_SCp(cmd->next_link);
cmd2303drivers/scsi/atari_NCR5380.ccmd->next_link->tag = cmd->tag;
cmd2304drivers/scsi/atari_NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2308drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target, cmd->lun);
cmd2311drivers/scsi/atari_NCR5380.ccollect_stats(hostdata, cmd);
cmd2313drivers/scsi/atari_NCR5380.ccmd->scsi_done(cmd);
cmd2314drivers/scsi/atari_NCR5380.ccmd = hostdata->connected;
cmd2326drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target, cmd->lun);
cmd2329drivers/scsi/atari_NCR5380.ccmd_free_tag( cmd );
cmd2330drivers/scsi/atari_NCR5380.cif (cmd->SCp.Status == QUEUE_FULL) {
cmd2337drivers/scsi/atari_NCR5380.cTAG_ALLOC *ta = &TagAlloc[cmd->target][cmd->lun];
cmd2341drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target, cmd->lun,
cmd2346drivers/scsi/atari_NCR5380.ccmd->SCp.Status = BUSY;
cmd2349drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2370drivers/scsi/atari_NCR5380.cif (cmd->cmnd[0] != REQUEST_SENSE) 
cmd2371drivers/scsi/atari_NCR5380.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
cmd2372drivers/scsi/atari_NCR5380.celse if (cmd->SCp.Status != GOOD)
cmd2373drivers/scsi/atari_NCR5380.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd2376drivers/scsi/atari_NCR5380.cif ((cmd->cmnd[0] != REQUEST_SENSE) && 
cmd2377drivers/scsi/atari_NCR5380.c(cmd->SCp.Status == CHECK_CONDITION)) {
cmd2381drivers/scsi/atari_NCR5380.ccmd->cmnd[0] = REQUEST_SENSE;
cmd2382drivers/scsi/atari_NCR5380.ccmd->cmnd[1] &= 0xe0;
cmd2383drivers/scsi/atari_NCR5380.ccmd->cmnd[2] = 0;
cmd2384drivers/scsi/atari_NCR5380.ccmd->cmnd[3] = 0;
cmd2385drivers/scsi/atari_NCR5380.ccmd->cmnd[4] = sizeof(cmd->sense_buffer);
cmd2386drivers/scsi/atari_NCR5380.ccmd->cmnd[5] = 0;
cmd2388drivers/scsi/atari_NCR5380.ccmd->SCp.buffer = NULL;
cmd2389drivers/scsi/atari_NCR5380.ccmd->SCp.buffers_residual = 0;
cmd2390drivers/scsi/atari_NCR5380.ccmd->SCp.ptr = (char *) cmd->sense_buffer;
cmd2391drivers/scsi/atari_NCR5380.ccmd->SCp.this_residual = sizeof(cmd->sense_buffer);
cmd2395drivers/scsi/atari_NCR5380.cLIST(cmd,hostdata->issue_queue);
cmd2396drivers/scsi/atari_NCR5380.cNEXT(cmd) = hostdata->issue_queue;
cmd2397drivers/scsi/atari_NCR5380.chostdata->issue_queue = (Scsi_Cmnd *) cmd;
cmd2401drivers/scsi/atari_NCR5380.c"issue queue\n", H_NO(cmd));
cmd2407drivers/scsi/atari_NCR5380.ccollect_stats(hostdata, cmd);
cmd2409drivers/scsi/atari_NCR5380.ccmd->scsi_done(cmd);
cmd2444drivers/scsi/atari_NCR5380.ccmd->device->tagged_supported = 0;
cmd2445drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd2446drivers/scsi/atari_NCR5380.ccmd->tag = TAG_NONE;
cmd2450drivers/scsi/atari_NCR5380.cHOSTNO, cmd->target, cmd->lun );
cmd2460drivers/scsi/atari_NCR5380.ccmd->device->disconnect = 1;
cmd2461drivers/scsi/atari_NCR5380.cLIST(cmd,hostdata->disconnected_queue);
cmd2462drivers/scsi/atari_NCR5380.cNEXT(cmd) = hostdata->disconnected_queue;
cmd2464drivers/scsi/atari_NCR5380.chostdata->disconnected_queue = cmd;
cmd2469drivers/scsi/atari_NCR5380.ccmd->target, cmd->lun);
cmd2576drivers/scsi/atari_NCR5380.cHOSTNO, tmp, cmd->target, cmd->lun);
cmd2581drivers/scsi/atari_NCR5380.ccmd->target, cmd->lun);
cmd2597drivers/scsi/atari_NCR5380.ccmd_free_tag( cmd );
cmd2599drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd2602drivers/scsi/atari_NCR5380.ccmd->result = DID_ERROR << 16;
cmd2604drivers/scsi/atari_NCR5380.ccollect_stats(hostdata, cmd);
cmd2606drivers/scsi/atari_NCR5380.ccmd->scsi_done(cmd);
cmd2614drivers/scsi/atari_NCR5380.clen = cmd->cmd_len;
cmd2615drivers/scsi/atari_NCR5380.cdata = cmd->cmnd;
cmd2628drivers/scsi/atari_NCR5380.ccmd->SCp.Status = tmp;
cmd2811drivers/scsi/atari_NCR5380.cint NCR5380_abort (Scsi_Cmnd *cmd)
cmd2813drivers/scsi/atari_NCR5380.cstruct Scsi_Host *instance = cmd->host;
cmd2819drivers/scsi/atari_NCR5380.cprint_Scsi_Cmnd (cmd);
cmd2843drivers/scsi/atari_NCR5380.cif (hostdata->connected == cmd) {
cmd2876drivers/scsi/atari_NCR5380.cif (cmd == tmp) {
cmd2939drivers/scsi/atari_NCR5380.cif (cmd == tmp) {
cmd2945drivers/scsi/atari_NCR5380.cif (NCR5380_select (instance, cmd, (int) cmd->tag)) 
cmd2959drivers/scsi/atari_NCR5380.cif (cmd == tmp) {
cmd2971drivers/scsi/atari_NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd3013drivers/scsi/atari_NCR5380.cstatic int NCR5380_reset( Scsi_Cmnd *cmd, unsigned int reset_flags)
cmd3016drivers/scsi/atari_NCR5380.cSETUP_HOSTDATA(cmd->host);
cmd3024drivers/scsi/atari_NCR5380.cH_NO(cmd) );
cmd3026drivers/scsi/atari_NCR5380.cNCR5380_print_status (cmd->host);
cmd3066drivers/scsi/atari_NCR5380.cif ((cmd = connected)) {
cmd3068drivers/scsi/atari_NCR5380.cprintk( "scsi%d: reset aborted a connected command\n", H_NO(cmd));
cmd3070drivers/scsi/atari_NCR5380.ccmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
cmd3071drivers/scsi/atari_NCR5380.ccmd->scsi_done( cmd );
cmd3074drivers/scsi/atari_NCR5380.cfor (i = 0; (cmd = disconnected_queue); ++i) {
cmd3075drivers/scsi/atari_NCR5380.cdisconnected_queue = NEXT(cmd);
cmd3076drivers/scsi/atari_NCR5380.cNEXT(cmd) = NULL;
cmd3077drivers/scsi/atari_NCR5380.ccmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
cmd3078drivers/scsi/atari_NCR5380.ccmd->scsi_done( cmd );
cmd192drivers/scsi/atari_scsi.cstatic int falcon_classify_cmd( Scsi_Cmnd *cmd );
cmd194drivers/scsi/atari_scsi.cScsi_Cmnd *cmd, int write_flag );
cmd593drivers/scsi/atari_scsi.cint atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
cmd599drivers/scsi/atari_scsi.creturn( NCR5380_queue_command( cmd, done ) );
cmd843drivers/scsi/atari_scsi.cint atari_scsi_reset( Scsi_Cmnd *cmd, unsigned int reset_flags)
cmd847drivers/scsi/atari_scsi.c(struct NCR5380_hostdata *)cmd->host->hostdata;
cmd869drivers/scsi/atari_scsi.crv = NCR5380_reset(cmd, reset_flags);
cmd1004drivers/scsi/atari_scsi.cstatic int falcon_classify_cmd( Scsi_Cmnd *cmd )
cmd1006drivers/scsi/atari_scsi.cunsigned char opcode = cmd->cmnd[0];
cmd1017drivers/scsi/atari_scsi.cif (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
cmd1037drivers/scsi/atari_scsi.cScsi_Cmnd *cmd,
cmd1091drivers/scsi/atari_scsi.cswitch( falcon_classify_cmd( cmd )) {
cmd1109drivers/scsi/atari_scsi.climit = (atari_dma_buffer && !STRAM_ADDR( VTOP(cmd->SCp.ptr) )) ?
cmd92drivers/scsi/atari_scsi.h#define  NCR5380_dma_xfer_len(i,cmd,phase) \
cmd93drivers/scsi/atari_scsi.hatari_dma_xfer_len(cmd->SCp.this_residual,cmd,((phase) & SR_IO) ? 0 : 1)
cmd565drivers/scsi/constants.cvoid print_Scsi_Cmnd (Scsi_Cmnd *cmd) {
cmd567drivers/scsi/constants.ccmd->host->host_no, 
cmd568drivers/scsi/constants.ccmd->target, 
cmd569drivers/scsi/constants.ccmd->lun);
cmd571drivers/scsi/constants.cprint_command (cmd->cmnd);
cmd340drivers/scsi/eata.cstatic inline unchar do_dma (ushort iobase, unsigned int addr, unchar cmd) {
cmd351drivers/scsi/eata.coutb(cmd, iobase + REG_CMD);
cmd156drivers/scsi/eata_dma.cScsi_Cmnd *cmd;
cmd185drivers/scsi/eata_dma.ccmd = cp->cmd;
cmd186drivers/scsi/eata_dma.cbase = (uint) cmd->host->base;
cmd213drivers/scsi/eata_dma.c"%#.2x \n", irq, base, cmd->pid, cmd->target,
cmd214drivers/scsi/eata_dma.ccmd->lun, eata_stat, hba_stat));
cmd219drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
cmd220drivers/scsi/eata_dma.c&& (HD(cmd)->t_state[cp->cp_channel][cp->cp_id] == RESET))
cmd223drivers/scsi/eata_dma.cHD(cmd)->t_state[cp->cp_channel][cp->cp_id] = OK;
cmd224drivers/scsi/eata_dma.cif(HD(cmd)->do_latency == TRUE && cp->timestamp) {
cmd228drivers/scsi/eata_dma.cif(HD(cmd)->writes_lat[cp->sizeindex][1] > time)
cmd229drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][1] = time;
cmd230drivers/scsi/eata_dma.cif(HD(cmd)->writes_lat[cp->sizeindex][2] < time)
cmd231drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][2] = time;
cmd232drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][3] += time;
cmd233drivers/scsi/eata_dma.cHD(cmd)->writes_lat[cp->sizeindex][0]++;
cmd235drivers/scsi/eata_dma.cif(HD(cmd)->reads_lat[cp->sizeindex][1] > time)
cmd236drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][1] = time;
cmd237drivers/scsi/eata_dma.cif(HD(cmd)->reads_lat[cp->sizeindex][2] < time)
cmd238drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][2] = time;
cmd239drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][3] += time;
cmd240drivers/scsi/eata_dma.cHD(cmd)->reads_lat[cp->sizeindex][0]++;
cmd245drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
cmd246drivers/scsi/eata_dma.c&& (cmd->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
cmd250drivers/scsi/eata_dma.cHD(cmd)->t_timeout[cp->cp_channel][cp->cp_id] = OK;
cmd256drivers/scsi/eata_dma.cif (HD(cmd)->t_timeout[cp->cp_channel][cp->cp_id] > 1)
cmd260drivers/scsi/eata_dma.cHD(cmd)->t_timeout[cp->cp_channel][cp->cp_id]++;
cmd265drivers/scsi/eata_dma.cif (cmd->device->type != TYPE_TAPE)
cmd271drivers/scsi/eata_dma.cHD(cmd)->t_state[cp->cp_channel][i] = RESET;
cmd285drivers/scsi/eata_dma.ccmd->result = result | (scsi_stat << 1); 
cmd289drivers/scsi/eata_dma.c|| cmd->scsi_done == NULL || cmd->device->id == 7) 
cmd293drivers/scsi/eata_dma.ccmd->device->channel, cmd->device->id, cmd->device->lun,
cmd294drivers/scsi/eata_dma.ccmd->pid, eata_stat, hba_stat, scsi_stat, 
cmd295drivers/scsi/eata_dma.ccmd->sense_buffer[2] & 0xf, cmd->result); 
cmd300drivers/scsi/eata_dma.ccmd->scsi_done(cmd);
cmd345drivers/scsi/eata_dma.cint eata_queue(Scsi_Cmnd * cmd, void (* done) (Scsi_Cmnd *))
cmd359drivers/scsi/eata_dma.chd = HD(cmd);
cmd360drivers/scsi/eata_dma.csh = cmd->host;
cmd373drivers/scsi/eata_dma.ccmd->result = DID_BUS_BUSY << 16;
cmd376drivers/scsi/eata_dma.c"returning DID_BUS_BUSY\n", cmd->pid));
cmd377drivers/scsi/eata_dma.cdone(cmd);
cmd388drivers/scsi/eata_dma.ccmd->pid, cmd->target, cmd->lun, y));
cmd396drivers/scsi/eata_dma.cif (cmd->cmnd[0] == WRITE_6 || cmd->cmnd[0] == WRITE_10 || 
cmd397drivers/scsi/eata_dma.ccmd->cmnd[0] == WRITE_12 || cmd->cmnd[0] == READ_6 || 
cmd398drivers/scsi/eata_dma.ccmd->cmnd[0] == READ_10 || cmd->cmnd[0] == READ_12) {
cmd401drivers/scsi/eata_dma.cswitch(cmd->cmnd[0]) {
cmd404drivers/scsi/eata_dma.cx = cmd->cmnd[4]/2; 
cmd408drivers/scsi/eata_dma.csho = (short *) &cmd->cmnd[7];
cmd413drivers/scsi/eata_dma.clon = (long *) &cmd->cmnd[6];
cmd421drivers/scsi/eata_dma.cif (cmd->cmnd[0] ==  WRITE_6 || cmd->cmnd[0] == WRITE_10 || 
cmd422drivers/scsi/eata_dma.ccmd->cmnd[0] ==  WRITE_12){
cmd427drivers/scsi/eata_dma.ccmd->scsi_done = (void *)done;
cmd429drivers/scsi/eata_dma.cswitch (cmd->cmnd[0]) {
cmd451drivers/scsi/eata_dma.cif (cmd->target == sh->this_id) 
cmd454drivers/scsi/eata_dma.cif (cmd->use_sg) {
cmd464drivers/scsi/eata_dma.ccp->cp_datalen = htonl(cmd->use_sg * sizeof(struct eata_sg_list));
cmd465drivers/scsi/eata_dma.csl=(struct scatterlist *)cmd->request_buffer;
cmd466drivers/scsi/eata_dma.cfor(i = 0; i < cmd->use_sg; i++, sl++){
cmd472drivers/scsi/eata_dma.ccp->cp_datalen = htonl(cmd->request_bufflen);
cmd473drivers/scsi/eata_dma.ccp->cp_dataDMA = htonl(virt_to_bus(cmd->request_buffer));
cmd477drivers/scsi/eata_dma.ccp->cp_reqDMA = htonl(virt_to_bus(cmd->sense_buffer));
cmd478drivers/scsi/eata_dma.ccp->reqlen = sizeof(cmd->sense_buffer);
cmd480drivers/scsi/eata_dma.ccp->cp_id = cmd->target;
cmd481drivers/scsi/eata_dma.ccp->cp_channel = cmd->channel;
cmd482drivers/scsi/eata_dma.ccp->cp_lun = cmd->lun;
cmd485drivers/scsi/eata_dma.cmemcpy(cp->cp_cdb, cmd->cmnd, cmd->cmd_len);
cmd491drivers/scsi/eata_dma.ccp->cmd = cmd;
cmd492drivers/scsi/eata_dma.ccmd->host_scribble = (char *)&hd->ccb[y];  
cmd495drivers/scsi/eata_dma.ccmd->result = DID_BUS_BUSY << 16;
cmd498drivers/scsi/eata_dma.c"returning DID_BUS_BUSY\n",cmd->target, cmd->pid));
cmd499drivers/scsi/eata_dma.cdone(cmd);
cmd505drivers/scsi/eata_dma.c"slot %d irq %d\n", (s32)sh->base, cmd->pid, 
cmd506drivers/scsi/eata_dma.ccmd->target, cmd->lun, y, sh->irq));
cmd513drivers/scsi/eata_dma.cint eata_abort(Scsi_Cmnd * cmd)
cmd522drivers/scsi/eata_dma.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
cmd523drivers/scsi/eata_dma.ccmd->abort_reason));
cmd526drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY) {
cmd534drivers/scsi/eata_dma.cif (CD(cmd)->status == RESET) {
cmd540drivers/scsi/eata_dma.cif (CD(cmd)->status == LOCKED) {
cmd546drivers/scsi/eata_dma.cif (CD(cmd)->status == USED) {
cmd551drivers/scsi/eata_dma.cif (CD(cmd)->status == FREE) {
cmd560drivers/scsi/eata_dma.cint eata_reset(Scsi_Cmnd * cmd, int resetflags)
cmd573drivers/scsi/eata_dma.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
cmd574drivers/scsi/eata_dma.ccmd->abort_reason));
cmd576drivers/scsi/eata_dma.cif (HD(cmd)->state == RESET) {
cmd583drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd593drivers/scsi/eata_dma.cHD(cmd)->t_state[x][z] = RESET;
cmd594drivers/scsi/eata_dma.cHD(cmd)->t_timeout[x][z] = NO_TIMEOUT;
cmd598drivers/scsi/eata_dma.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd599drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status == FREE)
cmd602drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status == LOCKED) {
cmd603drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = FREE;
cmd608drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
cmd609drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = RESET;
cmd617drivers/scsi/eata_dma.cif (sp == cmd)
cmd622drivers/scsi/eata_dma.cinb((u32) (cmd->host->base) + HA_RSTATUS);  /* This might cause trouble */
cmd623drivers/scsi/eata_dma.ceata_send_command(0, (u32) cmd->host->base, EATA_CMD_RESET);
cmd626drivers/scsi/eata_dma.cHD(cmd)->state = RESET;
cmd641drivers/scsi/eata_dma.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd644drivers/scsi/eata_dma.cif (HD(cmd)->ccb[x].status != RESET)
cmd647drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
cmd651drivers/scsi/eata_dma.cHD(cmd)->ccb[x].status = LOCKED;
cmd661drivers/scsi/eata_dma.cHD(cmd)->state = FALSE;
cmd82drivers/scsi/eata_generic.h#define HD(cmd)   ((hostdata *)&(cmd->host->hostdata))
cmd83drivers/scsi/eata_generic.h#define CD(cmd)   ((struct eata_ccb *)(cmd->host_scribble))
cmd305drivers/scsi/eata_generic.hScsi_Cmnd *cmd;        /* address of cmd        */
cmd130drivers/scsi/eata_pio.cScsi_Cmnd *cmd;
cmd154drivers/scsi/eata_pio.ccmd = cp->cmd;
cmd155drivers/scsi/eata_pio.cbase = (uint) cmd->host->base;
cmd164drivers/scsi/eata_pio.cwhile ((cmd->SCp.Status)&&((z>0)||(odd)))
cmd168drivers/scsi/eata_pio.c*(cmd->SCp.ptr)=zwickel>>8; 
cmd169drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1);
cmd172drivers/scsi/eata_pio.cx=min(z,cmd->SCp.this_residual/2);
cmd173drivers/scsi/eata_pio.cinsw(base+HA_RDATA,cmd->SCp.ptr,x);
cmd175drivers/scsi/eata_pio.cIncStat(&cmd->SCp,2*x);
cmd176drivers/scsi/eata_pio.cif ((z>0)&&(cmd->SCp.this_residual==1))
cmd179drivers/scsi/eata_pio.c*(cmd->SCp.ptr)=zwickel&0xff;
cmd180drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1); z--; 
cmd192drivers/scsi/eata_pio.cwhile ((cmd->SCp.Status)&&((z>0)||(odd)))
cmd196drivers/scsi/eata_pio.czwickel+=*(cmd->SCp.ptr)<<8; 
cmd197drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1);
cmd202drivers/scsi/eata_pio.cx=min(z,cmd->SCp.this_residual/2);
cmd203drivers/scsi/eata_pio.coutsw(base+HA_RDATA,cmd->SCp.ptr,x);
cmd205drivers/scsi/eata_pio.cIncStat(&cmd->SCp,2*x);
cmd206drivers/scsi/eata_pio.cif ((z>0)&&(cmd->SCp.this_residual==1))
cmd208drivers/scsi/eata_pio.czwickel=*(cmd->SCp.ptr); 
cmd210drivers/scsi/eata_pio.cIncStat(&cmd->SCp,1); 
cmd233drivers/scsi/eata_pio.ccmd->result=(DID_OK<<16); 
cmd237drivers/scsi/eata_pio.ccmd->result=(DID_OK<<16)+0x02;
cmd238drivers/scsi/eata_pio.celse cmd->result=(DID_NO_CONNECT<<16);
cmd253drivers/scsi/eata_pio.ccmd->result); 
cmd260drivers/scsi/eata_pio.ccmd->scsi_done(cmd);
cmd281drivers/scsi/eata_pio.cint eata_pio_queue(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd296drivers/scsi/eata_pio.chd = HD(cmd);
cmd297drivers/scsi/eata_pio.csh = cmd->host;
cmd319drivers/scsi/eata_pio.cmemset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
cmd324drivers/scsi/eata_pio.c" %x, y %d\n", cmd->pid, cmd->target, cmd->lun, y));
cmd327drivers/scsi/eata_pio.ccmd->scsi_done = (void *)done;
cmd329drivers/scsi/eata_pio.cswitch (cmd->cmnd[0]) {
cmd348drivers/scsi/eata_pio.ccp->Interpret = (cmd->target == hd->hostid);
cmd349drivers/scsi/eata_pio.ccp->cp_datalen = htonl((ulong)cmd->request_bufflen);
cmd354drivers/scsi/eata_pio.ccp->cp_id = cmd->target;
cmd355drivers/scsi/eata_pio.ccp->cp_lun = cmd->lun;
cmd358drivers/scsi/eata_pio.cmemcpy(cp->cp_cdb, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
cmd363drivers/scsi/eata_pio.ccp->cmd = cmd;
cmd364drivers/scsi/eata_pio.ccmd->host_scribble = (char *)&hd->ccb[y];   
cmd366drivers/scsi/eata_pio.cif (cmd->use_sg == 0)
cmd368drivers/scsi/eata_pio.ccmd->SCp.buffers_residual=1;
cmd369drivers/scsi/eata_pio.ccmd->SCp.ptr = cmd->request_buffer;
cmd370drivers/scsi/eata_pio.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd371drivers/scsi/eata_pio.ccmd->SCp.buffer = NULL;
cmd373drivers/scsi/eata_pio.ccmd->SCp.buffer = cmd->request_buffer;
cmd374drivers/scsi/eata_pio.ccmd->SCp.buffers_residual = cmd->use_sg;
cmd375drivers/scsi/eata_pio.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd376drivers/scsi/eata_pio.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd378drivers/scsi/eata_pio.ccmd->SCp.Status = (cmd->SCp.this_residual != 0);  /* TRUE as long as bytes 
cmd383drivers/scsi/eata_pio.ccmd->result = DID_BUS_BUSY << 16;
cmd385drivers/scsi/eata_pio.c"returning DID_BUS_BUSY, done.\n", cmd->target, cmd->pid);
cmd386drivers/scsi/eata_pio.cdone(cmd);
cmd397drivers/scsi/eata_pio.c"lun: %x slot %d irq %d\n", (long)sh->base, cmd->pid, 
cmd398drivers/scsi/eata_pio.ccmd->target, cmd->lun, y, sh->irq));
cmd405drivers/scsi/eata_pio.cint eata_pio_abort(Scsi_Cmnd * cmd)
cmd414drivers/scsi/eata_pio.c"target: %x lun: %x reason %x\n", cmd->pid, 
cmd415drivers/scsi/eata_pio.ccmd->target, cmd->lun, cmd->abort_reason));
cmd419drivers/scsi/eata_pio.cwhile (inb((uint)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
cmd426drivers/scsi/eata_pio.cif (CD(cmd)->status == FREE) {
cmd431drivers/scsi/eata_pio.cif (CD(cmd)->status == USED) {
cmd436drivers/scsi/eata_pio.cif (CD(cmd)->status == RESET) {
cmd442drivers/scsi/eata_pio.cif (CD(cmd)->status == LOCKED) {
cmd453drivers/scsi/eata_pio.cint eata_pio_reset(Scsi_Cmnd * cmd, int dummy)
cmd464drivers/scsi/eata_pio.c" %x lun: %x reason %x\n", cmd->pid, cmd->target, 
cmd465drivers/scsi/eata_pio.ccmd->lun, cmd->abort_reason));
cmd467drivers/scsi/eata_pio.cif (HD(cmd)->state == RESET) {
cmd475drivers/scsi/eata_pio.cHD(cmd)->t_state[0][z] = RESET;
cmd476drivers/scsi/eata_pio.cHD(cmd)->t_timeout[0][z] = NO_TIMEOUT;
cmd481drivers/scsi/eata_pio.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd483drivers/scsi/eata_pio.cif (HD(cmd)->ccb[x].status == FREE) 
cmd486drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
cmd487drivers/scsi/eata_pio.cHD(cmd)->ccb[x].status = RESET;
cmd498drivers/scsi/eata_pio.coutb((uint) cmd->host->base+HA_WCOMMAND, EATA_CMD_RESET);
cmd501drivers/scsi/eata_pio.cHD(cmd)->state = RESET;
cmd510drivers/scsi/eata_pio.cfor (x = 0; x < cmd->host->can_queue; x++) {
cmd513drivers/scsi/eata_pio.cif (HD(cmd)->ccb[x].status != RESET)
cmd516drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
cmd521drivers/scsi/eata_pio.cHD(cmd)->ccb[x].status = FREE;
cmd528drivers/scsi/eata_pio.cHD(cmd)->state = FALSE;
cmd592drivers/scsi/g_NCR5380.cstatic int sprint_Scsi_Cmnd (char* buffer, int len, Scsi_Cmnd *cmd) {
cmd595drivers/scsi/g_NCR5380.ccmd->host->host_no ANDP
cmd596drivers/scsi/g_NCR5380.ccmd->target ANDP
cmd597drivers/scsi/g_NCR5380.ccmd->lun);
cmd599drivers/scsi/g_NCR5380.clen += sprint_command (buffer, len, cmd->cmnd);
cmd67drivers/scsi/gvp11.cstatic int dma_setup (Scsi_Cmnd *cmd, int dir_in)
cmd70drivers/scsi/gvp11.cunsigned long addr = VTOP(cmd->SCp.ptr);
cmd74drivers/scsi/gvp11.c(!dir_in && mm_end_of_chunk (addr, cmd->SCp.this_residual)))
cmd76drivers/scsi/gvp11.cHDATA(cmd->host)->dma_bounce_len = (cmd->SCp.this_residual + 511)
cmd78drivers/scsi/gvp11.cHDATA(cmd->host)->dma_bounce_buffer =
cmd79drivers/scsi/gvp11.cscsi_malloc (HDATA(cmd->host)->dma_bounce_len);
cmd82drivers/scsi/gvp11.cif (!HDATA(cmd->host)->dma_bounce_buffer) {
cmd83drivers/scsi/gvp11.cHDATA(cmd->host)->dma_bounce_len = 0;
cmd88drivers/scsi/gvp11.caddr = VTOP(HDATA(cmd->host)->dma_bounce_buffer);
cmd91drivers/scsi/gvp11.cscsi_free (HDATA(cmd->host)->dma_bounce_buffer,
cmd92drivers/scsi/gvp11.cHDATA(cmd->host)->dma_bounce_len);
cmd93drivers/scsi/gvp11.cHDATA(cmd->host)->dma_bounce_buffer = NULL;
cmd94drivers/scsi/gvp11.cHDATA(cmd->host)->dma_bounce_len = 0;
cmd100drivers/scsi/gvp11.cif (cmd->use_sg)
cmd103drivers/scsi/gvp11.ccmd->host->host_no);
cmd105drivers/scsi/gvp11.cmemcpy (HDATA(cmd->host)->dma_bounce_buffer,
cmd106drivers/scsi/gvp11.ccmd->SCp.ptr, cmd->SCp.this_residual);
cmd109drivers/scsi/gvp11.cmemcpy (HDATA(cmd->host)->dma_bounce_buffer,
cmd110drivers/scsi/gvp11.ccmd->request_buffer, cmd->request_bufflen);
cmd118drivers/scsi/gvp11.cHDATA(cmd->host)->dma_dir = dir_in;
cmd119drivers/scsi/gvp11.cDMA(cmd->host)->CNTR = cntr;
cmd122drivers/scsi/gvp11.cDMA(cmd->host)->ACR = addr;
cmd126drivers/scsi/gvp11.ccache_clear (addr, cmd->SCp.this_residual);
cmd129drivers/scsi/gvp11.ccache_push (addr, cmd->SCp.this_residual);
cmd132drivers/scsi/gvp11.cDMA(cmd->host)->ST_DMA = 1;
cmd154drivers/scsi/in2000.c#define IS_DIR_OUT(cmd) ((cmd)->cmnd[0] == WRITE_6  || \
cmd155drivers/scsi/in2000.c(cmd)->cmnd[0] == WRITE_10 || \
cmd156drivers/scsi/in2000.c(cmd)->cmnd[0] == WRITE_12)
cmd271drivers/scsi/in2000.cinline void write_3393_cmd(struct IN2000_hostdata *hostdata, uchar cmd)
cmd276drivers/scsi/in2000.cwrite1_io(cmd,IO_WD_DATA);
cmd355drivers/scsi/in2000.cint in2000_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
cmd362drivers/scsi/in2000.chostdata = (struct IN2000_hostdata *)cmd->host->hostdata;
cmd364drivers/scsi/in2000.cDB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld(",cmd->target,cmd->cmnd[0],cmd->pid))
cmd372drivers/scsi/in2000.ccmd->host_scribble = NULL;
cmd373drivers/scsi/in2000.ccmd->scsi_done = done;
cmd374drivers/scsi/in2000.ccmd->result = 0;
cmd391drivers/scsi/in2000.cif (cmd->use_sg) {
cmd392drivers/scsi/in2000.ccmd->SCp.buffer = (struct scatterlist *)cmd->buffer;
cmd393drivers/scsi/in2000.ccmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd394drivers/scsi/in2000.ccmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
cmd395drivers/scsi/in2000.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd398drivers/scsi/in2000.ccmd->SCp.buffer = NULL;
cmd399drivers/scsi/in2000.ccmd->SCp.buffers_residual = 0;
cmd400drivers/scsi/in2000.ccmd->SCp.ptr = (char *)cmd->request_buffer;
cmd401drivers/scsi/in2000.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd403drivers/scsi/in2000.ccmd->SCp.have_data_in = 0;
cmd409drivers/scsi/in2000.ccmd->SCp.Status = GOOD;
cmd420drivers/scsi/in2000.cif (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd421drivers/scsi/in2000.ccmd->host_scribble = (uchar *)hostdata->input_Q;
cmd422drivers/scsi/in2000.chostdata->input_Q = cmd;
cmd428drivers/scsi/in2000.ctmp->host_scribble = (uchar *)cmd;
cmd435drivers/scsi/in2000.cin2000_execute(cmd->host);
cmd437drivers/scsi/in2000.cDB(DB_QUEUE_COMMAND,printk(")Q-%ld ",cmd->pid))
cmd454drivers/scsi/in2000.cScsi_Cmnd *cmd, *prev;
cmd481drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hostdata->input_Q;
cmd483drivers/scsi/in2000.cwhile (cmd) {
cmd484drivers/scsi/in2000.cif (!(hostdata->busy[cmd->target] & (1 << cmd->lun)))
cmd486drivers/scsi/in2000.cprev = cmd;
cmd487drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd492drivers/scsi/in2000.cif (!cmd) {
cmd503drivers/scsi/in2000.cprev->host_scribble = cmd->host_scribble;
cmd505drivers/scsi/in2000.chostdata->input_Q = (Scsi_Cmnd *)cmd->host_scribble;
cmd511drivers/scsi/in2000.cif (IS_DIR_OUT(cmd))
cmd512drivers/scsi/in2000.cwrite_3393(hostdata,WD_DESTINATION_ID, cmd->target);
cmd514drivers/scsi/in2000.cwrite_3393(hostdata,WD_DESTINATION_ID, cmd->target | DSTID_DPD);
cmd539drivers/scsi/in2000.ccmd->SCp.phase = 0;  /* assume no disconnect */
cmd544drivers/scsi/in2000.cif (cmd->device->type == 1)   /* tape drive? */
cmd552drivers/scsi/in2000.cif ((prev->target != cmd->target) || (prev->lun != cmd->lun)) {
cmd562drivers/scsi/in2000.ccmd->SCp.phase = 1;
cmd569drivers/scsi/in2000.cwrite_3393(hostdata,WD_SOURCE_ID,((cmd->SCp.phase)?SRCID_ER:0));
cmd571drivers/scsi/in2000.cwrite_3393(hostdata,WD_TARGET_LUN, cmd->lun);
cmd572drivers/scsi/in2000.cwrite_3393(hostdata,WD_SYNCHRONOUS_TRANSFER,hostdata->sync_xfer[cmd->target]);
cmd573drivers/scsi/in2000.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd576drivers/scsi/in2000.c(hostdata->sync_stat[cmd->target] == SS_UNSET)) {
cmd586drivers/scsi/in2000.chostdata->selecting = cmd;
cmd598drivers/scsi/in2000.cif (hostdata->sync_stat[cmd->target] == SS_UNSET) {
cmd599drivers/scsi/in2000.cif (hostdata->sync_off & (1 << cmd->target))
cmd600drivers/scsi/in2000.chostdata->sync_stat[cmd->target] = SS_SET;
cmd602drivers/scsi/in2000.chostdata->sync_stat[cmd->target] = SS_FIRST;
cmd619drivers/scsi/in2000.chostdata->connected = cmd;
cmd627drivers/scsi/in2000.cfor (i=0; i<cmd->cmd_len; i++)
cmd628drivers/scsi/in2000.cwrite1_io(cmd->cmnd[i], IO_WD_DATA);
cmd636drivers/scsi/in2000.cwrite_3393(hostdata, WD_OWN_ID, cmd->cmd_len);
cmd656drivers/scsi/in2000.cif (!(cmd->SCp.phase)) {
cmd657drivers/scsi/in2000.cwrite_3393_count(hostdata, cmd->SCp.this_residual);
cmd661drivers/scsi/in2000.cif (IS_DIR_OUT(cmd)) {
cmd663drivers/scsi/in2000.cif ((i = cmd->SCp.this_residual) > (IN2000_FIFO_SIZE - 16) )
cmd665drivers/scsi/in2000.ccmd->SCp.have_data_in = i;    /* this much data in fifo */
cmd667drivers/scsi/in2000.csp = (unsigned short *)cmd->SCp.ptr;
cmd681drivers/scsi/in2000.cif (cmd->SCp.have_data_in <= ((IN2000_FIFO_SIZE - 16) - 32)) {
cmd700drivers/scsi/in2000.ccmd->SCp.have_data_in = 0;    /* nothing transfered yet */
cmd718drivers/scsi/in2000.cDB(DB_EXECUTE,printk("%s%ld)EX-2 ",(cmd->SCp.phase)?"d:":"",cmd->pid))
cmd761drivers/scsi/in2000.cvoid transfer_bytes(Scsi_Cmnd *cmd, int data_in_dir)
cmd768drivers/scsi/in2000.chostdata = (struct IN2000_hostdata *)cmd->host->hostdata;
cmd778drivers/scsi/in2000.cif (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
cmd779drivers/scsi/in2000.c++cmd->SCp.buffer;
cmd780drivers/scsi/in2000.c--cmd->SCp.buffers_residual;
cmd781drivers/scsi/in2000.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd782drivers/scsi/in2000.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd787drivers/scsi/in2000.cwrite_3393(hostdata,WD_SYNCHRONOUS_TRANSFER,hostdata->sync_xfer[cmd->target]);
cmd788drivers/scsi/in2000.cwrite_3393_count(hostdata,cmd->SCp.this_residual);
cmd798drivers/scsi/in2000.cif ((hostdata->level2 >= L2_DATA) || (cmd->SCp.phase == 0)) {
cmd806drivers/scsi/in2000.ccmd->SCp.have_data_in = 0;
cmd815drivers/scsi/in2000.cif ((hostdata->level2 >= L2_DATA) || (cmd->SCp.phase == 0)) {
cmd823drivers/scsi/in2000.csp = (unsigned short *)cmd->SCp.ptr;
cmd825drivers/scsi/in2000.cif ((i = cmd->SCp.this_residual) > IN2000_FIFO_SIZE)
cmd827drivers/scsi/in2000.ccmd->SCp.have_data_in = i;
cmd862drivers/scsi/in2000.cScsi_Cmnd *patch, *cmd;
cmd943drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hostdata->connected;   /* assume we're connected */
cmd944drivers/scsi/in2000.cCHECK_NULL(cmd,"fifo_int")
cmd950drivers/scsi/in2000.csp = (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
cmd964drivers/scsi/in2000.ci = sp - (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
cmd966drivers/scsi/in2000.ccmd->SCp.have_data_in += i;
cmd984drivers/scsi/in2000.cif (cmd->SCp.this_residual == cmd->SCp.have_data_in) {
cmd995drivers/scsi/in2000.csp = (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
cmd996drivers/scsi/in2000.ci = cmd->SCp.this_residual - cmd->SCp.have_data_in;   /* bytes yet to go */
cmd1004drivers/scsi/in2000.ci = sp - (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
cmd1006drivers/scsi/in2000.ccmd->SCp.have_data_in += i;
cmd1024drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hostdata->connected;   /* assume we're connected */
cmd1028drivers/scsi/in2000.cif (!cmd && (sr != CSR_RESEL_AM && sr != CSR_TIMEOUT && sr != CSR_SELECT)) {
cmd1054drivers/scsi/in2000.csp = (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
cmd1058drivers/scsi/in2000.ci = (cmd->SCp.this_residual - read_3393_count(hostdata)) - cmd->SCp.have_data_in;
cmd1072drivers/scsi/in2000.clength = cmd->SCp.this_residual;
cmd1073drivers/scsi/in2000.ccmd->SCp.this_residual = read_3393_count(hostdata);
cmd1074drivers/scsi/in2000.ccmd->SCp.ptr += (length - cmd->SCp.this_residual);
cmd1076drivers/scsi/in2000.cDB(DB_TRANSFER,printk("(%p,%d)",cmd->SCp.ptr,cmd->SCp.this_residual))
cmd1082drivers/scsi/in2000.clength = cmd->SCp.this_residual;
cmd1083drivers/scsi/in2000.ccmd->SCp.this_residual = read_3393_count(hostdata);
cmd1084drivers/scsi/in2000.ccmd->SCp.ptr += (length - cmd->SCp.this_residual);
cmd1086drivers/scsi/in2000.cDB(DB_TRANSFER,printk("(%p,%d)",cmd->SCp.ptr,cmd->SCp.this_residual))
cmd1101drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hostdata->selecting;   /* get a valid cmd */
cmd1102drivers/scsi/in2000.cCHECK_NULL(cmd,"csr_timeout")
cmd1106drivers/scsi/in2000.ccmd->result = DID_NO_CONNECT << 16;
cmd1107drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1109drivers/scsi/in2000.ccmd->scsi_done(cmd);
cmd1125drivers/scsi/in2000.chostdata->connected = cmd = (Scsi_Cmnd *)hostdata->selecting;
cmd1126drivers/scsi/in2000.cCHECK_NULL(cmd,"csr_select")
cmd1131drivers/scsi/in2000.chostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->lun);
cmd1132drivers/scsi/in2000.cif (cmd->SCp.phase)
cmd1135drivers/scsi/in2000.cif (hostdata->sync_stat[cmd->target] == SS_FIRST) {
cmd1140drivers/scsi/in2000.chostdata->sync_stat[cmd->target] = SS_WAITING;
cmd1161drivers/scsi/in2000.cDB(DB_INTR,printk("IN-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual))
cmd1162drivers/scsi/in2000.ctransfer_bytes(cmd, DATA_IN_DIR);
cmd1171drivers/scsi/in2000.cDB(DB_INTR,printk("OUT-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual))
cmd1172drivers/scsi/in2000.ctransfer_bytes(cmd, DATA_OUT_DIR);
cmd1183drivers/scsi/in2000.cDB(DB_INTR,printk("CMND-%02x,%ld",cmd->cmnd[0],cmd->pid))
cmd1184drivers/scsi/in2000.ctransfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
cmd1194drivers/scsi/in2000.ccmd->SCp.Status = read_1_byte(hostdata);
cmd1202drivers/scsi/in2000.cDB(DB_INTR,printk("=%02x",cmd->SCp.Status))
cmd1223drivers/scsi/in2000.ccmd->SCp.Message = msg;
cmd1227drivers/scsi/in2000.cDB(DB_INTR,printk("CCMP-%ld",cmd->pid))
cmd1253drivers/scsi/in2000.ccmd->device->disconnect = 1;
cmd1263drivers/scsi/in2000.cif (hostdata->sync_stat[cmd->target] == SS_WAITING)
cmd1264drivers/scsi/in2000.chostdata->sync_stat[cmd->target] = SS_SET;
cmd1285drivers/scsi/in2000.cif (hostdata->sync_stat[cmd->target] != SS_WAITING) {
cmd1303drivers/scsi/in2000.chostdata->sync_xfer[cmd->target] =
cmd1307drivers/scsi/in2000.chostdata->sync_xfer[cmd->target] = id;
cmd1310drivers/scsi/in2000.cprintk("sync_xfer=%02x",hostdata->sync_xfer[cmd->target]);
cmd1312drivers/scsi/in2000.chostdata->sync_stat[cmd->target] = SS_SET;
cmd1370drivers/scsi/in2000.cDB(DB_INTR,printk("SX-DONE-%ld",cmd->pid))
cmd1371drivers/scsi/in2000.ccmd->SCp.Message = COMMAND_COMPLETE;
cmd1373drivers/scsi/in2000.cif (cmd->SCp.Status == GOOD)
cmd1374drivers/scsi/in2000.ccmd->SCp.Status = lun;
cmd1376drivers/scsi/in2000.cif (cmd->cmnd[0] != REQUEST_SENSE)
cmd1377drivers/scsi/in2000.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
cmd1378drivers/scsi/in2000.celse if (cmd->SCp.Status != GOOD)
cmd1379drivers/scsi/in2000.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd1380drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1382drivers/scsi/in2000.ccmd->scsi_done(cmd);
cmd1392drivers/scsi/in2000.cprintk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---",asr,sr,phs,cmd->pid);
cmd1454drivers/scsi/in2000.cif (cmd == NULL) {
cmd1459drivers/scsi/in2000.cDB(DB_INTR,printk("UNEXP_DISC-%ld",cmd->pid))
cmd1461drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1463drivers/scsi/in2000.cif (cmd->cmnd[0] != REQUEST_SENSE)
cmd1464drivers/scsi/in2000.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
cmd1465drivers/scsi/in2000.celse if (cmd->SCp.Status != GOOD)
cmd1466drivers/scsi/in2000.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd1467drivers/scsi/in2000.ccmd->scsi_done(cmd);
cmd1486drivers/scsi/in2000.cDB(DB_INTR,printk("DISC-%ld",cmd->pid))
cmd1487drivers/scsi/in2000.cif (cmd == NULL) {
cmd1494drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1496drivers/scsi/in2000.cif (cmd->cmnd[0] != REQUEST_SENSE)
cmd1497drivers/scsi/in2000.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
cmd1498drivers/scsi/in2000.celse if (cmd->SCp.Status != GOOD)
cmd1499drivers/scsi/in2000.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd1500drivers/scsi/in2000.ccmd->scsi_done(cmd);
cmd1504drivers/scsi/in2000.ccmd->host_scribble = (uchar *)hostdata->disconnected_Q;
cmd1505drivers/scsi/in2000.chostdata->disconnected_Q = cmd;
cmd1540drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hostdata->selecting;
cmd1542drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1543drivers/scsi/in2000.ccmd->host_scribble = (uchar *)hostdata->input_Q;
cmd1544drivers/scsi/in2000.chostdata->input_Q = cmd;
cmd1550drivers/scsi/in2000.cif (cmd) {
cmd1552drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1553drivers/scsi/in2000.ccmd->host_scribble = (uchar *)hostdata->input_Q;
cmd1554drivers/scsi/in2000.chostdata->input_Q = cmd;
cmd1582drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hostdata->disconnected_Q;
cmd1584drivers/scsi/in2000.cwhile (cmd) {
cmd1585drivers/scsi/in2000.cif (id == cmd->target && lun == cmd->lun)
cmd1587drivers/scsi/in2000.cpatch = cmd;
cmd1588drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd1593drivers/scsi/in2000.cif (!cmd) {
cmd1601drivers/scsi/in2000.cpatch->host_scribble = cmd->host_scribble;
cmd1603drivers/scsi/in2000.chostdata->disconnected_Q = (Scsi_Cmnd *)cmd->host_scribble;
cmd1604drivers/scsi/in2000.chostdata->connected = cmd;
cmd1611drivers/scsi/in2000.cif (IS_DIR_OUT(cmd))
cmd1612drivers/scsi/in2000.cwrite_3393(hostdata,WD_DESTINATION_ID,cmd->target);
cmd1614drivers/scsi/in2000.cwrite_3393(hostdata,WD_DESTINATION_ID,cmd->target | DSTID_DPD);
cmd1624drivers/scsi/in2000.cDB(DB_INTR,printk("-%ld",cmd->pid))
cmd1688drivers/scsi/in2000.cint in2000_reset(Scsi_Cmnd *cmd, unsigned int reset_flags)
cmd1690drivers/scsi/in2000.cint in2000_reset(Scsi_Cmnd *cmd)
cmd1698drivers/scsi/in2000.cinstance = cmd->host;
cmd1722drivers/scsi/in2000.ccmd->result = DID_RESET << 16;
cmd1729drivers/scsi/in2000.cint in2000_abort (Scsi_Cmnd *cmd)
cmd1741drivers/scsi/in2000.cinstance = cmd->host;
cmd1746drivers/scsi/in2000.cREAD_AUX_STAT(),read_3393_count(hostdata),cmd->SCp.this_residual,cmd->SCp.buffers_residual,
cmd1747drivers/scsi/in2000.ccmd->SCp.have_data_in,read1_io(IO_FIFO_COUNT));
cmd1757drivers/scsi/in2000.cif (tmp == cmd) {
cmd1759drivers/scsi/in2000.cprev->host_scribble = cmd->host_scribble;
cmd1760drivers/scsi/in2000.ccmd->host_scribble = NULL;
cmd1761drivers/scsi/in2000.ccmd->result = DID_ABORT << 16;
cmd1763drivers/scsi/in2000.cinstance->host_no, cmd->pid);
cmd1764drivers/scsi/in2000.ccmd->scsi_done(cmd);
cmd1783drivers/scsi/in2000.cif (hostdata->connected == cmd) {
cmd1786drivers/scsi/in2000.cinstance->host_no, cmd->pid);
cmd1821drivers/scsi/in2000.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1824drivers/scsi/in2000.ccmd->result = DID_ABORT << 16;
cmd1825drivers/scsi/in2000.ccmd->scsi_done(cmd);
cmd1842drivers/scsi/in2000.cif (cmd == tmp) {
cmd2237drivers/scsi/in2000.cScsi_Cmnd *cmd;
cmd2317drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hd->connected;
cmd2319drivers/scsi/in2000.ccmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
cmd2325drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hd->input_Q;
cmd2326drivers/scsi/in2000.cwhile (cmd) {
cmd2328drivers/scsi/in2000.ccmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
cmd2330drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd2335drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)hd->disconnected_Q;
cmd2336drivers/scsi/in2000.cwhile (cmd) {
cmd2338drivers/scsi/in2000.ccmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
cmd2340drivers/scsi/in2000.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd205drivers/scsi/ppa.cint     ppa_start( Scsi_Cmnd * cmd )
cmd212drivers/scsi/ppa.cif (cmd->target == PPA_INITIATOR) {
cmd217drivers/scsi/ppa.cif (!ppa_select(PPA_INITIATOR,cmd->target)) {
cmd224drivers/scsi/ppa.cfor (k=0; k < cmd->cmd_len; k++) {        /* send the command */
cmd226drivers/scsi/ppa.cout_p(0,cmd->cmnd[k]);
cmd233drivers/scsi/ppa.cfor (k=0; k < cmd->cmd_len; k++)
cmd234drivers/scsi/ppa.cprintk("%3x",(cmd->cmnd[k]) & 0xff );
cmd241drivers/scsi/ppa.cint     ppa_completion( Scsi_Cmnd * cmd )
cmd260drivers/scsi/ppa.cv = cmd->cmnd[0];
cmd262drivers/scsi/ppa.cbuffer = cmd->request_buffer;
cmd263drivers/scsi/ppa.cblen = cmd->request_bufflen;
cmd327drivers/scsi/ppa.cint     ppa_command( Scsi_Cmnd * cmd )
cmd333drivers/scsi/ppa.cif (ppa_start(cmd))
cmd335drivers/scsi/ppa.cs = ppa_completion(cmd);
cmd352drivers/scsi/ppa.c{       Scsi_Cmnd *cmd;
cmd355drivers/scsi/ppa.ccmd = ppa_current;
cmd357drivers/scsi/ppa.cif (!cmd) return;
cmd361drivers/scsi/ppa.cif(ppa_abort_flag == 1) cmd->result = DID_ABORT << 16;
cmd363drivers/scsi/ppa.ccmd->result = DID_RESET << 16;
cmd366drivers/scsi/ppa.cdone(cmd);
cmd373drivers/scsi/ppa.ccmd->result = ppa_completion(cmd) + (ppa_error_code << 16);
cmd375drivers/scsi/ppa.cdone(cmd);
cmd379drivers/scsi/ppa.cint     ppa_queuecommand( Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd383drivers/scsi/ppa.cppa_current = cmd;
cmd385drivers/scsi/ppa.cif (!ppa_start(cmd)) {
cmd386drivers/scsi/ppa.ccmd->result = ppa_error_code << 16;
cmd388drivers/scsi/ppa.cdone(cmd);
cmd460drivers/scsi/ppa.cint     ppa_abort( Scsi_Cmnd * cmd )
cmd466drivers/scsi/ppa.cint     ppa_reset( Scsi_Cmnd * cmd )
cmd295drivers/scsi/qlogic.cstatic void  ql_icmd(Scsi_Cmnd * cmd)
cmd329drivers/scsi/qlogic.coutb(cmd->target, qbase + 4);
cmd331drivers/scsi/qlogic.cfor (i = 0; i < cmd->cmd_len; i++)
cmd332drivers/scsi/qlogic.coutb(cmd->cmnd[i], qbase + 2);
cmd333drivers/scsi/qlogic.cqlcmd = cmd;
cmd339drivers/scsi/qlogic.cstatic unsigned int  ql_pcmd(Scsi_Cmnd * cmd)
cmd376drivers/scsi/qlogic.creqlen = cmd->request_bufflen;
cmd386drivers/scsi/qlogic.cif (!cmd->use_sg)
cmd387drivers/scsi/qlogic.cql_pdma(phase, cmd->request_buffer, cmd->request_bufflen);
cmd389drivers/scsi/qlogic.csgcount = cmd->use_sg;
cmd390drivers/scsi/qlogic.csglist = cmd->request_buffer;
cmd474drivers/scsi/qlogic.cstatic void  qlidone(Scsi_Cmnd * cmd) {};    /* null function */
cmd478drivers/scsi/qlogic.cint  qlogic_command(Scsi_Cmnd * cmd)
cmd483drivers/scsi/qlogic.cqlogic_queuecommand(cmd, qlidone);
cmd485drivers/scsi/qlogic.creturn cmd->result;
cmd489drivers/scsi/qlogic.cif (cmd->target == qinitid)
cmd491drivers/scsi/qlogic.cql_icmd(cmd);
cmd494drivers/scsi/qlogic.creturn ql_pcmd(cmd);
cmd501drivers/scsi/qlogic.cint  qlogic_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd503drivers/scsi/qlogic.cif(cmd->target == qinitid) {
cmd504drivers/scsi/qlogic.ccmd->result = DID_BAD_TARGET << 16;
cmd505drivers/scsi/qlogic.cdone(cmd);
cmd509drivers/scsi/qlogic.ccmd->scsi_done = done;
cmd513drivers/scsi/qlogic.cql_icmd(cmd);
cmd517drivers/scsi/qlogic.cint  qlogic_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
cmd650drivers/scsi/qlogic.cint  qlogic_abort(Scsi_Cmnd * cmd)
cmd659drivers/scsi/qlogic.cint  qlogic_reset(Scsi_Cmnd * cmd)
cmd3363drivers/scsi/scsi.creq->cmd,
cmd100drivers/scsi/scsi_debug.cif (SCpnt->request.cmd != RW) panic ("Wrong  operation");       \
cmd175drivers/scsi/scsi_debug.cunchar *cmd = (unchar *) SCpnt->cmnd;
cmd209drivers/scsi/scsi_debug.cswitch(*cmd){
cmd227drivers/scsi/scsi_debug.cif(cmd[4]) printk("Medium removal inhibited...");
cmd265drivers/scsi/scsi_debug.cif ((*cmd) == READ_10)
cmd266drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
cmd268drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
cmd346drivers/scsi/scsi_debug.cmemcpy(buff+sizeof(target), cmd, 24);
cmd378drivers/scsi/scsi_debug.cif ((*cmd) == WRITE_10)
cmd379drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
cmd381drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
cmd400drivers/scsi/scsi_debug.cprintk("Unknown command %d\n",*cmd);
cmd104drivers/scsi/scsi_ioctl.cstatic int ioctl_internal_command(Scsi_Device *dev, char * cmd)
cmd113drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd, NULL,  0,
cmd122drivers/scsi/scsi_ioctl.cif(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0;
cmd168drivers/scsi/scsi_ioctl.cchar cmd[12];
cmd228drivers/scsi/scsi_ioctl.cmemcpy_fromfs ((void *) cmd,  cmd_in,  cmdlen);
cmd240drivers/scsi/scsi_ioctl.ccmd[1] = ( cmd[1] & 0x1f ) | (dev->lun << 5);
cmd249drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd,  buf, needed,  scsi_ioctl_done,  MAX_TIMEOUT, 
cmd286drivers/scsi/scsi_ioctl.cprintk("%02x ", cmd[i]);
cmd304drivers/scsi/scsi_ioctl.cint scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
cmd312drivers/scsi/scsi_ioctl.cswitch (cmd) {
cmd374drivers/scsi/scsi_ioctl.cint kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) {
cmd379drivers/scsi/scsi_ioctl.ctmp = scsi_ioctl (dev, cmd, arg);
cmd249drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
cmd264drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
cmd509drivers/scsi/sd.cunsigned char cmd[10];
cmd576drivers/scsi/sd.cswitch (SCpnt->request.cmd)
cmd584drivers/scsi/sd.ccmd[0] = WRITE_6;
cmd587drivers/scsi/sd.ccmd[0] = READ_6;
cmd590drivers/scsi/sd.cpanic ("Unknown sd command %d\n", SCpnt->request.cmd);
cmd808drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
cmd830drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
cmd837drivers/scsi/sd.c(SCpnt->request.cmd == WRITE) ? "writing" : "reading",
cmd841drivers/scsi/sd.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
cmd860drivers/scsi/sd.ccmd[0] += READ_10 - READ_6 ;
cmd861drivers/scsi/sd.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
cmd862drivers/scsi/sd.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
cmd863drivers/scsi/sd.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
cmd864drivers/scsi/sd.ccmd[5] = (unsigned char) block & 0xff;
cmd865drivers/scsi/sd.ccmd[6] = cmd[9] = 0;
cmd866drivers/scsi/sd.ccmd[7] = (unsigned char) (this_count >> 8) & 0xff;
cmd867drivers/scsi/sd.ccmd[8] = (unsigned char) this_count & 0xff;
cmd874drivers/scsi/sd.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
cmd875drivers/scsi/sd.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
cmd876drivers/scsi/sd.ccmd[3] = (unsigned char) block & 0xff;
cmd877drivers/scsi/sd.ccmd[4] = (unsigned char) this_count;
cmd878drivers/scsi/sd.ccmd[5] = 0;
cmd889drivers/scsi/sd.cscsi_do_cmd (SCpnt, (void *) cmd, buff, 
cmd954drivers/scsi/sd.cunsigned char cmd[10];
cmd976drivers/scsi/sd.ccmd[0] = TEST_UNIT_READY;
cmd977drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd978drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd989drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd1009drivers/scsi/sd.ccmd[0] = START_STOP;
cmd1010drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd1011drivers/scsi/sd.ccmd[1] |= 1;  /* Return immediately */
cmd1012drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd1013drivers/scsi/sd.ccmd[4] = 1; /* Start spin cycle */
cmd1024drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd1049drivers/scsi/sd.ccmd[0] = READ_CAPACITY;
cmd1050drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd1051drivers/scsi/sd.cmemset ((void *) &cmd[2], 0, 8);
cmd1063drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd1202drivers/scsi/sd.cmemset ((void *) &cmd[0], 0, 8);
cmd1203drivers/scsi/sd.ccmd[0] = MODE_SENSE;
cmd1204drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
cmd1205drivers/scsi/sd.ccmd[2] = 1;   /* page code 1 ?? */
cmd1206drivers/scsi/sd.ccmd[4] = 12;
cmd1217drivers/scsi/sd.c(void *) cmd, (void *) buffer,
cmd23drivers/scsi/sd_ioctl.cint sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
cmd31drivers/scsi/sd_ioctl.cswitch (cmd) {
cmd95drivers/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg);
cmd1638drivers/scsi/seagate.cunsigned char buf[256 + sizeof(int) * 2], cmd[6], *data, *page;
cmd1654drivers/scsi/seagate.ccmd[0] = MODE_SENSE;
cmd1655drivers/scsi/seagate.ccmd[1] = (disk->device->lun << 5) & 0xe5;
cmd1656drivers/scsi/seagate.ccmd[2] = 0x04; /* Read page 4, rigid disk geometry page current values */
cmd1657drivers/scsi/seagate.ccmd[3] = 0;
cmd1658drivers/scsi/seagate.ccmd[4] = 255;
cmd1659drivers/scsi/seagate.ccmd[5] = 0;
cmd1669drivers/scsi/seagate.cmemcpy (data, cmd, 6);
cmd1681drivers/scsi/seagate.ccmd[2] = 0x03; /* Read page 3, format page current values */
cmd1682drivers/scsi/seagate.cmemcpy (data, cmd, 6);
cmd323drivers/scsi/sr.cunsigned char   *cmd;       /* the scsi-command */
cmd352drivers/scsi/sr.ccmd = rec = &buf[8];
cmd363drivers/scsi/sr.ccmd[0] = 0xde;
cmd364drivers/scsi/sr.ccmd[1] = 0x03;
cmd365drivers/scsi/sr.ccmd[2] = 0xb0;
cmd400drivers/scsi/sr.ccmd[0] = 0xc7;
cmd401drivers/scsi/sr.ccmd[1] = 3;
cmd435drivers/scsi/sr.ccmd[0] = 0x1a;
cmd436drivers/scsi/sr.ccmd[2] = 1;
cmd437drivers/scsi/sr.ccmd[4] = 12;
cmd456drivers/scsi/sr.ccmd[0] = 0x15;
cmd457drivers/scsi/sr.ccmd[1] = (1 << 4);
cmd458drivers/scsi/sr.ccmd[4] = 12;
cmd459drivers/scsi/sr.csend = &cmd[6];                 /* this is a 6-Byte command    */
cmd482drivers/scsi/sr.ccmd[0] = 0x43; /* Read TOC */
cmd483drivers/scsi/sr.ccmd[8] = 0x0c;
cmd484drivers/scsi/sr.ccmd[9] = 0x40;
cmd647drivers/scsi/sr.cunsigned char cmd[10], *buffer, tries;
cmd688drivers/scsi/sr.cswitch (SCpnt->request.cmd)
cmd695drivers/scsi/sr.ccmd[0] = READ_6;
cmd698drivers/scsi/sr.cpanic ("Unknown sr command %d\n", SCpnt->request.cmd);
cmd701drivers/scsi/sr.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
cmd876drivers/scsi/sr.ccmd[0] += READ_10 - READ_6 ;
cmd877drivers/scsi/sr.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
cmd878drivers/scsi/sr.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
cmd879drivers/scsi/sr.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
cmd880drivers/scsi/sr.ccmd[5] = (unsigned char) block & 0xff;
cmd881drivers/scsi/sr.ccmd[6] = cmd[9] = 0;
cmd882drivers/scsi/sr.ccmd[7] = (unsigned char) (realcount >> 8) & 0xff;
cmd883drivers/scsi/sr.ccmd[8] = (unsigned char) realcount & 0xff;
cmd893drivers/scsi/sr.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
cmd894drivers/scsi/sr.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
cmd895drivers/scsi/sr.ccmd[3] = (unsigned char) block & 0xff;
cmd896drivers/scsi/sr.ccmd[4] = (unsigned char) realcount;
cmd897drivers/scsi/sr.ccmd[5] = 0;
cmd906drivers/scsi/sr.cfor(i=0; i<12; i++) printk("%2.2x ", cmd[i]);
cmd925drivers/scsi/sr.cscsi_do_cmd (SCpnt, (void *) cmd, buffer, 
cmd980drivers/scsi/sr.cunsigned char cmd[10];
cmd990drivers/scsi/sr.ccmd[0] = READ_CAPACITY;
cmd991drivers/scsi/sr.ccmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
cmd992drivers/scsi/sr.cmemset ((void *) &cmd[2], 0, 8);
cmd1003drivers/scsi/sr.c(void *) cmd, (void *) buffer,
cmd91drivers/scsi/sr_ioctl.cint sr_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
cmd103drivers/scsi/sr_ioctl.cswitch (cmd) 
cmd574drivers/scsi/sr_ioctl.creturn scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
cmd243drivers/scsi/st.cst_do_scsi(Scsi_Cmnd *SCpnt, Scsi_Tape *STp, unsigned char *cmd, int bytes,
cmd252drivers/scsi/st.ccmd[1] |= (SCpnt->lun << 5) & 0xe0;
cmd258drivers/scsi/st.cscsi_do_cmd(SCpnt, (void *)cmd, (STp->buffer)->b_data, bytes,
cmd309drivers/scsi/st.cunsigned char cmd[10];
cmd311drivers/scsi/st.ccmd[0] = SPACE;
cmd312drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd313drivers/scsi/st.ccmd[2] = cmd[3] = cmd[4] = 0xff;  /* -1 filemarks */
cmd314drivers/scsi/st.ccmd[5] = 0;
cmd316drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_RETRIES);
cmd338drivers/scsi/st.cunsigned char cmd[10];
cmd370drivers/scsi/st.cmemset(cmd, 0, 10);
cmd371drivers/scsi/st.ccmd[0] = WRITE_6;
cmd372drivers/scsi/st.ccmd[1] = 1;
cmd374drivers/scsi/st.ccmd[2] = blks >> 16;
cmd375drivers/scsi/st.ccmd[3] = blks >> 8;
cmd376drivers/scsi/st.ccmd[4] = blks;
cmd378drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
cmd509drivers/scsi/st.cunsigned char cmd[10];
cmd573drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd574drivers/scsi/st.ccmd[0] = TEST_UNIT_READY;
cmd576drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
cmd583drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd584drivers/scsi/st.ccmd[0] = TEST_UNIT_READY;
cmd586drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
cmd631drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd632drivers/scsi/st.ccmd[0] = READ_BLOCK_LIMITS;
cmd634drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 6, ST_TIMEOUT, MAX_READY_RETRIES);
cmd656drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd657drivers/scsi/st.ccmd[0] = MODE_SENSE;
cmd658drivers/scsi/st.ccmd[4] = 12;
cmd660drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 12, ST_TIMEOUT, MAX_READY_RETRIES);
cmd780drivers/scsi/st.cstatic unsigned char cmd[10];
cmd813drivers/scsi/st.cmemset(cmd, 0, 10);
cmd814drivers/scsi/st.ccmd[0] = WRITE_FILEMARKS;
cmd815drivers/scsi/st.ccmd[4] = 1 + STp->two_fm;
cmd817drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_WRITE_RETRIES);
cmd837drivers/scsi/st.cdev, cmd[4]);
cmd875drivers/scsi/st.cstatic unsigned char cmd[10];
cmd979drivers/scsi/st.cmemset(cmd, 0, 10);
cmd980drivers/scsi/st.ccmd[0] = WRITE_6;
cmd981drivers/scsi/st.ccmd[1] = (STp->block_size != 0);
cmd1009drivers/scsi/st.ccmd[2] = blks >> 16;
cmd1010drivers/scsi/st.ccmd[3] = blks >> 8;
cmd1011drivers/scsi/st.ccmd[4] = blks;
cmd1013drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
cmd1122drivers/scsi/st.ccmd[2] = blks >> 16;
cmd1123drivers/scsi/st.ccmd[3] = blks >> 8;
cmd1124drivers/scsi/st.ccmd[4] = blks;
cmd1134drivers/scsi/st.c(void *) cmd, (STp->buffer)->b_data,
cmd1152drivers/scsi/st.cstatic unsigned char cmd[10];
cmd1215drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1216drivers/scsi/st.ccmd[0] = READ_6;
cmd1217drivers/scsi/st.ccmd[1] = (STp->block_size != 0);
cmd1233drivers/scsi/st.ccmd[2] = blks >> 16;
cmd1234drivers/scsi/st.ccmd[3] = blks >> 8;
cmd1235drivers/scsi/st.ccmd[4] = blks;
cmd1237drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, bytes, ST_TIMEOUT, MAX_RETRIES);
cmd1593drivers/scsi/st.cunsigned char cmd[10];
cmd1600drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1601drivers/scsi/st.ccmd[0] = MODE_SENSE;
cmd1602drivers/scsi/st.ccmd[1] = 8;
cmd1603drivers/scsi/st.ccmd[2] = COMPRESSION_PAGE;
cmd1604drivers/scsi/st.ccmd[4] = COMPRESSION_PAGE_LENGTH + MODE_HEADER_LENGTH;
cmd1606drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_TIMEOUT, 0);
cmd1641drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1642drivers/scsi/st.ccmd[0] = MODE_SELECT;
cmd1643drivers/scsi/st.ccmd[1] = 0x10;
cmd1644drivers/scsi/st.ccmd[4] = COMPRESSION_PAGE_LENGTH + MODE_HEADER_LENGTH;
cmd1649drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_TIMEOUT, 0);
cmd1680drivers/scsi/st.cunsigned char cmd[10];
cmd1695drivers/scsi/st.cmemset(cmd, 0, 10);
cmd1700drivers/scsi/st.ccmd[0] = SPACE;
cmd1701drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd1702drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1703drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1704drivers/scsi/st.ccmd[4] = arg;
cmd1708drivers/scsi/st.cdev, cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1717drivers/scsi/st.ccmd[0] = SPACE;
cmd1718drivers/scsi/st.ccmd[1] = 0x01; /* Space FileMarks */
cmd1720drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1721drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1722drivers/scsi/st.ccmd[4] = ltmp;
cmd1725drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1727drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1738drivers/scsi/st.ccmd[0] = SPACE;
cmd1739drivers/scsi/st.ccmd[1] = 0x00; /* Space Blocks */
cmd1740drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1741drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1742drivers/scsi/st.ccmd[4] = arg;
cmd1746drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1753drivers/scsi/st.ccmd[0] = SPACE;
cmd1754drivers/scsi/st.ccmd[1] = 0x00; /* Space Blocks */
cmd1756drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1757drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1758drivers/scsi/st.ccmd[4] = ltmp;
cmd1761drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1763drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1772drivers/scsi/st.ccmd[0] = SPACE;
cmd1773drivers/scsi/st.ccmd[1] = 0x04; /* Space Setmarks */
cmd1774drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1775drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1776drivers/scsi/st.ccmd[4] = arg;
cmd1780drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1788drivers/scsi/st.ccmd[0] = SPACE;
cmd1789drivers/scsi/st.ccmd[1] = 0x04; /* Space Setmarks */
cmd1791drivers/scsi/st.ccmd[2] = (ltmp >> 16);
cmd1792drivers/scsi/st.ccmd[3] = (ltmp >> 8);
cmd1793drivers/scsi/st.ccmd[4] = ltmp;
cmd1796drivers/scsi/st.cif (cmd[2] & 0x80)
cmd1798drivers/scsi/st.cltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
cmd1812drivers/scsi/st.ccmd[0] = WRITE_FILEMARKS;
cmd1814drivers/scsi/st.ccmd[1] = 2;
cmd1815drivers/scsi/st.ccmd[2] = (arg >> 16);
cmd1816drivers/scsi/st.ccmd[3] = (arg >> 8);
cmd1817drivers/scsi/st.ccmd[4] = arg;
cmd1823drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1826drivers/scsi/st.ccmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
cmd1835drivers/scsi/st.ccmd[0] = REZERO_UNIT;
cmd1837drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1849drivers/scsi/st.ccmd[0] = START_STOP;
cmd1851drivers/scsi/st.ccmd[4] |= 1;
cmd1853drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1876drivers/scsi/st.ccmd[0] = START_STOP;
cmd1878drivers/scsi/st.ccmd[1] = 1;  /* Don't wait for completion */
cmd1881drivers/scsi/st.ccmd[4] = 3;
cmd1902drivers/scsi/st.ccmd[0] = SPACE;
cmd1903drivers/scsi/st.ccmd[1] = 3;
cmd1914drivers/scsi/st.ccmd[0] = ERASE;
cmd1915drivers/scsi/st.ccmd[1] = 1;  /* To the end of tape */
cmd1917drivers/scsi/st.ccmd[1] |= 2;  /* Don't wait for completion */
cmd1929drivers/scsi/st.ccmd[0] = ALLOW_MEDIUM_REMOVAL;
cmd1930drivers/scsi/st.ccmd[4] = SCSI_REMOVAL_PREVENT;
cmd1937drivers/scsi/st.ccmd[0] = ALLOW_MEDIUM_REMOVAL;
cmd1938drivers/scsi/st.ccmd[4] = SCSI_REMOVAL_ALLOW;
cmd1958drivers/scsi/st.ccmd[0] = MODE_SELECT;
cmd1959drivers/scsi/st.ccmd[4] = datalen = 12;
cmd2007drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, datalen, timeout, MAX_RETRIES);
cmd2356drivers/scsi/st.cunsigned char cmd[10];
cmd2362drivers/scsi/st.cmemset ((void *) &cmd[0], 0, 10);
cmd2363drivers/scsi/st.ccmd[0] = MODE_SENSE;
cmd2364drivers/scsi/st.ccmd[1] = 8;   /* Page format */
cmd2365drivers/scsi/st.ccmd[2] = PART_PAGE;
cmd2366drivers/scsi/st.ccmd[4] = 200;
cmd2368drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 200, ST_TIMEOUT, MAX_READY_RETRIES);
cmd2401drivers/scsi/st.cunsigned char cmd[10], *bp;
cmd2437drivers/scsi/st.cmemset(cmd, 0, 10);
cmd2438drivers/scsi/st.ccmd[0] = MODE_SELECT;
cmd2439drivers/scsi/st.ccmd[1] = 0x10;
cmd2440drivers/scsi/st.ccmd[4] = length + MODE_HEADER_LENGTH;
cmd2442drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_LONG_TIMEOUT, MAX_READY_RETRIES);
cmd109drivers/scsi/wd33c93.c#define IS_DIR_OUT(cmd) ((cmd)->cmnd[0] == WRITE_6  || \
cmd110drivers/scsi/wd33c93.c(cmd)->cmnd[0] == WRITE_10 || \
cmd111drivers/scsi/wd33c93.c(cmd)->cmnd[0] == WRITE_12)
cmd187drivers/scsi/wd33c93.cinline void write_wd33c93_cmd(wd33c93_regs *regp, uchar cmd)
cmd190drivers/scsi/wd33c93.cregp->SCMD = cmd;
cmd270drivers/scsi/wd33c93.cint wd33c93_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
cmd279drivers/scsi/wd33c93.chostdata = (struct WD33C93_hostdata *)cmd->host->hostdata;
cmd281drivers/scsi/wd33c93.cDB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld( ",cmd->target,cmd->cmnd[0],cmd->pid))
cmd289drivers/scsi/wd33c93.ccmd->host_scribble = NULL;
cmd290drivers/scsi/wd33c93.ccmd->scsi_done = done;
cmd291drivers/scsi/wd33c93.ccmd->result = 0;
cmd308drivers/scsi/wd33c93.cif (cmd->use_sg) {
cmd309drivers/scsi/wd33c93.ccmd->SCp.buffer = (struct scatterlist *)cmd->buffer;
cmd310drivers/scsi/wd33c93.ccmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd311drivers/scsi/wd33c93.ccmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
cmd312drivers/scsi/wd33c93.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd315drivers/scsi/wd33c93.ccmd->SCp.buffer = NULL;
cmd316drivers/scsi/wd33c93.ccmd->SCp.buffers_residual = 0;
cmd317drivers/scsi/wd33c93.ccmd->SCp.ptr = (char *)cmd->request_buffer;
cmd318drivers/scsi/wd33c93.ccmd->SCp.this_residual = cmd->request_bufflen;
cmd323drivers/scsi/wd33c93.ccmd->SCp.Status = GOOD;
cmd331drivers/scsi/wd33c93.cif (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd332drivers/scsi/wd33c93.ccmd->host_scribble = (uchar *)hostdata->input_Q;
cmd333drivers/scsi/wd33c93.chostdata->input_Q = cmd;
cmd339drivers/scsi/wd33c93.ctmp->host_scribble = (uchar *)cmd;
cmd346drivers/scsi/wd33c93.cwd33c93_execute(cmd->host);
cmd348drivers/scsi/wd33c93.cDB(DB_QUEUE_COMMAND,printk(")Q-%ld ",cmd->pid))
cmd366drivers/scsi/wd33c93.cScsi_Cmnd *cmd, *prev;
cmd391drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hostdata->input_Q;
cmd393drivers/scsi/wd33c93.cwhile (cmd) {
cmd394drivers/scsi/wd33c93.cif (!(hostdata->busy[cmd->target] & (1 << cmd->lun)))
cmd396drivers/scsi/wd33c93.cprev = cmd;
cmd397drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd402drivers/scsi/wd33c93.cif (!cmd) {
cmd413drivers/scsi/wd33c93.cprev->host_scribble = cmd->host_scribble;
cmd415drivers/scsi/wd33c93.chostdata->input_Q = (Scsi_Cmnd *)cmd->host_scribble;
cmd421drivers/scsi/wd33c93.cif (IS_DIR_OUT(cmd))
cmd422drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_DESTINATION_ID, cmd->target);
cmd424drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_DESTINATION_ID, cmd->target | DSTID_DPD);
cmd449drivers/scsi/wd33c93.ccmd->SCp.phase = 0;  /* assume no disconnect */
cmd454drivers/scsi/wd33c93.cif (cmd->device->type == 1)   /* tape drive? */
cmd462drivers/scsi/wd33c93.cif ((prev->target != cmd->target) || (prev->lun != cmd->lun)) {
cmd472drivers/scsi/wd33c93.ccmd->SCp.phase = 1;
cmd479drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_SOURCE_ID, ((cmd->SCp.phase)?SRCID_ER:0));
cmd481drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_TARGET_LUN, cmd->lun);
cmd482drivers/scsi/wd33c93.cwrite_wd33c93(regp,WD_SYNCHRONOUS_TRANSFER,hostdata->sync_xfer[cmd->target]);
cmd483drivers/scsi/wd33c93.chostdata->busy[cmd->target] |= (1 << cmd->lun);
cmd486drivers/scsi/wd33c93.c(hostdata->sync_stat[cmd->target] == SS_UNSET)) {
cmd496drivers/scsi/wd33c93.chostdata->selecting = cmd;
cmd509drivers/scsi/wd33c93.cif (hostdata->sync_stat[cmd->target] == SS_UNSET) {
cmd510drivers/scsi/wd33c93.cif (hostdata->no_sync & (1 << cmd->target))
cmd511drivers/scsi/wd33c93.chostdata->sync_stat[cmd->target] = SS_SET;
cmd513drivers/scsi/wd33c93.chostdata->sync_stat[cmd->target] = SS_FIRST;
cmd530drivers/scsi/wd33c93.chostdata->connected = cmd;
cmd538drivers/scsi/wd33c93.cfor (i=0; i<cmd->cmd_len; i++)
cmd539drivers/scsi/wd33c93.cregp->SCMD = cmd->cmnd[i];
cmd547drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_OWN_ID, cmd->cmd_len);
cmd553drivers/scsi/wd33c93.cif (cmd->SCp.phase == 0) {
cmd554drivers/scsi/wd33c93.cif (hostdata->dma_setup(cmd,
cmd555drivers/scsi/wd33c93.c(IS_DIR_OUT(cmd))?DATA_OUT_DIR:DATA_IN_DIR))
cmd558drivers/scsi/wd33c93.cwrite_wd33c93_count(regp, cmd->SCp.this_residual);
cmd577drivers/scsi/wd33c93.cDB(DB_EXECUTE,printk("%s%ld)EX-2 ",(cmd->SCp.phase)?"d:":"",cmd->pid))
cmd620drivers/scsi/wd33c93.cvoid transfer_bytes(wd33c93_regs *regp, Scsi_Cmnd *cmd, int data_in_dir)
cmd624drivers/scsi/wd33c93.chostdata = (struct WD33C93_hostdata *)cmd->host->hostdata;
cmd634drivers/scsi/wd33c93.cif (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
cmd635drivers/scsi/wd33c93.c++cmd->SCp.buffer;
cmd636drivers/scsi/wd33c93.c--cmd->SCp.buffers_residual;
cmd637drivers/scsi/wd33c93.ccmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd638drivers/scsi/wd33c93.ccmd->SCp.ptr = cmd->SCp.buffer->address;
cmd641drivers/scsi/wd33c93.cwrite_wd33c93(regp,WD_SYNCHRONOUS_TRANSFER,hostdata->sync_xfer[cmd->target]);
cmd645drivers/scsi/wd33c93.cif (hostdata->dma_setup(cmd, data_in_dir)) {
cmd646drivers/scsi/wd33c93.ctransfer_pio(regp, (uchar *)&cmd->SCp.ptr, cmd->SCp.this_residual,
cmd661drivers/scsi/wd33c93.cwrite_wd33c93_count(regp,cmd->SCp.this_residual);
cmd663drivers/scsi/wd33c93.cif ((hostdata->level2 >= L2_DATA) || (cmd->SCp.phase == 0)) {
cmd680drivers/scsi/wd33c93.cScsi_Cmnd *patch, *cmd;
cmd699drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hostdata->connected;   /* assume we're connected */
cmd721drivers/scsi/wd33c93.cDB(DB_TRANSFER,printk("[%p/%d:",cmd->SCp.ptr,cmd->SCp.this_residual))
cmd722drivers/scsi/wd33c93.chostdata->dma_stop(cmd->host, cmd, 1);
cmd724drivers/scsi/wd33c93.clength = cmd->SCp.this_residual;
cmd725drivers/scsi/wd33c93.ccmd->SCp.this_residual = read_wd33c93_count(regp);
cmd726drivers/scsi/wd33c93.ccmd->SCp.ptr += (length - cmd->SCp.this_residual);
cmd727drivers/scsi/wd33c93.cDB(DB_TRANSFER,printk("%p/%d]",cmd->SCp.ptr,cmd->SCp.this_residual))
cmd741drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hostdata->selecting;   /* get a valid cmd */
cmd745drivers/scsi/wd33c93.ccmd->result = DID_NO_CONNECT << 16;
cmd746drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd748drivers/scsi/wd33c93.ccmd->scsi_done(cmd);
cmd764drivers/scsi/wd33c93.chostdata->connected = cmd = (Scsi_Cmnd *)hostdata->selecting;
cmd769drivers/scsi/wd33c93.chostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->lun);
cmd770drivers/scsi/wd33c93.cif (cmd->SCp.phase)
cmd773drivers/scsi/wd33c93.cif (hostdata->sync_stat[cmd->target] == SS_FIRST) {
cmd778drivers/scsi/wd33c93.chostdata->sync_stat[cmd->target] = SS_WAITING;
cmd799drivers/scsi/wd33c93.cDB(DB_INTR,printk("IN-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual))
cmd800drivers/scsi/wd33c93.ctransfer_bytes(regp, cmd, DATA_IN_DIR);
cmd809drivers/scsi/wd33c93.cDB(DB_INTR,printk("OUT-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual))
cmd810drivers/scsi/wd33c93.ctransfer_bytes(regp, cmd, DATA_OUT_DIR);
cmd821drivers/scsi/wd33c93.cDB(DB_INTR,printk("CMND-%02x,%ld",cmd->cmnd[0],cmd->pid))
cmd822drivers/scsi/wd33c93.ctransfer_pio(regp, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
cmd832drivers/scsi/wd33c93.ccmd->SCp.Status = read_1_byte(regp);
cmd840drivers/scsi/wd33c93.cDB(DB_INTR,printk("=%02x",cmd->SCp.Status))
cmd861drivers/scsi/wd33c93.ccmd->SCp.Message = msg;
cmd865drivers/scsi/wd33c93.cDB(DB_INTR,printk("CCMP-%ld",cmd->pid))
cmd891drivers/scsi/wd33c93.ccmd->device->disconnect = 1;
cmd901drivers/scsi/wd33c93.cif (hostdata->sync_stat[cmd->target] == SS_WAITING)
cmd902drivers/scsi/wd33c93.chostdata->sync_stat[cmd->target] = SS_SET;
cmd923drivers/scsi/wd33c93.cif (hostdata->sync_stat[cmd->target] != SS_WAITING) {
cmd941drivers/scsi/wd33c93.chostdata->sync_xfer[cmd->target] =
cmd945drivers/scsi/wd33c93.chostdata->sync_xfer[cmd->target] = id;
cmd948drivers/scsi/wd33c93.cprintk("sync_xfer=%02x",hostdata->sync_xfer[cmd->target]);
cmd950drivers/scsi/wd33c93.chostdata->sync_stat[cmd->target] = SS_SET;
cmd1008drivers/scsi/wd33c93.cDB(DB_INTR,printk("SX-DONE-%ld",cmd->pid))
cmd1009drivers/scsi/wd33c93.ccmd->SCp.Message = COMMAND_COMPLETE;
cmd1011drivers/scsi/wd33c93.cif (cmd->SCp.Status == GOOD)
cmd1012drivers/scsi/wd33c93.ccmd->SCp.Status = lun;
cmd1014drivers/scsi/wd33c93.cif (cmd->cmnd[0] != REQUEST_SENSE)
cmd1015drivers/scsi/wd33c93.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
cmd1016drivers/scsi/wd33c93.celse if (cmd->SCp.Status != GOOD)
cmd1017drivers/scsi/wd33c93.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd1018drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1020drivers/scsi/wd33c93.ccmd->scsi_done(cmd);
cmd1029drivers/scsi/wd33c93.cprintk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---",asr,sr,phs,cmd->pid);
cmd1091drivers/scsi/wd33c93.cif (cmd == NULL) {
cmd1096drivers/scsi/wd33c93.cDB(DB_INTR,printk("UNEXP_DISC-%ld",cmd->pid))
cmd1098drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1100drivers/scsi/wd33c93.cif (cmd->cmnd[0] != REQUEST_SENSE)
cmd1101drivers/scsi/wd33c93.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
cmd1102drivers/scsi/wd33c93.celse if (cmd->SCp.Status != GOOD)
cmd1103drivers/scsi/wd33c93.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd1104drivers/scsi/wd33c93.ccmd->scsi_done(cmd);
cmd1122drivers/scsi/wd33c93.cDB(DB_INTR,printk("DISC-%ld",cmd->pid))
cmd1123drivers/scsi/wd33c93.cif (cmd == NULL) {
cmd1130drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1132drivers/scsi/wd33c93.cif (cmd->cmnd[0] != REQUEST_SENSE)
cmd1133drivers/scsi/wd33c93.ccmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
cmd1134drivers/scsi/wd33c93.celse if (cmd->SCp.Status != GOOD)
cmd1135drivers/scsi/wd33c93.ccmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
cmd1136drivers/scsi/wd33c93.ccmd->scsi_done(cmd);
cmd1140drivers/scsi/wd33c93.ccmd->host_scribble = (uchar *)hostdata->disconnected_Q;
cmd1141drivers/scsi/wd33c93.chostdata->disconnected_Q = cmd;
cmd1175drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hostdata->selecting;
cmd1177drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1178drivers/scsi/wd33c93.ccmd->host_scribble = (uchar *)hostdata->input_Q;
cmd1179drivers/scsi/wd33c93.chostdata->input_Q = cmd;
cmd1185drivers/scsi/wd33c93.cif (cmd) {
cmd1187drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1188drivers/scsi/wd33c93.ccmd->host_scribble = (uchar *)hostdata->input_Q;
cmd1189drivers/scsi/wd33c93.chostdata->input_Q = cmd;
cmd1217drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hostdata->disconnected_Q;
cmd1219drivers/scsi/wd33c93.cwhile (cmd) {
cmd1220drivers/scsi/wd33c93.cif (id == cmd->target && lun == cmd->lun)
cmd1222drivers/scsi/wd33c93.cpatch = cmd;
cmd1223drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd1228drivers/scsi/wd33c93.cif (!cmd) {
cmd1236drivers/scsi/wd33c93.cpatch->host_scribble = cmd->host_scribble;
cmd1238drivers/scsi/wd33c93.chostdata->disconnected_Q = (Scsi_Cmnd *)cmd->host_scribble;
cmd1239drivers/scsi/wd33c93.chostdata->connected = cmd;
cmd1246drivers/scsi/wd33c93.cif (IS_DIR_OUT(cmd))
cmd1247drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_DESTINATION_ID, cmd->target);
cmd1249drivers/scsi/wd33c93.cwrite_wd33c93(regp, WD_DESTINATION_ID, cmd->target | DSTID_DPD);
cmd1259drivers/scsi/wd33c93.cDB(DB_INTR,printk("-%ld",cmd->pid))
cmd1357drivers/scsi/wd33c93.cint wd33c93_abort (Scsi_Cmnd *cmd)
cmd1368drivers/scsi/wd33c93.cinstance = cmd->host;
cmd1380drivers/scsi/wd33c93.cif (tmp == cmd) {
cmd1382drivers/scsi/wd33c93.cprev->host_scribble = cmd->host_scribble;
cmd1383drivers/scsi/wd33c93.ccmd->host_scribble = NULL;
cmd1384drivers/scsi/wd33c93.ccmd->result = DID_ABORT << 16;
cmd1386drivers/scsi/wd33c93.cinstance->host_no, cmd->pid);
cmd1387drivers/scsi/wd33c93.ccmd->scsi_done(cmd);
cmd1406drivers/scsi/wd33c93.cif (hostdata->connected == cmd) {
cmd1411drivers/scsi/wd33c93.cinstance->host_no, cmd->pid);
cmd1415drivers/scsi/wd33c93.chostdata->dma_stop(instance, cmd, 0);
cmd1452drivers/scsi/wd33c93.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
cmd1455drivers/scsi/wd33c93.ccmd->result = DID_ABORT << 16;
cmd1456drivers/scsi/wd33c93.ccmd->scsi_done(cmd);
cmd1473drivers/scsi/wd33c93.cif (tmp == cmd) {
cmd1475drivers/scsi/wd33c93.cinstance->host_no, cmd->pid);
cmd1707drivers/scsi/wd33c93.cScsi_Cmnd *cmd;
cmd1783drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hd->connected;
cmd1785drivers/scsi/wd33c93.ccmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
cmd1791drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hd->input_Q;
cmd1792drivers/scsi/wd33c93.cwhile (cmd) {
cmd1794drivers/scsi/wd33c93.ccmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
cmd1796drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd1801drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)hd->disconnected_Q;
cmd1802drivers/scsi/wd33c93.cwhile (cmd) {
cmd1804drivers/scsi/wd33c93.ccmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
cmd1806drivers/scsi/wd33c93.ccmd = (Scsi_Cmnd *)cmd->host_scribble;
cmd307drivers/scsi/wd33c93.hint wd33c93_abort (Scsi_Cmnd *cmd);
cmd308drivers/scsi/wd33c93.hint wd33c93_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *));
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++;
cmd121drivers/sound/ad1848.cstatic int      ad1848_ioctl (int dev, unsigned int cmd, caddr_t arg, int local);
cmd470drivers/sound/ad1848.cad1848_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
cmd483drivers/sound/ad1848.cif (((cmd >> 8) & 0xff) == 'M')
cmd486drivers/sound/ad1848.cif (_IOC_DIR (cmd) & _IOC_WRITE)
cmd487drivers/sound/ad1848.cswitch (cmd & 0xff)
cmd494drivers/sound/ad1848.creturn snd_ioctl_return ((int *) arg, ad1848_mixer_set (devc, cmd & 0xff, get_fs_long ((long *) arg)));
cmd497drivers/sound/ad1848.cswitch (cmd & 0xff)  /*
cmd523drivers/sound/ad1848.creturn snd_ioctl_return ((int *) arg, ad1848_mixer_get (devc, cmd & 0xff));
cmd791drivers/sound/ad1848.cad1848_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd795drivers/sound/ad1848.cswitch (cmd)
cmd415drivers/sound/aedsp16.cWriteDSPCommand (int port, int cmd)
cmd428drivers/sound/aedsp16.coutb (cmd, port + DSP_COMMAND);
cmd434drivers/sound/aedsp16.cprintk ("[aedsp16] DSP Command (0x%x) timeout.\n", cmd);
cmd357drivers/sound/audio.cunsigned int cmd, caddr_t arg)
cmd362drivers/sound/audio.cif (((cmd >> 8) & 0xff) == 'C')
cmd365drivers/sound/audio.creturn audio_devs[dev]->coproc->ioctl (audio_devs[dev]->coproc->devc, cmd, arg, 0);
cmd372drivers/sound/audio.cswitch (cmd)
cmd376drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd386drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd403drivers/sound/audio.cint             err = DMAbuf_ioctl (dev, cmd, (caddr_t) & info, 1);
cmd421drivers/sound/audio.cint             err = DMAbuf_ioctl (dev, cmd, (caddr_t) & info, 1);
cmd462drivers/sound/audio.creturn DMAbuf_ioctl (dev, cmd, arg, 0);
cmd1554drivers/sound/configure.cchar            cmd[200];
cmd1556drivers/sound/configure.csprintf (cmd, "cp local.h %s", oldconf);
cmd1559drivers/sound/configure.cif (system (cmd) != 0)
cmd1560drivers/sound/configure.cperror (cmd);
cmd140drivers/sound/dev_table.hint (*ioctl) (void *devc, unsigned int cmd, caddr_t arg, int local);
cmd162drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, caddr_t arg, int local);
cmd185drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, caddr_t arg);
cmd196drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, caddr_t arg);
cmd240drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, caddr_t arg);
cmd266drivers/sound/dev_table.hint (*ioctl) (int dev, unsigned int cmd, caddr_t arg);
cmd726drivers/sound/dmabuf.cDMAbuf_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd731drivers/sound/dmabuf.cswitch (cmd)
cmd806drivers/sound/dmabuf.cif (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
cmd813drivers/sound/dmabuf.creorganize_buffers (dev, dmap, (cmd == SNDCTL_DSP_GETISPACE));
cmd817drivers/sound/dmabuf.cif (cmd == SNDCTL_DSP_GETISPACE)
cmd847drivers/sound/dmabuf.cif (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
cmd969drivers/sound/dmabuf.creturn audio_devs[dev]->ioctl (dev, cmd, arg, local);
cmd1768drivers/sound/dmabuf.cDMAbuf_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd97drivers/sound/dmasound.cextern void atari_microwire_cmd(int cmd);
cmd562drivers/sound/dmasound.cstatic int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd650drivers/sound/dmasound.cstatic int sound_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd2452drivers/sound/dmasound.cstatic int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd2458drivers/sound/dmasound.cswitch (cmd) {
cmd2506drivers/sound/dmasound.cswitch (cmd) {
cmd2560drivers/sound/dmasound.cswitch (cmd) {
cmd3052drivers/sound/dmasound.cstatic int sound_ioctl(struct inode *inode, struct file *file, u_int cmd,
cmd3062drivers/sound/dmasound.creturn(mixer_ioctl(inode, file, cmd, arg));
cmd3065drivers/sound/dmasound.cswitch (cmd) {
cmd3116drivers/sound/dmasound.creturn(mixer_ioctl(inode, file, cmd, arg));
cmd197drivers/sound/gus_midi.cgus_midi_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd897drivers/sound/gus_wave.cunsigned int cmd, caddr_t arg)
cmd900drivers/sound/gus_wave.cswitch (cmd)
cmd1779drivers/sound/gus_wave.cint             voice, cmd;
cmd1784drivers/sound/gus_wave.ccmd = event_rec[2];
cmd1791drivers/sound/gus_wave.c(cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS))
cmd1794drivers/sound/gus_wave.cswitch (cmd)
cmd1992drivers/sound/gus_wave.cgus_sampling_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd1994drivers/sound/gus_wave.cswitch (cmd)
cmd2830drivers/sound/gus_wave.cgus_default_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
cmd2834drivers/sound/gus_wave.cif (((cmd >> 8) & 0xff) == 'M')
cmd2836drivers/sound/gus_wave.cif (_IOC_DIR (cmd) & _IOC_WRITE)
cmd2837drivers/sound/gus_wave.cswitch (cmd & 0xff)
cmd2908drivers/sound/gus_wave.cswitch (cmd & 0xff)  /*
cmd135drivers/sound/ics2101.cics2101_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
cmd137drivers/sound/ics2101.cif (((cmd >> 8) & 0xff) == 'M')
cmd139drivers/sound/ics2101.cif (_IOC_DIR (cmd) & _IOC_WRITE)
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);
cmd311drivers/sound/mad16_sb_midi.cmad16_sb_midi_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd53drivers/sound/midi_synth.c#define STORE(cmd)
cmd55drivers/sound/midi_synth.c#define STORE(cmd) \
cmd59drivers/sound/midi_synth.ccmd; \
cmd284drivers/sound/midi_synth.cunsigned int cmd, caddr_t arg)
cmd290drivers/sound/midi_synth.cswitch (cmd)
cmd2drivers/sound/midi_synth.hunsigned int cmd, caddr_t arg);
cmd472drivers/sound/midibuf.cunsigned int cmd, caddr_t arg)
cmd478drivers/sound/midibuf.cif (((cmd >> 8) & 0xff) == 'C')
cmd481drivers/sound/midibuf.creturn midi_devs[dev]->coproc->ioctl (midi_devs[dev]->coproc->devc, cmd, arg, 0);
cmd488drivers/sound/midibuf.cswitch (cmd)
cmd502drivers/sound/midibuf.creturn midi_devs[dev]->ioctl (dev, cmd, arg);
cmd99drivers/sound/mpu401.cwrite_command (struct mpu_config *devc, unsigned char cmd)
cmd101drivers/sound/mpu401.coutb (cmd, COMDPORT (devc->base));
cmd170drivers/sound/mpu401.c#define STORE(cmd)
cmd172drivers/sound/mpu401.c#define STORE(cmd) \
cmd176drivers/sound/mpu401.ccmd; \
cmd613drivers/sound/mpu401.cmpu401_command (int dev, mpu_command_rec * cmd)
cmd645drivers/sound/mpu401.cprintk ("MPU-401: Command (0x%x) timeout\n", (int) cmd->cmd);
cmd658drivers/sound/mpu401.cwrite_command (devc, cmd->cmd);
cmd683drivers/sound/mpu401.cif (cmd->nr_args)
cmd684drivers/sound/mpu401.cfor (i = 0; i < cmd->nr_args; i++)
cmd688drivers/sound/mpu401.cif (!mpu401_out (dev, cmd->data[i]))
cmd691drivers/sound/mpu401.cprintk ("MPU: Command (0x%x), parm send failed.\n", (int) cmd->cmd);
cmd697drivers/sound/mpu401.ccmd->data[0] = 0;
cmd699drivers/sound/mpu401.cif (cmd->nr_returns)
cmd700drivers/sound/mpu401.cfor (i = 0; i < cmd->nr_returns; i++)
cmd706drivers/sound/mpu401.ccmd->data[i] = read_data (devc);
cmd724drivers/sound/mpu401.cmpu_cmd (int dev, int cmd, int data)
cmd730drivers/sound/mpu401.crec.cmd = cmd & 0xff;
cmd731drivers/sound/mpu401.crec.nr_args = ((cmd & 0xf0) == 0xE0);
cmd732drivers/sound/mpu401.crec.nr_returns = ((cmd & 0xf0) == 0xA0);
cmd790drivers/sound/mpu401.cmpu401_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd796drivers/sound/mpu401.cswitch (cmd)
cmd848drivers/sound/mpu401.cunsigned int cmd, caddr_t arg)
cmd860drivers/sound/mpu401.cswitch (cmd)
cmd127drivers/sound/opl3.cunsigned int cmd, caddr_t arg)
cmd129drivers/sound/opl3.cswitch (cmd)
cmd220drivers/sound/pas2_midi.cpas_midi_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd263drivers/sound/pas2_mixer.cpas_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
cmd265drivers/sound/pas2_mixer.cTRACE (printk ("pas2_mixer.c: int pas_mixer_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
cmd267drivers/sound/pas2_mixer.cif (((cmd >> 8) & 0xff) == 'M')
cmd269drivers/sound/pas2_mixer.cif (_IOC_DIR (cmd) & _IOC_WRITE)
cmd270drivers/sound/pas2_mixer.creturn snd_ioctl_return ((int *) arg, pas_mixer_set (cmd & 0xff, get_fs_long ((long *) arg)));
cmd276drivers/sound/pas2_mixer.cswitch (cmd & 0xff)
cmd316drivers/sound/pas2_mixer.creturn snd_ioctl_return ((int *) arg, levels[cmd & 0xff]);
cmd164drivers/sound/pas2_pcm.cpas_pcm_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd166drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static int pas_pcm_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg));
cmd168drivers/sound/pas2_pcm.cswitch (cmd)
cmd494drivers/sound/pss.cpss_coproc_ioctl (void *dev_info, unsigned int cmd, caddr_t arg, int local)
cmd498drivers/sound/pss.cswitch (cmd)
cmd64drivers/sound/sb16_dsp.cstatic int      sb16_dsp_ioctl (int dev, unsigned int cmd, caddr_t arg, int local);
cmd154drivers/sound/sb16_dsp.csb16_dsp_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd156drivers/sound/sb16_dsp.cswitch (cmd)
cmd53drivers/sound/sb16_midi.csb16midi_cmd (unsigned char cmd)
cmd55drivers/sound/sb16_midi.coutb (cmd, COMDPORT);
cmd193drivers/sound/sb16_midi.csb16midi_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd935drivers/sound/sb_dsp.csb_dsp_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd937drivers/sound/sb_dsp.cswitch (cmd)
cmd197drivers/sound/sb_midi.csb_midi_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd448drivers/sound/sb_mixer.csb_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
cmd450drivers/sound/sb_mixer.cif (((cmd >> 8) & 0xff) == 'M')
cmd452drivers/sound/sb_mixer.cif (_IOC_DIR (cmd) & _IOC_WRITE)
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));
cmd519drivers/sound/sequencer.cunsigned char   cmd = event_rec[2];
cmd537drivers/sound/sequencer.cif (cmd == MIDI_NOTEON && parm == 0)
cmd539drivers/sound/sequencer.ccmd = MIDI_NOTEOFF;
cmd544drivers/sound/sequencer.cswitch (cmd)
cmd601drivers/sound/sequencer.cunsigned char   cmd = event_rec[2];
cmd615drivers/sound/sequencer.cswitch (cmd)
cmd698drivers/sound/sequencer.cunsigned char   cmd = event_rec[1];
cmd726drivers/sound/sequencer.cswitch (cmd)
cmd801drivers/sound/sequencer.cunsigned char   cmd = event_rec[1];
cmd804drivers/sound/sequencer.cswitch (cmd)
cmd1529drivers/sound/sequencer.cunsigned int cmd, caddr_t arg)
cmd1536drivers/sound/sequencer.cswitch (cmd)
cmd1550drivers/sound/sequencer.creturn tmr->ioctl (tmr_no, cmd, arg);
cmd1652drivers/sound/sequencer.creturn tmr->ioctl (tmr_no, cmd, arg);
cmd1678drivers/sound/sequencer.cerr = synth_devs[dev]->ioctl (dev, cmd, arg);
cmd1701drivers/sound/sequencer.creturn snd_ioctl_return ((int *) arg, synth_devs[dev]->ioctl (dev, cmd, arg));
cmd1715drivers/sound/sequencer.csynth_devs[dev]->ioctl (dev, cmd, arg);
cmd1734drivers/sound/sequencer.creturn synth_devs[dev]->ioctl (dev, cmd, arg);
cmd1890drivers/sound/sequencer.creturn synth_devs[0]->ioctl (0, cmd, arg);
cmd13drivers/sound/sound_calls.hint DMAbuf_ioctl(int dev, unsigned int cmd, caddr_t arg, int local);
cmd33drivers/sound/sound_calls.hunsigned int cmd, caddr_t arg);
cmd48drivers/sound/sound_calls.hunsigned int cmd, caddr_t arg);
cmd68drivers/sound/sound_calls.hunsigned int cmd, caddr_t arg);
cmd99drivers/sound/sound_calls.hunsigned int cmd, caddr_t arg);
cmd180drivers/sound/sound_calls.hint gus_default_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg);
cmd249drivers/sound/sound_calls.hunsigned int cmd, caddr_t arg);
cmd519drivers/sound/sound_switch.cunsigned int cmd, caddr_t arg)
cmd521drivers/sound/sound_switch.cDEB (printk ("sound_ioctl_sw(dev=%d, cmd=0x%x, arg=0x%x)\n", dev, cmd, arg));
cmd523drivers/sound/sound_switch.cif (((cmd >> 8) & 0xff) == 'M' && num_mixers > 0)  /* Mixer ioctl */
cmd538drivers/sound/sound_switch.creturn mixer_devs[mixdev]->ioctl (mixdev, cmd, arg);
cmd541drivers/sound/sound_switch.creturn mixer_devs[0]->ioctl (0, cmd, arg);
cmd557drivers/sound/sound_switch.creturn mixer_devs[dev]->ioctl (dev, cmd, arg);
cmd563drivers/sound/sound_switch.creturn sequencer_ioctl (dev, file, cmd, arg);
cmd571drivers/sound/sound_switch.creturn audio_ioctl (dev, file, cmd, arg);
cmd577drivers/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, caddr_t arg)
cmd209drivers/sound/sound_timer.cswitch (cmd)
cmd156drivers/sound/soundcard.cunsigned int cmd, unsigned long arg)
cmd164drivers/sound/soundcard.cif (_IOC_DIR (cmd) != _IOC_NONE)
cmd171drivers/sound/soundcard.clen = _IOC_SIZE (cmd);
cmd173drivers/sound/soundcard.cif (_IOC_DIR (cmd) & _IOC_WRITE)
cmd179drivers/sound/soundcard.cif (_IOC_DIR (cmd) & _IOC_READ)
cmd187drivers/sound/soundcard.cerr = sound_ioctl_sw (dev, &files[dev], cmd, (caddr_t) arg);
cmd232drivers/sound/sscape.chost_command1 (struct sscape_info *devc, int cmd)
cmd236drivers/sound/sscape.cbuf[0] = (unsigned char) (cmd & 0xff);
cmd242drivers/sound/sscape.chost_command2 (struct sscape_info *devc, int cmd, int parm1)
cmd246drivers/sound/sscape.cbuf[0] = (unsigned char) (cmd & 0xff);
cmd253drivers/sound/sscape.chost_command3 (struct sscape_info *devc, int cmd, int parm1, int parm2)
cmd257drivers/sound/sscape.cbuf[0] = (unsigned char) (cmd & 0xff);
cmd651drivers/sound/sscape.csscape_coproc_ioctl (void *dev_info, unsigned int cmd, caddr_t arg, int local)
cmd654drivers/sound/sscape.cswitch (cmd)
cmd758drivers/sound/sscape.csscape_audio_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
cmd762drivers/sound/sscape.cswitch (cmd)
cmd136drivers/sound/sys_timer.cunsigned char   cmd = event[1];
cmd139drivers/sound/sys_timer.cswitch (cmd)
cmd206drivers/sound/sys_timer.cunsigned int cmd, caddr_t arg)
cmd208drivers/sound/sys_timer.cswitch (cmd)
cmd53drivers/sound/uart6850.cuart6850_cmd (unsigned char cmd)
cmd55drivers/sound/uart6850.coutb (cmd, COMDPORT);
cmd239drivers/sound/uart6850.cuart6850_ioctl (int dev, unsigned cmd, caddr_t arg)
cmd1011fs/dquot.casmlinkage int sys_quotactl(int cmd, const char *special, int id, caddr_t addr)
cmd1017fs/dquot.ccmds = cmd >> SUBCMDSHIFT;
cmd1018fs/dquot.ctype = cmd & SUBCMDMASK;
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) {
cmd381fs/fat/dir.cunsigned int cmd, unsigned long arg)
cmd389fs/fat/dir.cswitch (cmd) {
cmd16fs/fcntl.cextern int sock_fcntl (struct file *, unsigned int cmd, unsigned long arg);
cmd54fs/fcntl.casmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
cmd62fs/fcntl.cswitch (cmd) {
cmd99fs/fcntl.creturn fcntl_setlk(fd, cmd, (struct flock *) arg);
cmd101fs/fcntl.creturn fcntl_setlk(fd, cmd, (struct flock *) arg);
cmd160fs/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) {
cmd101fs/ioctl.creturn file_ioctl(filp, cmd, arg);
cmd104fs/ioctl.creturn filp->f_op->ioctl(filp->f_inode, filp, cmd, arg);
cmd92fs/locks.cunsigned int cmd);
cmd168fs/locks.casmlinkage int sys_flock(unsigned int fd, unsigned int cmd)
cmd176fs/locks.cif (!flock_make_lock(filp, &file_lock, cmd))
cmd182fs/locks.creturn (flock_lock_file(filp, &file_lock, cmd & LOCK_UN ? 0 : cmd & LOCK_NB ? 0 : 1));
cmd232fs/locks.cint fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l)
cmd300fs/locks.creturn (posix_lock_file(filp, &file_lock, cmd == F_SETLKW));
cmd466fs/locks.cunsigned int cmd)
cmd471fs/locks.cswitch (cmd & ~LOCK_NB) {
cmd19fs/ncpfs/ioctl.cunsigned int cmd, unsigned long arg)
cmd31fs/ncpfs/ioctl.cswitch(cmd) {
cmd33fs/ncpfs/ioctl.ccmd = NCP_IOC_NCPREQUEST;
cmd36fs/ncpfs/ioctl.ccmd = NCP_IOC_GETMOUNTUID;
cmd39fs/ncpfs/ioctl.ccmd = NCP_IOC_CONN_LOGGED_IN;
cmd42fs/ncpfs/ioctl.ccmd = NCP_IOC_GET_FS_INFO;
cmd46fs/ncpfs/ioctl.cswitch(cmd) {
cmd76fs/noquot.casmlinkage int sys_quotactl(int cmd, const char *special, int id, caddr_t addr)
cmd140fs/pipe.cunsigned int cmd, unsigned long arg)
cmd144fs/pipe.cswitch (cmd) {
cmd18fs/smbfs/ioctl.cunsigned int cmd, unsigned long arg)
cmd22fs/smbfs/ioctl.cswitch (cmd) {
cmd58fs/umsdos/ioctl.cunsigned int cmd,
cmd75fs/umsdos/ioctl.c|| cmd == UMSDOS_GETVERSION){
cmd97fs/umsdos/ioctl.cPRINTK (("ioctl %d ",cmd));
cmd98fs/umsdos/ioctl.cif (cmd == UMSDOS_GETVERSION){
cmd112fs/umsdos/ioctl.c}else if (cmd == UMSDOS_READDIR_DOS){
cmd125fs/umsdos/ioctl.c}else if (cmd == UMSDOS_READDIR_EMD){
cmd168fs/umsdos/ioctl.c}else if (cmd == UMSDOS_INIT_EMD){
cmd191fs/umsdos/ioctl.cif (cmd == UMSDOS_CREAT_EMD){
cmd208fs/umsdos/ioctl.c}else if (cmd == UMSDOS_RENAME_DOS){
cmd223fs/umsdos/ioctl.c}else if (cmd == UMSDOS_UNLINK_EMD){
cmd241fs/umsdos/ioctl.c}else if (cmd == UMSDOS_UNLINK_DOS){
cmd252fs/umsdos/ioctl.c}else if (cmd == UMSDOS_RMDIR_DOS){
cmd263fs/umsdos/ioctl.c}else if (cmd == UMSDOS_STAT_DOS){
cmd287fs/umsdos/ioctl.c}else if (cmd == UMSDOS_DOS_SETUP){
cmd39include/linux/ax25.hint cmd;
cmd48include/linux/ax25.hunsigned int cmd;
cmd24include/linux/blkdev.hint cmd;    /* READ or WRITE */
cmd424include/linux/cdk.hunsigned long  cmd;
cmd350include/linux/fd.hunsigned char cmd[16];
cmd354include/linux/fs.hextern int fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l);
cmd83include/linux/kerneld.hstatic inline int ksystem(const char *cmd, int waitflag)
cmd87include/linux/kerneld.hstrlen(cmd), cmd, NULL);
cmd27include/linux/loop.hint    (*transfer)(struct loop_device *, int cmd,
cmd37include/linux/loop.htypedef  int (* transfer_proc_t)(struct loop_device *, int cmd,
cmd114include/linux/md.hunsigned int cmd, unsigned long arg);
cmd122include/linux/mroute.hextern int ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd219include/linux/msdos_fs.hunsigned int cmd, unsigned long arg);
cmd74include/linux/msg.hasmlinkage int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf);
cmd142include/linux/ncp_fs.hunsigned int cmd, unsigned long arg);
cmd105include/linux/net.hint  (*ioctl)  (struct socket *sock, unsigned int cmd,
cmd113include/linux/net.hint  (*fcntl)  (struct socket *sock, unsigned int cmd,
cmd184include/linux/netdevice.hint        (*do_ioctl)(struct device *dev, struct ifreq *ifr, int cmd);
cmd240include/linux/netdevice.hextern int    dev_ioctl(unsigned int cmd, void *);
cmd45include/linux/netrom.hunsigned int  cmd;
cmd96include/linux/quota.h#define QCMD(cmd, type)  (((cmd) << SUBCMDSHIFT) | ((type) & SUBCMDMASK))
cmd297include/linux/sdla.hchar  cmd      __attribute__((packed));
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);
cmd112include/linux/smb_fs.hunsigned int cmd, unsigned long arg);
cmd534include/linux/soundcard.hunsigned char cmd;
cmd326include/linux/tty.hunsigned int cmd, unsigned long arg);
cmd346include/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);
cmd91include/linux/ultrasound.h#define _GUS_CMD(chn, voice, cmd, p1, p2) \
cmd93include/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);
cmd11include/net/arp.hextern int  arp_ioctl(unsigned int cmd, void *arg);
cmd175include/net/br.hunsigned int cmd;
cmd262include/net/br.hint br_ioctl(unsigned int cmd, void *arg);
cmd36include/net/icmp.hextern int  icmp_ioctl(struct sock *sk, int cmd,
cmd87include/net/ip.hextern int    ip_ioctl(struct sock *sk, int cmd, unsigned long arg);
cmd5include/net/rarp.hextern int rarp_ioctl(unsigned int cmd, void *arg);
cmd192include/net/route.hextern int    ip_rt_ioctl(unsigned int cmd, void *arg);
cmd358include/net/sock.hint      (*ioctl)(struct sock *sk, int cmd,
cmd139include/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);
cmd16include/scsi/scsi_ioctl.hextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd17include/scsi/scsi_ioctl.hextern int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
cmd483ipc/msg.casmlinkage int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf)
cmd490ipc/msg.cif (msqid < 0 || cmd < 0)
cmd492ipc/msg.cswitch (cmd) {
cmd507ipc/msg.cif (cmd == MSG_INFO) {
cmd568ipc/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) {
cmd203ipc/shm.casmlinkage int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf)
cmd210ipc/shm.cif (cmd < 0 || shmid < 0)
cmd212ipc/shm.cif (cmd == IPC_SET) {
cmd221ipc/shm.cswitch (cmd) { /* replace with proc interface ? */
cmd288ipc/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)
cmd730net/appletalk/ddp.cint atif_ioctl(int cmd, void *arg)
cmd738net/appletalk/ddp.cint ro=(cmd==SIOCSIFADDR);
cmd755net/appletalk/ddp.cswitch(cmd)
cmd866net/appletalk/ddp.cstatic int atrtr_ioctl(unsigned int cmd, void *arg)
cmd876net/appletalk/ddp.cswitch(cmd)
cmd1002net/appletalk/ddp.cstatic int atalk_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1005net/appletalk/ddp.cswitch(cmd)
cmd1875net/appletalk/ddp.cstatic int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
cmd1881net/appletalk/ddp.cswitch(cmd)
cmd1918net/appletalk/ddp.creturn(atrtr_ioctl(cmd,(void *)arg));
cmd1925net/appletalk/ddp.creturn atif_ioctl(cmd,(void *)arg);
cmd1939net/appletalk/ddp.creturn(dev_ioctl(cmd,(void *) arg));
cmd484net/ax25/af_ax25.cstatic int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
cmd488net/ax25/af_ax25.cswitch (cmd) {
cmd537net/ax25/af_ax25.cstatic int ax25_ctl_ioctl(const unsigned int cmd, void *arg)
cmd556net/ax25/af_ax25.cswitch (ax25_ctl.cmd) {
cmd871net/ax25/af_ax25.cstatic int ax25_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd2161net/ax25/af_ax25.cstatic int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd2167net/ax25/af_ax25.cswitch (cmd) {
cmd2208net/ax25/af_ax25.creturn ax25_uid_ioctl(cmd, &sax25);
cmd2226net/ax25/af_ax25.creturn ax25_bpq_ioctl(cmd, (void *)arg);
cmd2231net/ax25/af_ax25.creturn ax25_dev_ioctl(cmd, (void *)arg);
cmd2238net/ax25/af_ax25.creturn ax25_rt_ioctl(cmd, (void *)arg);
cmd2243net/ax25/af_ax25.creturn ax25_ctl_ioctl(cmd, (void *)arg);
cmd2258net/ax25/af_ax25.creturn dev_ioctl(cmd, (void *)arg);
cmd230net/ax25/ax25_route.cint ax25_rt_ioctl(unsigned int cmd, void *arg)
cmd239net/ax25/ax25_route.cswitch (cmd) {
cmd335net/ax25/ax25_route.cswitch(rt_option.cmd) {
cmd734net/ax25/ax25_route.cint ax25_dev_ioctl(unsigned int cmd, void *arg)
cmd741net/ax25/ax25_route.cswitch (cmd) {
cmd878net/ax25/ax25_route.cint ax25_bpq_ioctl(unsigned int cmd, void *arg)
cmd886net/ax25/ax25_route.cswitch (cmd) {
cmd523net/ax25/ax25_subr.cvoid ax25_kiss_cmd(ax25_cb *ax25, unsigned char cmd, unsigned char param)
cmd546net/ax25/ax25_subr.c*p++=cmd;
cmd1421net/bridge/br.cint br_ioctl(unsigned int cmd, void *arg)
cmd1427net/bridge/br.cswitch(cmd)
cmd1446net/bridge/br.cswitch (bcf.cmd) {
cmd1277net/core/dev.cint dev_ioctl(unsigned int cmd, void *arg)
cmd1279net/core/dev.cswitch(cmd) 
cmd1301net/core/dev.creturn dev_ifsioc(arg, cmd);
cmd1321net/core/dev.creturn dev_ifsioc(arg, cmd);
cmd1331net/core/dev.cif((cmd >= SIOCDEVPRIVATE) &&
cmd1332net/core/dev.c(cmd <= (SIOCDEVPRIVATE + 15))) {
cmd1333net/core/dev.creturn dev_ifsioc(arg, cmd);
cmd438net/ipv4/af_inet.cstatic int inet_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd444net/ipv4/af_inet.cswitch(cmd) 
cmd1206net/ipv4/af_inet.cstatic int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1212net/ipv4/af_inet.cswitch(cmd) 
cmd1242net/ipv4/af_inet.creturn(ip_rt_ioctl(cmd,(void *) arg));
cmd1249net/ipv4/af_inet.creturn(arp_ioctl(cmd,(void *) arg));
cmd1258net/ipv4/af_inet.creturn(rarp_ioctl_hook(cmd,(void *) arg));
cmd1285net/ipv4/af_inet.creturn(dev_ioctl(cmd,(void *) arg));
cmd1290net/ipv4/af_inet.creturn(br_ioctl(cmd,(void *) arg));
cmd1296net/ipv4/af_inet.cif ((cmd >= SIOCDEVPRIVATE) &&
cmd1297net/ipv4/af_inet.c(cmd <= (SIOCDEVPRIVATE + 15)))
cmd1298net/ipv4/af_inet.creturn(dev_ioctl(cmd,(void *) arg));
cmd1302net/ipv4/af_inet.creturn(sk->prot->ioctl(sk, cmd, arg));
cmd2086net/ipv4/arp.cint arp_ioctl(unsigned int cmd, void *arg)
cmd2093net/ipv4/arp.cswitch(cmd)
cmd2138net/ipv4/arp.c((cmd == SIOCSARP) || (cmd == OLD_SIOCSARP))) {
cmd2144net/ipv4/arp.cswitch(cmd)
cmd829net/ipv4/ip_fw.cint ret, cmd, fwtype;
cmd831net/ipv4/ip_fw.ccmd = stage & IP_FW_COMMAND;
cmd834net/ipv4/ip_fw.cif ( cmd == IP_FW_FLUSH )
cmd840net/ipv4/ip_fw.cif ( cmd == IP_FW_ZERO )
cmd846net/ipv4/ip_fw.cif ( cmd == IP_FW_POLICY )
cmd854net/ipv4/ip_fw.cif ( cmd == IP_FW_CHECK )
cmd902net/ipv4/ip_fw.cif ( cmd == IP_FW_MASQ_TIMEOUTS )
cmd945net/ipv4/ip_fw.cif ( cmd == IP_FW_INSERT || cmd == IP_FW_APPEND || cmd == IP_FW_DELETE )
cmd955net/ipv4/ip_fw.cswitch (cmd) 
cmd183net/ipv4/ip_input.cint ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd185net/ipv4/ip_input.cswitch(cmd)
cmd596net/ipv4/ipmr.cint ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd603net/ipv4/ipmr.cswitch(cmd)
cmd443net/ipv4/rarp.cint rarp_ioctl(unsigned int cmd, void *arg)
cmd449net/ipv4/rarp.cswitch(cmd)
cmd1759net/ipv4/route.cint ip_rt_ioctl(unsigned int cmd, void *arg)
cmd1764net/ipv4/route.cswitch(cmd) 
cmd1774net/ipv4/route.creturn (cmd == SIOCDELRT) ? ip_rt_kill(&rt) : ip_rt_new(&rt);
cmd734net/ipv4/tcp.cint tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd737net/ipv4/tcp.cswitch(cmd)
cmd442net/ipv4/udp.cint udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
cmd445net/ipv4/udp.cswitch(cmd) 
cmd1018net/ipx/af_ipx.cipxitf_ioctl(unsigned int cmd, void *arg)
cmd1021net/ipx/af_ipx.cswitch(cmd)
cmd1355net/ipx/af_ipx.cstatic int ipxrtr_ioctl(unsigned int cmd, void *arg)
cmd1377net/ipx/af_ipx.cswitch(cmd)
cmd1580net/ipx/af_ipx.cstatic int ipx_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1582net/ipx/af_ipx.cswitch(cmd)
cmd2169net/ipx/af_ipx.cstatic int ipx_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
cmd2175net/ipx/af_ipx.cswitch(cmd)
cmd2202net/ipx/af_ipx.creturn(ipxrtr_ioctl(cmd,(void *)arg));
cmd2209net/ipx/af_ipx.creturn(ipxitf_ioctl(cmd,(void *)arg));
cmd2237net/ipx/af_ipx.creturn(dev_ioctl(cmd,(void *) arg));
cmd144net/netlink.cunsigned int cmd, unsigned long arg)
cmd151net/netlink.cswitch ( cmd ) {
cmd280net/netrom/af_netrom.cstatic int nr_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd290net/netrom/af_netrom.cstatic int nr_ctl_ioctl(const unsigned int cmd, void *arg)
cmd305net/netrom/af_netrom.cswitch (nr_ctl.cmd) {
cmd1230net/netrom/af_netrom.cstatic int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1236net/netrom/af_netrom.cswitch (cmd) {
cmd1285net/netrom/af_netrom.creturn nr_rt_ioctl(cmd, (void *)arg);
cmd1309net/netrom/af_netrom.creturn nr_ctl_ioctl(cmd, (void *)arg);
cmd1312net/netrom/af_netrom.creturn dev_ioctl(cmd, (void *)arg);
cmd564net/netrom/nr_route.cint nr_rt_ioctl(unsigned int cmd, void *arg)
cmd571net/netrom/nr_route.cswitch (cmd) {
cmd93net/socket.cunsigned int cmd, unsigned long arg);
cmd401net/socket.cint sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
cmd406net/socket.creturn(sock->ops->ioctl(sock, cmd, arg));
cmd1214net/socket.cint sock_fcntl(struct file *filp, unsigned int cmd, unsigned long arg)
cmd1220net/socket.creturn(sock->ops->fcntl(sock, cmd, arg));
cmd218net/unix/af_unix.cstatic int unix_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1198net/unix/af_unix.cstatic int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
cmd1204net/unix/af_unix.cswitch(cmd)