drivers/scsi/eata_dma

/* */
This source file includes following definitions.
swap_statistics
eata_set_info
eata_proc_info
   1 
   2 #define MAX_SCSI_DEVICE_CODE 10
   3 const char *const scsi_dev_types[MAX_SCSI_DEVICE_CODE] =
   4 {
   5     "Direct-Access    ",
   6     "Sequential-Access",
   7     "Printer          ",
   8     "Processor        ",
   9     "WORM             ",
  10     "CD-ROM           ",
  11     "Scanner          ",
  12     "Optical Device   ",
  13     "Medium Changer   ",
  14     "Communications   "
  15 };
  16 
  17 
  18 void swap_statistics(u8 *p)
     /*  */
  19 {
  20     u32 y;
  21     u32 *lp, h_lp;
  22     u16 *sp, h_sp;
  23     u8 *bp;
  24     
  25     lp = (u32 *)p;
  26     sp = ((short *)lp) + 1;         /* Convert Header */
  27     h_sp = *sp = ntohs(*sp);
  28     lp++;
  29 
  30     do {
  31         sp = (u16 *)lp;           /* Convert SubHeader */
  32     *sp = ntohs(*sp);
  33     bp = (u8 *) lp;
  34     y = *(bp + 3);
  35     lp++;
  36     for (h_lp = (u32)lp; (u32)lp < h_lp + ((u32)*(bp + 3)); lp++)
  37         *lp = ntohl(*lp);
  38     }while ((u32)lp < ((u32)p) + 4 + h_sp);
  39 
  40 }
  41 
  42 /*
  43  * eata_set_info
  44  * buffer : pointer to the data that has been written to the hostfile
  45  * length : number of bytes written to the hostfile
  46  * HBA_ptr: pointer to the Scsi_Host struct
  47  */
  48 int eata_set_info(char *buffer, int length, struct Scsi_Host *HBA_ptr)
     /*  */
  49 {
  50     DBG(DBG_PROC_WRITE, printk("%s\n", buffer));
  51     return(-ENOSYS);  /* Currently this is a no-op */
  52 }
  53 
  54 /*
  55  * eata_proc_info
  56  * inout : decides on the direction of the dataflow and the meaning of the variables
  57  * buffer: If inout==FALSE data is beeing written to it else read from it
  58  * *start: If inout==FALSE start of the valid data in the buffer
  59  * offset: If inout==FALSE offset from the beginning of the imaginary file from which we start writing into the buffer
  60  * length: If inout==FALSE max number of bytes to be written into the buffer else number of bytes in the buffer
  61  */
  62 int eata_proc_info(char *buffer, char **start, off_t offset, int length, int hostno, int inout)
     /*  */
  63 {
  64 
  65     Scsi_Device *scd;
  66     struct Scsi_Host *HBA_ptr;
  67     Scsi_Cmnd scmd;
  68     static u8 buff[512];
  69     static u8 buff2[512];
  70     hst_cmd_stat *rhcs, *whcs;
  71     coco         *cc;
  72     scsitrans    *st;
  73     scsimod      *sm;
  74     hobu         *hb;
  75     scbu         *sb;
  76     boty         *bt;
  77     memco        *mc;
  78     firm         *fm;
  79     subinf       *si; 
  80     pcinf        *pi;
  81     arrlim       *al;
  82     int i, x; 
  83     int   size, len = 0;
  84     off_t begin = 0;
  85     off_t pos = 0;
  86 
  87     HBA_ptr = first_HBA;
  88     for (i = 1; i <= registered_HBAs; i++) {
  89         if (HBA_ptr->host_no == hostno)
  90             break;
  91         HBA_ptr = SD(HBA_ptr)->next;
  92     }        
  93 
  94     if(inout == TRUE) /* Has data been writen to the file ? */ 
  95         return(eata_set_info(buffer, length, HBA_ptr));
  96 
  97     if (offset == 0)
  98         memset(buff, 0, sizeof(buff));
  99 
 100     cc = (coco *)     (buff + 0x148);
 101     st = (scsitrans *)(buff + 0x164); 
 102     sm = (scsimod *)  (buff + 0x16c);
 103     hb = (hobu *)     (buff + 0x172);
 104     sb = (scbu *)     (buff + 0x178);
 105     bt = (boty *)     (buff + 0x17e);
 106     mc = (memco *)    (buff + 0x186);
 107     fm = (firm *)     (buff + 0x18e);
 108     si = (subinf *)   (buff + 0x196); 
 109     pi = (pcinf *)    (buff + 0x19c);
 110     al = (arrlim *)   (buff + 0x1a2);
 111 
 112     size = sprintf(buffer+len, "EATA (Extended Attachment) driver version: "
 113                    "%d.%d%s\n",VER_MAJOR, VER_MINOR, VER_SUB);
 114     len += size; pos = begin + len;
 115     size = sprintf(buffer + len, "queued commands:     %10ld\n"
 116                    "processed interrupts:%10ld\n", queue_counter, int_counter);
 117     len += size; pos = begin + len;
 118 
 119     if(SD(HBA_ptr)->bustype == IS_EISA)
 120         goto devices;
 121     
 122     scmd.cmnd[0] = LOG_SENSE;
 123     scmd.cmnd[1] = 0;
 124     scmd.cmnd[2] = 0x33 + (3<<6);
 125     scmd.cmnd[3] = 0;
 126     scmd.cmnd[4] = 0;
 127     scmd.cmnd[5] = 0;
 128     scmd.cmnd[6] = 0;
 129     scmd.cmnd[7] = 0x00;
 130     scmd.cmnd[8] = 0x66;
 131     scmd.cmnd[9] = 0;
 132     scmd.cmd_len = 10;
 133     
 134     scmd.host = HBA_ptr; 
 135     scmd.target = HBA_ptr->this_id; 
 136     scmd.lun = 0; 
 137     scmd.channel = 0;
 138     
 139     scmd.use_sg = 0;
 140     scmd.request_bufflen = 0x66;
 141     scmd.request_buffer = buff + 0x144;
 142     HBA_interpret = TRUE;
 143     
 144     eata_queue(&scmd, (void *) eata_scsi_done);
 145     while (internal_command_finished == FALSE)
 146         barrier();
 147     
 148     size = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
 149                    HBA_ptr->host_no, SD(HBA_ptr)->name);
 150     len += size; 
 151     pos = begin + len;
 152     size = sprintf(buffer + len, "Firmware revision: v%s\n", 
 153                    SD(HBA_ptr)->revision);
 154     len += size;
 155     pos = begin + len;
 156     size = sprintf(buffer + len, "Hardware Configuration:\n");
 157     len += size; 
 158     pos = begin + len;
 159     size = sprintf(buffer + len, "IRQ: %2d, %s triggered\n", cc->interrupt,
 160                    (cc->intt == TRUE)?"level":"edge");
 161     len += size; 
 162     pos = begin + len;
 163     if (HBA_ptr->dma_channel == 0xff)
 164         size = sprintf(buffer + len, "DMA: BUSMASTER\n");
 165     else
 166         size = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
 167     len += size; 
 168     pos = begin + len;
 169     size = sprintf(buffer + len, "CPU: MC680%02d %dMHz\n", bt->cpu_type,
 170                    bt->cpu_speed);
 171     len += size; 
 172     pos = begin + len;
 173     size = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
 174     len += size; 
 175     pos = begin + len;
 176     size = sprintf(buffer + len, "Host Bus: %s\n", 
 177                    (SD(HBA_ptr)->bustype == IS_PCI)?"PCI ":
 178                    (SD(HBA_ptr)->bustype == IS_EISA)?"EISA":"ISA ");
 179     
 180     len += size; 
 181     pos = begin + len;
 182     size = sprintf(buffer + len, "SCSI Bus:%s%s Speed: %sMB/sec. %s\n",
 183                    (sb->wide == TRUE)?" WIDE":"", 
 184                    (sb->dif == TRUE)?" DIFFERENTIAL":"",
 185                    (sb->speed == 0)?"5":(sb->speed == 1)?"10":"20",
 186                    (sb->ext == TRUE)?"With external cable detection":"");
 187     len += size; 
 188     pos = begin + len;
 189     size = sprintf(buffer + len, "SCSI channel expansion Module: %s installed\n",
 190                    (bt->sx1 == TRUE)?"SX1 (one channel)":
 191                    ((bt->sx2 == TRUE)?"SX2 (two channels)":"not"));
 192     len += size; 
 193     pos = begin + len;
 194     size = sprintf(buffer + len, "SmartRAID hardware: %spresent.\n",
 195                    (cc->srs == TRUE)?"":"not ");
 196     len += size; 
 197     pos = begin + len;
 198     size = sprintf(buffer + len, "    Type: %s\n",
 199                    ((cc->key == TRUE)?((bt->dmi == TRUE)?"integrated"
 200                                        :((bt->dm4 == TRUE)?"DM401X"
 201                                        :(bt->dm4k == TRUE)?"DM4000"
 202                                        :"-"))
 203                                        :"-"));
 204     len += size; 
 205     pos = begin + len;
 206     
 207     size = sprintf(buffer + len, "    Max array groups:              %d\n",
 208                    (al->code == 0x0e)?al->max_groups:7);
 209     len += size; 
 210     pos = begin + len;
 211     size = sprintf(buffer + len, "    Max drives per RAID 0 array:   %d\n",
 212                    (al->code == 0x0e)?al->raid0_drv:7);
 213     len += size; 
 214     pos = begin + len;
 215     size = sprintf(buffer + len, "    Max drives per RAID 3/5 array: %d\n",
 216                    (al->code == 0x0e)?al->raid35_drv:7);
 217     len += size; 
 218     pos = begin + len;
 219     size = sprintf(buffer + len, "Cache Module: %sinstalled.\n",
 220                    (cc->csh)?"":"not ");
 221     len += size; 
 222     pos = begin + len;
 223     size = sprintf(buffer + len, "    Type: %s\n",
 224                    ((cc->csh == TRUE)?((bt->cmi == TRUE)?"integrated"
 225                                        :((bt->cm4 == TRUE)?"CM401X"
 226                                        :((bt->cm4k == TRUE)?"CM4000"
 227                                        :"-")))
 228                                        :"-"));
 229     len += size; 
 230     pos = begin + len;
 231     for (x = 0; x <= 3; x++) {
 232         size = sprintf(buffer + len, "    Bank%d: %dMB with%s ECC\n",x,
 233                        mc->banksize[x] & 0x7f, 
 234                        (mc->banksize[x] & 0x80)?"":"out");
 235         len += size; 
 236         pos = begin + len;      
 237     }   
 238     size = sprintf(buffer + len, "Timer Modification: %sinstalled\n",
 239                    (cc->tmr == TRUE)?"":"not ");
 240     len += size; 
 241     pos = begin + len;
 242     size = sprintf(buffer + len, "NVRAM: %spresent\n",
 243                    (cc->nvr == TRUE)?"":"not ");
 244     len += size; 
 245     pos = begin + len;
 246     size = sprintf(buffer + len, "SmartROM: %senabled\n",
 247                    (bt->srom == TRUE)?"not ":"");
 248     len += size; 
 249     pos = begin + len;
 250     size = sprintf(buffer + len, "HBA indicates %salarm.\n",
 251                    (bt->alrm == TRUE)?"":"no ");
 252     len += size; 
 253     pos = begin + len;
 254     
 255     if (pos < offset) {
 256         len = 0;
 257         begin = pos;
 258     }
 259     if (pos > offset + length)
 260         goto stop_output; 
 261     
 262     scmd.cmnd[0] = LOG_SENSE;
 263     scmd.cmnd[1] = 0;
 264     scmd.cmnd[2] = 0x32 + (3<<6); 
 265     scmd.cmnd[3] = 0;
 266     scmd.cmnd[4] = 0;
 267     scmd.cmnd[5] = 0;
 268     scmd.cmnd[6] = 0;
 269     scmd.cmnd[7] = 0x01;
 270     scmd.cmnd[8] = 0x44;
 271     scmd.cmnd[9] = 0;
 272     scmd.cmd_len = 10;
 273     scmd.host = HBA_ptr; 
 274     scmd.target = HBA_ptr->this_id; 
 275     scmd.lun = 0; 
 276     scmd.channel = 0;
 277     scmd.use_sg = 0;
 278     scmd.request_bufflen = 0x144;
 279     scmd.request_buffer = buff2;
 280     HBA_interpret = TRUE;
 281     
 282     eata_queue(&scmd, (void *) eata_scsi_done);
 283     while (internal_command_finished == FALSE)
 284         barrier();
 285     
 286     swap_statistics(buff2);
 287     rhcs = (hst_cmd_stat *)(buff2 + 0x2c); 
 288     whcs = (hst_cmd_stat *)(buff2 + 0x8c);           
 289     
 290     for (x = 0; x <= 11; x++) {
 291         SD(HBA_ptr)->reads[x] += rhcs->sizes[x];
 292         SD(HBA_ptr)->writes[x] += whcs->sizes[x];
 293         SD(HBA_ptr)->reads[12] += rhcs->sizes[x];
 294         SD(HBA_ptr)->writes[12] += whcs->sizes[x];
 295     }
 296     size = sprintf(buffer + len, "Host Disk Command Statistics:\n"
 297                    "         Reads:      Writes:\n");
 298     len += size; 
 299     pos = begin + len;
 300     for (x = 0; x <= 10; x++) {
 301         size = sprintf(buffer+len,"%5dk:%12u %12u\n", 1 << x,
 302                        SD(HBA_ptr)->reads[x], 
 303                        SD(HBA_ptr)->writes[x]);
 304         len += size; 
 305         pos = begin + len;
 306     }
 307     size = sprintf(buffer+len,">1024k:%12u %12u\n",
 308                    SD(HBA_ptr)->reads[11], 
 309                    SD(HBA_ptr)->writes[11]);
 310     len += size; 
 311     pos = begin + len;
 312     size = sprintf(buffer+len,"Sum   :%12u %12u\n",
 313                    SD(HBA_ptr)->reads[12], 
 314                    SD(HBA_ptr)->writes[12]);
 315     len += size; 
 316     pos = begin + len;
 317     
 318     if (pos < offset) {
 319         len = 0;
 320         begin = pos;
 321     }
 322     if (pos > offset + length)
 323         goto stop_output;
 324 
 325  devices:    
 326     scd = scsi_devices;
 327     
 328     size = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
 329     len += size; 
 330     pos = begin + len;
 331     
 332     while (scd) {
 333         if (scd->host == HBA_ptr) {
 334             
 335             size = sprintf(buffer + len, "Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
 336                            scd->channel, scd->id, scd->lun);
 337             for (x = 0; x < 8; x++) {
 338                 if (scd->vendor[x] >= 0x20)
 339                     size += sprintf(buffer + len + size, "%c", scd->vendor[x]);
 340                 else
 341                     size += sprintf(buffer + len + size," ");
 342             }
 343             size += sprintf(buffer + len + size, " Model: ");
 344             for (x = 0; x < 16; x++) {
 345                 if (scd->model[x] >= 0x20)
 346                     size +=  sprintf(buffer + len + size, "%c", scd->model[x]);
 347                 else
 348                     size += sprintf(buffer + len + size, " ");
 349             }
 350             size += sprintf(buffer + len + size, " Rev: ");
 351             for (x = 0; x < 4; x++) {
 352                 if (scd->rev[x] >= 0x20)
 353                     size += sprintf(buffer + len + size, "%c", scd->rev[x]);
 354                 else
 355                     size += sprintf(buffer + len + size, " ");
 356             }
 357             size += sprintf(buffer + len + size, "\n");
 358             
 359             size += sprintf(buffer + len + size, "  Type:   %s ",
 360                             scd->type < MAX_SCSI_DEVICE_CODE ? 
 361                             scsi_dev_types[(int)scd->type] : "Unknown          " );
 362             size += sprintf(buffer + len + size, "               ANSI"
 363                             " SCSI revision: %02x", (scd->scsi_level < 3)?1:2);
 364             if (scd->scsi_level == 2)
 365                 size += sprintf(buffer + len + size, " CCS\n");
 366             else
 367                 size += sprintf(buffer + len + size, "\n");
 368             len += size; 
 369             pos = begin + len;
 370             
 371             if (pos < offset) {
 372                 len = 0;
 373                 begin = pos;
 374             }
 375             if (pos > offset + length)
 376                 goto stop_output;
 377         }
 378         scd = scd->next;
 379     }
 380     
 381  stop_output:
 382     DBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
 383     *start=buffer+(offset-begin);   /* Start of wanted data */
 384     len-=(offset-begin);            /* Start slop */
 385     if(len>length)
 386         len = length;               /* Ending slop */
 387     DBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
 388     
 389     return (len);     
 390 }
 391 
 392 /*
 393  * Overrides for Emacs so that we follow Linus's tabbing style.
 394  * Emacs will notice this stuff at the end of the file and automatically
 395  * adjust the settings for this buffer only.  This must remain at the end
 396  * of the file.
 397  * ---------------------------------------------------------------------------
 398  * Local variables:
 399  * c-indent-level: 4
 400  * c-brace-imaginary-offset: 0
 401  * c-brace-offset: -4
 402  * c-argdecl-indent: 4
 403  * c-label-offset: -4
 404  * c-continued-statement-offset: 4
 405  * c-continued-brace-offset: 0
 406  * indent-tabs-mode: nil
 407  * tab-width: 8
 408  * End:
 409  */
/* */
root/drivers/scsi/eata_dma_proc.c

DEFINITIONS
