home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / update701 / root.16 / etc / dcu.d / scripts / dculib.sh / dculib.sh
Encoding:
Text File  |  1998-08-18  |  57.0 KB  |  3,015 lines

  1. #!/sbin/sh
  2.  
  3. # Copyright (c) 1998 The Santa Cruz Operation, Inc.. All Rights Reserved. 
  4. #                                                                         
  5. #        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE               
  6. #                   SANTA CRUZ OPERATION INC.                             
  7. #                                                                         
  8. #   The copyright notice above does not evidence any actual or intended   
  9. #   publication of such source code.                                      
  10.  
  11. #ident    "@(#)dcu:scripts/dculib.sh    1.74.9.2"
  12.  
  13. #
  14. # NOTE: if you want a blank line in a embedded string a string use
  15. # ${IM_A_BLANK_LINE_DONT_TOUCH}
  16. #
  17.  
  18. function dcuinit
  19. {
  20. # dcuinit()
  21. # Called from main() to initialize the world
  22. # declare/initialize all dcu globals HERE!!!.
  23. # Calling/Exit State: void.
  24.  
  25. [ "$DCUDEBUG" -gt 3 ] && {
  26. print -u2 "$0 called"
  27. set -x
  28. }
  29.  
  30. rsrcinit && return 0
  31. # unset board and driver settings
  32. set -A BDTYPE
  33. set -A BDKEY
  34. set -A BDCHGS
  35. set -A BDCNFG
  36. set -A BDCLEANED 
  37. set -A BDMODNAME
  38. set -A BDMODINDX
  39. set -A BDINTERPSM
  40.  
  41. set -A BDNAME
  42. set -A BDUNIT
  43. set -A BDIPL
  44. set -A BDITYPE
  45. set -A BDIRQ
  46. set -A BDPORTSTART
  47. set -A BDPORTEND
  48. set -A BDADDRSTART
  49. set -A BDADDREND
  50. set -A BDDMA
  51. set -A BDCPU
  52. set -A BDBUSTYPE
  53. set -A BDID
  54. set -A BDCLASS
  55. set -A BDENTRYTYPE
  56.  
  57. # If set for a board, then board has changes to boards specific parameters
  58. set -A BDHASBSP
  59. set -A BDBSPPARAMS
  60. set -A BDBSPVALS
  61.  
  62. set -A DRVMODCHOICES
  63. set -A DRVISCCHOICES
  64. set -A DRVUNITCHOICES
  65. set -A DRVIPLCHOICES
  66. set -A DRVITYPECHOICES
  67. set -A DRVIRQCHOICES
  68. set -A DRVPORTSCHOICES
  69. set -A DRVPORTECHOICES
  70. set -A DRVMEMSCHOICES
  71. set -A DRVMEMECHOICES
  72. set -A DRVDMACHOICES
  73. set -A DRVCPUCHOICES
  74.  
  75. set -A DRVAUTOCONFIG
  76. set -A DRVVERIFY
  77. set -A DRVCATEGORY
  78. set -A DRVBRAND
  79.  
  80. set -A DRVBUSTYPE
  81. set -A DRVBOARDID
  82. set -A DRVBOARDNAME
  83. set -A DRVBOARDNAMEFULL
  84. set -A DRVSTATIC
  85. set -A DRVBCFGFILE
  86.  
  87. set -A MODNAME
  88. set -A LOADMODS
  89. set -A MODNAMECHOICES "$unused"
  90. set -A BDNAMECHOICES 
  91. set -A DEVNAMECHOICES 
  92.  
  93. set -A IHVDISKETTE
  94. set -A IHVMODULES
  95. set -A OLDLINETOBD
  96. set -A OLDBOARDFLD
  97. HBADISKETTE=0
  98. CNFGWAITWIN=
  99. CNFGBDFID=
  100. LDHBAWAITWIN=
  101. DCUCNFGIHV=
  102. RSMGR_UPDATE=
  103. BOARDXPND=
  104. CONFBDTABLE_WIDTH=
  105. SDVCNFG=""
  106. SDV=""
  107. SDVMODNAME=""
  108. SDVIRQCHOICES=""
  109. SDVPORTSCHOICES=""
  110. SDVPORTECHOICES=""
  111. SDVADDRSCHOICES=""
  112. SDVADDRECHOICES=""
  113. SDVPORTS=""
  114. SDVADDRS=""
  115. SDVSTATIC=""
  116.  
  117. IRQCHKD=""
  118. IOSCHKD=""
  119. IOECHKD=""
  120. MEMSCHKD=""
  121. MEMECHKD=""
  122. DMACHKD=""
  123.  
  124. RMIOCHKD=""
  125. RMMEMCHKD=""
  126.  
  127. DCU_HALT=N
  128. DCU_ENTRY="ENTRY"
  129. DCU_EXIT="EXIT"
  130. DCU_EXIT_CODE=0
  131. DCU_CONF_TYPE="$DCU_ENTRY"
  132. APPLY_CONF=""
  133. EXIT_CONF=""
  134. ADD_KEYS=""
  135. DEL_KEYS=""
  136.  
  137. NETCAT=0
  138. HOSTCAT=0
  139. COMMCAT=0
  140. VIDEOCAT=0
  141. SOUNDCAT=0
  142. MISCCAT=0
  143.  
  144. DCU_REBOOT="REBOOT"
  145. DCU_REBUILD="REBUILD"
  146. DCU_MAX_WIDTH=78
  147. DCU_MAX_HEIGHT=21
  148.  
  149. ADD_DEL_CHG=1
  150. NAME_CHG=2
  151. IRQ_CHG=4
  152. IOS_CHG=8
  153. IOE_CHG=16
  154. MEMS_CHG=32
  155. MEME_CHG=64
  156. DMA_CHG=128
  157. IPL_CHG=256
  158. ITYPE_CHG=512
  159. CPU_CHG=1024
  160. BSP_CHG=2048
  161. UNIT_CHG=4096
  162.  
  163. setpltfm
  164. driversinit
  165. boardsinit
  166. return 1
  167. }
  168.  
  169. function rsrcinit
  170. {
  171. # rsrcinit()
  172. # Called when the DCU is invoked to open the resmgr interface.
  173. # Calling/Exit State: void.
  174.  
  175. [ "$DCUDEBUG" -gt 3 ] && {
  176. print -u2 "$0 called"
  177. set -x
  178. }
  179.  
  180. RMopen 2
  181. if [ ! $? = 0 ]
  182. then
  183.     footer ""
  184.     display -w "$RM_OPEN_RDONLY" -bg $RED -fg $WHITE
  185.     call proc_loop
  186.  
  187.     RMopen 0
  188.     if [ ! $? = 0 ]
  189.     then
  190.         footer ""
  191.         display -w "$RM_OPEN_ERROR" -bg $RED -fg $WHITE
  192.         call proc_loop
  193.         return 0
  194.     fi
  195. fi
  196. RMnextkey 0
  197. RMKEY=$?
  198. return 1
  199. }
  200.  
  201. function driversinit
  202. {
  203. # driversinit()
  204. # Called once at startup from dcuinit to
  205. # initialize the driver array elements using resmgr info.
  206. # Calling/Exit State: void.
  207.  
  208. [ "$DCUDEBUG" -gt 3 ] && {
  209. print -u2 "$0 called"
  210. set -x
  211. }
  212.  
  213. typeset i dn sn
  214. DRVINDX=1
  215. for i in ${ROOT}/etc/conf/sdevice.d/*
  216. do
  217.     sn=${i#*sdevice.d/}
  218.     dn=${ROOT}/etc/conf/drvmap.d/${sn}
  219.     if [ -s $dn ]
  220.     then
  221.         readdrvmap ${sn} $dn
  222.     else
  223.         if isdriver ${ROOT}/etc/conf/mdevice.d/${sn} 
  224.         then
  225.             readsdevice ${sn} $i $DRVINDX
  226.             ALLDRIVERS="$ALLDRIVERS $DRVINDX"
  227.             let DRVINDX+=1
  228.         fi
  229.     fi
  230. done
  231. }
  232.  
  233. function boardsinit
  234. {
  235. # boardsinit()
  236. # Called once at startup from dcuinit to
  237. # initialize the board array elements using resmgr info.
  238. # Calling/Exit State: void.
  239.  
  240. [ "$DCUDEBUG" -gt 3 ] && {
  241. print -u2 "$0 called"
  242. set -x
  243. }
  244.  
  245. integer brd drv i ok
  246. LASTBOARD=1
  247. integer curkey=$RMKEY
  248. integer inst=0
  249. BDCNFGCHOICES="$Y $N"
  250.  
  251. #get each board record from resmgr
  252. while true
  253. do
  254.  
  255.     ok=1
  256.     rdRM_key $curkey $LASTBOARD $inst
  257.  
  258.  
  259.         if [ $? = 2 ]
  260.     then
  261.         ok=0
  262.     fi
  263.  
  264.     if [ $ok = 1 ]; then
  265.         if grep "^\$interface psm" ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[LASTBOARD]} 2> /dev/null > /dev/null
  266.         then
  267.             BDINTERPSM[LASTBOARD]="Y"
  268.         fi
  269.     fi
  270.  
  271.     RMnextkey $curkey
  272.     if (( curkey=$? ))
  273.     then
  274.         if [ $ok = 1 ]
  275.         then
  276.             let LASTBOARD+=1
  277.         fi
  278.         RMKEY=$curkey
  279.         inst=0
  280.     else
  281.         if [ $ok = 0 ]; then
  282.             let LASTBOARD-=1
  283.         fi
  284.         break
  285.     fi
  286. done
  287.  
  288. if [ "$DCUMAP" = Y ] 
  289. then
  290.     typeset id_matched
  291.  
  292.     brd=1
  293.     while (( $brd <= $LASTBOARD ))
  294.     do
  295.         idmatched="N"
  296.  
  297.         if [ ! "${BDMODNAME[brd]}" = "$dash" ]
  298.         then
  299.             let brd+=1
  300.             continue
  301.         fi
  302.  
  303.         drv=1
  304.         while (( $drv <= $DRVINDX ))
  305.         do
  306.             case "${BDID[brd]}" in
  307.             ${DRVBOARDID[drv]}) \
  308.                 if [ "${BDBUSTYPE[brd]}" = "${DRVBUSTYPE[drv]}" ]
  309.                 then
  310.                     if [ "${DRVVERIFY[drv]}" = V ]
  311.                     then
  312.                         silent_verify $brd $drv
  313.                         if [ $? -ne 0 ]
  314.                         then
  315.                             let drv+=1
  316.                             continue
  317.                         fi
  318.                     fi
  319.                     BDNAME[brd]="${DRVBOARDNAME[drv]}"
  320.                     BDMODNAME[brd]="${MODNAME[drv]}"
  321.                     silent_match $brd $drv
  322.                     if [ "${DRVSTATIC[drv]}" = "Y" ]
  323.                     then
  324.                         if [ "${DRVAUTOCONFIG[drv]}" = "Y" ]
  325.                         then
  326.                             dcu_action $DCU_REBOOT
  327.                         else
  328.                             dcu_action $DCU_REBUILD
  329.                         fi
  330.                     else
  331.                         if [ ! -f ${ROOT}/etc/conf/mod.d/${BDMODNAME[brd]} ]
  332.                         then
  333.                             addloadmods ${BDMODNAME[brd]}
  334.                         fi
  335.                     fi
  336.                     let drv=DRVINDX
  337.                     idmatched="Y"
  338.                 fi
  339.                 ;;
  340.             esac
  341.             let drv+=1
  342.         done
  343.  
  344.         drv=1
  345.         [ ${idmatched} = "N" ] && while (( $drv <= $DRVINDX ))
  346.         do
  347.             case "CLASS${BDCLASS[brd]}" in
  348.             ${DRVBOARDID[drv]}) \
  349.                 if [ "${BDBUSTYPE[brd]}" = "${DRVBUSTYPE[drv]}" ]
  350.                 then
  351.                     if [ "${DRVVERIFY[drv]}" = V ]
  352.                     then
  353.                         silent_verify $brd $drv
  354.                         if [ $? -ne 0 ]
  355.                         then
  356.                             let drv+=1
  357.                             continue
  358.                         fi
  359.                     fi
  360.                     BDNAME[brd]="${DRVBOARDNAME[drv]}"
  361.                     BDMODNAME[brd]="${MODNAME[drv]}"
  362.                     silent_match $brd $drv
  363.                     if [ "${DRVSTATIC[drv]}" = "Y" ]
  364.                     then
  365.                         if [ "${DRVAUTOCONFIG[drv]}" = "Y" ]
  366.                         then
  367.                             dcu_action $DCU_REBOOT
  368.                         else
  369.                             dcu_action $DCU_REBUILD
  370.                         fi
  371.                     else
  372.                         if [ ! -f ${ROOT}/etc/conf/mod.d/${BDMODNAME[brd]} ]
  373.                         then
  374.                             addloadmods ${BDMODNAME[brd]}
  375.                         fi
  376.                     fi
  377.                     let drv=DRVINDX
  378.                 fi
  379.                 ;;
  380.             esac
  381.             let drv+=1
  382.         done
  383.     
  384.         let brd+=1
  385.     done
  386. fi
  387.  
  388.  
  389. #init first free board array element
  390. NXTFREE=0
  391. let LASTBOARD+=1
  392. pushfree $LASTBOARD
  393. let LASTBOARD+=1
  394. #configure dummy end of list record
  395. setlastboard $LASTBOARD
  396.  
  397. if [ "$UNIX_INSTALL" = "Y" ] \
  398. && [ "$DCUMAP" = "Y" ]
  399. then
  400.     # then determine if first serial port is configured
  401.     if /usr/sbin/check_devs -s /dev/tty00
  402.     then
  403.         :
  404.     else
  405.         brd=1
  406.         while (( $brd <= $LASTBOARD ))
  407.         do
  408.             if [ "${BDMODNAME[brd]}" = "asyc" ] \
  409.             && [ "${BDPORTSTART[brd]}" = "3f8" ]
  410.             then
  411.                 RMdelkey ${BDKEY[brd]}
  412.                 BDMODNAME[brd]=$dash
  413.                 BDNAME[brd]=$dash
  414.                 BDCNFG[brd]="$N"
  415.                 BDTYPE[brd]=$unused
  416.                 break
  417.             fi
  418.             let brd+=1
  419.         done
  420.     fi
  421.     
  422.     # now determine if second serial port is configured
  423.     if /usr/sbin/check_devs -s /dev/tty01
  424.     then
  425.         :
  426.     else
  427.         brd=1
  428.         while (( $brd <= $LASTBOARD ))
  429.         do
  430.             if [ "${BDMODNAME[brd]}" = "asyc" ] \
  431.             && [ "${BDPORTSTART[brd]}" = "2f8" ]
  432.             then
  433.                 RMdelkey ${BDKEY[brd]}
  434.                 BDMODNAME[brd]=$dash
  435.                 BDNAME[brd]=$dash
  436.                 BDCNFG[brd]="$N"
  437.                 BDTYPE[brd]=$unused
  438.                 break
  439.             fi
  440.             let brd+=1
  441.         done
  442.     fi
  443.     
  444.     # get parallel port I/O addr from check_devs. 
  445.     typeset Sio Eio Irq
  446.     /usr/sbin/check_devs -p
  447.  
  448.     case $? in
  449.     1)
  450.         Sio=3BC
  451.         Eio=3BF
  452.         Irq=7
  453.         ;;
  454.     2)
  455.         Sio=378
  456.         Eio=37F
  457.         Irq=7
  458.         ;;
  459.     3)
  460.         Sio=278
  461.         Eio=27F
  462.         Irq=7
  463.         ;;
  464.     *)
  465.         Sio=0
  466.         Eio=0
  467.         ;;
  468.     esac
  469.  
  470.     brd=1
  471.  
  472.     while (( $brd <= $LASTBOARD ))
  473.     do
  474.         if [ "${BDMODNAME[brd]}" = "mfpd" ]
  475.         then
  476.             if [ "$Sio" != "0" ]
  477.             then
  478.                 RMdelvals ${BDKEY[brd]} "IOADDR IRQ"
  479.                 RMputvals ${BDKEY[brd]} "IOADDR IRQ" "$Sio $Eio $Irq"
  480.                 BDPORTSTART[brd]="$Sio"
  481.                 BDPORTEND[brd]="$Eio"
  482.                 BDIRQ[brd]="$Irq"
  483.             else
  484.                 RMdelkey ${BDKEY[brd]}
  485.                 BDMODNAME[brd]=$dash
  486.                 BDNAME[brd]=$dash
  487.                 BDCNFG[brd]="$N"
  488.                 BDTYPE[brd]=$unused
  489.             fi
  490.             break
  491.         fi
  492.  
  493.         let brd+=1
  494.     done
  495. fi
  496. RMentryconf
  497. }
  498.  
  499. function popfree
  500. {
  501. # popfree()
  502. # Called to pop a boards array element.
  503. # It will grow boards array if free stack is empty.
  504. # Calling/Exit State: next bd_array_index.
  505.  
  506. [ "$DCUDEBUG" -gt 3 ] && {
  507. print -u2 "$0 called"
  508. set -x
  509. }
  510. integer i nxt=$NXTFREE
  511.  
  512. BDTYPE[$NXTFREE]=$unused
  513. BDID[$NXTFREE]=''
  514. BDCLASS[$NXTFREE]=''
  515. BDIRQ[$NXTFREE]=''
  516. BDPORTSTART[$NXTFREE]=''
  517. BDPORTEND[$NXTFREE]=''
  518. BDADDRSTART[$NXTFREE]=''
  519. BDADDREND[$NXTFREE]=''
  520. BDDMA[$NXTFREE]=''
  521.  
  522. BDKEY[$NXTFREE]=''
  523. BDCHGS[$NXTFREE]=''
  524. BDCNFG[$NXTFREE]=''
  525. BDNAME[$NXTFREE]=''
  526. BDMODNAME[$NXTFREE]=''
  527. BDMODINDX[$NXTFREE]=''
  528. BDID[$NXTFREE]=''
  529. BDIRQ[$NXTFREE]=''
  530. BDBUSTYPE[$NXTFREE]=''
  531.  
  532. NXTFREE="${BDLNK[$NXTFREE]}"
  533. if (( !NXTFREE ))
  534. then
  535.     let i=LASTBOARD+1
  536.     pushfree $i
  537.     let i=LASTBOARD+2
  538.     setlastboard $i
  539. fi
  540. return $nxt
  541. }
  542.  
  543. function pushfree
  544. {
  545. # pushfree(bd_array_index)
  546. # Called to add to the free boards array stack.
  547. # Calling/Exit State: void.
  548.  
  549. [ "$DCUDEBUG" -gt 3 ] && {
  550. print -u2 "$0 called"
  551. set -x
  552. }
  553.  
  554. BDLNK[$1]=$NXTFREE
  555. NXTFREE=$1
  556. BDTYPE[$1]=$unused
  557. }
  558.  
  559. function setlastboard
  560. {
  561. # setlastboard(bd_array_indx)
  562. # Called to assign last boardarray element.
  563. # Calling/Exit State: void.
  564. [ "$DCUDEBUG" -gt 3 ] && {
  565. print -u2 "$0 called"
  566. set -x
  567. }
  568.  
  569. BDTYPE[$LASTBOARD]=$unused
  570. let LASTBOARD=$1
  571. mkboard $LASTBOARD
  572. BDTYPE[$LASTBOARD]=$none
  573.  
  574. }
  575.  
  576. function lookupdrv
  577. {
  578. # lookupdrv(bd_array_index)
  579. # Called to verify that the board array index
  580. # in question has a corresponding driver index.
  581. # Calling/Exit State: 0 for failure and non-zero DRV index for success.
  582.  
  583. [ "$DCUDEBUG" -gt 3 ] && {
  584. print -u2 "$0 called"
  585. set -x
  586. }
  587.  
  588. integer rc=0 i=1
  589. FNDDRVBOARDNAME=""
  590. FNDMODNAME=""
  591. while (( $i < $DRVINDX ))
  592. do
  593.      if [ "${BDMODNAME[$1]}" = "${MODNAME[i]}" ]
  594.     then
  595.         FNDMODNAME="${MODNAME[i]}"
  596.          if [ "${MODNAME[i]}" = "${MODNAME[i-1]}" ] \
  597.          || [ "${MODNAME[i]}" = "${MODNAME[i+1]}" ]
  598.         then
  599.             case ${DRVBUSTYPE[i]} in
  600.             $isa|$unknown|"")
  601.                 if [ "$(cmd grep -c "^|ISA" /etc/conf/drvmap.d/${MODNAME[i]})" = "1" ]
  602.                 then
  603.                     FNDDRVBOARDNAME="${DRVBOARDNAME[i]}"
  604.                 else
  605.                     FNDDRVBOARDNAME="${DRVBRAND[i]}"
  606.                     DRVBOARDNAMEFULL[i]="${DRVBRAND[i]}"
  607.  
  608.                     if [ ${#FNDDRVBOARDNAME} -gt 20 ]
  609.                     then
  610.                         typeset -L20 trunc_bdname="${FNDDRVBOARDNAME}"
  611.                         FNDDRVBOARDNAME="$trunc_bdname"
  612.                     fi
  613.                 fi
  614.  
  615.                 rc=$i
  616.                 break
  617.                 ;;
  618.             *)
  619.                 FNDDRVBOARDNAME="${MODNAME[i]}"
  620.                 ;;
  621.             esac
  622.         else
  623.             FNDDRVBOARDNAME="${DRVBOARDNAME[i]}"
  624.             if [ -n "${DRVBUSTYPE[i]}" ]
  625.             then
  626.                 BDBUSTYPE[$1]="${DRVBUSTYPE[i]}"
  627.             fi
  628.             rc=$i
  629.             break
  630.         fi
  631.         if [ "${BDID[$1]}" = "${DRVBOARDID[i]}" ]
  632.         then
  633.             FNDDRVBOARDNAME="${DRVBOARDNAME[i]}"
  634.             if [ -n "${DRVBUSTYPE[i]}" ]
  635.             then
  636.                 BDBUSTYPE[$1]="${DRVBUSTYPE[i]}"
  637.             fi
  638.             rc=$i
  639.             break
  640.         fi
  641.     fi
  642.     let i+=1
  643. done
  644. return $rc
  645. }
  646.  
  647. function lookupisa
  648. {
  649. # lookupisa(bd_array_index)
  650. # Called to get the first non-PCU instance in drvmap.d file.
  651. # Calling/Exit State: 0 for failure and non-zero DRV index for success.
  652.  
  653. [ "$DCUDEBUG" -gt 3 ] && {
  654. print -u2 "$0 called"
  655. set -x
  656. }
  657.  
  658. integer rc=0 i=1
  659. while (( $i < $DRVINDX ))
  660. do
  661.      if [ "${BDMODNAME[$1]}" = "${MODNAME[i]}" ]
  662.     then
  663.         if [ -z "${DRVBUSTYPE[i]}" -o "${DRVBUSTYPE[i]}" = "$isa" ]
  664.         then
  665.             rc=$i
  666.             break
  667.         fi
  668.     fi
  669.     let i+=1
  670. done
  671. return $rc
  672. }
  673.  
  674. function readdrvmap
  675. {
  676. # readdrvmap(MODNAME, drvmap_filename)
  677. # Called to read drvmap file for hardware device drivers
  678. # to initialize variables.
  679. # Calling/Exit State: void.
  680.  
  681. [ "$DCUDEBUG" -gt 3 ] && {
  682. print -u2 "$0 called"
  683. set -x
  684. }
  685. integer drv=$DRVINDX
  686. typeset ifs=$IFS
  687. typeset bdid bustype drvname bdname bcfgfile autoconfig category verify brand
  688. typeset mn dpath
  689. typeset throaway
  690. typeset -L20 trunc_bdname
  691.  
  692. dpath=${2%/*/*}
  693. mn=sdevice.d/$1
  694. [ ! -d ${dpath}/sdevice.d ] && mn=${1}/System
  695. {
  696. IFS="$PIPE"
  697. while read drvname autoconfig verify category brand
  698. do
  699.     if [ ! "$drvname" = "$1" ]
  700.     then
  701.         continue
  702.     fi
  703.     while read throaway bustype bdid bdname bcfgfile
  704.     do
  705.         IFS=$ifs
  706.         readsdevice $1 ${dpath}/$mn $drv
  707.         DRVBOARDID[drv]=$bdid
  708.         typeset -u bustype
  709.         DRVBUSTYPE[drv]=$bustype
  710.         MODNAME[drv]=$drvname
  711.         DRVBOARDNAMEFULL[drv]="$bdname"
  712.         integer Length=${#bdname}
  713.         if [ Length -gt 20 ]
  714.         then
  715.             trunc_bdname="$bdname"
  716.             DRVBOARDNAME[drv]="$trunc_bdname"
  717.         else
  718.             DRVBOARDNAME[drv]="$bdname"
  719.         fi
  720.         case "${category}" in
  721.             "Network Interface Cards") \
  722.                 let NETCAT+=1
  723.                 DRVCATEGORY[drv]="$network_interface_cards"
  724.                 ;;
  725.             "Host Bus Adapters") \
  726.                 let HOSTCAT+=1 
  727.                 DRVCATEGORY[drv]="$host_bus_adapters"
  728.                 ;;
  729.             "Communications Cards") \
  730.                 let COMMCAT+=1
  731.                 DRVCATEGORY[drv]="$communications_cards"
  732.                 ;;
  733.             "Video Cards") \
  734.                 let VIDEOCAT+=1
  735.                 DRVCATEGORY[drv]="$video_cards"
  736.                 ;;
  737.             "Sound Boards") \
  738.                 let SOUNDCAT+=1
  739.                 DRVCATEGORY[drv]="$sound_boards"
  740.                 ;;
  741.             *)    let MISCCAT+=1
  742.                 DRVCATEGORY[drv]="$miscellaneous"
  743.                 ;;
  744.         esac
  745.         DRVVERIFY[drv]="$verify"
  746.         DRVAUTOCONFIG[drv]=$autoconfig
  747.         DRVBRAND[drv]=$brand
  748.         ALLDRIVERS="$ALLDRIVERS $drv"
  749.         DRVBCFGFILE[drv]=""
  750.         let drv+=1
  751.         IFS="$PIPE"
  752.     done 
  753. done 
  754. }<$2 
  755. IFS=$ifs
  756. DRVINDX=$drv
  757. }
  758.  
  759. function readsdevice
  760. {
  761. # readsdevice(MODNAME, sdevice_filename, drv_array_index)
  762. # Called to read sdevice file for hardware device drivers
  763. # to initialize variables.
  764. # Calling/Exit State: void.
  765. # ALLDRIVERS variable is expanded and DRVINDX variable is incremented.
  766.  
  767. [ "$DCUDEBUG" -gt 3 ] && {
  768. print -u2 "$0 called"
  769. set -x
  770. }
  771. integer drv=$3
  772. typeset drvname isc
  773. typeset -R8 name8
  774. typeset -R8 isc8
  775. typeset -R8 unit
  776. typeset -R8 ipl
  777. typeset -R8 itype
  778. typeset -R8 irq
  779. typeset -R8 ports
  780. typeset -R8 porte
  781. typeset -R8 mems
  782. typeset -R8 meme
  783. typeset -R8 dma
  784. typeset -R8 cpu
  785. integer t=0
  786.  
  787. if [  ! "${1}" = "$SDV" ]
  788. then
  789.     SDVCNFG=N
  790.     SDV=$1
  791.     SDVSTATIC=""
  792.     SDVMODNAME=$1
  793.     SDVMODCHOICES=""
  794.     SDVISCCHOICES=""
  795.     SDVUNITCHOICES=""
  796.     SDVIPLCHOICES=""
  797.     SDVITYPECHOICES=""
  798.     SDVIRQCHOICES=""
  799.     SDVPORTSCHOICES=""
  800.     SDVPORTECHOICES=""
  801.     SDVADDRSCHOICES=""
  802.     SDVADDRECHOICES=""
  803.     SDVDMACHOICES=""
  804.     SDVCPUCHOICES=""
  805.     SDVPORTS=""
  806.     SDVADDRS=""
  807.     while read drvname isc unit ipl itype irq ports porte mems meme dma cpu
  808.     do
  809.         if [ "$drvname" = "\$static" ]
  810.         then
  811.             SDVSTATIC="Y"
  812.             continue
  813.         fi
  814.         if [ ! "$drvname" = "$1" ]
  815.         then
  816.             continue
  817.         fi
  818.         if [ "$isc" = Y ]
  819.         then
  820.             SDVCNFG=Y
  821.             let t+=1
  822.         fi
  823.         name8="$drvname"
  824.         if [ "$isc" = Y ]
  825.         then
  826.             isc8="$Y"
  827.         else
  828.             isc8="$N"
  829.         fi
  830.             
  831.         SDVMODCHOICES="$SDVMODCHOICES    $name8"
  832.         SDVISCCHOICES="$SDVISCCHOICES    $isc8"
  833.         SDVUNITCHOICES="$SDVUNITCHOICES    $unit"
  834.         SDVIPLCHOICES="$SDVIPLCHOICES    $ipl"
  835.         SDVITYPECHOICES="$SDVITYPECHOICES    $itype"
  836.         SDVIRQCHOICES="$SDVIRQCHOICES    $irq"
  837.         SDVPORTSCHOICES="$SDVPORTSCHOICES    $ports"
  838.         SDVPORTECHOICES="$SDVPORTECHOICES    $porte"
  839.         SDVADDRSCHOICES="$SDVADDRSCHOICES    $mems"
  840.         SDVADDRECHOICES="$SDVADDRECHOICES    $meme"
  841.         SDVDMACHOICES="$SDVDMACHOICES    $dma"
  842.         SDVCPUCHOICES="$SDVCPUCHOICES    $cpu"
  843.     done <$2
  844.     eval "$1"=\$t
  845.     MODNAMECHOICES="$SDVMODNAME $MODNAMECHOICES"
  846. fi
  847. DRVSTATIC[drv]="$SDVSTATIC"
  848. DRVCNFG[drv]="$SDVCNFG"
  849. MODNAME[drv]="$SDVMODNAME"
  850. DRVMODCHOICES[drv]="$SDVMODCHOICES"
  851. DRVISCCHOICES[drv]="$SDVISCCHOICES"
  852. DRVUNITCHOICES[drv]="$SDVUNITCHOICES"
  853. DRVIPLCHOICES[drv]="$SDVIPLCHOICES"
  854. DRVITYPECHOICES[drv]="$SDVITYPECHOICES"
  855. DRVIRQCHOICES[drv]="$SDVIRQCHOICES"
  856. DRVPORTSCHOICES[drv]="$SDVPORTSCHOICES"
  857. DRVPORTECHOICES[drv]="$SDVPORTECHOICES"
  858. DRVMEMSCHOICES[drv]="$SDVADDRSCHOICES"
  859. DRVMEMECHOICES[drv]="$SDVADDRECHOICES"
  860. DRVDMACHOICES[drv]="$SDVDMACHOICES"
  861. DRVCPUCHOICES[drv]="$SDVCPUCHOICES"
  862. DRVBOARDID[drv]="$SDVMODNAME"
  863. DRVBOARDNAME[drv]="$SDVMODNAME"
  864. DRVAUTOCONFIG[drv]=N
  865. DRVVERIFY[drv]="N"
  866. if [ ! -f ${ROOT}/etc/conf/drvmap.d/$1 ]
  867. then
  868.     DRVCATEGORY[drv]="$miscellaneous"
  869.     let MISCCAT+=1
  870. fi
  871. DRVBUSTYPE[drv]="$unknown"
  872. }
  873.  
  874. function mkboard
  875. {
  876. # mkboard(bd_array_index)
  877. # Called from the setlastboard function
  878. # to initialize variables for designated board.
  879. # Calling/Exit State: void.
  880.  
  881. [ "$DCUDEBUG" -gt 3 ] && {
  882. print -u2 "$0 called"
  883. set -x
  884. }
  885.  
  886. BDTYPE[$1]=$unused
  887. BDCNFG[$1]=''
  888. BDNAME[$1]=''
  889. BDID[$1]=''
  890. BDCLASS[$1]=''
  891. BDIRQ[$1]=''
  892. BDPORTSTART[$1]=''
  893. BDPORTEND[$1]=''
  894. BDADDRSTART[$1]=''
  895. BDADDREND[$1]=''
  896. BDDMA[$1]=''
  897.  
  898. }
  899.  
  900. function mkdriver
  901. {
  902. # mkdriver(drivername, drv_array_index) NOT_CURRENTLY_USED
  903. # Called from the ? function
  904. # to initialize variables for designated drivers.
  905. # Calling/Exit State: void.
  906.  
  907. [ "$DCUDEBUG" -gt 3 ] && {
  908. print -u2 "$0 called"
  909. set -x
  910. }
  911.  
  912. integer drv=$2
  913. MODNAME[drv]="$1"
  914. DRVBOARDNAME[drv]="$1"
  915. DRVCNFG[drv]="N"
  916. DRVIPLCHOICES[drv]=""
  917. DRVITYPECHOICES[drv]=""
  918. DRVIRQCHOICES[drv]=""
  919. DRVPORTSCHOICES[drv]=""
  920. DRVPORTECHOICES[drv]=""
  921. DRVMEMSCHOICES[drv]=""
  922. DRVMEMECHOICES[drv]=""
  923. DRVDMACHOICES[drv]=""
  924. DRVBOARDID[drv]="$1"
  925. DRVAUTOCONFIG[drv]=N
  926. DRVBUSTYPE[drv]=$unknown
  927. }
  928.  
  929. function isdriver
  930. {
  931. # isdriver(mdevice_filename)
  932. # Called to read the mdevice file is for a device driver
  933. # checking for an 'h' or 'H' hardware flag to indicate that it is a
  934. # driver for the DCU.
  935. # Calling/Exit State: 0 for success and 1 for failure.
  936.  
  937. [ "$DCUDEBUG" -gt 3 ] && {
  938. print -u2 "$0 called"
  939. set -x
  940. }
  941. typeset -u drvname pre char ord bmaj cmaj
  942. typeset x w
  943.  
  944. w=${1#*mdevice.d/}
  945. grep ^$w $1 2> /dev/null | read drvname pre char ord bmaj cmaj 
  946. case "$char" in
  947. *h*|*H*)
  948.     return 0
  949.     ;;
  950. *)
  951.     return 1
  952.     ;;
  953. esac
  954. }
  955.  
  956. function choose_name
  957. {
  958. # choose_name(bd_array_index)
  959. # Called when the Choices key for the Device Name field is selected
  960. # to display the Choices.
  961. # Calling/Exit State: void.
  962.  
  963. [ "$DCUDEBUG" -gt 3 ] && {
  964. print -u2 "$0 called"
  965. set -x
  966. }
  967.  
  968. integer i=0 
  969. typeset m
  970.  
  971. unset DEVNAMECHOICES
  972. DEVNAMECHOICES[i]="${BDNAME[$1]}"
  973. let i+=1
  974.  
  975. for m in $MODNAMECHOICES
  976. do
  977.     DEVNAMECHOICES[i]="$m"
  978.     let i+=1
  979. done
  980.  
  981. CHOOSE_TITLE="$boardname $CHOICES [${BDNAME[$1]}]"
  982. CHOOSE_FOOTER="$DCU_CHOOSE_FOOTER"
  983. choose "${BDNAME[$1]}" "${DEVNAMECHOICES[@]}"
  984. }
  985.  
  986. function check_name
  987. {
  988. # check_name(bd_array_index)
  989. # Called when the Device Name field is changed to perform validation checking.
  990. # Calling/Exit State: 0 for success and 1 for failure.
  991.  
  992. [ "$DCUDEBUG" -gt 3 ] && {
  993. print -u2 "$0 called"
  994. set -x
  995. }
  996. if (( !FLD_CHANGED ))
  997. then
  998.     return 0
  999. fi
  1000.  
  1001. typeset m 
  1002. for m in $MODNAMECHOICES
  1003. do
  1004.     if [ "$m" = "${BDNAME[$1]}" ]
  1005.     then
  1006.         BDMODNAME[$1]="${BDNAME[$1]}"
  1007.         if [ "${BDNAME[$1]}" != "$unused" ]
  1008.         then
  1009.             set_adv_params $1
  1010.         fi
  1011.         error_pending=''
  1012.         integer x=${BDCHGS[$1]}
  1013.         let x\|=$NAME_CHG
  1014.         BDCHGS[$1]=$x
  1015.         return 0
  1016.     fi
  1017. done
  1018. msgnoerr "$BD_BAD_NAME"
  1019. return 1
  1020. }
  1021.  
  1022. function choose_unit
  1023. {
  1024. # choose_unit(bd_array_index)
  1025. # Called when the Choices key for the UNIT field is selected
  1026. # to display the GENERIC_NO_CHOICES message.
  1027. # Calling/Exit State: void.
  1028.  
  1029. [ "$DCUDEBUG" -gt 3 ] && {
  1030. print -u2 "$0 called"
  1031. set -x
  1032. }
  1033. msgnoerr "$GENERIC_NO_CHOICES"
  1034. }
  1035.  
  1036. function check_unit
  1037. {
  1038. # check_unit(bd_array_index)
  1039. # Called when the UNIT field is changed to perform validation checking.
  1040. # Calling/Exit State: 0 for success and 1 for failure.
  1041.  
  1042. [ "$DCUDEBUG" -gt 3 ] && {
  1043. print -u2 "$0 called"
  1044. set -x
  1045. }
  1046.  
  1047. if (( !FLD_CHANGED ))
  1048. then
  1049.     return 0
  1050. fi
  1051.  
  1052. case "${BDUNIT[$1]}" in
  1053. -[0-9]*([0-9]))
  1054.     error_pending=''
  1055.     integer x=${BDCHGS[$1]}
  1056.     let x\|=$UNIT_CHG
  1057.     BDCHGS[$1]=$x
  1058.     return 0
  1059.     ;;
  1060. [0-9]*([0-9]))
  1061.     error_pending=''
  1062.     integer x=${BDCHGS[$1]}
  1063.     let x\|=$UNIT_CHG
  1064.     BDCHGS[$1]=$x
  1065.     return 0
  1066.     ;;
  1067. *)
  1068.     msgnoerr "$BD_BAD_UNIT"
  1069.     return 1
  1070. esac
  1071. }
  1072.  
  1073.  
  1074. function choose_ipl
  1075. {
  1076. # choose_ipl(bd_array_index)
  1077. # Called when the Choices key for the IPL field is selected
  1078. # to display the Choices.
  1079. # Calling/Exit State: void.
  1080.  
  1081. [ "$DCUDEBUG" -gt 3 ] && {
  1082. print -u2 "$0 called"
  1083. set -x
  1084. }
  1085. CHOOSE_TITLE="$boardipl $CHOICES"
  1086. CHOOSE_FOOTER="$DCU_CHOOSE_FOOTER"
  1087. choose "${BDIPL[$1]}" $IPLCHOICES
  1088. }
  1089.  
  1090. function check_ipl
  1091. {
  1092. # check_ipl(bd_array_index)
  1093. # Called when the IPL field is changed to perform validation checking.
  1094. # Calling/Exit State: 0 for success and 1 for failure.
  1095.  
  1096. [ "$DCUDEBUG" -gt 3 ] && {
  1097. print -u2 "$0 called"
  1098. set -x
  1099. }
  1100.  
  1101. if (( !FLD_CHANGED ))
  1102. then
  1103.     return 0
  1104. fi
  1105.  
  1106. case "${BDIPL[$1]}" in
  1107. [0-9])
  1108.     if [ ${BDIPL[$1]} -lt 0 -o ${BDIPL[$1]} -gt 9 ]
  1109.     then
  1110.         msgnoerr "$BD_BAD_IPL"
  1111.         return 1
  1112.     else
  1113.         error_pending=''
  1114.         integer x=${BDCHGS[$1]}
  1115.         let x\|=$IPL_CHG
  1116.         BDCHGS[$1]=$x
  1117.         return 0
  1118.     fi
  1119.     ;;
  1120. *)
  1121.     msgnoerr "$BD_BAD_IPL"
  1122.     return 1
  1123. esac
  1124. }
  1125.  
  1126. function choose_itype
  1127. {
  1128. # choose_itype(bd_array_index)
  1129. # Called when the Choices key for the ITYPE field is selected
  1130. # to display the GENERIC_NO_CHOICES message.
  1131. # Calling/Exit State: void.
  1132.  
  1133. [ "$DCUDEBUG" -gt 3 ] && {
  1134. print -u2 "$0 called"
  1135. set -x
  1136. }
  1137. CHOOSE_TITLE="$boarditype $CHOICES"
  1138. CHOOSE_FOOTER="$DCU_CHOOSE_FOOTER"
  1139. choose "${BDITYPE[$1]}" $ITYPECHOICES
  1140. }
  1141.  
  1142. function check_itype
  1143. {
  1144. # check_itype(bd_array_index)
  1145. # Called when the ITYPE field is changed to perform validation checking.
  1146. # Calling/Exit State: 0 for success and 1 for failure.
  1147.  
  1148. [ "$DCUDEBUG" -gt 3 ] && {
  1149. print -u2 "$0 called"
  1150. set -x
  1151. }
  1152.  
  1153. if (( !FLD_CHANGED ))
  1154. then
  1155.     return 0
  1156. fi
  1157.  
  1158. case "${BDITYPE[$1]}" in
  1159. [0-4])
  1160.     if [ ${BDITYPE[$1]} -lt 0 -o ${BDITYPE[$1]} -gt 4 ]
  1161.     then
  1162.         msgnoerr "$BD_BAD_ITYPE"
  1163.         return 1
  1164.     else
  1165.         error_pending=''
  1166.         integer x=${BDCHGS[$1]}
  1167.         let x\|=$ITYPE_CHG
  1168.         BDCHGS[$1]=$x
  1169.         return 0
  1170.     fi
  1171.     ;;
  1172. *)
  1173.     msgnoerr "$BD_BAD_ITYPE"
  1174.     return 1
  1175. esac
  1176. }
  1177.  
  1178. function choose_irq
  1179. {
  1180. # choose_irq(bd_array_index)
  1181. # Called when the Choices key for the IRQ field is selected
  1182. # to display the GENERIC_NO_CHOICES message.
  1183. # Calling/Exit State: void.
  1184.  
  1185. [ "$DCUDEBUG" -gt 3 ] && {
  1186. print -u2 "$0 called"
  1187. set -x
  1188. }
  1189. msgnoerr "$GENERIC_NO_CHOICES"
  1190. }
  1191.  
  1192. function check_irq
  1193. {
  1194. # check_irq(bd_array_index)
  1195. # Called when the IRQ field is changed to perform validation checking.
  1196. # Calling/Exit State: 0 for success and 1 for failure.
  1197.  
  1198. [ "$DCUDEBUG" -gt 3 ] && {
  1199. print -u2 "$0 called"
  1200. set -x
  1201. }
  1202.  
  1203. if (( !FLD_CHANGED ))
  1204. then
  1205.     IRQCHKD=""
  1206.     return 0
  1207. fi
  1208.  
  1209. if [ "$IRQCHKD" = "${BDIRQ[$1]}" ]
  1210. then
  1211.     IRQCHKD=""
  1212.     return 0
  1213. fi
  1214.  
  1215.  
  1216. case "${BDIRQ[$1]}" in
  1217. -)
  1218.     error_pending=''
  1219.     integer x=${BDCHGS[$1]}
  1220.     let x\|=$IRQ_CHG
  1221.     BDCHGS[$1]=$x
  1222.     IRQCHKD=""
  1223.     return 0
  1224.     ;;
  1225. [0-9]*([0-9]))
  1226.     
  1227.     if [ ${BDIRQ[$1]} -lt 0 -o ${BDIRQ[$1]} -gt 15 ]
  1228.     then
  1229.         msgnoerr "$BD_BAD_IRQ"
  1230.         return 1
  1231.     else
  1232.         error_pending=''
  1233.         integer x=${BDCHGS[$1]}
  1234.         let x\|=$IRQ_CHG
  1235.         BDCHGS[$1]=$x
  1236.         irq_conflict $1
  1237.         if [ "$?" = 0 ]
  1238.         then
  1239.             IRQCHKD=""
  1240.         fi
  1241.         return 0
  1242.     fi
  1243.     ;;
  1244. *)
  1245.     msgnoerr "$BD_BAD_IRQ"
  1246.     return 1
  1247.     ;;
  1248. esac
  1249. }
  1250.  
  1251. function irq_conflict
  1252. {
  1253. # irq_conflict(bd_array_index)
  1254. # Called when the IRQ field is changed to perform conflict checking.
  1255. # A special flag is set to allow the field to be exited
  1256. # if a conflict is displayed.
  1257. # Calling/Exit State: 0 for success and 1 for failure.
  1258.  
  1259. [ "$DCUDEBUG" -gt 3 ] && {
  1260. print -u2 "$0 called"
  1261. set -x
  1262. }
  1263.  
  1264. if [ "${BDCNFG[$1]}" = "$N" ] \
  1265. || [ -z "${BDNAME[$1]}" ] \
  1266. || [ "${BDIRQ[$1]}" = "$dash" ] \
  1267. || [ "${BDIRQ[$1]}" = "0" ] \
  1268. || [ "${BDNAME[$1]}" = "$dash" ] \
  1269. || [ "${BDNAME[$1]}" = "$unused" ] \
  1270. || [ "${BDNAME[$1]}" = "$unknown" ] 
  1271. then
  1272.     return 0
  1273. fi
  1274.  
  1275. typeset MESSAGE=""
  1276. typeset brd=1
  1277. while (( $brd <= $LASTBOARD ))
  1278. do
  1279.     if [ "$brd" = "$1" ] \
  1280.     || [ ! "${BDIRQ[brd]}" = "${BDIRQ[$1]}" ] \
  1281.     || [ "${BDCNFG[brd]}" = "$N" ] \
  1282.     || [ -z "${BDNAME[brd]}" ] \
  1283.     || [ "${BDIRQ[brd]}" = "$dash" ] \
  1284.     || [ "${BDNAME[brd]}" = "$dash" ] \
  1285.     || [ "${BDNAME[brd]}" = "$unused" ] \
  1286.     || [ "${BDNAME[brd]}" = "$unknown" ] 
  1287.     then
  1288.         let brd+=1
  1289.         continue
  1290.     fi
  1291.     if [ "${BDINTERPSM[$1]}" = "Y" ] \
  1292.     && [ "${BDINTERPSM[brd]}" = "Y" ]
  1293.     then
  1294.         let brd+=1
  1295.         continue
  1296.     fi
  1297.  
  1298.     MESSAGE=""
  1299.     if [ "${BDITYPE[brd]}" = 1 ] || [ "${BDITYPE[$1]}" = 1 ] 
  1300.     then
  1301.         MESSAGE="$IRQNOSHARE"
  1302.         break
  1303.     fi
  1304.  
  1305.     if [ "${BDITYPE[brd]}" = 2 ] && [ "${BDITYPE[$1]}" = 2 ] \
  1306.     && [ ! "${BDMODNAME[brd]}" = "${BDMODNAME[$1]}" ]
  1307.     then
  1308.         MESSAGE="$IRQSELFSHARE"
  1309.         break
  1310.     fi
  1311.  
  1312.     if [ "${BDITYPE[brd]}" = 3 ] && [ "${BDITYPE[$1]}" = 4 ]
  1313.     then
  1314.         MESSAGE="$IRQNOSHARE"
  1315.         break
  1316.     fi
  1317.  
  1318.     if [ "${BDITYPE[brd]}" = 4 ] && [ "${BDITYPE[$1]}" = 3 ]
  1319.     then
  1320.         MESSAGE="$IRQNOSHARE"
  1321.         break
  1322.     fi
  1323.  
  1324.     let brd+=1
  1325. done
  1326.  
  1327. if [ -n "$MESSAGE" ]
  1328. then
  1329.     IRQCHKD="${BDIRQ[$1]}"
  1330.     display  -w "ERROR:
  1331. $boardname=${BDNAME[$1]}, $boardipl=${BDIPL[$1]}, $boarditype=${BDITYPE[$1]}, $boardirq=${BDIRQ[$1]}.
  1332. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1333. $MESSAGE
  1334. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1335. $boardname=${BDNAME[brd]}, $boardipl=${BDIPL[brd]}, $boarditype=${BDITYPE[brd]}, $boardirq=${BDIRQ[brd]}." \
  1336.         -bg $RED -fg $WHITE
  1337.     footer $GENERIC_CONTINUE_FOOTER
  1338.     return 1
  1339. fi
  1340. return 0
  1341. }
  1342.  
  1343. function choose_ports
  1344. {
  1345. # choose_ports(bd_array_index)
  1346. # Called when the Choices key for the IOStart field is selected
  1347. # to display the GENERIC_NO_CHOICES message.
  1348. # Calling/Exit State: void.
  1349.  
  1350. [ "$DCUDEBUG" -gt 3 ] && {
  1351. print -u2 "$0 called"
  1352. set -x
  1353. }
  1354. msgnoerr "$GENERIC_NO_CHOICES"
  1355. }
  1356.  
  1357. function check_ports
  1358. {
  1359. # check_ports(bd_array_index)
  1360. # Called when the IOStart field is changed to perform validation checking.
  1361. # Calling/Exit State: 0 for success and 1 for failure.
  1362.  
  1363. [ "$DCUDEBUG" -gt 3 ] && {
  1364. print -u2 "$0 called"
  1365. set -x
  1366. }
  1367.  
  1368. if (( !FLD_CHANGED ))
  1369. then
  1370.         IOSCHKD=""
  1371.     return 0
  1372. fi
  1373.  
  1374. if [ "$IOSCHKD" = "${BDPORTSTART[$1]}" ]
  1375. then
  1376.         IOSCHKD=""
  1377.         return 0
  1378. fi
  1379.  
  1380. case "${BDPORTSTART[$1]}" in
  1381. "-")
  1382.     integer x=${BDCHGS[$1]}
  1383.     let x\|=$IOS_CHG
  1384.     BDCHGS[$1]=$x
  1385.     error_pending=''
  1386.         IOSCHKD=""
  1387.     return 0
  1388.     ;;
  1389. [0-9abcdefABCDEF]*([0-9abcdefABCDEF]))
  1390.     integer x=${BDCHGS[$1]}
  1391.     let x\|=$IOS_CHG
  1392.     BDCHGS[$1]=$x
  1393.     error_pending=''
  1394.     ports_conflict $1
  1395.     if [ "$?" = 0 ]
  1396.     then
  1397.             IOSCHKD=""
  1398.     fi
  1399.     return 0
  1400.     ;;
  1401. *)
  1402.     msgnoerr "$BD_BAD_PORT"
  1403.     return 1
  1404.     ;;
  1405. esac
  1406. }
  1407.  
  1408. function ports_conflict
  1409. {
  1410. # ports_conflict(bd_array_index)
  1411. # Called when the IOStart field is changed to perform conflict checking.
  1412. # A special flag is set to allow the field to be exited
  1413. # if a conflict is displayed.
  1414. # Calling/Exit State: 0 for success and 1 for failure.
  1415.  
  1416. [ "$DCUDEBUG" -gt 3 ] && {
  1417. print -u2 "$0 called"
  1418. set -x
  1419. }
  1420.  
  1421. if [ "${BDCNFG[$1]}" = "$N" ] \
  1422. || [ -z "${BDNAME[$1]}" ] \
  1423. || [ "${BDNAME[$1]}" = "$dash" ] \
  1424. || [ "${BDNAME[$1]}" = "$unused" ] \
  1425. || [ "${BDNAME[$1]}" = "$unknown" ] \
  1426. || [ "${BDPORTSTART[$1]}" = "$dash" ] \
  1427. || [ "${BDPORTSTART[$1]}" = "0" -a "${BDPORTEND[$1]}" = "0" ]
  1428. then
  1429.     return 0
  1430. fi
  1431.  
  1432. typeset x ports ios ioe
  1433. x=${BDPORTSTART[$1]}
  1434. typeset -i16 ports=16#$x
  1435.  
  1436. typeset brd=1
  1437. while (( $brd <= $LASTBOARD ))
  1438. do
  1439.     if [ "$brd" = "$1" ] \
  1440.     || [ "${BDCNFG[brd]}" = "$N" ] \
  1441.     || [ -z "${BDNAME[brd]}" ] \
  1442.     || [ "${BDPORTSTART[brd]}" = "$dash" ] \
  1443.     || [ "${BDNAME[brd]}" = "$dash" ] \
  1444.     || [ "${BDNAME[brd]}" = "$unused" ] \
  1445.     || [ "${BDMODNAME[brd]}" = "$unknown" ] 
  1446.     then
  1447.         let brd+=1
  1448.         continue
  1449.     fi
  1450.  
  1451.     if [ "${BDINTERPSM[$1]}" = "Y" ] \
  1452.     && [ "${BDINTERPSM[brd]}" = "Y" ]
  1453.     then
  1454.         let brd+=1
  1455.         continue
  1456.     fi
  1457.  
  1458.     if [ "${BDPORTSTART[brd]}" = "$dash" ] \
  1459.     || [ "${BDPORTEND[brd]}" = "$dash" ]
  1460.     then
  1461.         let brd+=1
  1462.         continue
  1463.     fi
  1464.  
  1465.     if [ "${BDPORTSTART[brd]}" = "0" ] \
  1466.     && [ "${BDPORTEND[brd]}" = "0" ]
  1467.     then
  1468.         let brd+=1
  1469.         continue
  1470.     fi
  1471.  
  1472.     x=${BDPORTSTART[brd]}
  1473.     typeset -i16 ios=16#$x
  1474.     x=${BDPORTEND[brd]}
  1475.     typeset -i16 ioe=16#$x
  1476.  
  1477.     if [ ports -ge ios -a ports -le ioe ]
  1478.     then
  1479.         typeset allow1 allow2
  1480.         allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} O
  1481.         allow1=$?
  1482.         allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[brd]} O
  1483.         allow2=$?
  1484.         if (( allow1 && allow2 ))
  1485.         then
  1486.             let brd+=1
  1487.             continue
  1488.         fi
  1489.             IOSCHKD="${BDPORTSTART[$1]}"
  1490.         display  -w "ERROR:
  1491. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  1492. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1493. $IOSCONF
  1494. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1495. $boardname=${BDNAME[brd]}, $boardios=${BDPORTSTART[brd]}, $boardioe=${BDPORTEND[brd]}." \
  1496.             -bg $RED -fg $WHITE
  1497.         footer $GENERIC_CONTINUE_FOOTER
  1498.         return 1
  1499.     fi
  1500.     let brd+=1
  1501. done
  1502. return 0
  1503. }
  1504.  
  1505. function choose_porte
  1506. {
  1507. # choose_porte(bd_array_index)
  1508. # Called when the Choices key for the IOEnd field is selected
  1509. # to display the GENERIC_NO_CHOICES message.
  1510. # Calling/Exit State: void.
  1511.  
  1512. [ "$DCUDEBUG" -gt 3 ] && {
  1513. print -u2 "$0 called"
  1514. set -x
  1515. }
  1516. msgnoerr "$GENERIC_NO_CHOICES"
  1517. }
  1518.  
  1519. function check_porte
  1520. {
  1521. # check_porte(bd_array_index)
  1522. # Called when the IOEnd field is changed to perform validation checking.
  1523. # Calling/Exit State: 0 for success and 1 for failure.
  1524.  
  1525. [ "$DCUDEBUG" -gt 3 ] && {
  1526. print -u2 "$0 called"
  1527. set -x
  1528. }
  1529.  
  1530. if [ ! "${BDPORTSTART[$1]}" = "$dash" ] \
  1531. && [   "${BDPORTEND[$1]}"   = "$dash" ]
  1532. then
  1533.     if [ "$IOECHKD" = "${BDPORTEND[$1]}" ]
  1534.     then
  1535.             IOECHKD=""
  1536.             return 0
  1537.     fi
  1538.            IOECHKD="${BDPORTEND[$1]}"
  1539.     display  -w "ERROR:
  1540. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  1541. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1542. $IOEREQ" \
  1543.         -bg $RED -fg $WHITE
  1544.     footer $GENERIC_CONTINUE_FOOTER
  1545.     return 1
  1546. fi
  1547.  
  1548. if [   "${BDPORTSTART[$1]}" = "$dash" ] \
  1549. && [ ! "${BDPORTEND[$1]}"   = "$dash" ]
  1550. then
  1551.     if [ "$IOECHKD" = "${BDPORTEND[$1]}" ]
  1552.     then
  1553.             IOECHKD=""
  1554.             return 0
  1555.     fi
  1556.            IOECHKD="${BDPORTEND[$1]}"
  1557.     display  -w "ERROR:
  1558. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  1559. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1560. $IOSREQ" \
  1561.         -bg $RED -fg $WHITE
  1562.     footer $GENERIC_CONTINUE_FOOTER
  1563.     return 1
  1564. fi
  1565.  
  1566. if (( !FLD_CHANGED ))
  1567. then
  1568.         IOECHKD=""
  1569.     return 0
  1570. fi
  1571.  
  1572. if [ "$IOECHKD" = "${BDPORTEND[$1]}" ]
  1573. then
  1574.         IOECHKD=""
  1575.         return 0
  1576. fi
  1577.  
  1578. case "${BDPORTEND[$1]}" in
  1579. "-")
  1580.     error_pending=''
  1581.     integer x=${BDCHGS[$1]}
  1582.     let x\|=$IOE_CHG
  1583.     BDCHGS[$1]=$x
  1584.     IOECHKD=""
  1585.     return 0
  1586.     ;;
  1587. [0-9abcdefABCDEF]*([0-9abcdefABCDEF]))
  1588.     error_pending=''
  1589.     integer x=${BDCHGS[$1]}
  1590.     let x\|=$IOE_CHG
  1591.     BDCHGS[$1]=$x
  1592.     porte_conflict $1
  1593.     if [ "$?" = 0 ]
  1594.     then
  1595.         IOECHKD=""
  1596.     fi
  1597.     return 0
  1598.     ;;
  1599. *)
  1600.     msgnoerr "$BD_BAD_PORT"
  1601.     return 1
  1602. esac
  1603. }
  1604.  
  1605. function porte_conflict
  1606. {
  1607. # porte_conflict(bd_array_index)
  1608. # Called when the IOEnd field is changed to perform conflict checking.
  1609. # A special flag is set to allow the field to be exited
  1610. # if a conflict is displayed.
  1611. # Calling/Exit State: 0 for success and 1 for failure.
  1612.  
  1613. [ "$DCUDEBUG" -gt 3 ] && {
  1614. print -u2 "$0 called"
  1615. set -x
  1616. }
  1617.  
  1618. if [ "${BDCNFG[$1]}" = "$N" ] \
  1619. || [ -z "${BDNAME[$1]}" ] \
  1620. || [ "${BDNAME[$1]}" = "$dash" ] \
  1621. || [ "${BDNAME[$1]}" = "$unused" ] \
  1622. || [ "${BDNAME[$1]}" = "$unknown" ]
  1623. then
  1624.     return 0
  1625. fi
  1626.  
  1627. [ "${BDPORTSTART[$1]}" = "$dash" -a "${BDPORTEND[$1]}" = "$dash" ] && return 0
  1628. [ "${BDPORTSTART[$1]}" = "0" -a "${BDPORTEND[$1]}" = "0" ] && return 0
  1629.  
  1630. typeset x ports porte
  1631. x=${BDPORTSTART[$1]}
  1632. typeset -i16 ports=16#$x
  1633. x=${BDPORTEND[$1]}
  1634. typeset -i16 porte=16#$x
  1635. typeset brd=1
  1636. if [ "${BDPORTSTART[$1]}" != "$dash" ] \
  1637. && [ "${BDPORTEND[$1]}" != "$dash" ]
  1638. then
  1639.     if [ porte -lt ports ]
  1640.     then
  1641.         if [ "$IOECHKD" = "${BDPORTEND[$1]}" ]
  1642.         then
  1643.                 IOECHKD=""
  1644.                 return 0
  1645.         fi
  1646.                IOECHKD="${BDPORTEND[$1]}"
  1647.         display  -w "ERROR:
  1648. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  1649. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1650. $BD_BAD_PORTE." \
  1651.             -bg $RED -fg $WHITE
  1652.         footer $GENERIC_CONTINUE_FOOTER
  1653.         return 1
  1654.     fi
  1655. fi
  1656.  
  1657. while (( $brd <= $LASTBOARD ))
  1658. do
  1659.     if [ "$brd" = "$1" ] \
  1660.     || [ "${BDCNFG[brd]}" = "$N" ] \
  1661.     || [ -z "${BDNAME[brd]}" ] \
  1662.     || [ "${BDNAME[brd]}" = "$dash" ] \
  1663.     || [ "${BDNAME[brd]}" = "$unused" ] \
  1664.     || [ "${BDNAME[brd]}" = "$unknown" ]
  1665.     then
  1666.         let brd+=1
  1667.         continue
  1668.     fi
  1669.  
  1670.     if [ "${BDINTERPSM[$1]}" = "Y" ] \
  1671.     && [ "${BDINTERPSM[brd]}" = "Y" ]
  1672.     then
  1673.         let brd+=1
  1674.         continue
  1675.     fi
  1676.  
  1677.     if [ "${BDPORTSTART[brd]}" = "$dash" ] \
  1678.     || [ "${BDPORTEND[brd]}" = "$dash" ]
  1679.     then
  1680.         let brd+=1
  1681.         continue
  1682.     fi
  1683.  
  1684.     if [ "${BDPORTSTART[brd]}" = "0" ] \
  1685.     && [ "${BDPORTEND[brd]}" = "0" ]
  1686.     then
  1687.         let brd+=1
  1688.         continue
  1689.     fi
  1690.  
  1691.     x=${BDPORTSTART[brd]}
  1692.     typeset -i16 ios=16#$x
  1693.     x=${BDPORTEND[brd]}
  1694.     typeset -i16 ioe=16#$x
  1695.  
  1696.     if [ porte -ge ios -a ports -le ioe ]
  1697.     then
  1698.         typeset allow1 allow2
  1699.         allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} O
  1700.         allow1=$?
  1701.         allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[brd]} O
  1702.         allow2=$?
  1703.         if (( allow1 && allow2 ))
  1704.         then
  1705.             let brd+=1
  1706.             continue
  1707.         fi
  1708.                IOECHKD="${BDPORTEND[$1]}"
  1709.         display  -w "ERROR:
  1710. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  1711. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1712. $IOECONF
  1713. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1714. $boardname=${BDNAME[brd]}, $boardios=${BDPORTSTART[brd]}, $boardioe=${BDPORTEND[brd]}." \
  1715.             -bg $RED -fg $WHITE
  1716.         footer $GENERIC_CONTINUE_FOOTER
  1717.         return 1
  1718.     fi
  1719.     let brd+=1
  1720. done
  1721. return 0
  1722. }
  1723.  
  1724. function choose_addrs
  1725. {
  1726. # choose_addrs(bd_array_index)
  1727. # Called when the Choices key for the MemStart field is selected
  1728. # to display the GENERIC_NO_CHOICES message.
  1729. # Calling/Exit State: void.
  1730.  
  1731. [ "$DCUDEBUG" -gt 3 ] && {
  1732. print -u2 "$0 called"
  1733. set -x
  1734. }
  1735. msgnoerr "$GENERIC_NO_CHOICES"
  1736. }
  1737.  
  1738. function check_addrs
  1739. {
  1740. # check_addrs(bd_array_index)
  1741. # Called when the MemEnd field is changed to perform validation checking.
  1742. # Calling/Exit State: 0 for success and 1 for failure.
  1743.  
  1744. [ "$DCUDEBUG" -gt 3 ] && {
  1745. print -u2 "$0 called"
  1746. set -x
  1747. }
  1748. if (( !FLD_CHANGED ))
  1749. then
  1750.         MEMSCHKD=""
  1751.     return 0
  1752. fi
  1753.  
  1754. if [ "$MEMSCHKD" = "${BDADDRSTART[$1]}" ]
  1755. then
  1756.         MEMSCHKD=""
  1757.         return 0
  1758. fi
  1759.  
  1760. if [ -z "${BDADDRSTART[$1]}" ]
  1761. then
  1762.         MEMSCHKD=""
  1763.     return 0
  1764. fi
  1765.  
  1766. case "${BDADDRSTART[$1]}" in
  1767. "-")
  1768.     error_pending=''
  1769.     integer x=${BDCHGS[$1]}
  1770.     let x\|=$MEMS_CHG
  1771.     BDCHGS[$1]=$x
  1772.         MEMSCHKD=""
  1773.     return 0
  1774.     ;;
  1775. [0-9abcdefABCDEF]*([0-9abcdefABCDEF]))
  1776.     error_pending=''
  1777.     integer x=${BDCHGS[$1]}
  1778.     let x\|=$MEMS_CHG
  1779.     BDCHGS[$1]=$x
  1780.     addrs_conflict $1
  1781.     if [ "$?" = 0 ]
  1782.     then
  1783.             MEMSCHKD=""
  1784.     fi
  1785.     return 0
  1786.     ;;
  1787. *)
  1788.     msgnoerr "$BD_BAD_MEM"
  1789.     return 1
  1790. esac
  1791. }
  1792.  
  1793. function addrs_conflict
  1794. {
  1795. # addrs_conflict(bd_array_index)
  1796. # Called when the MemStart field is changed to perform conflict checking.
  1797. # A special flag is set to allow the field to be exited
  1798. # if a conflict is displayed.
  1799. # Calling/Exit State: 0 for success and 1 for failure.
  1800.  
  1801. [ "$DCUDEBUG" -gt 3 ] && {
  1802. print -u2 "$0 called"
  1803. set -x
  1804. }
  1805.  
  1806. if [ "${BDCNFG[$1]}" = "$N" ] \
  1807. || [ -z "${BDNAME[$1]}" ] \
  1808. || [ "${BDNAME[$1]}" = "$dash" ] \
  1809. || [ "${BDNAME[$1]}" = "$unused" ] \
  1810. || [ "${BDNAME[$1]}" = "$unknown" ] \
  1811. || [ "${BDADDRSTART[$1]}" = "$dash" ] \
  1812. || [ "${BDADDRSTART[$1]}" = "0" -a "${BDADDREND[$1]}" = "0" ]
  1813. then
  1814.     return 0
  1815. fi
  1816.  
  1817. typeset x addrs mems meme
  1818. x=${BDADDRSTART[$1]}
  1819. typeset -i16 addrs=16#$x
  1820.  
  1821. typeset brd=1
  1822. while (( $brd <= $LASTBOARD ))
  1823. do
  1824.     if [ "$brd" = "$1" ] \
  1825.     || [ "${BDCNFG[brd]}" = "$N" ] \
  1826.     || [ -z "${BDNAME[brd]}" ] \
  1827.     || [ "${BDNAME[brd]}" = "$dash" ] \
  1828.     || [ "${BDNAME[brd]}" = "$unused" ] \
  1829.     || [ "${BDNAME[brd]}" = "$unknown" ] 
  1830.     then
  1831.         let brd+=1
  1832.         continue
  1833.     fi
  1834.     if [ "${BDINTERPSM[$1]}" = "Y" ] \
  1835.     && [ "${BDINTERPSM[brd]}" = "Y" ]
  1836.     then
  1837.         let brd+=1
  1838.         continue
  1839.     fi
  1840.  
  1841.     if [ "${BDADDRSTART[brd]}" = "$dash" ] \
  1842.     || [ "${BDADDREND[brd]}" = "$dash" ]
  1843.     then
  1844.         let brd+=1
  1845.         continue
  1846.     fi
  1847.  
  1848.     if [ "${BDADDRSTART[brd]}" = "0" ] \
  1849.     && [ "${BDADDREND[brd]}" = "0" ]
  1850.     then
  1851.         let brd+=1
  1852.         continue
  1853.     fi
  1854.  
  1855.     x=${BDADDRSTART[brd]}
  1856.     typeset -i16 mems=16#$x
  1857.     x=${BDADDREND[brd]}
  1858.     typeset -i16 meme=16#$x
  1859.  
  1860.     if [ addrs -ge mems -a  addrs -le meme ]
  1861.     then
  1862.             MEMSCHKD="${BDADDRSTART[$1]}"
  1863.         display  -w "ERROR:
  1864. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  1865. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1866. $MEMSCONF
  1867. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1868. $boardname=${BDNAME[brd]}, $boardmems=${BDADDRSTART[brd]}, $boardmeme=${BDADDREND[brd]}." \
  1869.             -bg $RED -fg $WHITE
  1870.         footer $GENERIC_CONTINUE_FOOTER
  1871.         return 1
  1872.     fi
  1873.     let brd+=1
  1874. done
  1875. return 0
  1876. }
  1877.  
  1878. function choose_addre
  1879. {
  1880. # choose_addre(bd_array_index)
  1881. # Called when the Choices key for the MemEnd field is selected
  1882. # to display the GENERIC_NO_CHOICES message.
  1883. # Calling/Exit State: void.
  1884.  
  1885. [ "$DCUDEBUG" -gt 3 ] && {
  1886. print -u2 "$0 called"
  1887. set -x
  1888. }
  1889. msgnoerr "$GENERIC_NO_CHOICES"
  1890. }
  1891.  
  1892. function check_addre
  1893. {
  1894. # check_addre(bd_array_index)
  1895. # Called when the MemEnd field is changed to perform validation checking.
  1896. # This functions checks for the existence of MemStart and
  1897. # allows either '-' or any hex number.
  1898. # Calling/Exit State: 0 for success and 1 for failure.
  1899.  
  1900. [ "$DCUDEBUG" -gt 3 ] && {
  1901. print -u2 "$0 called"
  1902. set -x
  1903. }
  1904.  
  1905. if [ ! "${BDADDRSTART[$1]}" = "$dash" ] \
  1906. && [   "${BDADDREND[$1]}" = "$dash" ]
  1907. then
  1908.            if [ "$MEMECHKD" = "${BDADDREND[$1]}" ]
  1909.     then
  1910.                MEMECHKD=""
  1911.         return 0
  1912.     fi
  1913.            MEMECHKD="${BDADDREND[$1]}"
  1914.     display  -w "ERROR:
  1915. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  1916. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1917. $MEMEREQ" \
  1918.         -bg $RED -fg $WHITE
  1919.     footer $GENERIC_CONTINUE_FOOTER
  1920.     return 1
  1921. fi
  1922.  
  1923. if [   "${BDADDRSTART[$1]}" = "$dash" ] \
  1924. && [ ! "${BDADDREND[$1]}" = "$dash" ]
  1925. then
  1926.            if [ "$MEMECHKD" = "${BDADDREND[$1]}" ]
  1927.     then
  1928.                MEMECHKD=""
  1929.         return 0
  1930.     fi
  1931.            MEMECHKD="${BDADDREND[$1]}"
  1932.     display  -w "ERROR:
  1933. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  1934. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1935. $MEMSREQ" \
  1936.         -bg $RED -fg $WHITE
  1937.     footer $GENERIC_CONTINUE_FOOTER
  1938.     return 1
  1939. fi
  1940.  
  1941. if (( !FLD_CHANGED ))
  1942. then
  1943.         MEMECHKD=""
  1944.     return 0
  1945. fi
  1946.  
  1947. if [ "$MEMECHKD" = "${BDADDREND[$1]}" ]
  1948. then
  1949.         MEMECHKD=""
  1950.         return 0
  1951. fi
  1952.  
  1953. case "${BDADDREND[$1]}" in
  1954. "-")
  1955.     error_pending=''
  1956.     integer x=${BDCHGS[$1]}
  1957.     let x\|=$MEME_CHG
  1958.     BDCHGS[$1]=$x
  1959.            MEMECHKD=""
  1960.     return 0
  1961.     ;;
  1962. [0-9abcdefABCDEF]*([0-9abcdefABCDEF]))
  1963.     error_pending=''
  1964.     integer x=${BDCHGS[$1]}
  1965.     let x\|=$MEME_CHG
  1966.     BDCHGS[$1]=$x
  1967.     addre_conflict $1
  1968.     if [ "$?" = 0 ]
  1969.     then
  1970.         MEMECHKD=""
  1971.     fi
  1972.     return 0
  1973.     ;;
  1974. *)
  1975.     msgnoerr "$BD_BAD_MEM"
  1976.     return 1
  1977. esac
  1978. }
  1979.  
  1980. function addre_conflict
  1981. {
  1982. # addre_conflict(bd_array_index)
  1983. # Called when the MemEnd field is changed to perform conflict checking.
  1984. # A special flag is set to allow the field to be exited
  1985. # if a conflict is displayed.
  1986. # Calling/Exit State: 0 for success and 1 for failure.
  1987.  
  1988. [ "$DCUDEBUG" -gt 3 ] && {
  1989. print -u2 "$0 called"
  1990. set -x
  1991. }
  1992.  
  1993. if [ "${BDCNFG[$1]}" = "$N" ] \
  1994. || [ -z "${BDMODNAME[$1]}" ] \
  1995. || [ "${BDMODNAME[$1]}" = "$dash" ] \
  1996. || [ "${BDMODNAME[$1]}" = "$unused" ] \
  1997. || [ "${BDMODNAME[$1]}" = "$unknown" ]
  1998. then
  1999.     return 0
  2000. fi
  2001.  
  2002. [ "${BDADDRSTART[$1]}" = "$dash" -a "${BDADDREND[$1]}" = "$dash" ] && return 0
  2003. [ "${BDADDRSTART[$1]}" = "0" -a "${BDADDREND[$1]}" = "0" ] && return 0
  2004.  
  2005. typeset x addrs addre
  2006. x=${BDADDRSTART[$1]}
  2007. typeset -i16 addrs=16#$x
  2008. x=${BDADDREND[$1]}
  2009. typeset -i16 addre=16#$x
  2010. typeset brd=1
  2011. if [ "${BDADDRSTART[$1]}" != "$dash" ] \
  2012. && [ "${BDADDREND[$1]}" != "$dash" ]
  2013. then
  2014.     if [ addre -lt addrs ]
  2015.     then
  2016.                if [ "$MEMECHKD" = "${BDADDREND[$1]}" ]
  2017.         then
  2018.                    MEMECHKD=""
  2019.             return 0
  2020.         fi
  2021.               MEMECHKD="${BDADDREND[$1]}"
  2022.         display  -w "ERROR:
  2023. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  2024. ${IM_A_BLANK_LINE_DONT_TOUCH}
  2025. $BD_BAD_MEME " \
  2026.             -bg $RED -fg $WHITE
  2027.         footer $GENERIC_CONTINUE_FOOTER
  2028.         return 1
  2029.     fi
  2030. fi
  2031.  
  2032. while (( $brd <= $LASTBOARD ))
  2033. do
  2034.     if [ "$brd" = "$1" ] \
  2035.     || [ "${BDCNFG[brd]}" = "$N" ] \
  2036.     || [ -z "${BDMODNAME[brd]}" ] \
  2037.     || [ "${BDMODNAME[brd]}" = "$dash" ] \
  2038.     || [ "${BDMODNAME[brd]}" = "$unused" ] \
  2039.     || [ "${BDMODNAME[brd]}" = "$unknown" ]
  2040.     then
  2041.         let brd+=1
  2042.         continue
  2043.     fi
  2044.  
  2045.     if [ "${BDINTERPSM[$1]}" = "Y" ] \
  2046.     && [ "${BDINTERPSM[brd]}" = "Y" ]
  2047.     then
  2048.         let brd+=1
  2049.         continue
  2050.     fi
  2051.  
  2052.     if [ "${BDADDRSTART[brd]}" = "$dash" ] \
  2053.     && [ "${BDADDREND[brd]}" = "$dash" ]
  2054.     then
  2055.         let brd+=1
  2056.         continue
  2057.     fi
  2058.  
  2059.     if [ "${BDADDRSTART[brd]}" = "0" ] \
  2060.     && [ "${BDADDREND[brd]}" = "0" ]
  2061.     then
  2062.         let brd+=1
  2063.         continue
  2064.     fi
  2065.  
  2066.     x=${BDADDRSTART[brd]}
  2067.     typeset -i16 mems=16#$x
  2068.     x=${BDADDREND[brd]}
  2069.     typeset -i16 meme=16#$x
  2070.     
  2071.     if [ addre -ge mems -a  addrs -le meme ]
  2072.     then
  2073.         typeset allow1 allow2
  2074.         allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} M
  2075.         allow1=$?
  2076.         allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[brd]} M
  2077.         allow2=$?
  2078.         if (( allow1 && allow2 ))
  2079.         then
  2080.             let brd+=1
  2081.             continue
  2082.         fi
  2083.                MEMECHKD="${BDADDREND[$1]}"
  2084.         display  -w "ERROR:
  2085. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  2086. ${IM_A_BLANK_LINE_DONT_TOUCH}
  2087. $MEMECONF
  2088. ${IM_A_BLANK_LINE_DONT_TOUCH}
  2089. $boardname=${BDNAME[brd]}, $boardmems=${BDADDRSTART[brd]}, $boardmeme=${BDADDREND[brd]}." \
  2090.             -bg $RED -fg $WHITE
  2091.         footer $GENERIC_CONTINUE_FOOTER
  2092.         return 1
  2093.     fi
  2094.     let brd+=1
  2095. done
  2096. return 0
  2097. }
  2098.  
  2099. function choose_dma
  2100. {
  2101. # choose_dma(bd_array_index)
  2102. # Called when the Choices key for the DMA field is selected
  2103. # to display the Coices.
  2104. # Calling/Exit State: void.
  2105.  
  2106. [ "$DCUDEBUG" -gt 3 ] && {
  2107. print -u2 "$0 called"
  2108. set -x
  2109. }
  2110. CHOOSE_TITLE="$boarddma $CHOICES"
  2111. CHOOSE_FOOTER="$DCU_CHOOSE_FOOTER"
  2112. choose "${BDDMA[$1]}" $DMACHOICES
  2113. }
  2114.  
  2115. function check_dma
  2116. {
  2117. # check_dma(bd_array_index)
  2118. # Called when the MemEnd field is changed to perform validation checking.
  2119. # Calling/Exit State: 0 for success and 1 for failure.
  2120.  
  2121. [ "$DCUDEBUG" -gt 3 ] && {
  2122. print -u2 "$0 called"
  2123. set -x
  2124. }
  2125.  
  2126. if (( !FLD_CHANGED ))
  2127. then
  2128.     DMACHKD=""
  2129.     return 0
  2130. fi
  2131.  
  2132. if [ "$DMACHKD" = "${BDDMA[$1]}" ]
  2133. then
  2134.     DMACHKD=""
  2135.     return 0
  2136. fi
  2137.  
  2138. case "${BDDMA[$1]}" in
  2139. "-")
  2140.     error_pending=''
  2141.     integer x=${BDCHGS[$1]}
  2142.     let x\|=$DMA_CHG
  2143.     BDCHGS[$1]=$x
  2144.     DMACHKD=""
  2145.     return 0
  2146.     ;;
  2147. -1)
  2148.     error_pending=''
  2149.     integer x=${BDCHGS[$1]}
  2150.     let x\|=$DMA_CHG
  2151.     BDCHGS[$1]=$x
  2152.     DMACHKD=""
  2153.     return 0
  2154.     ;;
  2155. [0-7])
  2156.     if [ ${BDDMA[$1]} -lt 0 -o ${BDDMA[$1]} -gt 7 ]
  2157.     then
  2158.         msgnoerr "$BD_BAD_DMA"
  2159.         return 1
  2160.     else
  2161.         error_pending=''
  2162.         integer x=${BDCHGS[$1]}
  2163.         let x\|=$DMA_CHG
  2164.         BDCHGS[$1]=$x
  2165.         dma_conflict $1
  2166.         if [ "$?" = 0 ]
  2167.         then
  2168.             DMACHKD=""
  2169.         fi
  2170.         return 0
  2171.     fi
  2172.     ;;
  2173. *)
  2174.     msgnoerr "$BD_BAD_DMA"
  2175.     return 1
  2176. esac
  2177. }
  2178.  
  2179. function dma_conflict
  2180. {
  2181. # dma_conflict(bd_array_index)
  2182. # Called when the DMA field is changed to perform conflict checking.
  2183. # A special flag is set to allow the field to be exited
  2184. # if a conflict is displayed.
  2185. # Calling/Exit State: 0 for success and 1 for failure.
  2186.  
  2187. [ "$DCUDEBUG" -gt 3 ] && {
  2188. print -u2 "$0 called"
  2189. set -x
  2190. }
  2191.  
  2192. if [ "${BDCNFG[$1]}" = "$N" ] \
  2193. || [ -z "${BDNAME[$1]}" ] \
  2194. || [ "${BDDMA[$1]}" = "$dash" ] \
  2195. || [ "${BDDMA[$1]}" = "-1" ] \
  2196. || [ "${BDNAME[$1]}" = "$dash" ] \
  2197. || [ "${BDNAME[$1]}" = "$unused" ] \
  2198. || [ "${BDNAME[$1]}" = "$unknown" ] 
  2199. then
  2200.     return 0
  2201. fi
  2202.  
  2203. typeset brd=1
  2204. while (( $brd <= $LASTBOARD ))
  2205. do
  2206.     if [ "$brd" = "$1" ] \
  2207.     || [ ! "${BDDMA[brd]}" = "${BDDMA[$1]}" ] \
  2208.     || [ "${BDCNFG[brd]}" = "$N" ] \
  2209.     || [ -z "${BDNAME[brd]}" ] \
  2210.     || [ "${BDIRQ[brd]}" = "$dash" ] \
  2211.     || [ "${BDNAME[brd]}" = "$dash" ] \
  2212.     || [ "${BDNAME[brd]}" = "$unused" ] \
  2213.     || [ "${BDNAME[brd]}" = "$unknown" ] 
  2214.     then
  2215.         let brd+=1
  2216.         continue
  2217.     fi
  2218.     if [ "${BDINTERPSM[$1]}" = "Y" ] \
  2219.     && [ "${BDINTERPSM[brd]}" = "Y" ]
  2220.     then
  2221.         let brd+=1
  2222.         continue
  2223.     fi
  2224.  
  2225.     typeset allow1 allow2
  2226.     allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} D
  2227.     allow1=$?
  2228.     allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[brd]} D
  2229.     allow2=$?
  2230.     if (( allow1 && allow2 ))
  2231.     then
  2232.         let brd+=1
  2233.         continue
  2234.     fi
  2235.  
  2236.     DMACHKD="${BDDMA[$1]}"
  2237.     display  -w "ERROR:
  2238. $DMACONF
  2239. ${IM_A_BLANK_LINE_DONT_TOUCH}
  2240. $boardname=${BDNAME[$1]}, $boarddma=${BDDMA[$1]},
  2241. ${IM_A_BLANK_LINE_DONT_TOUCH}
  2242. $boardname=${BDNAME[brd]}, $boarddma=${BDDMA[brd]}." \
  2243.         -bg $RED -fg $WHITE
  2244.     footer $GENERIC_CONTINUE_FOOTER
  2245.     return 1
  2246. done
  2247. return 0
  2248. }
  2249.  
  2250. function choose_cpu
  2251. {
  2252. # choose_cpu(bd_array_index)
  2253. # Called when the Choices key for the BindCPU field is selected
  2254. # to display the Choices.
  2255. # Calling/Exit State: void
  2256.  
  2257. [ "$DCUDEBUG" -gt 3 ] && {
  2258. print -u2 "$0 called"
  2259. set -x
  2260. }
  2261. typeset i ncpu cpuchoices
  2262. CHOOSE_TITLE="$boardcpu $CHOICES"
  2263. CHOOSE_FOOTER="$DCU_CHOOSE_FOOTER"
  2264. cpuchoices='- 0'
  2265. call sysconfig 12    # _CONFIG_NENGINE=12
  2266. ncpu=$?
  2267. i=1
  2268. while (( i < ncpu ))
  2269. do
  2270.     cpuchoices="$cpuchoices $i"
  2271.     let i+=1
  2272. done
  2273. choose -f "${BDCPU[$1]}" $cpuchoices
  2274. }
  2275.  
  2276. function check_cpu
  2277. {
  2278. # check_cpu(bd_array_index)
  2279. # Called when the BindCPU field is changed to perform validation checking.
  2280. # Calling/Exit State: 0 for success and 1 for failure.
  2281.  
  2282. [ "$DCUDEBUG" -gt 3 ] && {
  2283. print -u2 "$0 called"
  2284. set -x
  2285. }
  2286. typeset ncpu badmsg 
  2287.  
  2288. call sysconfig 12    # _CONFIG_NENGINE=12
  2289. ncpu=$?
  2290. if [ "$ncpu" = "1" ]
  2291. then
  2292.     badmsg="$BD_ONE_CPU"
  2293. else
  2294.     badmsg="$BD_BAD_CPU ${ncpu}."
  2295. fi
  2296. let ncpu-=1
  2297.  
  2298. if (( !FLD_CHANGED ))
  2299. then
  2300.     return 0
  2301. fi
  2302.  
  2303. case "${BDCPU[$1]}" in
  2304. "-")
  2305.     error_pending=''
  2306.     integer x=${BDCHGS[$1]}
  2307.     let x\|=$CPU_CHG
  2308.     BDCHGS[$1]=$x
  2309.     return 0
  2310.     ;;
  2311. [0-9]*([0-9]))
  2312.     if [ ${BDCPU[$1]} -gt "$ncpu" ]
  2313.     then
  2314.         msgnoerr "$badmsg"
  2315.         return 1
  2316.     else
  2317.         error_pending=''
  2318.         integer x=${BDCHGS[$1]}
  2319.         let x\|=$CPU_CHG
  2320.         BDCHGS[$1]=$x
  2321.         return 0
  2322.     fi
  2323.     ;;
  2324. *)
  2325.     msgnoerr "$badmsg"
  2326.     return 1
  2327. esac
  2328. }
  2329.  
  2330. function reset_name
  2331. {
  2332. # reset_name() NOT_CURRENTLY_USED"
  2333. # Callback to clear name field of BDLINE board array
  2334. # Calling/Exit State: void.
  2335.  
  2336. [ "$DCUDEBUG" -gt 3 ] && {
  2337. print -u2 "$0 called"
  2338. set -x
  2339. }
  2340.  
  2341. integer chce="${BOARDFLD[$BDLINE]}"
  2342. fld_change $BDFID $chce ''
  2343. return 0
  2344. }
  2345.  
  2346. function rdRM_key
  2347. {
  2348. # rdRM_key(key, bd_array_index, inst)
  2349. # query the resource manager for key information
  2350. # return: 0 - valid data found in resmgr
  2351. # Calling/Exit State: void.
  2352.  
  2353. [ "$DCUDEBUG" -gt 3 ] && {
  2354. print -u2 "$0 called"
  2355. set -x
  2356. }
  2357.  
  2358. integer i retd
  2359. integer n=$3
  2360. typeset parm_list="MODNAME UNIT IPL ITYPE IRQ IOADDR MEMADDR DMAC BINDCPU BRDID SCLASSID BRDBUSTYPE ENTRYTYPE"
  2361. RMgetvals $1 "$parm_list" $n
  2362. if (( i=$? ))
  2363. then
  2364.         if [ "$RMIRQ" = "$dash" -a "$RMPORTSTART" = "$dash" -a "$RMADDRSTART" = "$dash" -a "$RMDMAC" = "$dash" -a \( "$RMBRDBUSTYPE" = "$dash" -o "$RMBRDBUSTYPE" = "$unk" \) ]
  2365.         then
  2366.                 return 2 # no hardware info -> ignore
  2367.         fi
  2368.  
  2369.     BDKEY[$2]="$1"
  2370.     if [ "$RMBRDBUSTYPE" = "$isa" -o "$RMBRDBUSTYPE" = "$unk" ]
  2371.     then
  2372.         BDTYPE[$2]=$prompt
  2373.     else
  2374.         BDTYPE[$2]=$noprompt
  2375.     fi
  2376.     if [ "$RMENTRYTYPE" = "2" ]
  2377.     then
  2378.         BDTYPE[$2]=$noprompt
  2379.     fi
  2380.     BDBUSTYPE[$2]="$RMBRDBUSTYPE"
  2381.     BDID[$2]="$RMBRDID"
  2382.     BDCLASS[$2]="$RMSCLASSID"
  2383.     BDMODNAME[$2]="$RMMODNAME"
  2384.     BDCNFG[$2]="$Y"
  2385.     BDIRQ[$2]="$RMIRQ"
  2386.     BDUNIT[$2]="$RMUNIT"
  2387.     BDIPL[$2]="$RMIPL"
  2388.     BDITYPE[$2]="$RMITYPE"
  2389.     BDPORTSTART[$2]="$RMPORTSTART"
  2390.     BDPORTEND[$2]="$RMPORTEND"
  2391.     BDADDRSTART[$2]="$RMADDRSTART"
  2392.     BDADDREND[$2]="$RMADDREND"
  2393.     BDDMA[$2]="$RMDMAC"
  2394.     BDCPU[$2]="$RMBINDCPU"
  2395.     BDENTRYTYPE[$2]="$RMENTRYTYPE"
  2396. else
  2397.     return 1
  2398. fi
  2399.  
  2400. if [ "$RMMODNAME" = "$unused" ]
  2401. then
  2402.     BDNAME[$2]="$unused"
  2403.     return 0
  2404. fi
  2405.  
  2406. # search driver knowledge base for match on board
  2407. lookupdrv $2
  2408. if (( i=$? ))
  2409. then
  2410.     BDNAME[$2]="$FNDDRVBOARDNAME"
  2411.     BDMODNAME[$2]="$FNDMODNAME"
  2412.      BDMODINDX[$2]="$i"
  2413.  
  2414.     if [ "$RMBRDBUSTYPE" = "$isa" -o "$RMBRDBUSTYPE" = "$unk" ]
  2415.     then
  2416.         if [ "${DRVBUSTYPE[i]}" = "$isa" -o "${DRVBUSTYPE[i]}" = "$unk" ] \
  2417.         || [ -z "${DRVBUSTYPE[i]}" ]
  2418.         then
  2419.             BDTYPE[$2]=$prompt
  2420.         else
  2421.             BDTYPE[$2]=$noprompt
  2422.         fi
  2423.     fi
  2424.     if [ "$RMENTRYTYPE" = "2" ]
  2425.     then
  2426.         BDTYPE[$2]=$noprompt
  2427.     fi
  2428. else
  2429.     if [ -n "$FNDMODNAME" ]
  2430.     then
  2431.         BDNAME[$2]="$FNDDRVBOARDNAME"
  2432.         BDMODNAME[$2]="$FNDMODNAME"
  2433.     else
  2434.         BDNAME[$2]=$unknown
  2435.     fi
  2436. fi
  2437. return 0
  2438. }
  2439.  
  2440. function wrtBSP_key
  2441. {
  2442. # wrtBSP_key(bd_array_index)
  2443. # Called to write the board specific parameter record to
  2444. # the resource manager database for the given board array index key.
  2445. # Calling/Exit State: 0 for success and see RMputvals(3) for failure.
  2446.  
  2447. typeset parm_list
  2448. typeset val_list
  2449. typeset bd=$1
  2450.  
  2451. # If there are no BSPs to write, just return
  2452. if [ -z "${BDBSPPARAMS[bd]}" ]
  2453. then
  2454.     return 0
  2455. fi
  2456. val_list="${BDBSPVALS[bd]}"
  2457.  
  2458. # All BSPs are type string.  We add a ',s' to tell the RM this
  2459. OIFS=$IFS
  2460. IFS=" "
  2461. set ${BDBSPPARAMS[bd]}
  2462. parm_list="$1,s"
  2463. shift
  2464. while (( $#>0 ))
  2465. do
  2466.     parm_list="$parm_list $1,s"
  2467.     shift
  2468. done
  2469. IFS=$OIFS
  2470.  
  2471. RMdelvals ${BDKEY[bd]} "$parm_list"
  2472. RMputvals ${BDKEY[bd]} "$parm_list" "$val_list"
  2473. return $?
  2474. }
  2475.  
  2476. function wrtRM_key
  2477. {
  2478. # wrtRM_key(bd_array_index)
  2479. # Called to write a record to the resource manager database for the given board
  2480. # array index key.
  2481. # Calling/Exit State: 0 for success and see RMputvals(3) for failure
  2482.  
  2483. [ "$DCUDEBUG" -gt 3 ] && {
  2484. print -u2 "$0 called"
  2485. set -x
  2486. }
  2487. typeset bdmodname bdunit bdipl bditype bdirq bdportstart bdportend bdaddrstart bdaddrend bddma bdcpu bdid bdclass bdbustype bdentrytype
  2488. typeset m val_list
  2489. typeset parm_list="MODNAME UNIT IPL ITYPE IRQ IOADDR MEMADDR DMAC BINDCPU BRDID SCLASSID BRDBUSTYPE ENTRYTYPE"
  2490. RMdelvals ${BDKEY[$1]} "$parm_list"
  2491.  
  2492. bdmodname="${BDMODNAME[$1]}"
  2493. bdunit="${BDUNIT[$1]}"
  2494. bdipl="${BDIPL[$1]}"
  2495. bditype="${BDITYPE[$1]}"
  2496. bdirq="${BDIRQ[$1]}"
  2497. bdportstart="${BDPORTSTART[$1]}"
  2498. bdportend="${BDPORTEND[$1]}"
  2499. bdaddrstart="${BDADDRSTART[$1]}"
  2500. bdaddrend="${BDADDREND[$1]}"
  2501. bddma="${BDDMA[$1]}"
  2502. bdcpu="${BDCPU[$1]}"
  2503. bdid="${BDID[$1]}"
  2504. bdclass="${BDCLASS[$1]}"
  2505. bdbustype="${BDBUSTYPE[$1]}"
  2506. bdentrytype="${BDENTRYTYPE[$1]}"
  2507.  
  2508. for m in bdmodname bdunit bdipl bditype bdirq bdportstart bdportend bdaddrstart bdaddrend bddma bdcpu bdid bdclass bdbustype bdentrytype
  2509. do
  2510.     eval $m=\$\{$m:-$dash\}
  2511. done
  2512.  
  2513. val_list="$bdmodname $bdunit $bdipl $bditype $bdirq $bdportstart $bdportend $bdaddrstart $bdaddrend $bddma $bdcpu $bdid $bdclass $bdbustype $bdentrytype" 
  2514.  
  2515. if [ "$val_list" = "$dash $dash $dash $dash $dash $dash $dash $dash $dash $dash $dash $dash $dash $dash" ]
  2516. then
  2517.     RMdelkey ${BDKEY[$1]}
  2518.     return 0
  2519. fi
  2520. RMputvals ${BDKEY[$1]} "$parm_list" "$val_list"
  2521. return $?
  2522. }
  2523.  
  2524. function setpltfm
  2525. {
  2526. # setpltfm()
  2527. # Called to set the platform specific choices for IPL, ITYPE and DMA.
  2528. # Calling/Exit State: void.
  2529.  
  2530. [ "$DCUDEBUG" -gt 3 ] && {
  2531. print -u2 "$0 called"
  2532. set -x
  2533. }
  2534.  
  2535. IPLCHOICES='0 1 2 3 4 5 6 7 8 9'
  2536. ITYPECHOICES='0 1 2 3 4'
  2537. DMACHOICES='- -1 0 1 2 3 4 5 6 7'
  2538. }
  2539.  
  2540. function boardset
  2541. {
  2542. # boardset(bd_array_index)
  2543. # Field exit callback when the Configure field is exited.
  2544. # Calling/Exit State: 0 for success and 1 for failure.
  2545.  
  2546. [ "$DCUDEBUG" -gt 3 ] && {
  2547. print -u2 "$0 called"
  2548. set -x
  2549. }
  2550. if (( !FLD_CHANGED ))
  2551. then
  2552.     return 0
  2553. fi
  2554. typeset -u cnfg="${BDCNFG[$1]}"
  2555. case "$cnfg"
  2556. in
  2557. "$Y"|"$N")
  2558.     fld_change $BDFID ${BOARDFLD[$BDLINE]} $cnfg 
  2559.     integer x=${BDCHGS[$1]}
  2560.     let x\|=$ADD_DEL_CHG
  2561.     BDCHGS[$1]=$x
  2562.     return 0
  2563.     ;;
  2564. *)
  2565.     msgnoerr "$BD_ERR_CNFG"
  2566.     return 1
  2567. esac
  2568. }
  2569.  
  2570. function boardxpnd
  2571. {
  2572. # boardxpnd()
  2573. # Called when the F6=Info key is selected from the Hardware Device Configuration
  2574. # screen to display additional Configuration Information.
  2575. # Calling/Exit State: void.
  2576.  
  2577. [ "$DCUDEBUG" -gt 3 ] && {
  2578. print -u2 "$0 called"
  2579. set -x
  2580. }
  2581. integer bd=LINETOBD[BDLINE]
  2582. integer drv
  2583. typeset -R28 imsg
  2584. typeset -L48 msg
  2585.  
  2586. place_window $DCU_MAX_WIDTH $DCU_MAX_HEIGHT-$FOOTER_HEIGHT-1 -below 0 -title "$CONFIG_INFO" 
  2587.  
  2588. imsg="$DriverName"
  2589. msg=" : ${BDMODNAME[bd]}"
  2590. wprintf $CURWIN "%s %s\n $imsg $msg"
  2591.  
  2592. imsg="$BoardName"
  2593. lookupdrv $bd
  2594. if (( drv=$? ))
  2595. then
  2596.     msg=" : ${DRVBOARDNAMEFULL[drv]}"
  2597. else
  2598.     msg=" : ${BDMODNAME[bd]}"
  2599. fi
  2600. wprintf $CURWIN "%s %s\n $imsg $msg"
  2601.  
  2602. imsg="$UNITs"
  2603. msg=" : ${BDUNIT[bd]}"
  2604. wprintf $CURWIN "%s %s\n $imsg $msg"
  2605.  
  2606. imsg="$IPLs"
  2607. msg=" : ${BDIPL[bd]}"
  2608. wprintf $CURWIN "%s %s\n $imsg $msg"
  2609.  
  2610. imsg="$ITYPEs"
  2611. msg=" : ${BDITYPE[bd]}"
  2612. wprintf $CURWIN "%s %s\n $imsg $msg"
  2613.  
  2614. imsg="$IRQs"
  2615. msg=" : ${BDIRQ[bd]}"
  2616. wprintf $CURWIN "%s %s\n $imsg $msg"
  2617.  
  2618. imsg="$boardios"
  2619. msg=" : ${BDPORTSTART[bd]}"
  2620. wprintf $CURWIN "%s %s\n $imsg $msg"
  2621.  
  2622. imsg="$boardioe"
  2623. msg=" : ${BDPORTEND[bd]}"
  2624. wprintf $CURWIN "%s %s\n $imsg $msg"
  2625.  
  2626. imsg="$boardmems"
  2627. msg=" : ${BDADDRSTART[bd]}"
  2628. wprintf $CURWIN "%s %s\n $imsg $msg"
  2629.  
  2630. imsg="$boardmeme"
  2631. msg=" : ${BDADDREND[bd]}"
  2632. wprintf $CURWIN "%s %s\n $imsg $msg"
  2633.  
  2634. imsg="$DMAs"
  2635. msg=" : ${BDDMA[bd]}"
  2636. wprintf $CURWIN "%s %s\n $imsg $msg"
  2637.  
  2638. imsg="$boardcpu"
  2639. msg=" : ${BDCPU[bd]}"
  2640. wprintf $CURWIN "%s %s\n $imsg $msg"
  2641.  
  2642. imsg="$BoardId"
  2643. msg=" : ${BDID[bd]}"
  2644. wprintf $CURWIN "%s %s\n $imsg $msg"
  2645.  
  2646. imsg="$BoardClass"
  2647. msg=" : ${BDCLASS[bd]}"
  2648. wprintf $CURWIN "%s %s\n $imsg $msg"
  2649.  
  2650. imsg="$BoardBusType"
  2651. msg=" : ${BDBUSTYPE[bd]}"
  2652. wprintf $CURWIN "%s %s\n $imsg $msg"
  2653.  
  2654. footer "$ESCXNDFOOTER"
  2655. integer bdxwin="$CURWIN"
  2656. call getkey
  2657. wclose $bdx_win
  2658. footer "$BOARDXPND"
  2659. }
  2660.  
  2661.  
  2662. function silent_match
  2663. {
  2664. # silent_match(bd_array_index drv_array_index)
  2665. # Called during the silent boardid mapping phase when a
  2666. # boardid and board bus type pairing is matched.
  2667. # It fills in the UNKNOWN PCU entry and attempts to
  2668. # delete any "default" entries.
  2669. # Calling/Exit State: void.
  2670.  
  2671. [ "$DCUDEBUG" -gt 3 ] && {
  2672. print -u2 "$0 called"
  2673. set -x
  2674. }
  2675.  
  2676. typeset drvname isc unit ipl itype irq ports porte mems meme dma cpu
  2677.  
  2678. while read drvname isc unit ipl itype irq ports porte mems meme dma cpu
  2679. do
  2680.     if [ ! "$drvname" = "${BDMODNAME[$1]}" ]
  2681.     then
  2682.         continue
  2683.     fi
  2684.     break
  2685. done < ${ROOT}/etc/conf/sdevice.d/${BDMODNAME[$1]}
  2686.  
  2687. for m in unit ipl itype irq ports porte mems meme dma cpu
  2688. do
  2689. eval $m=\$\{$m:-$dash\}
  2690. done
  2691.  
  2692. if [ "${DRVBUSTYPE[$2]}" = "mca" -o "${DRVBUSTYPE[$2]}" = "MCA" ]
  2693. then
  2694.     if [ "${DRVAUTOCONFIG[$2]}" = "Y" ]
  2695.     then
  2696.          BDIPL[$1]="$ipl"
  2697.          if [ "${BDITYPE[$1]}" = "$dash" ]
  2698.         then
  2699.              BDITYPE[$1]="$itype"
  2700.         fi
  2701.         if [ "${BDCPU[$1]}" = "$dash" ]
  2702.         then
  2703.             BDCPU[$1]="$cpu"
  2704.         fi
  2705.  
  2706.     else
  2707.          BDIPL[$1]="$ipl"
  2708.          BDITYPE[$1]="$itype"
  2709.          BDIRQ[$1]="$irq"
  2710.          BDPORTSTART[$1]="$ports"
  2711.          BDPORTEND[$1]="$porte"
  2712.          BDADDRSTART[$1]="$mems"
  2713.          BDADDREND[$1]="$meme"
  2714.          BDDMAC[$1]="$dma"
  2715.          BDCPU[$1]="$cpu"
  2716.     fi
  2717.     wrtRM_key  $1
  2718. else
  2719.      BDIPL[$1]="$ipl"
  2720.      if [ "${BDITYPE[$1]}" = "$dash" ]
  2721.     then
  2722.          BDITYPE[$1]="$itype"
  2723.     fi
  2724.      if [ "${BDCPU[$1]}" = "$dash" ]
  2725.     then
  2726.          BDCPU[$1]="$cpu"
  2727.     fi
  2728.     RMputvals ${BDKEY[$1]} "CPU" "${BDCPU[$1]}"
  2729.     RMputvals ${BDKEY[$1]} "MODNAME" "${BDMODNAME[$1]}"
  2730.     RMputvals ${BDKEY[$1]} "IPL" "${BDIPL[$1]}"
  2731.     RMputvals ${BDKEY[$1]} "ITYPE" "${BDITYPE[$1]}"
  2732. fi
  2733.  
  2734. silent_clean ${BDMODNAME[$1]} $1
  2735. }
  2736.  
  2737. function silent_clean
  2738. {
  2739. # silent_clean(MODNAME, bd_array_index)
  2740. # Called during the silent boardid mapping phase after
  2741. # the PCU entry has been updated.
  2742. # Its purpose is to delete any default entries for the
  2743. # corresponding MODNAME.
  2744. # Calling/Exit State: void.
  2745.  
  2746. [ "$DCUDEBUG" -gt 3 ] && {
  2747. print -u2 "$0 called"
  2748. set -x
  2749. }
  2750. integer i=1
  2751.  
  2752. #if [ "${BDCLEANED[$2]}" = "Y" ]
  2753. #then
  2754. #    return 0
  2755. #fi
  2756.  
  2757. while (( i <= ${LASTBOARD} ))
  2758. do
  2759.  
  2760.      if [ "$1" = "${BDMODNAME[i]}" ]
  2761.     then
  2762.         if [ "${BDENTRYTYPE[i]}" = "1" ]
  2763.         then
  2764.             RMdelkey ${BDKEY[i]}
  2765. #            ${BDCLEANED[i]}="Y" 
  2766.         fi
  2767.     fi
  2768.     let i+=1
  2769. done
  2770. }
  2771.  
  2772.  
  2773. function verifyconf
  2774. {
  2775. # verifyconf(formid, bd_array_index)
  2776. # Called from both the verifydriver() and verifyhdw() functions
  2777. # to verify the configuration for board index specified after
  2778. # syncing input on the form specified.
  2779. # Calling/Exit State: void.
  2780.  
  2781. [ "$DCUDEBUG" -gt 3 ] && {
  2782. print -u2 "$0 called"
  2783. set -x
  2784. }
  2785. typeset found=0
  2786. typeset lMODNAME=""
  2787. integer drv
  2788. integer bd=0
  2789.  
  2790. call fld_sync $1
  2791. BDTYPE[0]=$changed
  2792. RMnewkey
  2793. BDKEY[0]=$?
  2794. BDMODNAME[0]="${BDMODNAME[$2]}"
  2795. BDNAME[0]="${BDNAME[$2]}"
  2796. BDUNIT[0]="${BDUNIT[$2]}"
  2797. BDIPL[0]="${BDIPL[$2]}"
  2798. BDITYPE[0]="${BDITYPE[$2]}"
  2799. BDIRQ[0]="${BDIRQ[$2]}"
  2800. BDPORTSTART[0]="${BDPORTSTART[$2]}"
  2801. BDPORTEND[0]="${BDPORTEND[$2]}"
  2802. BDADDRSTART[0]="${BDADDRSTART[$2]}"
  2803. BDADDREND[0]="${BDADDREND[$2]}"
  2804. BDDMA[0]="${BDDMA[$2]}"
  2805. BDCPU[0]="${BDCPU[$2]}"
  2806. BDBUSTYPE[0]="${BDBUSTYPE[$2]}"
  2807. BDID[0]="${BDID[$2]}"
  2808. BDCLASS[0]="${BDCLASS[$2]}"
  2809. BDCNFG[0]="$Y"
  2810. BDCHGS[0]=$ADD_DEL_CHG
  2811.  
  2812. for drv in $ALLDRIVERS
  2813. do
  2814.     if [ "${BDMODNAME[bd]}" = "${MODNAME[drv]}" ]
  2815.     then
  2816.         found=1
  2817.         break
  2818.     fi
  2819. done
  2820. if [ $found = 0 ]
  2821. then
  2822.     RMdelkey ${BDKEY[0]}
  2823.     return
  2824. fi
  2825. if [ ${DRVVERIFY[drv]} = N ]
  2826. then
  2827.     drv_noverify $bd
  2828.     RMdelkey ${BDKEY[0]}
  2829.     return
  2830. fi
  2831. footer "$VERIFYFOOTER"
  2832. if [ -n "${BDKEY[$bd]}" ]
  2833. then
  2834.     #update resmgr for board record
  2835.     lMODNAME="${BDMODNAME[$bd]}"
  2836.     BDMODNAME[$bd]="$dash"
  2837.     RMadd "$bd"
  2838.     BDMODNAME[$bd]="$lMODNAME"
  2839.     if verify $bd $drv
  2840.     then
  2841.         display -w "$BoardName ${BDMODNAME[bd]} $VERIFYSUCCESS"
  2842.         footer "$GENERIC_CONTINUE_FOOTER"
  2843.     else
  2844.         display -w "$BoardName ${BDMODNAME[bd]} $VERIFYFAIL" -bg $RED -fg $WHITE
  2845.         footer "$GENERIC_CONTINUE_FOOTER"
  2846.     fi
  2847. else
  2848.     display -w "$BD_NOSAVED" -bg $RED -fg $WHITE
  2849.     footer "$GENERIC_CONTINUE_FOOTER"
  2850. fi
  2851. RMdelkey ${BDKEY[0]}
  2852. }
  2853.  
  2854.  
  2855. function drv_noverify
  2856. {
  2857. # drv_noverify(bd_array_index)
  2858. # Called to display a message when the F4=Verify hotkey is invoked and
  2859. # the corresponding drvmap.d file has an 'N' instead of a 'Y' for the
  2860. # verify function.
  2861. # Calling/Exit State: void.
  2862.  
  2863. [ "$DCUDEBUG" -gt 3 ] && {
  2864. print -u2 "$0 called"
  2865. set -x
  2866. }
  2867. display -w "$BoardName ${BDMODNAME[$1]} $DRV_NOVERIFY" -bg $MAGENTA -fg $WHITE
  2868. footer "$GENERIC_CONTINUE_FOOTER"
  2869. }
  2870.  
  2871. function dcu_action
  2872. {
  2873. # dcu_action(action)
  2874. # Called to set the DCU_ACTION parameter to either $DCU_REBOOT or $DCU_REBUILD
  2875. # for the special RM_KEY.
  2876. # Calling/Exit State: void.
  2877.  
  2878. [ "$DCUDEBUG" -gt 3 ] && {
  2879. print -u2 "$0 called"
  2880. set -x
  2881. }
  2882.  
  2883. RMputvals -1 "DCU_ACTION,s" $1
  2884. if [ ! "$?" = "0" ] \
  2885. && [ "$UNIX_INSTALL" = "N" ]
  2886. then
  2887.     display -w "$DCUACTION" -bg $RED -fg $WHITE
  2888.     footer "$GENERIC_CONTINUE_FOOTER"
  2889.     call proc_loop
  2890. fi
  2891. }
  2892.  
  2893. function allow_conflict
  2894. {
  2895. # allow_conflict(MODNAME, flag)
  2896. # Read the /etc/conf/mdevice.d/[MODNAME] file for a device driver
  2897. # checking for flag that indicates conflict override capability.
  2898. # Calling/Exit State: 0 for false and 1 for true(override).
  2899.  
  2900. [ "$DCUDEBUG" -gt 3 ] && {
  2901. print -u2 "$0 called"
  2902. set -x
  2903. }
  2904. typeset -u drvname pre char ord bmaj cmaj
  2905. typeset x w
  2906.  
  2907. w=${1#*mdevice.d/}
  2908. grep ^$w $1 2> /dev/null | read drvname pre char ord bmaj cmaj 
  2909. case "$char" in
  2910. *$2*)
  2911.     return 1
  2912.     ;;
  2913. *)
  2914.     return 0
  2915.     ;;
  2916. esac
  2917. }
  2918.  
  2919. function set_adv_params
  2920. {
  2921. # set_adv_params(bd_array_index)
  2922. # Called to read sdevice file for a IPL, ITYPE and BINDCPU fields
  2923. # and set them for the corresponding board.
  2924. # Only set ITYPE if not currently set.
  2925. # Calling/Exit State: void.
  2926.  
  2927. [ "$DCUDEBUG" -gt 3 ] && {
  2928. print -u2 "$0 called"
  2929. set -x
  2930. }
  2931. typeset drvname isc unit ipl itype irq ports porte mems meme dma cpu
  2932.  
  2933. while read drvname isc unit ipl itype irq ports porte mems meme dma cpu
  2934. do
  2935.     if [ ! "$drvname" = "${BDMODNAME[$1]}" ]
  2936.     then
  2937.         continue
  2938.     fi
  2939.     BDIPL[$1]="$ipl"
  2940.     if [ "${BDITYPE[$1]}" = "$dash" ]
  2941.     then
  2942.         BDITYPE[$1]="$itype"
  2943.     fi
  2944.     if [ -z "$cpu" ]
  2945.     then
  2946.         BDCPU[$1]="$dash"
  2947.     else
  2948.         BDCPU[$1]="$cpu"
  2949.     fi
  2950. done <${ROOT}/etc/conf/sdevice.d/"${BDMODNAME[$1]}"
  2951. }
  2952.  
  2953.  
  2954. function silent_verify
  2955. {
  2956. # silent_verify(bd_array_index, drv_array_index)
  2957. # Called when performing the silent boardid mapping and
  2958. # the driver's drvmap file has a 'V' in the verify field
  2959. # so that the verify() is invoked before the silent matching.
  2960. # If this is not during Installation,
  2961. # try to idbuild the driver when the verify initially fails.
  2962. # Calling/Exit State: 0 for success and 1 for failure.
  2963.  
  2964. [ "$DCUDEBUG" -gt 3 ] && {
  2965. print -u2 "$0 called"
  2966. set -x
  2967. }
  2968.     integer brd=$1
  2969.     integer drv=$2
  2970.     typeset CLEAR_ITYPE=N
  2971.  
  2972.     verify $brd $drv
  2973.     if [ $? -eq 0 ]
  2974.     then
  2975.         return 0
  2976.     fi
  2977.     if [ "$UNIX_INSTALL" = "Y" ]
  2978.     then
  2979.         return 1
  2980.     fi
  2981. # check to see if the error was ENOENT (2).  If it was, this means
  2982. # that the verify failed because the driver was not loaded and we
  2983. # try to load it.  If the error was something else, then we just fail.
  2984.     cdecl intp sv_errno='&Xk_errno'
  2985.     cprint -v sv_errno sv_errno
  2986.     if [ "$sv_errno" != 2 ]
  2987.     then
  2988.         return 1
  2989.     fi
  2990.     BDNAME[brd]="${DRVBOARDNAME[drv]}"
  2991.     BDMODNAME[brd]="${MODNAME[drv]}"
  2992.     [ -z BDITYPE[brd] ] && CLEAR_ITYPE=Y
  2993.     set_adv_params $brd
  2994.     BDMODNAME[brd]="$dash"
  2995.     wrtRM_key $brd
  2996.     RMclose
  2997.     /etc/conf/bin/idbuild -c -M ${MODNAME[drv]} > /dev/null 2>&1
  2998.     RMopen 2
  2999.     verify $brd $drv
  3000.     if [ $? -eq 0 ]
  3001.     then
  3002.         BDMODNAME[brd]="${MODNAME[drv]}"
  3003.         wrtRM_key $brd 
  3004.         return 0
  3005.     fi
  3006.     BDNAME[brd]="$dash"
  3007.     BDMODNAME[brd]="$dash"
  3008.     if [ "$CLEAR_ITYPE" = Y ]
  3009.     then
  3010.         BDITYPE[brd]="$dash"
  3011.     fi
  3012.     wrtRM_key $brd
  3013.     return 1
  3014. }
  3015.