taglinefilesource code
target935arch/i386/kernel/smp.cvoid smp_message_pass(int target, int msg, unsigned long data, int wait)
target1028arch/i386/kernel/smp.capic_write(APIC_ICR2, cfg|SET_APIC_DEST_FIELD(target));      /* Target chip         */
target1037arch/i386/kernel/smp.cif(target==MSG_ALL_BUT_SELF)
target1043arch/i386/kernel/smp.celse if(target==MSG_ALL)
target1051arch/i386/kernel/smp.ctarget_map=(1<<target);
target55arch/sparc/kernel/smp.cvoid smp_message_pass(int target, int msg, unsigned long data, int wait)
target82arch/sparc/kernel/smp.cif(target == MSG_ALL_BUT_SELF) {
target85arch/sparc/kernel/smp.c} else if(target == MSG_ALL) {
target89arch/sparc/kernel/smp.ctarget_map = (1<<target);
target892drivers/block/hd.cint target;
target893drivers/block/hd.ctarget =  DEVICE_NR(inode->i_rdev);
target895drivers/block/hd.cif (target >= NR_HD)
target897drivers/block/hd.cwhile (busy[target])
target899drivers/block/hd.caccess_count[target]++;
target909drivers/block/hd.cint target;
target912drivers/block/hd.ctarget =  DEVICE_NR(inode->i_rdev);
target913drivers/block/hd.caccess_count[target]--;
target1064drivers/block/hd.c#define DEVICE_BUSY busy[target]
target1065drivers/block/hd.c#define USAGE access_count[target]
target1066drivers/block/hd.c#define CAPACITY (bios_info[target].head*bios_info[target].sect*bios_info[target].cyl)
target1082drivers/block/hd.cint target;
target1089drivers/block/hd.ctarget = DEVICE_NR(dev);
target1102drivers/block/hd.cstart = target << gdev->minor_shift;
target1119drivers/block/hd.cresetup_one_dev(gdev, target);
target306drivers/block/xd.cint target = DEVICE_NR(dev);
target307drivers/block/xd.cint start = target << xd_gendisk.minor_shift;
target310drivers/block/xd.ccli(); xd_valid[target] = (xd_access[target] != 1); sti();
target311drivers/block/xd.cif (xd_valid[target])
target324drivers/block/xd.cxd_gendisk.part[start].nr_sects = xd_info[target].heads * xd_info[target].cylinders * xd_info[target].sectors;
target325drivers/block/xd.cresetup_one_dev(&xd_gendisk,target);
target327drivers/block/xd.cxd_valid[target] = 1;
target174drivers/cdrom/gscd.cint target;
target177drivers/cdrom/gscd.ctarget = MINOR(full_dev);
target179drivers/cdrom/gscd.cif (target > 0) 
target211drivers/cdrom/mcd.cint retval, target;
target217drivers/cdrom/mcd.ctarget = MINOR(full_dev);
target219drivers/cdrom/mcd.cif (target > 0) {
target554drivers/char/ftape/ftape-rw.cint target = segment_id - margin;
target570drivers/char/ftape/ftape-rw.ccount = target - location.segment - overshoot;
target648drivers/char/ftape/ftape-rw.cint target = segment_id - margin;
target670drivers/char/ftape/ftape-rw.cif (location.segment - target - (min_rewind - 1) < 1) {
target673drivers/char/ftape/ftape-rw.ccount = location.segment - target - overshoot;
target683drivers/char/ftape/ftape-rw.cexpected = target;
target641drivers/net/3c505.cunsigned long target;
target651drivers/net/3c505.ctarget = virt_to_bus(adapter->dma_buffer);
target654drivers/net/3c505.ctarget = virt_to_bus(skb_put(skb, rlen));
target655drivers/net/3c505.cif ((target + rlen) >= MAX_DMA_ADDRESS) {
target656drivers/net/3c505.ctarget = virt_to_bus(adapter->dma_buffer);
target674drivers/net/3c505.cset_dma_addr(dev->dma, target);
target1060drivers/net/3c505.cunsigned long target;
target1095drivers/net/3c505.ctarget = virt_to_bus(skb->data);
target1096drivers/net/3c505.cif ((target + nlen) >= MAX_DMA_ADDRESS) {
target1098drivers/net/3c505.ctarget = virt_to_bus(adapter->dma_buffer);
target1105drivers/net/3c505.cset_dma_addr(dev->dma, target);
target837drivers/net/eql.cslave_t *target;
target839drivers/net/eql.ctarget = eql_find_slave_dev (queue, dev);
target841drivers/net/eql.cif (target != 0)
target846drivers/net/eql.cwhile (curr != target)
target133drivers/net/new_tunnel.c__u32          target;      /* The other host's IP address */
target182drivers/net/new_tunnel.ctarget = rt->rt_gateway;
target184drivers/net/new_tunnel.ctarget = dev->pa_dstaddr;
target186drivers/net/new_tunnel.cif ( ! target )
target198drivers/net/new_tunnel.cif ((rt = ip_rt_route(target, 0)) == NULL)
target282drivers/net/new_tunnel.ciph->daddr    =  target;
target302drivers/net/new_tunnel.cif (ip_forward(skb, dev, 0, target) == 1)
target283drivers/scsi/53c7,8xx.cstatic void set_synchronous (struct Scsi_Host *host, int target, int sxfer, 
target713drivers/scsi/53c7,8xx.crequest_synchronous (int host, int target) {
target717drivers/scsi/53c7,8xx.cif (target < 0) {
target718drivers/scsi/53c7,8xx.cprintk (KERN_ALERT "target %d is bogus\n", target);
target723drivers/scsi/53c7,8xx.celse if (h->this_id == target) {
target724drivers/scsi/53c7,8xx.cprintk (KERN_ALERT "target %d is host ID\n", target);
target728drivers/scsi/53c7,8xx.celse if (target > h->max_id) {
target729drivers/scsi/53c7,8xx.cprintk (KERN_ALERT "target %d exceeds maximum of %d\n", target,
target738drivers/scsi/53c7,8xx.cif (hostdata->initiate_sdtr & (1 << target)) {
target740drivers/scsi/53c7,8xx.cprintk (KERN_ALERT "target %d already doing SDTR\n", target);
target743drivers/scsi/53c7,8xx.chostdata->initiate_sdtr |= (1 << target);
target2038drivers/scsi/53c7,8xx.cdsa_temp_sync, virt_to_bus((void *)hostdata->sync[c->target].script));
target2040drivers/scsi/53c7,8xx.cdsa_temp_target, c->target);
target2186drivers/scsi/53c7,8xx.c--hostdata->busy[c->target][c->lun];
target2297drivers/scsi/53c7,8xx.cset_synchronous (struct Scsi_Host *host, int target, int sxfer, int scntl3,
target2309drivers/scsi/53c7,8xx.chostdata->sync[target].sxfer_sanity = sxfer;
target2310drivers/scsi/53c7,8xx.chostdata->sync[target].scntl3_sanity = scntl3;
target2318drivers/scsi/53c7,8xx.chostdata->sync[target].select_indirect = (scntl3 << 24) | 
target2319drivers/scsi/53c7,8xx.c(target << 16) | (sxfer << 8);
target2321drivers/scsi/53c7,8xx.cscript = (u32 *) hostdata->sync[target].script;
target2353drivers/scsi/53c7,8xx.chost->host_no, target, sxfer, scntl3);
target2375drivers/scsi/53c7,8xx.casynchronous (struct Scsi_Host *host, int target) {
target2380drivers/scsi/53c7,8xx.cset_synchronous (host, target, /* no offset */ 0, hostdata->saved_scntl3,
target2383drivers/scsi/53c7,8xx.chost->host_no, target);
target2426drivers/scsi/53c7,8xx.csynchronous (struct Scsi_Host *host, int target, char *msg) {
target2466drivers/scsi/53c7,8xx.cset_synchronous (host, target, sxfer, scntl3, 1);
target2467drivers/scsi/53c7,8xx.csprintf (buf, "scsi%d : setting target %d to ", host->host_no, target);
target2514drivers/scsi/53c7,8xx.cc->target);
target2516drivers/scsi/53c7,8xx.casynchronous (host, c->target);
target2538drivers/scsi/53c7,8xx.cprintk (" from target %d lun %d ", c->target, c->lun);
target2558drivers/scsi/53c7,8xx.csprintf (buf, "scsi%d : target %d %s ", host->host_no, c->target,
target2573drivers/scsi/53c7,8xx.csynchronous (host, c->target, (unsigned char *) 
target2576drivers/scsi/53c7,8xx.casynchronous (host, c->target);
target2584drivers/scsi/53c7,8xx.csynchronous (host, c->target, (unsigned char *) 
target2588drivers/scsi/53c7,8xx.casynchronous (host, c->target);
target2746drivers/scsi/53c7,8xx.chostdata->sync[c->target].script, "", 1);
target2748drivers/scsi/53c7,8xx.chostdata->sync[c->target].script + 2, "", 1);
target2854drivers/scsi/53c7,8xx.chost->host_no, c->target, c->lun);
target2875drivers/scsi/53c7,8xx.chostdata->sync[c->target].script, "", 1);
target2877drivers/scsi/53c7,8xx.chostdata->sync[c->target].script + 2, "", 1);
target2928drivers/scsi/53c7,8xx.cif (sxfer != hostdata->sync[c->target].sxfer_sanity ||
target2929drivers/scsi/53c7,8xx.cscntl3 != hostdata->sync[c->target].scntl3_sanity) {
target2970drivers/scsi/53c7,8xx.cif (c && sdid != c->target) {
target2972drivers/scsi/53c7,8xx.chost->host_no, sdid, c->target, where);
target2997drivers/scsi/53c7,8xx.cevent->target = NCR53c7x0_read8(SSID_REG_800);
target2999drivers/scsi/53c7,8xx.cevent->target = 255;
target3430drivers/scsi/53c7,8xx.ccmd->target, cmd->lun, (hostdata->cmd_allocated[cmd->target] &
target3439drivers/scsi/53c7,8xx.cif (!(hostdata->cmd_allocated[cmd->target] & (1 << cmd->lun)) &&
target3448drivers/scsi/53c7,8xx.chostdata->cmd_allocated[cmd->target] |= (1 << cmd->lun);
target3487drivers/scsi/53c7,8xx.chost->host_no, cmd->target, cmd->lun);
target3660drivers/scsi/53c7,8xx.cif (hostdata->sync[cmd->target].select_indirect != 
target3661drivers/scsi/53c7,8xx.c((hostdata->sync[cmd->target].scntl3_sanity << 24) | 
target3662drivers/scsi/53c7,8xx.c(cmd->target << 16) | 
target3663drivers/scsi/53c7,8xx.c(hostdata->sync[cmd->target].sxfer_sanity << 8))) {
target3665drivers/scsi/53c7,8xx.chost->host_no, hostdata->sync[cmd->target].select_indirect);
target3670drivers/scsi/53c7,8xx.cpatch_dsa_32(tmp->dsa, dsa_select, 0, hostdata->sync[cmd->target].
target3677drivers/scsi/53c7,8xx.cif (hostdata->initiate_wdtr & (1 << cmd->target)) {
target3683drivers/scsi/53c7,8xx.chostdata->initiate_wdtr &= ~(1 << cmd->target);
target3685drivers/scsi/53c7,8xx.c} else if (hostdata->initiate_sdtr & (1 << cmd->target)) {
target3692drivers/scsi/53c7,8xx.chostdata->initiate_sdtr &= ~(1 << cmd->target);
target3697drivers/scsi/53c7,8xx.celse if (!(hostdata->talked_to & (1 << cmd->target)) && 
target3707drivers/scsi/53c7,8xx.chostdata->talked_to |= (1 << cmd->target);
target3890drivers/scsi/53c7,8xx.c!(hostdata->debug_lun_limit[cmd->target] & (1 << cmd->lun))) 
target3892drivers/scsi/53c7,8xx.c|| cmd->target > 7
target3894drivers/scsi/53c7,8xx.c|| cmd->target > host->max_id
target3896drivers/scsi/53c7,8xx.c|| cmd->target == host->this_id
target3899drivers/scsi/53c7,8xx.ccmd->target, cmd->lun);
target4001drivers/scsi/53c7,8xx.c++hostdata->busy[tmp->target][tmp->lun];
target4058drivers/scsi/53c7,8xx.creturn hostdata->busy[cmd->target][cmd->lun];
target4132drivers/scsi/53c7,8xx.chost->host_no, tmp->target, tmp->lun);
target4205drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
target4243drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
target4259drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target, cmd->cmd->lun);
target4466drivers/scsi/53c7,8xx.c--hostdata->busy[tmp->target][tmp->lun];
target4474drivers/scsi/53c7,8xx.chost->host_no, tmp->pid, tmp->target, tmp->lun, tmp->result);
target4536drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->pid, (int) cmd->cmd->target,
target4929drivers/scsi/53c7,8xx.chost->host_no, cmd->cmd->target);
target5579drivers/scsi/53c7,8xx.c--hostdata->busy[cmd->target][cmd->lun];
target5845drivers/scsi/53c7,8xx.ccmd->result, cmd->target, cmd->lun);
target5854drivers/scsi/53c7,8xx.chost->host_no, cmd->target,
target5855drivers/scsi/53c7,8xx.chostdata->sync[cmd->target].sxfer_sanity,
target5856drivers/scsi/53c7,8xx.chostdata->sync[cmd->target].scntl3_sanity);
target5857drivers/scsi/53c7,8xx.cfor (i = 0; i < (sizeof(hostdata->sync[cmd->target].script) / 4); ++i)
target5858drivers/scsi/53c7,8xx.cprintk ("0x%x ", hostdata->sync[cmd->target].script[i]);
target5901drivers/scsi/53c7,8xx.chost->host_no, cmd->pid, cmd->target, cmd->lun);
target6327drivers/scsi/53c7,8xx.cevent.target, event.lun);
target1048drivers/scsi/53c7,8xx.hunsigned char target;
target136drivers/scsi/AM53C974.cstatic int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg);
target137drivers/scsi/AM53C974.cstatic __inline__ void AM53C974_set_async(struct Scsi_Host *instance, int target);
target138drivers/scsi/AM53C974.cstatic __inline__ void AM53C974_set_sync(struct Scsi_Host *instance, int target);
target822drivers/scsi/AM53C974.ccmd->cmnd[0], cmd->target, cmd->lun, cmd->request_bufflen, cmd->use_sg));
target890drivers/scsi/AM53C974.cif (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
target1017drivers/scsi/AM53C974.cif (hostdata->connected) hostdata->sync_off[hostdata->connected->target] = 0; /* setup asynchronous transfer */
target1088drivers/scsi/AM53C974.cAM53C974_set_sync(instance, hostdata->sel_cmd->target);
target1118drivers/scsi/AM53C974.chostdata->busy[hostdata->connected->target] |= (1 << hostdata->connected->lun);
target1188drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
target1190drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
target1198drivers/scsi/AM53C974.c"  the disconnected_queue\n", instance->host_no, cmd->target,
target1222drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
target1224drivers/scsi/AM53C974.cinstance->host_no, cmd->SCp.phase, cmd->target, cmd->SCp.this_residual, cmd->SCp.buffers_residual,
target1233drivers/scsi/AM53C974.chostdata->sync_off[cmd->target] = 0; }
target1248drivers/scsi/AM53C974.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
target1255drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target); 
target1270drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target); 
target1290drivers/scsi/AM53C974.cstatic int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg) 
target1310drivers/scsi/AM53C974.chostdata->sync_per[target] = period;
target1311drivers/scsi/AM53C974.chostdata->sync_off[target] = offset;
target1320drivers/scsi/AM53C974.ctarget, rate, rate_rem, offset);
target1322drivers/scsi/AM53C974.cprintk("\ntarget %d: rate=%d.%d Mhz, asynchronous\n", target, rate, rate_rem);
target1337drivers/scsi/AM53C974.cstatic __inline__ void AM53C974_set_async(struct Scsi_Host *instance, int target)
target1343drivers/scsi/AM53C974.cAM53C974_write_8(STPREG, hostdata->sync_per[target]);
target1357drivers/scsi/AM53C974.cstatic __inline__ void AM53C974_set_sync(struct Scsi_Host *instance, int target)
target1363drivers/scsi/AM53C974.cAM53C974_write_8(STPREG, hostdata->sync_per[target]);
target1364drivers/scsi/AM53C974.cAM53C974_write_8(SOFREG, (SOFREG_SO & hostdata->sync_off[target]) | 
target1433drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
target1460drivers/scsi/AM53C974.cAM53C974_set_sync(instance, cmd->target);
target1466drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
target1489drivers/scsi/AM53C974.cAM53C974_set_sync(instance, cmd->target);
target1494drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
target1498drivers/scsi/AM53C974.cAM53C974_set_sync(instance, cmd->target);
target1505drivers/scsi/AM53C974.cAM53C974_set_async(instance, cmd->target);
target1573drivers/scsi/AM53C974.cinstance->host_no, cmd->target, cmd->lun));
target1578drivers/scsi/AM53C974.cinstance->host_no, cmd->target, cmd->lun);
target1594drivers/scsi/AM53C974.cinstance->host_no, cmd->target, cmd->lun));
target1604drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
target1654drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
target1660drivers/scsi/AM53C974.ccmd->target,  DEF_CLK / DEF_STP);
target1661drivers/scsi/AM53C974.chostdata->sync_off[cmd->target] = 0;
target1662drivers/scsi/AM53C974.chostdata->sync_per[cmd->target] = DEF_STP; }
target1668drivers/scsi/AM53C974.chostdata->busy[cmd->target] |= (1 << cmd->lun);
target1679drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
target1688drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
target1706drivers/scsi/AM53C974.cinstance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
target1746drivers/scsi/AM53C974.cret = AM53C974_sync_neg(instance, cmd->target, extended_msg);
target1829drivers/scsi/AM53C974.c!(hostdata->sync_neg[cmd->target]) && hostdata->sync_en[cmd->target]) {
target1830drivers/scsi/AM53C974.chostdata->sync_neg[cmd->target] = 1;
target1834drivers/scsi/AM53C974.chostdata->msgout[3] = 250 / (int)hostdata->max_rate[cmd->target];
target1835drivers/scsi/AM53C974.chostdata->msgout[4] = hostdata->max_offset[cmd->target];
target1838drivers/scsi/AM53C974.cAM53C974_write_8(SDIDREG, SDIREG_MASK & cmd->target);       /* setup dest. id  */
target1873drivers/scsi/AM53C974.cunsigned char            cfifo, msg[3], lun, t, target = 0;
target1906drivers/scsi/AM53C974.ctarget = 0; while (t != 1) { t >>= 1; target++; }
target1907drivers/scsi/AM53C974.cDEB_RESEL(printk("scsi %d: reselect; target: %d\n", instance->host_no, target));
target1936drivers/scsi/AM53C974.cif ((target == tmp->target) && (lun == tmp->lun) 
target1955drivers/scsi/AM53C974.cinstance->host_no, target, lun, tag);
target1958drivers/scsi/AM53C974.cinstance->host_no, target, lun);
target1974drivers/scsi/AM53C974.cinstance->host_no, target, tmp->lun, tmp->tag));
target1975drivers/scsi/AM53C974.cAM53C974_set_sync(instance, target);
target1976drivers/scsi/AM53C974.cAM53C974_write_8(SDIDREG, SDIREG_MASK & target);       /* setup dest. id  */
target2397drivers/scsi/BusLogic.cunsigned char TargetID = Command->target;
target2591drivers/scsi/BusLogic.cunsigned char TargetID = Command->target;
target2699drivers/scsi/BusLogic.cTargetID = Command->target;
target2737drivers/scsi/BusLogic.cHostAdapter->HostNumber, HostAdapter->BoardName, Command->target);
target2810drivers/scsi/BusLogic.cunsigned char TargetID = Command->target;
target2959drivers/scsi/BusLogic.cunsigned char TargetID = Command->target;
target866drivers/scsi/NCR5380.ccmd->host->host_no, cmd->target, cmd->lun);
target1080drivers/scsi/NCR5380.chostdata->time_write[cmd->target] -= (jiffies - hostdata->timebase);
target1081drivers/scsi/NCR5380.chostdata->bytes_write[cmd->target] += cmd->request_bufflen;
target1087drivers/scsi/NCR5380.chostdata->time_read[cmd->target] -= (jiffies - hostdata->timebase);
target1088drivers/scsi/NCR5380.chostdata->bytes_read[cmd->target] += cmd->request_bufflen;
target1190drivers/scsi/NCR5380.cprintk("MAIN tmp=%p   target=%d   busy=%d lun=%d\n", tmp, tmp->target, hostdata->busy[tmp->target], tmp->lun);
target1193drivers/scsi/NCR5380.cif (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
target1214drivers/scsi/NCR5380.cinstance->host_no, tmp->target, tmp->lun);
target1405drivers/scsi/NCR5380.chostdata->time_write[cmd->target] += (jiffies - hostdata->timebase);
target1412drivers/scsi/NCR5380.chostdata->time_read[cmd->target] += (jiffies - hostdata->timebase);
target1565drivers/scsi/NCR5380.cNCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
target1613drivers/scsi/NCR5380.cprintk("scsi%d : selecting target %d\n", instance->host_no, cmd->target);
target1654drivers/scsi/NCR5380.cif (hostdata->targets_present & (1 << cmd->target)) {
target1678drivers/scsi/NCR5380.chostdata->targets_present |= (1 << cmd->target);
target1714drivers/scsi/NCR5380.cinstance->host_no, cmd->target);
target1752drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
target2467drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
target2509drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
target2519drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
target2531drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
target2548drivers/scsi/NCR5380.cinstance->host_no, cmd->target, cmd->lun);
target2550drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
target2627drivers/scsi/NCR5380.chostdata->busy[cmd->target] |= (1 << cmd->lun);
target2646drivers/scsi/NCR5380.ccmd->target, cmd->lun);
target2755drivers/scsi/NCR5380.cinstance->host_no, tmp, cmd->target, cmd->lun);
target2758drivers/scsi/NCR5380.cinstance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
target2772drivers/scsi/NCR5380.chostdata->busy[cmd->target] &= ~(1 << cmd->lun);
target2932drivers/scsi/NCR5380.cif ((target_mask == (1 << tmp->target)) && (lun == tmp->lun)
target2970drivers/scsi/NCR5380.cinstance->host_no, tmp->target, tmp->lun, tmp->tag);
target693drivers/scsi/NCR53c406a.cSCpnt->target, 
target712drivers/scsi/NCR53c406a.coutb(SCpnt->target, DEST_ID); /* set destination */
target3299drivers/scsi/advansys.casc_enqueue(shp, scp, scp->target, ASC_BACK);
target3329drivers/scsi/advansys.c} else if (asc_rmqueue(scp->host, scp, scp->target) == ASC_TRUE) {
target3332drivers/scsi/advansys.c(void) AscResetDevice(&ASC_BOARD(scp->host)->board, scp->target);
target3355drivers/scsi/advansys.c(void) AscResetDevice(boardp, scp->target);
target3694drivers/scsi/advansys.cASC_TIX_TO_TARGET_ID(scp->target)) == 0) {
target3700drivers/scsi/advansys.cASC_BOARD(scp->host)->init_tidmask |= ASC_TIX_TO_TARGET_ID(scp->target);
target3715drivers/scsi/advansys.cscsiq.q1.target_id = ASC_TID_TO_TARGET_ID(scp->target);
target3717drivers/scsi/advansys.cscsiq.q2.target_ix = ASC_TIDLUN_TO_IX(scp->target, scp->lun);
target3979drivers/scsi/advansys.cASC_DBG1(1, "asc_init_dev: target %d\n", (unsigned) scp->target);
target3982drivers/scsi/advansys.cif (boardp->cfg->chip_scsi_id == scp->target) {
target4019drivers/scsi/advansys.cscsireqq->r1.target_id = ASC_TID_TO_TARGET_ID(scp->target);
target4021drivers/scsi/advansys.cscsireqq->r2.target_ix = ASC_TIDLUN_TO_IX(scp->target, 0);
target4029drivers/scsi/advansys.ctidmask = ASC_TIX_TO_TARGET_ID(scp->target);
target4036drivers/scsi/advansys.cboardp->max_dvc_qng[scp->target]);
target355drivers/scsi/aha152x.c#define SYNCRATE    (HOSTDATA(shpnt)->syncrate[CURRENT_SC->target])
target490drivers/scsi/aha152x.cstatic inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, int target, int lun)
target495drivers/scsi/aha152x.cptr && ((ptr->target!=target) || (ptr->lun!=lun));
target886drivers/scsi/aha152x.cSCpnt->target, SCpnt->lun);
target1047drivers/scsi/aha152x.cSETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->target);
target1340drivers/scsi/aha152x.cint identify_msg, target, i;
target1368drivers/scsi/aha152x.ctarget=0;
target1370drivers/scsi/aha152x.cfor(; (i & 1)==0; target++, i>>=1)
target1377drivers/scsi/aha152x.cprintk("SELID=%02x, target=%d, ", GETPORT(SELID), target);
target1379drivers/scsi/aha152x.cSETPORT(SCSIID, (shpnt->this_id << OID_) | target);
target1385drivers/scsi/aha152x.cSETPORT(SCSIRATE, HOSTDATA(shpnt)->syncrate[target]&0x7f);
target1404drivers/scsi/aha152x.ctarget, identify_msg);
target1422drivers/scsi/aha152x.ctarget,
target1469drivers/scsi/aha152x.cprintk("selecting %d, ", CURRENT_SC->target); 
target1471drivers/scsi/aha152x.cSETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->target);
target2671drivers/scsi/aha152x.c(unsigned int) ptr, ptr->target, ptr->lun);
target2760drivers/scsi/aha152x.c(unsigned int) ptr, ptr->target, ptr->lun);
target515drivers/scsi/aha1542.cunchar target = SCpnt->target;
target529drivers/scsi/aha1542.cDEB(if (target > 1) {
target552drivers/scsi/aha1542.cprintk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
target554drivers/scsi/aha1542.cprintk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
target648drivers/scsi/aha1542.cccb[mbo].idlun = (target&7)<<5 | direction | (lun & 7); /*SCSI Target Id*/
target1231drivers/scsi/aha1542.cprintk("Sending DID_RESET for target %d\n", SCpnt->target);
target1265drivers/scsi/aha1542.cprintk("Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
target1272drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target)
target1278drivers/scsi/aha1542.cprintk("Sending DID_RESET for target %d\n", SCpnt->target);
target256drivers/scsi/aha1740.cunchar target = SCpnt->target;
target282drivers/scsi/aha1740.cprintk("aha1740_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
target402drivers/scsi/aha1740.coutb(ATTN_START | (target & 7), ATTN);  /* Start it up */
target1073drivers/scsi/aic7xxx.cint target, char channel)
target1091drivers/scsi/aic7xxx.c"above.\n", target, channel, aic7xxx_syncrates[i].english);
target1114drivers/scsi/aic7xxx.ctarget, channel, aic7xxx_syncrates[i].english, offset);
target1124drivers/scsi/aic7xxx.ctarget, channel);
target1196drivers/scsi/aic7xxx.caic7xxx_match_scb(struct aic7xxx_scb *scb, int target, char channel)
target1203drivers/scsi/aic7xxx.ctarget, channel, targ, chan);
target1205drivers/scsi/aic7xxx.cif (target == ALL_TARGETS)
target1211drivers/scsi/aic7xxx.creturn ((chan == channel) && (targ == target));
target1223drivers/scsi/aic7xxx.caic7xxx_busy_target(unsigned char target, char channel, int base)
target1228drivers/scsi/aic7xxx.cif ((target > 0x07) || (channel == 'B'))
target1237drivers/scsi/aic7xxx.cactive |= (0x01 << (target & 0x07));
target1249drivers/scsi/aic7xxx.caic7xxx_unbusy_target(unsigned char target, char channel, int base)
target1256drivers/scsi/aic7xxx.ctarget, channel);
target1258drivers/scsi/aic7xxx.cif ((target > 0x07) || (channel == 'B'))
target1267drivers/scsi/aic7xxx.cactive &= ~(0x01 << (target & 0x07));
target1286drivers/scsi/aic7xxx.ccmd->target, cmd->channel);
target1399drivers/scsi/aic7xxx.cint target = (scb->target_channel_lun >> 4) & 0x0F;
target1415drivers/scsi/aic7xxx.caic7xxx_unbusy_target(target, channel, base);
target1445drivers/scsi/aic7xxx.c"to_scb %d, next %d\n", target, channel, prev, timedout_scb, next);
target1459drivers/scsi/aic7xxx.caic7xxx_reset_device(struct aic7xxx_host *p, int target, char channel,
target1475drivers/scsi/aic7xxx.c"active_scb %d\n", target, channel, timedout_scb, active_scb);
target1492drivers/scsi/aic7xxx.cif (aic7xxx_match_scb(scb, target, channel))
target1535drivers/scsi/aic7xxx.cif (aic7xxx_match_scb(scb, target, channel))
target1557drivers/scsi/aic7xxx.cif ((scb->state & SCB_ACTIVE) && aic7xxx_match_scb(scb, target, channel))
target1565drivers/scsi/aic7xxx.caic7xxx_unbusy_target(target, channel, base);
target2213drivers/scsi/aic7xxx.ccmd->target, cmd->underflow, actual,
target2407drivers/scsi/aic7xxx.ccmd->target, cmd->channel & 0x01, cmd->lun & 0x07);
target2568drivers/scsi/aic7xxx.csp = &p->stats[cmd->channel & 0x01][cmd->target & 0x0F][cmd->lun & 0x07];
target4113drivers/scsi/aic7xxx.c"channel %d.\n", cmd->target, cmd->channel);
target4122drivers/scsi/aic7xxx.cmask = (0x01 << (cmd->target | (cmd->channel << 3)));
target4132drivers/scsi/aic7xxx.cprintk("aic7xxx: Sending WDTR request to target %d.\n", cmd->target);
target4142drivers/scsi/aic7xxx.cprintk("aic7xxx: Sending SDTR request to target %d.\n", cmd->target);
target4150drivers/scsi/aic7xxx.ccmd->target, cmd->cmnd[0], cmd->cmd_len, p->needwdtr, mask);
target4152drivers/scsi/aic7xxx.cscb->target_channel_lun = ((cmd->target << 4) & 0xF0) |
target4249drivers/scsi/aic7xxx.ccmd->cmnd[0], cmd->cmd_len, cmd->target, cmd->channel,
target4589drivers/scsi/aic7xxx.cprintk ("aic7xxx: (abort) target/channel %d/%d\n", cmd->target, cmd->channel);
target4621drivers/scsi/aic7xxx.cprintk ("aic7xxx: (reset) target/channel %d/%d\n", cmd->target, cmd->channel);
target200drivers/scsi/aic7xxx_proc.cint channel, target, lun;
target209drivers/scsi/aic7xxx_proc.cfor (target = 0; target < 16; target++)
target213drivers/scsi/aic7xxx_proc.csp = &p->stats[channel][target][lun];
target219drivers/scsi/aic7xxx_proc.c'A' + channel, target, lun);
target568drivers/scsi/constants.ccmd->target, 
target282drivers/scsi/eata.cunchar target;        /* SCSI Target ID */
target675drivers/scsi/eata.cBN(j), i, SCpnt->target, SCpnt->pid);
target687drivers/scsi/eata.ccpp->target = SCpnt->target;
target709drivers/scsi/eata.cBN(j), SCpnt->target, SCpnt->pid);
target729drivers/scsi/eata.cBN(j), SCarg->target, SCarg->pid);
target736drivers/scsi/eata.cBN(j), i, SCarg->target, SCarg->pid);
target788drivers/scsi/eata.cBN(j), SCarg->target, SCarg->pid, reset_flags);
target988drivers/scsi/eata.c&& HD(j)->target_reset[SCpnt->target])
target1001drivers/scsi/eata.cHD(j)->target_reset[SCpnt->target] = FALSE;
target1006drivers/scsi/eata.cSCpnt->target, SCpnt->lun, SCpnt->pid,
target1009drivers/scsi/eata.cHD(j)->target_time_out[SCpnt->target] = 0;
target1015drivers/scsi/eata.cif (HD(j)->target_time_out[SCpnt->target] > 1)
target1019drivers/scsi/eata.cHD(j)->target_time_out[SCpnt->target]++;
target1064drivers/scsi/eata.cSCpnt->target, SCpnt->lun, SCpnt->pid, HD(j)->iocount);
target214drivers/scsi/eata_dma.c"%#.2x \n", irq, base, cmd->pid, cmd->target,
target404drivers/scsi/eata_dma.ccmd->pid, cmd->target, cmd->lun, y));
target467drivers/scsi/eata_dma.cif (cmd->target == sh->this_id) 
target496drivers/scsi/eata_dma.ccp->cp_id = cmd->target;
target514drivers/scsi/eata_dma.c"returning DID_BUS_BUSY\n",cmd->target, cmd->pid));
target522drivers/scsi/eata_dma.ccmd->target, cmd->lun, y, sh->irq));
target538drivers/scsi/eata_dma.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
target589drivers/scsi/eata_dma.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
target179drivers/scsi/eata_dma_proc.cscmd.target = HBA_ptr->this_id; 
target321drivers/scsi/eata_pio.ccmd->pid, cmd->target, cmd->lun, y));
target345drivers/scsi/eata_pio.ccp->Interpret = (cmd->target == hd->hostid);
target351drivers/scsi/eata_pio.ccp->cp_id = cmd->target;
target382drivers/scsi/eata_pio.c"DID_BUS_BUSY, done.\n", cmd->target, cmd->pid);
target395drivers/scsi/eata_pio.ccmd->target, cmd->lun, y, sh->irq));
target411drivers/scsi/eata_pio.c" reason %x\n", cmd->pid, cmd->target, cmd->lun, 
target460drivers/scsi/eata_pio.c"reason %x\n", cmd->pid, cmd->target, cmd->lun, 
target1084drivers/scsi/fdomain.cSCinit.target = i;
target1218drivers/scsi/fdomain.cstatic int fdomain_select( int target )
target1226drivers/scsi/fdomain.coutb( adapter_mask | (1 << target), SCSI_Data_NoACK_port );
target1245drivers/scsi/fdomain.cif (!target) printk( "Selection failed\n" );
target1248drivers/scsi/fdomain.cif (!target) {
target1328drivers/scsi/fdomain.coutb( adapter_mask | (1 << current_SC->target), SCSI_Data_NoACK_port );
target1340drivers/scsi/fdomain.cif (fdomain_select( current_SC->target )) {
target1399drivers/scsi/fdomain.ccurrent_SC->target,
target1713drivers/scsi/fdomain.cSCpnt->target,
target1803drivers/scsi/fdomain.cSCpnt->target,
target596drivers/scsi/g_NCR5380.ccmd->target ANDP
target422drivers/scsi/in2000.cunchar target = SCpnt->target;
target528drivers/scsi/in2000.coutb(target&7,INDATA);
target119drivers/scsi/ppa.cchar    ppa_select( int  initiator, int target )
target125drivers/scsi/ppa.cout_p(0,(1<<target)); out_p(2,0xe); out_p(2,0xc);
target212drivers/scsi/ppa.cif (cmd->target == PPA_INITIATOR) {
target217drivers/scsi/ppa.cif (!ppa_select(PPA_INITIATOR,cmd->target)) {
target329drivers/scsi/qlogic.coutb(cmd->target, qbase + 4);
target489drivers/scsi/qlogic.cif (cmd->target == qinitid)
target503drivers/scsi/qlogic.cif(cmd->target == qinitid) {
target559drivers/scsi/scsi.cSCpnt->target = SDpnt->id;
target905drivers/scsi/scsi.c&& SCpnt->target == device->id) {
target980drivers/scsi/scsi.cSCpnt->target = device->id;
target1036drivers/scsi/scsi.c&& SCpnt->target == device->id) {
target1153drivers/scsi/scsi.cSCpnt->target = device->id;
target1196drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->channel, SCpnt->target, SCpnt->cmnd, 
target1287drivers/scsi/scsi.cint target = SCpnt->target;
target1291drivers/scsi/scsi.c"command : " , host->host_no, SCpnt->channel, target, buffer, 
target1339drivers/scsi/scsi.cSCpnt->target = target;
target1472drivers/scsi/scsi.cresult, SCpnt->target, SCpnt->lun);
target1513drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->channel, SCpnt->target, 
target1858drivers/scsi/scsi.cSCpnt->channel, SCpnt->target, SCpnt->lun);
target1870drivers/scsi/scsi.c(int) SCpnt->target, (int) SCpnt->lun);
target2426drivers/scsi/scsi.cSCpnt->target = SDpnt->id;
target3305drivers/scsi/scsi.cSCpnt->target,
target363drivers/scsi/scsi.hunsigned char target, lun, channel;
target183drivers/scsi/scsi_debug.cint target = SCpnt->target;
target190drivers/scsi/scsi_debug.cDEB(if (target > 1) { SCpnt->result = DID_TIME_OUT << 16;done(SCpnt);return 0;});
target194drivers/scsi/scsi_debug.cif(target>=1 || SCpnt->lun != 0) {
target200drivers/scsi/scsi_debug.cif( SCrst[target] != 0 && !scsi_debug_lockup )
target202drivers/scsi/scsi_debug.cSCrst[target] = 0;
target302drivers/scsi/scsi_debug.cif(block == 0 && target == 0) {
target345drivers/scsi/scsi_debug.cmemcpy(buff, &target, sizeof(target));
target346drivers/scsi/scsi_debug.cmemcpy(buff+sizeof(target), cmd, 24);
target96drivers/scsi/sd.cint target;
target97drivers/scsi/sd.ctarget =  DEVICE_NR(inode->i_rdev);
target99drivers/scsi/sd.cif(target >= sd_template.dev_max || !rscsi_disks[target].device)
target108drivers/scsi/sd.cwhile (rscsi_disks[target].device->busy)
target110drivers/scsi/sd.cif(rscsi_disks[target].device->removable) {
target116drivers/scsi/sd.cif ( !rscsi_disks[target].ready ) {
target125drivers/scsi/sd.cif ( (rscsi_disks[target].write_prot) && (filp->f_mode & 2) ) { 
target129drivers/scsi/sd.cif(!rscsi_disks[target].device->access_count)
target140drivers/scsi/sd.crscsi_disks[target].device->access_count++;
target141drivers/scsi/sd.cif (rscsi_disks[target].device->host->hostt->usage_count)
target142drivers/scsi/sd.c(*rscsi_disks[target].device->host->hostt->usage_count)++;
target149drivers/scsi/sd.cint target;
target152drivers/scsi/sd.ctarget =  DEVICE_NR(inode->i_rdev);
target154drivers/scsi/sd.crscsi_disks[target].device->access_count--;
target155drivers/scsi/sd.cif (rscsi_disks[target].device->host->hostt->usage_count)
target156drivers/scsi/sd.c(*rscsi_disks[target].device->host->hostt->usage_count)--;
target159drivers/scsi/sd.cif(rscsi_disks[target].device->removable) {
target160drivers/scsi/sd.cif(!rscsi_disks[target].device->access_count)
target899drivers/scsi/sd.cint target;
target903drivers/scsi/sd.ctarget =  DEVICE_NR(full_dev);
target905drivers/scsi/sd.cif (target >= sd_template.dev_max ||
target906drivers/scsi/sd.c!rscsi_disks[target].device) {
target911drivers/scsi/sd.cif(!rscsi_disks[target].device->removable) return 0;
target921drivers/scsi/sd.crscsi_disks[target].ready = 0;
target922drivers/scsi/sd.crscsi_disks[target].device->changed = 1;
target933drivers/scsi/sd.crscsi_disks[target].ready = 1;  /* FLOPTICAL */
target935drivers/scsi/sd.cretval = rscsi_disks[target].device->changed;
target936drivers/scsi/sd.cif(!flag) rscsi_disks[target].device->changed = 0;
target1372drivers/scsi/sd.c#define DEVICE_BUSY rscsi_disks[target].device->busy
target1373drivers/scsi/sd.c#define USAGE rscsi_disks[target].device->access_count
target1374drivers/scsi/sd.c#define CAPACITY rscsi_disks[target].capacity
target1375drivers/scsi/sd.c#define MAYBE_REINIT  sd_init_onedisk(target)
target1386drivers/scsi/sd.cint target;
target1393drivers/scsi/sd.ctarget =  DEVICE_NR(dev);
target1407drivers/scsi/sd.cstart = target << gdev->minor_shift;
target1429drivers/scsi/sd.cresetup_one_dev(gdev, target);
target93drivers/scsi/seagate.cstatic int internal_command(unsigned char target, unsigned char lun,
target558drivers/scsi/seagate.ccurrent_target = SCpnt->target;
target600drivers/scsi/seagate.cresult = internal_command (SCint->target, SCint->lun, SCint->cmnd, SCint->request_buffer,
target614drivers/scsi/seagate.creturn internal_command (SCpnt->target, SCpnt->lun, SCpnt->cmnd, SCpnt->request_buffer,
target619drivers/scsi/seagate.cstatic int internal_command(unsigned char target, unsigned char lun, const void *cmnd,
target660drivers/scsi/seagate.cprintk ("scsi%d : target = %d, command = ", hostno, target);
target688drivers/scsi/seagate.cif (target == (controller_type == SEAGATE ? 7 : 6))
target884drivers/scsi/seagate.cDATA = (unsigned char) ((1 << target) | (controller_type == SEAGATE ? 0x80 : 0x40));
target911drivers/scsi/seagate.chostno, target, STATUS);
target1076drivers/scsi/seagate.chostno, target, lun);
target1391drivers/scsi/seagate.cprintk("scsi%d : target %d requested MSGOUT, sent NOP message.\n", hostno, target);
target1464drivers/scsi/seagate.chostno, target, message & 7);
target1476drivers/scsi/seagate.chostno,  message,   target);
target111drivers/scsi/sr.cint retval, target;
target115drivers/scsi/sr.ctarget =  MINOR(full_dev);
target117drivers/scsi/sr.cif (target >= sr_template.nr_dev) {
target130drivers/scsi/sr.cscsi_CDs[target].device->changed = 1;
target135drivers/scsi/sr.cretval = scsi_CDs[target].device->changed;
target137drivers/scsi/sr.cscsi_CDs[target].device->changed = 0;
target140drivers/scsi/sr.cif (retval) scsi_CDs[target].needs_sector_size = 1;
target41drivers/scsi/sr_ioctl.cstatic int do_ioctl(int target, unsigned char * sr_cmd, void * buffer, unsigned buflength)
target46drivers/scsi/sr_ioctl.cSCpnt = allocate_device(NULL, scsi_CDs[target].device, 1);
target62drivers/scsi/sr_ioctl.cscsi_CDs[target].device->changed = 1;
target73drivers/scsi/sr_ioctl.cscsi_CDs[target].device->host->host_no, 
target74drivers/scsi/sr_ioctl.cscsi_CDs[target].device->id,
target75drivers/scsi/sr_ioctl.cscsi_CDs[target].device->lun,
target96drivers/scsi/sr_ioctl.cint result, target, err;
target98drivers/scsi/sr_ioctl.ctarget = MINOR(dev);
target100drivers/scsi/sr_ioctl.cif (target >= sr_template.nr_dev ||
target101drivers/scsi/sr_ioctl.c!scsi_CDs[target].device) return -ENXIO;
target109drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
target115drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target121drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
target127drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target141drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
target151drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target165drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
target175drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target189drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
target199drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target210drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5);
target220drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, buffer, 12);
target246drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) |
target257drivers/scsi/sr_ioctl.cresult = do_ioctl (target, sr_cmd, buffer, 12);
target283drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
target287drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target292drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
target296drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, NULL, 255);
target301drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5);
target305drivers/scsi/sr_ioctl.cif ((result = do_ioctl(target, sr_cmd, NULL, 255)))
target322drivers/scsi/sr_ioctl.cif (scsi_CDs[target].device -> access_count > 1)
target327drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 1;
target331drivers/scsi/sr_ioctl.cif (!(result = do_ioctl(target, sr_cmd, NULL, 255)))
target332drivers/scsi/sr_ioctl.cscsi_CDs[target].device -> changed = 1;
target337drivers/scsi/sr_ioctl.cscsi_CDs[target].auto_eject = !!arg;
target353drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
target362drivers/scsi/sr_ioctl.cif ((result = do_ioctl (target, sr_cmd, buffer, 28))) {
target369drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
target381drivers/scsi/sr_ioctl.cif ((result = do_ioctl (target, sr_cmd, mask, 28))) {
target397drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 0x10;    /* Params are SCSI-2 */
target402drivers/scsi/sr_ioctl.cresult = do_ioctl (target, sr_cmd, buffer, 28);
target419drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
target428drivers/scsi/sr_ioctl.cif ((result = do_ioctl (target, sr_cmd, buffer, 28))) {
target452drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
target464drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, buffer, 16);
target494drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5);
target506drivers/scsi/sr_ioctl.cresult = do_ioctl(target, sr_cmd, buffer, 24);
target538drivers/scsi/sr_ioctl.clba = scsi_CDs[target].mpcd_sector+CD_BLOCK_OFFSET;
target544drivers/scsi/sr_ioctl.cms_info.addr.lba=scsi_CDs[target].mpcd_sector;
target547drivers/scsi/sr_ioctl.cms_info.xa_flag=scsi_CDs[target].xa_flags & 0x01;
target565drivers/scsi/sr_ioctl.creturn scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
target246drivers/scsi/u14-34f.cunsigned char target: 3;             /* target SCSI id */
target631drivers/scsi/u14-34f.cBN(j), i, SCpnt->target, SCpnt->pid);
target642drivers/scsi/u14-34f.ccpp->target = SCpnt->target;
target664drivers/scsi/u14-34f.cBN(j), SCpnt->target, SCpnt->pid);
target690drivers/scsi/u14-34f.cBN(j), SCarg->target, SCarg->pid);
target697drivers/scsi/u14-34f.cBN(j), i, SCarg->target, SCarg->pid);
target749drivers/scsi/u14-34f.cBN(j), SCarg->target, SCarg->pid, reset_flags);
target952drivers/scsi/u14-34f.c&& HD(j)->target_reset[SCpnt->target])
target965drivers/scsi/u14-34f.cHD(j)->target_reset[SCpnt->target] = FALSE;
target970drivers/scsi/u14-34f.cSCpnt->target, SCpnt->lun, SCpnt->pid,
target973drivers/scsi/u14-34f.cHD(j)->target_time_out[SCpnt->target] = 0;
target978drivers/scsi/u14-34f.cif (HD(j)->target_time_out[SCpnt->target] > 1)
target982drivers/scsi/u14-34f.cHD(j)->target_time_out[SCpnt->target]++;
target1029drivers/scsi/u14-34f.cSCpnt->target, SCpnt->lun, SCpnt->pid, HD(j)->iocount);
target716drivers/scsi/ultrastor.cmy_mscp->target_id = SCpnt->target;
target908drivers/scsi/wd7000.cidlun = ((SCpnt->target << 5) & 0xe0) | (SCpnt->lun & 7);
target318drivers/sound/configure.cint             bin2hex (char *path, char *target, char *varname);
target1567drivers/sound/configure.cbin2hex (char *path, char *target, char *varname)
target1576drivers/sound/configure.cFILE           *sf = fopen (target, "w");
target1037drivers/sound/gus_wave.cint             curr, target, rate;
target1052drivers/sound/gus_wave.ctarget = voices[voice].initial_volume;
target1057drivers/sound/gus_wave.cgus_voice_volume (target);
target1068drivers/sound/gus_wave.cif ((target - curr) / 64 == 0)  /* Close enough to target. */
target1071drivers/sound/gus_wave.cgus_voice_volume (target);
target1076drivers/sound/gus_wave.cif (target > curr)
target1078drivers/sound/gus_wave.cif (target > (4095 - 65))
target1079drivers/sound/gus_wave.ctarget = 4095 - 65;
target1080drivers/sound/gus_wave.cgus_ramp_range (curr, target);
target1085drivers/sound/gus_wave.cif (target < 65)
target1086drivers/sound/gus_wave.ctarget = 65;
target1088drivers/sound/gus_wave.cgus_ramp_range (target, curr);
target1518drivers/sound/gus_wave.cunsigned long   blk_sz, blk_end, left, src_offs, target;
target1640drivers/sound/gus_wave.ctarget = free_mem_ptr;
target1652drivers/sound/gus_wave.cblk_end = target + blk_sz;
target1654drivers/sound/gus_wave.cif ((target >> 18) != (blk_end >> 18))
target1658drivers/sound/gus_wave.cblk_sz = blk_end - target;
target1677drivers/sound/gus_wave.cgus_poke (target + i, data);
target1704drivers/sound/gus_wave.caddress = target;
target1763drivers/sound/gus_wave.ctarget += blk_sz;
target68drivers/sound/hex2hex.hint hex2hex(char *source, char *target, char *varline)
target81drivers/sound/hex2hex.hif ((outf=fopen(target, "w"))==NULL)
target83drivers/sound/hex2hex.hperror(target);
target134fs/ncpfs/ncplib_kernel.cint size, int *target)
target147fs/ncpfs/ncplib_kernel.c*target =min(ntohs(ncp_reply_word(server, 0)), size);
target155fs/ncpfs/ncplib_kernel.cstruct ncp_volume_info *target)
target169fs/ncpfs/ncplib_kernel.ctarget->total_blocks = ncp_reply_dword(server, 0);
target170fs/ncpfs/ncplib_kernel.ctarget->free_blocks  = ncp_reply_dword(server, 4);
target171fs/ncpfs/ncplib_kernel.ctarget->purgeable_blocks = ncp_reply_dword(server, 8);
target172fs/ncpfs/ncplib_kernel.ctarget->not_yet_purgeable_blocks = ncp_reply_dword(server, 12);
target173fs/ncpfs/ncplib_kernel.ctarget->total_dir_entries = ncp_reply_dword(server, 16);
target174fs/ncpfs/ncplib_kernel.ctarget->available_dir_entries = ncp_reply_dword(server, 20);
target175fs/ncpfs/ncplib_kernel.ctarget->sectors_per_block = ncp_reply_byte(server, 28);
target177fs/ncpfs/ncplib_kernel.cmemset(&(target->volume_name), 0, sizeof(target->volume_name));
target187fs/ncpfs/ncplib_kernel.cmemcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
target193fs/ncpfs/ncplib_kernel.cncp_get_volume_number(struct ncp_server *server, const char *name, int *target)
target206fs/ncpfs/ncplib_kernel.c*target = ncp_reply_byte(server, 0);
target253fs/ncpfs/ncplib_kernel.cncp_extract_file_info(void *structure, struct nw_info_struct *target)
target258fs/ncpfs/ncplib_kernel.cmemcpy(target, structure, info_struct_size);
target260fs/ncpfs/ncplib_kernel.ctarget->nameLen = *name_len;
target261fs/ncpfs/ncplib_kernel.cstrncpy(target->entryName, name_len+1, *name_len);
target262fs/ncpfs/ncplib_kernel.ctarget->entryName[*name_len] = '\0';
target270fs/ncpfs/ncplib_kernel.cstruct nw_info_struct *target)
target274fs/ncpfs/ncplib_kernel.cif (target == NULL)
target293fs/ncpfs/ncplib_kernel.cncp_extract_file_info(ncp_reply_data(server, 0), target);
target301fs/ncpfs/ncplib_kernel.cstruct nw_info_struct *target)
target333fs/ncpfs/ncplib_kernel.ctarget)) != 0)
target338fs/ncpfs/ncplib_kernel.cDPRINTK("ncp_lookup_volume: attribs = %X\n", target->attributes);
target340fs/ncpfs/ncplib_kernel.ctarget->nameLen = strlen(volname);
target341fs/ncpfs/ncplib_kernel.cstrcpy(target->entryName, volname);
target405fs/ncpfs/ncplib_kernel.cstruct nw_file_info *target)
target434fs/ncpfs/ncplib_kernel.ctarget->i.volNumber, target->i.DosDirNum,
target444fs/ncpfs/ncplib_kernel.ctarget->opened = 1;
target445fs/ncpfs/ncplib_kernel.ctarget->server_file_handle = ncp_reply_dword(server, 0);
target446fs/ncpfs/ncplib_kernel.ctarget->open_create_action = ncp_reply_byte(server, 4);
target451fs/ncpfs/ncplib_kernel.cncp_extract_file_info(ncp_reply_data(server, 5), &(target->i));
target454fs/ncpfs/ncplib_kernel.cConvertToNWfromDWORD(target->server_file_handle, target->file_handle);
target464fs/ncpfs/ncplib_kernel.cstruct nw_search_sequence *target)
target480fs/ncpfs/ncplib_kernel.cmemcpy(target, ncp_reply_data(server, 0), sizeof(*target));
target490fs/ncpfs/ncplib_kernel.cstruct nw_info_struct *target)
target512fs/ncpfs/ncplib_kernel.cncp_extract_file_info(ncp_reply_data(server, 10), target);
target562fs/ncpfs/ncplib_kernel.cchar *target, int *bytes_read)
target580fs/ncpfs/ncplib_kernel.cmemcpy_tofs(target, ncp_reply_data(server, 2+(offset&1)), *bytes_read);
target27fs/ncpfs/ncplib_kernel.hint *target);
target30fs/ncpfs/ncplib_kernel.hchar *target);
target34fs/ncpfs/ncplib_kernel.hstruct ncp_bindery_object *target);
target46fs/ncpfs/ncplib_kernel.hstruct ncp_volume_info *target);
target50fs/ncpfs/ncplib_kernel.hint *target);
target55fs/ncpfs/ncplib_kernel.hstruct ncp_filesearch_info *target);
target61fs/ncpfs/ncplib_kernel.hstruct ncp_file_info *target);
target66fs/ncpfs/ncplib_kernel.hstruct ncp_file_info *target);
target72fs/ncpfs/ncplib_kernel.hstruct ncp_file_info *target);
target80fs/ncpfs/ncplib_kernel.hstruct ncp_file_info *target);
target86fs/ncpfs/ncplib_kernel.hstruct ncp_file_info *target);
target116fs/ncpfs/ncplib_kernel.hchar *target, int *bytes_read);
target127fs/ncpfs/ncplib_kernel.hstruct nw_info_struct *target);
target132fs/ncpfs/ncplib_kernel.hstruct nw_info_struct *target);
target151fs/ncpfs/ncplib_kernel.hstruct nw_file_info *target);
target156fs/ncpfs/ncplib_kernel.hstruct nw_search_sequence *target);
target161fs/ncpfs/ncplib_kernel.hstruct nw_info_struct *target);
target213fs/smbfs/sock.csmb_receive_raw(struct socket *sock, unsigned char *target,
target265fs/smbfs/sock.cmemcpy_tofs(target, peek_buf, 4);
target266fs/smbfs/sock.ctarget += 4;
target274fs/smbfs/sock.c(void *)(target+already_read),
target625fs/smbfs/sock.cunsigned char *target, int max_len)
target659fs/smbfs/sock.c(unsigned int)target, max_len);
target673fs/smbfs/sock.cresult = smb_receive_raw(sock, target, max_len, 0);
target44include/linux/atalk.hstruct at_addr target;
target167include/linux/smb_fs.hunsigned char *target, int max_len);
target12include/linux/smp.hextern void smp_message_pass(int target, int msg, unsigned long data, int wait);
target526net/appletalk/ddp.cstatic struct atalk_route *atrtr_find(struct at_addr *target)
target533net/appletalk/ddp.cif(r->target.s_net==target->s_net)
target535net/appletalk/ddp.cif(!(r->flags&RTF_HOST) || r->target.s_node==target->s_node)
target609net/appletalk/ddp.cif(ta->sat_addr.s_net == rt->target.s_net) 
target613net/appletalk/ddp.cif(ta->sat_addr.s_node == rt->target.s_node)
target648net/appletalk/ddp.crt->target=ta->sat_addr;      
target669net/appletalk/ddp.cif (tmp->target.s_net == addr->s_net &&
target671net/appletalk/ddp.ctmp->target.s_node == addr->s_node )) 
target942net/appletalk/ddp.cntohs(rt->target.s_net),rt->target.s_node,