struct Scsi_Host * scsi_register(Scsi_Host_Template * tpnt, int j){ struct Scsi_Host * retval, *shpnt; retval = (struct Scsi_Host *)scsi_init_malloc(sizeof(struct Scsi_Host) + j, (tpnt->unchecked_isa_dma && j ? GFP_DMA : 0) | GFP_ATOMIC); retval->host_busy = 0; retval->block = NULL; retval->wish_block = 0; if(j > 0xffff) panic("Too many extra bytes requested\n"); retval->extra_bytes = j; retval->loaded_as_module = scsi_loadable_module_flag; retval->host_no = max_scsi_hosts++; /* never reuse host_no (DB) */ next_scsi_host++; retval->host_queue = NULL; retval->host_wait = NULL; retval->last_reset = 0; retval->irq = 0; retval->dma_channel = 0xff; /* These three are default values which can be overridden */ retval->max_channel = 0; retval->max_id = 8; retval->max_lun = 8; retval->unique_id = 0; retval->io_port = 0; retval->hostt = tpnt; retval->next = NULL; #ifdef DEBUG printk("Register %x %x: %d\n", (int)retval, (int)retval->hostt, j); #endif /* The next six are the default values which can be overridden * if need be */ retval->this_id = tpnt->this_id; retval->can_queue = tpnt->can_queue; retval->sg_tablesize = tpnt->sg_tablesize; retval->cmd_per_lun = tpnt->cmd_per_lun; retval->unchecked_isa_dma = tpnt->unchecked_isa_dma; retval->use_clustering = tpnt->use_clustering; retval->select_queue_depths = NULL; if(!scsi_hostlist) scsi_hostlist = retval; else { shpnt = scsi_hostlist; while(shpnt->next) shpnt = shpnt->next; shpnt->next = retval; } return retval; }
/* Driver initialization */ static int sg_init() { static int sg_registered = 0; if (sg_template.dev_noticed == 0) return 0; if(!sg_registered) { if (register_chrdev(SCSI_GENERIC_MAJOR,"sg",&sg_fops)) { printk("Unable to get major %d for generic SCSI device\n", SCSI_GENERIC_MAJOR); return 1; } sg_registered++; } /* If we have already been through here, return */ if(scsi_generics) return 0; #ifdef DEBUG printk("sg: Init generic device.\n"); #endif #ifdef SG_BIG_BUFF big_buff= (char *) scsi_init_malloc(SG_BIG_BUFF, GFP_ATOMIC | GFP_DMA); #endif scsi_generics = (struct scsi_generic *) scsi_init_malloc((sg_template.dev_noticed + SG_EXTRA_DEVS) * sizeof(struct scsi_generic), GFP_ATOMIC); memset(scsi_generics, 0, (sg_template.dev_noticed + SG_EXTRA_DEVS) * sizeof(struct scsi_generic)); sg_template.dev_max = sg_template.dev_noticed + SG_EXTRA_DEVS; return 0; }
fcscount++; } PLND(("%d channels online\n", fcscount)) if (!fcscount) { #if defined(MODULE) && defined(CONFIG_FC4_SOC_MODULE) && defined(CONFIG_KMOD) request_module("soc"); for_each_online_fc_channel(fc) { if (!fc->posmap) fcscount++; } if (!fcscount) #endif return 0; } fcs = (struct ctrl_inquiry *) scsi_init_malloc (sizeof (struct ctrl_inquiry) * fcscount, GFP_DMA); if (!fcs) { printk ("PLUTO: Not enough memory to probe\n"); return 0; } memset (fcs, 0, sizeof (struct ctrl_inquiry) * fcscount); memset (&dev, 0, sizeof(dev)); atomic_set (&fcss, fcscount); fc_timer.function = pluto_detect_timeout; i = 0; for_each_online_fc_channel(fc) { Scsi_Cmnd *SCpnt; struct Scsi_Host *host; struct pluto *pluto;
/* Detect all SSAs attached to the machine. To be fast, do it on all online FC channels at the same time. */ __initfunc(int pluto_detect(Scsi_Host_Template *tpnt)) { int i, retry, nplutos; fc_channel *fc; Scsi_Device dev; tpnt->proc_dir = &proc_scsi_pluto; fcscount = 0; for_each_online_fc_channel(fc) fcscount++; PLND(("%d channels online\n", fcscount)) if (!fcscount) { #if defined(MODULE) && defined(CONFIG_FC4_SOC_MODULE) && defined(CONFIG_KMOD) request_module("soc"); for_each_online_fc_channel(fc) fcscount++; if (!fcscount) #endif return 0; } fcs = (struct ctrl_inquiry *) scsi_init_malloc (sizeof (struct ctrl_inquiry) * fcscount, GFP_DMA); if (!fcs) { printk ("PLUTO: Not enough memory to probe\n"); return 0; } memset (fcs, 0, sizeof (struct ctrl_inquiry) * fcscount); memset (&dev, 0, sizeof(dev)); atomic_set (&fcss, fcscount); fc_timer.function = pluto_detect_timeout; i = 0; for_each_online_fc_channel(fc) { Scsi_Cmnd *SCpnt; struct Scsi_Host *host; struct pluto *pluto; if (i == fcscount) break; PLD(("trying to find SSA\n")) /* If this is already registered to some other SCSI host, then it cannot be pluto */ if (fc->scsi_name[0]) continue; memcpy (fc->scsi_name, "SSA", 4); fcs[i].fc = fc; fc->can_queue = PLUTO_CAN_QUEUE; fc->rsp_size = 64; fc->encode_addr = pluto_encode_addr; fc->fcp_register(fc, TYPE_SCSI_FCP, 0); SCpnt = &(fcs[i].cmd); host = &(fcs[i].host); pluto = (struct pluto *)host->hostdata; pluto->fc = fc; SCpnt->host = host; SCpnt->cmnd[0] = INQUIRY; SCpnt->cmnd[4] = 255; /* FC layer requires this, so that SCpnt->device->tagged_supported is initially 0 */ SCpnt->device = &dev; SCpnt->cmd_len = COMMAND_SIZE(INQUIRY); SCpnt->request.rq_status = RQ_SCSI_BUSY; SCpnt->done = pluto_detect_done; SCpnt->bufflen = 256; SCpnt->buffer = fcs[i].inquiry; SCpnt->request_bufflen = 256; SCpnt->request_buffer = fcs[i].inquiry; PLD(("set up %d %08lx\n", i, (long)SCpnt)) i++; } for (retry = 0; retry < 5; retry++) { for (i = 0; i < fcscount; i++) { if (!fcs[i].fc) break; if (fcs[i].cmd.request.rq_status != RQ_SCSI_DONE) { disable_irq(fcs[i].fc->irq); PLND(("queuecommand %d %d\n", retry, i)) fcp_scsi_queuecommand (&(fcs[i].cmd), pluto_detect_scsi_done); enable_irq(fcs[i].fc->irq); } } fc_timer.expires = jiffies + 10 * HZ; add_timer(&fc_timer); down(&fc_sem); PLND(("Woken up\n")) if (!atomic_read(&fcss)) break; /* All fc channels have answered us */ } del_timer(&fc_timer); PLND(("Finished search\n")) for (i = 0, nplutos = 0; i < fcscount; i++) { Scsi_Cmnd *SCpnt; if (!(fc = fcs[i].fc)) break; SCpnt = &(fcs[i].cmd); /* Let FC mid-level free allocated resources */ SCpnt->done (SCpnt); if (!SCpnt->result) { struct pluto_inquiry *inq; struct pluto *pluto; struct Scsi_Host *host; inq = (struct pluto_inquiry *)fcs[i].inquiry; if ((inq->dtype & 0x1f) == TYPE_PROCESSOR && !strncmp (inq->vendor_id, "SUN", 3) && !strncmp (inq->product_id, "SSA", 3)) { char *p; long *ages; ages = kmalloc (((inq->channels + 1) * inq->targets) * sizeof(long), GFP_KERNEL); if (!ages) continue; host = scsi_register (tpnt, sizeof (struct pluto)); if (!host) panic ("Cannot register PLUTO host\n"); nplutos++; if (fc->module) __MOD_INC_USE_COUNT(fc->module); pluto = (struct pluto *)host->hostdata; host->max_id = inq->targets; host->max_channel = inq->channels; host->irq = fc->irq; host->select_queue_depths = pluto_select_queue_depths; fc->channels = inq->channels + 1; fc->targets = inq->targets; fc->ages = ages; memset (ages, 0, ((inq->channels + 1) * inq->targets) * sizeof(long)); pluto->fc = fc; memcpy (pluto->rev_str, inq->revision, 4); pluto->rev_str[4] = 0; p = strchr (pluto->rev_str, ' '); if (p) *p = 0; memcpy (pluto->fw_rev_str, inq->fw_revision, 4); pluto->fw_rev_str[4] = 0; p = strchr (pluto->fw_rev_str, ' '); if (p) *p = 0; memcpy (pluto->serial_str, inq->serial, 12); pluto->serial_str[12] = 0; p = strchr (pluto->serial_str, ' '); if (p) *p = 0; PLD(("Found SSA rev %s fw rev %s serial %s %dx%d\n", pluto->rev_str, pluto->fw_rev_str, pluto->serial_str, host->max_channel, host->max_id)) } else fc->fcp_register(fc, TYPE_SCSI_FCP, 1); } else
int atari_scsi_detect (Scsi_Host_Template *host) { static int called = 0; struct Scsi_Host *instance; if (!MACH_IS_ATARI || (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) || called) return( 0 ); host->proc_dir = &proc_scsi_atari; atari_scsi_reg_read = IS_A_TT() ? atari_scsi_tt_reg_read : atari_scsi_falcon_reg_read; atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write : atari_scsi_falcon_reg_write; /* setup variables */ host->can_queue = (setup_can_queue > 0) ? setup_can_queue : IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE; host->cmd_per_lun = (setup_cmd_per_lun > 0) ? setup_cmd_per_lun : IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN; /* Force sg_tablesize to 0 on a Falcon! */ host->sg_tablesize = !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE : (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE; if (setup_hostid >= 0) host->this_id = setup_hostid; else { /* use 7 as default */ host->this_id = 7; /* Test if a host id is set in the NVRam */ if (ATARIHW_PRESENT(TT_CLK)) { unsigned char sum = 0, b; int i; /* Make checksum */ for( i = 14; i < 62; ++i ) sum += RTC_READ(i); if (/* NV-Ram checksum valid? */ RTC_READ(62) == sum && RTC_READ(63) == ~sum && /* Arbitration enabled? (for TOS) */ (b = RTC_READ( 30 )) & 0x80) { host->this_id = b & 7; } } } #ifdef SUPPORT_TAGS if (setup_use_tagged_queuing < 0) setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING; #endif /* If running on a Falcon and if there's TT-Ram (i.e., more than one * memory block, since there's always ST-Ram in a Falcon), then allocate a * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative * Ram. */ if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(EXTD_DMA) && boot_info.num_memory > 1) { atari_dma_buffer = scsi_init_malloc(STRAM_BUFFER_SIZE, GFP_ATOMIC | GFP_DMA); atari_dma_phys_buffer = VTOP( atari_dma_buffer ); atari_dma_orig_addr = 0; } instance = scsi_register (host, sizeof (struct NCR5380_hostdata)); atari_scsi_host = instance; instance->irq = IS_A_TT() ? IRQ_TT_MFP_SCSI : IRQ_MFP_FSCSI; atari_scsi_reset_boot(); NCR5380_init (instance, 0); if (IS_A_TT()) { /* This int is actually "pseudo-slow", i.e. it acts like a slow * interrupt after having cleared the pending flag for the DMA * interrupt. */ add_isr(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_SLOW, NULL, "SCSI NCR5380"); tt_mfp.active_edge |= 0x80; /* SCSI int on L->H */ #ifdef REAL_DMA tt_scsi_dma.dma_ctrl = 0; atari_dma_residual = 0; #endif /* REAL_DMA */ if (is_medusa) { /* While the read overruns (described by Drew Eckhardt in * NCR5380.c) never happened on TTs, they do in fact on the Medusa * (This was the cause why SCSI didn't work right for so long * there.) Since handling the overruns slows down a bit, I turned * the #ifdef's into a runtime condition. * * In principle it should be sufficient to do max. 1 byte with * PIO, but there is another problem on the Medusa with the DMA * rest data register. So 'atari_read_overruns' is currently set * to 4 to avoid having transfers that aren't a multiple of 4. If * the rest data bug is fixed, this can be lowered to 1. */ atari_read_overruns = 4; } } else { /* ! IS_A_TT */ /* Nothing to do for the interrupt: the ST-DMA is initialized * already by atari_init_INTS() */ #ifdef REAL_DMA atari_dma_residual = 0; atari_dma_active = 0; atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000 : 0xff000000); #endif } printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d " #ifdef SUPPORT_TAGS "TAGGED-QUEUING=%s " #endif "HOSTID=%d", instance->host_no, instance->hostt->can_queue, instance->hostt->cmd_per_lun, instance->hostt->sg_tablesize, #ifdef SUPPORT_TAGS setup_use_tagged_queuing ? "yes" : "no", #endif instance->hostt->this_id ); NCR5380_print_options (instance); printk ("\n"); called = 1; return( 1 ); }