home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / gtak / source / os2-add / init.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-29  |  8.3 KB  |  367 lines
  1. /*****************************************************************************
  2.  * $Id: init.c,v 1.4 1992/09/29 09:35:20 ak Exp $
  3.  *****************************************************************************
  4.  * $Log: init.c,v $
  5.  * Revision 1.4  1992/09/29  09:35:20  ak
  6.  * Must allow multiple DrvOpen calls. dup() seems to reopen the driver.
  7.  *
  8.  * Revision 1.3  1992/09/26  19:30:17  ak
  9.  * Initialize <trace> - doppelt genaeht halt besser.
  10.  *
  11.  * Revision 1.2  1992/09/18  15:59:16  ak
  12.  * *** empty log message ***
  13.  *
  14.  * Revision 1.1.1.1  1992/09/02  18:58:19  ak
  15.  * Initial checkin of OS/2 ADD based SCSI tape device driver.
  16.  *
  17.  * Revision 1.1  1992/09/02  18:58:17  ak
  18.  * Initial revision
  19.  *
  20.  *****************************************************************************/
  21.  
  22. static char _far rcsid[] = "$Id: init.c,v 1.4 1992/09/29 09:35:20 ak Exp $";
  23.  
  24. #include "addtape.h"
  25. #include <string.h>
  26.  
  27. #define TraceDEVTAB    3
  28.  
  29. static int    adapter;
  30. static int    target;
  31. static int    type_code = UIB_TYPE_TAPE;
  32.  
  33. #ifdef DEBUG
  34.  
  35. static char *    devbus[] = {
  36.     /* 0000 */    "?",
  37.     /* 0001 */    "ST506 CAM-I",
  38.     /* 0002 */    "ST506 CAM-II",
  39.     /* 0003 */    "ESDI",
  40.     /* 0004 */    "Floppy",
  41.     /* 0005 */    "SCSI-1",
  42.     /* 0006 */    "SCSI-2",
  43.     /* 0007 */    "SCSI-3",
  44. };
  45. static char *    hostbus[] = {
  46.     /* 0000 */    "?",
  47.     /* 0001 */    "ISA",
  48.     /* 0002 */    "EISA",
  49.     /* 0003 */    "MCA",
  50. };
  51. static char *    buswidth[] = {
  52.     /* 0000 */    "-?",
  53.     /* 0010 */    "-8",
  54.     /* 0020 */    "-16",
  55.     /* 0030 */    "-32",
  56.     /* 0040 */    "-64",
  57.     /* 0050 */    "-?",
  58.     /* 0060 */    "-?",
  59.     /* 0070 */    "-?",
  60. };
  61. static char *    unittype[] = {
  62.     /* 0000 */    "disk",
  63.     /* 0001 */    "tape",
  64.     /* 0002 */    "printer",
  65.     /* 0003 */    "processor",
  66.     /* 0004 */    "WORM",
  67.     /* 0005 */    "CDROM",
  68.     /* 0006 */    "scanner",
  69.     /* 0007 */    "optical",
  70.     /* 0008 */    "changed",
  71.     /* 0009 */    "comm",
  72.     /* 000A */    "?",
  73.     /* 000B */    "?",
  74.     /* 000C */    "?",
  75.     /* 000D */    "?",
  76.     /* 000E */    "?",
  77.     /* 000F */    "?",
  78. };
  79.  
  80. #endif
  81.  
  82. /*
  83.  * Handle device command line.
  84.  * Line is terminated by 0.
  85.  */
  86. int
  87. cmdline(char _far *line)
  88. {
  89.     byte *name;
  90.  
  91.     /*
  92.      * Skip driver name up to first argument.
  93.      */
  94.     for (; *line && *line != ' '; ++line) ;
  95.     for (; *line == ' '; ++line) ;
  96.  
  97.     /*
  98.      * First argument is device name.
  99.      */
  100.     name = header.name;
  101.     for (; *line && *line != ' '; ++line)
  102.         if (name < header.name+8)
  103.             *name++ = *line;
  104.     while (name < header.name+8)
  105.         *name++ = ' ';
  106.  
  107.     /*
  108.      * Handle arguments.
  109.      */
  110.     for (;;++line) {
  111.         switch (*line) {
  112.         default:
  113.             return 1;
  114.         case 0:
  115.             return 0;
  116.         case ' ':
  117.             continue;
  118.         case 'D': case 'd':            /* debug level */
  119.             if (*++line < '0' || *line > '9')
  120.                 return 1;
  121.             trace = *line - '0';
  122.             continue;
  123.         case 'A': case 'a':            /* adapter number */
  124.             if (*++line < '0' || *line > '9')
  125.                 return 1;
  126.             adapter = *line - '0';
  127.             continue;
  128.         case 'T': case 't':            /* target ID */
  129.             if (*++line < '0' || *line > '9')
  130.                 return 1;
  131.         case '0': case '1': case '2': case '3': case '4':
  132.         case '5': case '6': case '7': case '8': case '9':
  133.             target = *line - '0';
  134.             continue;
  135.         case 'S': case 's':            /* sense data mode */
  136.             if (*++line < '0' || *line > '9')
  137.                 return 1;
  138.             senseMode = *line - '0';
  139.             continue;
  140.         case 'V':
  141.             video_address = 0xB8000;    /* VGA output */
  142.             continue;
  143.         case 'C':                /* type code */
  144.             if (*++line < '0' || *line > '9')
  145.                 return 1;
  146.             type_code = *line - '0';
  147.             continue;
  148.         }
  149.     }        
  150. }
  151.  
  152.  
  153. word
  154. startup(void)
  155. {
  156.     int driver_no;
  157.  
  158.     unitinfo = NULL;
  159.     for (driver_no = 0; driver_no < dctbl->count; ++driver_no) {
  160.         DevClassTableEntry _far *dcent = &dctbl->entries[driver_no];
  161.         IORB_CONFIGURATION *iorb = (IORB_CONFIGURATION *)iorb1;
  162.         int adapter_no;
  163.  
  164. #ifdef DEBUG
  165.         if (trace >= TraceDEVTAB) {
  166.             puts("Driver ");
  167.             putd(driver_no);
  168.             puts(", name '");
  169.             puts(dcent->name);
  170.             putc('\'');
  171.         }
  172. #endif
  173.  
  174.         iorb->iorbh.Length = sizeof(IORB_CONFIGURATION);
  175.         iorb->iorbh.RequestControl = IORB_DISABLE_RETRY;
  176.         iorb->iorbh.CommandCode = IOCC_CONFIGURATION;
  177.         iorb->iorbh.CommandModifier = IOCM_GET_DEVICE_TABLE;
  178.         iorb->pDeviceTable = devtab;
  179.         iorb->DeviceTableLen = sizeof devtab_data;
  180.         dcent->entry(iorb);
  181.  
  182.         if (iorb->iorbh.Status != IORB_DONE) {
  183. #ifdef DEBUG
  184.             if (trace >= 1) {
  185.                 puts(" -- Error ");
  186.                 putx(iorb->iorbh.ErrorCode);
  187.                 putc('\n');
  188.                 continue;
  189.             }
  190. #endif
  191.         }
  192.  
  193. #ifdef DEBUG
  194.         if (trace >= TraceDEVTAB) {
  195.             puts(", level ");
  196.             putd(devtab->ADDLevelMajor);
  197.             putc('.');
  198.             putd(devtab->ADDLevelMinor);
  199.             puts(", ");
  200.             putd(devtab->TotalAdapters);
  201.             puts(" adapters\n");
  202.         }
  203. #endif
  204.  
  205.         for (adapter_no = 0; adapter_no < devtab->TotalAdapters; ++adapter_no) {
  206.             ADAPTERINFO *adap = devtab->pAdapter[adapter_no];
  207.             int unit_no, i;
  208.             int scsi = (adap->AdapterDevBus & 7) >= AI_DEVBUS_SCSI_1;
  209.  
  210. #ifdef DEBUG
  211.             if (trace >= TraceDEVTAB) {
  212.                 puts("   Adapter ");
  213.                 putd(adapter_no);
  214.                 puts(", name '");
  215.                 puts(adap->AdapterName);
  216.                 puts("', ");
  217.                 putd(adap->AdapterUnits);
  218.                 puts(" units\n");
  219.  
  220.                 puts("      ");
  221.                 i = adap->AdapterDevBus;
  222.                 puts(devbus[i & 7]);
  223.                 if (i & AI_DEVBUS_FAST_SCSI)
  224.                     puts("-fast");
  225.                 if (i & AI_DEVBUS_8BIT)
  226.                     puts("-8");
  227.                 if (i & AI_DEVBUS_16BIT)
  228.                     puts("-16");
  229.                 if (i & AI_DEVBUS_32BIT)
  230.                     puts("-32");
  231.                 i = adap->AdapterIOAccess;
  232.                 if (i & AI_IOACCESS_BUS_MASTER)
  233.                     puts(", bus-master");
  234.                 if (i & AI_IOACCESS_PIO)
  235.                     puts(", programmed-i/o");
  236.                 if (i & AI_IOACCESS_DMA_SLAVE)
  237.                     puts(", DMA-slave");
  238.                 if (i & AI_IOACCESS_MEMORY_MAP)
  239.                     puts(", memory-mapped");
  240.                 puts(", ");
  241.                 puts(hostbus[adap->AdapterHostBus & 3]);
  242.                 puts(buswidth[adap->AdapterHostBus >> 4 & 15]);
  243.                 if (scsi) {
  244.                     puts(", ID ");
  245.                     putx(adap->AdapterSCSITargetID);
  246.                     puts(", LUN ");
  247.                     putx(adap->AdapterSCSILUN);
  248.                 }
  249.                 puts("\n      S/G max ");
  250.                 putd(adap->MaxHWSGList);
  251.                 if (scsi) {
  252.                     puts(", CDB max ");
  253.                     putd(adap->MaxCDBTransferLength);
  254.                 }
  255.                 i = adap->AdapterFlags;
  256.                 if (i & AF_16M)
  257.                     puts(", > 16MB");
  258.                 else
  259.                     puts(", max 16MB");
  260.                 if (i & AF_IBM_SCB)
  261.                     puts(", IBM SCB");
  262.                 if (i & AF_HW_SCATGAT)
  263.                     puts(", hardware S/G");
  264.                 if (i & AF_HW_SCATGAT)
  265.                     puts(", CHS addressing");
  266.                 putc('\n');
  267.             }
  268. #endif
  269.  
  270.             for (unit_no = 0; unit_no < adap->AdapterUnits; ++unit_no) {
  271.                 UNITINFO *unit = &adap->UnitInfo[unit_no];
  272.  
  273. #ifdef DEBUG
  274.                 if (trace >= TraceDEVTAB) {
  275.                     puts("      Unit ");
  276.                     putd(unit_no);
  277.                     if (scsi) {
  278.                         puts(", ID ");
  279.                         putd(unit->UnitSCSITargetID);
  280.                         puts(", LUN ");
  281.                         putd(unit->UnitSCSILUN);
  282.                     }
  283.                     puts(", ");
  284.                     puts(unittype[unit->UnitType]);
  285.                     puts(" dev");
  286.                     i = unit->UnitFlags;
  287.                     if (i & UF_REMOVABLE)
  288.                         puts(", removable");
  289.                     if (i & UF_REMOVABLE)
  290.                         puts(", changeline");
  291.                     if (i & UF_PREFETCH)
  292.                         puts(", prefetch");
  293.                     if (i & UF_A_DRIVE)
  294.                         puts(", drive A");
  295.                     if (i & UF_B_DRIVE)
  296.                         puts(", drive B");
  297.                     if (i & UF_NODASD_SUPT)
  298.                         puts(", no DASD");
  299.                     if (i & UF_NOSCSI_SUPT)
  300.                         puts(", no SCSI");
  301.                     if (i & UF_DEFECTIVE)
  302.                         puts(", defective");
  303.                     puts(", queuing ");
  304.                     putd(unit->QueuingCount);
  305.                     putc('\n');
  306.                 }
  307. #endif
  308.  
  309.                 if (scsi
  310.                  && unit->UnitType == type_code
  311.                  && !(unit->UnitFlags & UF_NOSCSI_SUPT)
  312.                  && adapter_no == adapter
  313.                  && unit->UnitSCSITargetID == target) {
  314.                      PUTS(TraceDEVTAB, "         Matched\n");
  315.                      callADD = dcent->entry;
  316.                     unitinfo = unit;
  317.                     if (trace < TraceDEVTAB)
  318.                         goto found;
  319.                 }
  320.             }
  321.         }
  322.     }
  323.  
  324.     if (!unitinfo || !callADD) {
  325.         PUTS(1, "No such tape device found\n");
  326.         return ERROR+DONE+GeneralFailure;
  327.     }
  328.  
  329. found:    return DONE;
  330. }
  331.  
  332. word
  333. DrvInitBase(char _far *line)
  334. {
  335.     int driver_no;
  336.  
  337. #ifndef __ZTC__
  338.     _STI_d2debug();
  339. #endif
  340.  
  341.     trace = 0;
  342.     open_count = 0;
  343.  
  344.     devtab = (DEVICETABLE *)devtab_data;
  345.     memset(iorb1, 0, MAX_IORB_SIZE);
  346.     memset(iorb2, 0, MAX_IORB_SIZE);
  347.     ((IORBH *)iorb2)->Status = DONE;
  348.     paddr_iorb1 = VirtToPhys(iorb1);
  349.     paddr_sglist = VirtToPhys(sglist);
  350.     blocksize = 512;
  351.  
  352.     if (cmdline(line)) {
  353.         PUTS(1, "SCSITAPE command line error\n");
  354.         return ERROR+DONE+GeneralFailure;
  355.     }
  356.  
  357.     dctbl = GetDOSVar(DosVar_DeviceClassTable, 1);
  358.     if (dctbl == NULL) {
  359.         PUTS(1, "GetDOSVar failed\n");
  360.         return ERROR+DONE+GeneralFailure;
  361.     }
  362.  
  363.     startup();
  364.  
  365.     return DONE;
  366. }
  367.