home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / update701 / root.17 / etc / dcu.d / scripts / dcurc / dcurc~
Text File  |  1998-08-18  |  31KB  |  1,617 lines
  1. #ident    "@(#)dcu:scripts/dcurc    1.62.5.3"
  2.  
  3. #
  4. # NOTE: if you want a blank line in a embedded string a string use
  5. # ${IM_A_BLANK_LINE_DONT_TOUCH}
  6. #
  7.  
  8. function RMopen
  9. {
  10. # RMopen(flags)
  11. # Call its C function equivalent from libresmgr
  12. # to open /dev/resmgr according to flags.
  13. # Calling/Exit State: see RMopen(3).
  14.  
  15. [ "$DCUDEBUG" -gt 3 ] && {
  16. print -u2 "$0 called"
  17. set -x
  18. }
  19.     typeset rmfd rtnd
  20.     
  21.     call RMopen $1
  22.     rtnd=$_RETD
  23.     call RMgetfd
  24.     rmfd=$_RETD
  25.     case $rmfd
  26.     in
  27.     $FD3)
  28.         FD3=5
  29.         ;;
  30.     $FD4)
  31.         FD4=5
  32.         ;;
  33.     esac
  34.     return $rtnd
  35. }
  36.         
  37. function RMclose
  38. {
  39. # RMclose()
  40. # Call its C function equivalent from libresmgr
  41. # to close /dev/resmgr.
  42. # Calling/Exit State: see RMclose(3).
  43.  
  44. [ "$DCUDEBUG" -gt 3 ] && {
  45. print -u2 "$0 called"
  46. set -x
  47. }
  48.     call RMclose
  49.     return $_RETD
  50. }
  51.         
  52. function RMdelkey
  53. {
  54. # RMdelkey(rm_key)
  55. # Call its C function equivalent from libresmgr
  56. # to delete designated resmgr key.
  57. # Calling/Exit State: Ignored. SHOULD be checking! see RMdelkey(3).
  58.  
  59. [ "$DCUDEBUG" -gt 3 ] && {
  60. print -u2 "$0 called"
  61. set -x
  62. }
  63.     call RMdelkey $1
  64. }
  65.  
  66. function RMnewkey
  67. {
  68. # RMnewkey()
  69. # Call its C function equivalent from libresmgr
  70. # to generate a key for a new in-core resmgr database entry.
  71. # Calling/Exit State: see RMnewkey(3).
  72.  
  73. [ "$DCUDEBUG" -gt 3 ] && {
  74. print -u2 "$0 called"
  75. set -x
  76. }
  77.     integer retrnd
  78.     cdecl intp rmkp=0
  79.     ccall RMnewkey rmkp
  80.     if (( retrnd=$_RETD ))
  81.     then
  82.         retrnd=0
  83.     else
  84.         cprint -v retrnd rmkp
  85.     fi
  86.     ccall RMend_trans rmkp
  87.     return $retrnd
  88. }
  89.  
  90. function RMnextkey
  91. {
  92. # RMnextkey(current_key)
  93. # Call its C function equivalent from libresmgr
  94. # to get the next key; current key value 0 returns the first key.
  95. # Calling/Exit State: next key value.
  96.  
  97. [ "$DCUDEBUG" -gt 3 ] && {
  98. print -u2 "$0 called"
  99. set -x
  100. }
  101.  
  102.     integer retrnd
  103.     cdecl intp rmkp=$1
  104.     ccall RMbegin_trans $1 100
  105.     ccall RMnextkey rmkp
  106.     let retrnd=$_RETD
  107.     ccall RMend_trans $1
  108.     if (( $retrnd ))
  109.     then
  110.         retrnd=0
  111.     else
  112.         cprint -v retrnd rmkp
  113.     fi
  114.     return $retrnd
  115. }
  116.  
  117. function RMgetvals
  118. {
  119. # RMgetvals(key, parm_list, inst)
  120. # Call its C function equivalent from libresmgr
  121. # to read inst instance of parm_list values from in-core resmgr database.
  122. # Calling/Exit State: returns the number of parameters read, 0
  123. # indicates failure
  124. # otherwise, returns parm_out_array[n] where n equals number of input parms.
  125.  
  126. [ "$DCUDEBUG" -gt 3 ] && {
  127. print -u2 "$0 called"
  128. set -x
  129. }
  130.  
  131.     integer retrnd  n m
  132.     typeset valp
  133.     set -A RMINPARMS $2
  134.     integer nparms=${#RMINPARMS[*]}
  135.  
  136.     cdecl string_t plistp="!$2!"
  137.     let n=nparms*20
  138.     call malloc $n
  139.     valp=$_RETX
  140.  
  141.     ccall RMbegin_trans $1 100
  142.     ccall RMgetvals $1 plistp $3 $valp $n
  143.     ccall RMend_trans $1
  144.     if (( retrnd=$_RETD ))
  145.     then
  146.         call free $valp
  147.         return 0
  148.     else
  149.         set -A RMOUTVALS x $(call altprintf '%s ' $valp)
  150.         m=1
  151.         n=0
  152.         while (( n <= nparms ))
  153.         do
  154.             case "${RMINPARMS[n]}"
  155.             in
  156.             IRQ)
  157.                 eval RM${RMINPARMS[n]}=\""${RMOUTVALS[m]}"\"
  158.                 [ "${RMOUTVALS[m]}" = 9 ] && {
  159.                 eval RM${RMINPARMS[n]}=2
  160.                 }
  161.                 let m+=1
  162.                 ;;
  163.             IOADDR)
  164.                 RMPORTSTART="${RMOUTVALS[m]}"
  165.                 RMPORTEND="${RMOUTVALS[m+1]}"
  166.                 let m+=2
  167.                 ;;
  168.             MEMADDR)
  169.                 eval RMADDRSTART="${RMOUTVALS[m]}"
  170.                 eval RMADDREND="${RMOUTVALS[m+1]}"
  171.                 let m+=2
  172.                 ;;
  173.             BRDBUSTYPE)
  174.                 case "${RMOUTVALS[m]}"
  175.                 in
  176.                 $unktype|$dash)
  177.                     eval RM${RMINPARMS[n]}=\""$unknown"\"
  178.                     ;;
  179.                 $isatype)
  180.                     eval RM${RMINPARMS[n]}=\""$isa"\"
  181.                     ;;
  182.                 $eisatype)
  183.                     eval RM${RMINPARMS[n]}=\""$eisa"\"
  184.                     ;;
  185.                 $mcatype)
  186.                     eval RM${RMINPARMS[n]}=\""$mca"\"
  187.                     ;;
  188.                 $systype)
  189.                     eval RM${RMINPARMS[n]}=\""$sys"\"
  190.                     ;;
  191.                 $pnptype)
  192.                     eval RM${RMINPARMS[n]}=\""$pnp"\"
  193.                     ;;
  194.                 $pcitype)
  195.                     eval RM${RMINPARMS[n]}=\""$pci"\"
  196.                     ;;
  197.                 $pcmciatype)
  198.                     eval RM${RMINPARMS[n]}=\""$pcmcia"\"
  199.                     ;;
  200.                 $i2otype)
  201.                     eval RM${RMINPARMS[n]}=\""$i2o"\"
  202.                     ;;
  203.                 *)
  204.                     eval RM${RMINPARMS[n]}=\""$unknown"\"
  205.                     ;;
  206.                 esac
  207.                 let m+=1
  208.                 ;;
  209.             *)
  210.                 eval RM${RMINPARMS[n]%%,*}=\""${RMOUTVALS[m]}"\"
  211.                 let m+=1
  212.                 ;;
  213.             esac
  214.             let n+=1
  215.         done
  216.         call free $valp
  217.         return $nparms
  218.     fi
  219.         
  220. }
  221.  
  222. function RMputvals
  223. {
  224. # RMputvals(key, parm_list, value_list)
  225. # Call its C function equivalent from libresmgr
  226. # to add parameter and value pairs supplied to resmgr entry for specified key.
  227. # Calling/Exit State: see RMputvals(3).
  228.  
  229. [ "$DCUDEBUG" -gt 3 ] && {
  230. print -u2 "$0 called"
  231. set -x
  232. }
  233.     integer m n
  234.     set -A RMINPARMS $2
  235.     set -A RMINVALS - $3
  236.     integer nparms=${#RMINPARMS[*]}
  237.  
  238.     m=0
  239.     n=0
  240.     while (( n < nparms ))
  241.     do
  242.         case "${RMINPARMS[n]}"
  243.         in
  244.         IRQ)
  245.             [ "${RMINVALS[m]}" = 2 ] && RMINVALS[m]=9
  246.             let m+=1
  247.             ;;
  248.         IOADDR|MEMADDR)
  249.             let m+=2
  250.             ;;
  251.         BRDBUSTYPE)
  252.             case "${RMINVALS[m]}"
  253.             in
  254.             $isa)
  255.                 RMINVALS[m]=$isatype
  256.                 ;;
  257.             $eisa)
  258.                 RMINVALS[m]=$eisatype
  259.                 ;;
  260.             $mca)
  261.                 RMINVALS[m]=$mcatype
  262.                 ;;
  263.             $sys)
  264.                 RMINVALS[m]=$systype
  265.                 ;;
  266.             $pnp)
  267.                 RMINVALS[m]=$pnptype
  268.                 ;;
  269.             $pci)
  270.                 RMINVALS[m]=$pcitype
  271.                 ;;
  272.             $pcmcia)
  273.                 RMINVALS[m]=$pcmciatype
  274.                 ;;
  275.             $i2o)
  276.                 RMINVALS[m]=$i2otype
  277.                 ;;
  278.             *)
  279.                 RMINVALS[m]=$unktype
  280.                 ;;
  281.             esac
  282.             let m+=1
  283.             ;;
  284.         *)
  285.             let m+=1
  286.             ;;
  287.         esac
  288.         let n+=1
  289.     done
  290.  
  291.     cdecl string_t plistp="!${RMINPARMS[*]}!"
  292.     cdecl string_t vlistp="!${RMINVALS[*]}!"
  293.     cdecl ulong key=$1
  294.  
  295.     ccall RMbegin_trans $1 200
  296.     ccall RMputvals key plistp vlistp
  297.     ccall RMend_trans $1
  298.     return $_RETD
  299. }
  300.  
  301. function RMdelvals
  302. {
  303. # RMdelvals(key, param_list)
  304. # Call its C function equivalent from libresmgr
  305. # to delete all instances of parameters listed in param_list.
  306. # Calling/Exit State: see RMdelvals(3).
  307.  
  308. [ "$DCUDEBUG" -gt 3 ] && {
  309. print -u2 "$0 called"
  310. set -x
  311. }
  312.  
  313.     cdecl string_t plistp="!$2!"
  314.  
  315.     ccall RMbegin_trans $1 200
  316.     ccall RMdelvals $1 plistp
  317.     ccall RMend_trans $1
  318.     return $_RETD
  319. }
  320.  
  321. function verify
  322. {
  323. # verify(bd_array_index, module)
  324. # Called to invoke driver verify routine.
  325. # Calling/Exit State: 0 for success and driver's verify return code for failure.
  326.  
  327. [ "$DCUDEBUG" -gt 3 ] && {
  328. print -u2 "$0 called"
  329. set -x
  330. }
  331.  
  332. struct modadm.ver name:'char [16]' typedata:int
  333. call modadm 1 2 "@modadm.ver:{ !${MODNAME[$2]}!, ${BDKEY[$1]} }" || call altperror 'modadm failed'
  334. return $_RETD
  335. }
  336.  
  337. function verifym
  338. {
  339. #verifym (bd_array_index, modname)
  340. #invokes the modname's verify routine
  341. # Calling/Exit State: 0 is success, verify's return code for failure
  342.  
  343. [ "$DCUDEBUG" -gt 3 ] && {
  344. print -u2 "$0 called"
  345. set -x
  346. }
  347. struct modadm.ver name:'char [16]' typedata:int
  348. call modadm 1 2 "@modadm.ver:{ !$2!, ${BDKEY[$1]} }"
  349. return $_RETD
  350. }
  351. function RMadd
  352. {
  353. # RMadd(bd_array_index)
  354. # Called to update a resmgr database key by writing or deleting
  355. # the key based upon the BDCNFG variable.
  356. # Calling/Exit State: 0 is success, 1 is failure.
  357.  
  358. [ "$DCUDEBUG" -gt 3 ] && {
  359. print -u2 "$0 called"
  360. set -x
  361. }
  362. [ ${DCUMODE} = DCUSCREENS ] && footer "$BDUPDATE_FOOTER"
  363. #update RM database
  364. integer err=0
  365. if [ "${BDTYPE[$1]}" = $none ]
  366. then
  367.     return 0
  368. fi
  369. if [ "${BDTYPE[$1]}" = $unused ]
  370. then
  371.     return 0
  372. fi
  373. if (( ${BDCHGS[$1]} ))
  374. then
  375.     if [ "${BDCNFG[$1]}" = "$N" ]
  376.     then
  377.         RMdelkey ${BDKEY[$1]}
  378.         err=$?
  379.         continue
  380.     else
  381.         wrtRM_key $1
  382.         err=$?
  383.     fi
  384. fi
  385. if (( err ))
  386. then
  387.     msgnoerr "$BAD_UPDATE"
  388.     return 1
  389. else
  390.     return 0
  391. fi
  392. }
  393.  
  394. function RMapply_choice
  395. {
  396. # RMapply_choice()
  397. # Called by the conflict detection routines when
  398. # Apply Changes & Exit DCU was selected and a conflict is detected.
  399. # Its purpose is to allow the user the ability to resolve or ignore
  400. # the conflict being displayed.
  401. # Calling/Exit State:
  402. # 0 indicates Enter the DCU to resolve conflicts,
  403. # 1 indicates Ignore conflicts and Apply Changes.
  404.  
  405. [ "$DCUDEBUG" -gt 3 ] && {
  406. print -u2 "$0 called"
  407. set -x
  408. }
  409.         typeset applychoice
  410.  
  411.         if [ -z "${APPLY_OPT}" ]
  412.         then
  413.                 typeset OIFS="$IFS"
  414.                 IFS="$nl"
  415.                 set -A APPLY_OPT ${CHOOSE_APPLY_CONF}
  416.                 IFS="$OIFS"
  417.         fi
  418.         applychoice=$APPLY_OPT
  419.     CHOOSE_TITLE="$CHOICES"
  420.     CHOOSE_FOOTER="$DCU_CHOOSE_FOOTER"
  421.         choose -f -e -exit apply_exit -winparms "-below 0 -fg $COMBO2_FG -bg $COMBO2_BG" "$applychoice" "${APPLY_OPT[@]}"
  422. }
  423.  
  424. function apply_exit
  425. {
  426. # apply_exit()
  427. # Called after the Choice has been made when "Apply Changes & Exit DCU"
  428. # was selected and a conflict was displayed.
  429. # Calling/Exit State: void.
  430.  
  431. [ "$DCUDEBUG" -gt 3 ] && {
  432. print -u2 "$0 called"
  433. set -x
  434. }
  435.         case $CHOICE in
  436.         ${APPLY_OPT[0]})
  437.                 APPLY_CONF=1
  438.                 ;;
  439.         ${APPLY_OPT[1]})
  440.                 APPLY_CONF=0
  441.                 ;;
  442.         esac
  443. }
  444.  
  445. function RMirqconf
  446. {
  447. # RMirqconf(bd_array_index1, bd_index2)
  448. # Called to check for IRQ conflicts
  449. # during entry into the dcu, or
  450. # before Applying Changes & Exiting.
  451. # It sets the DCU_EXIT_CODE variable to 3.
  452. # Calling/Exit State:
  453. # During DCU entry the return code is ignored,
  454. # 0 during DCU exit indicates Enter the DCU to resolve conflicts,
  455. # 1 during DCU exit indicates Ignore conflicts and Apply Changes.
  456.  
  457. [ "$DCUDEBUG" -gt 3 ] && {
  458. print -u2 "$0 called"
  459. set -x
  460. }
  461.  
  462. integer _t
  463.  
  464. if [ ! "${BDIRQ[$2]}" = "${BDIRQ[$1]}" ] \
  465. || [ -z "${BDNAME[$1]}" ] \
  466. || [ -z "${BDNAME[$2]}" ] \
  467. || [ "${BDCNFG[$1]}" = "$N" ] \
  468. || [ "${BDCNFG[$2]}" = "$N" ] \
  469. || [ "${BDIRQ[$1]}" = "$dash" ] \
  470. || [ "${BDIRQ[$2]}" = "$dash" ] \
  471. || [ "${BDITYPE[$1]}" = "0" ] \
  472. || [ "${BDITYPE[$2]}" = "0" ] \
  473. || [ "${BDNAME[$1]}" = "$dash" ] \
  474. || [ "${BDNAME[$2]}" = "$dash" ] \
  475. || [ "${BDNAME[$1]}" = "$unused" ] \
  476. || [ "${BDNAME[$2]}" = "$unused" ] \
  477. || [ "${BDNAME[$1]}" = "$unknown" ] \
  478. || [ "${BDNAME[$2]}" = "$unknown" ] 
  479. then
  480.     return 0
  481. fi
  482. if [ "$UNIX_INSTALL" = Y ]; then
  483.  
  484.     if [ "${BDBUSTYPE[$2]}" = "$unknown" ]; then
  485.         RMdelkey ${BDKEY[$2]}
  486.     fi
  487.     return 2
  488. fi
  489.  
  490.  
  491. if [ "${BDITYPE[$2]}" = 1 ] || [ "${BDITYPE[$1]}" = 1 ] 
  492. then
  493.     IRQ_display_error $1 $2 "$IRQNOSHARE"
  494.     return $?
  495. fi
  496.  
  497. if [ "${BDITYPE[$2]}" = 2 ] && [ "${BDITYPE[$1]}" = 2 ] \
  498. && [ ! "${BDMODNAME[$2]}" = "${BDMODNAME[$1]}" ]
  499. then
  500.     IRQ_display_error $1 $2 "$IRQSELFSHARE"
  501.     return $?
  502. fi
  503.  
  504. if [ "${BDITYPE[$2]}" = 3 ] && [ "${BDITYPE[$1]}" = 4 ]
  505. then
  506.     IRQ_display_error $1 $2 "$IRQNOSHARE"
  507.     return $?
  508. fi
  509.  
  510. if [ "${BDITYPE[$2]}" = 4 ] && [ "${BDITYPE[$1]}" = 3 ]
  511. then
  512.     IRQ_display_error $1 $2 "$IRQNOSHARE"
  513.     return $?
  514. fi
  515.  
  516. return 0
  517. }
  518.  
  519. function IRQ_display_error
  520. {
  521. # IRQ_display_error(bd_array_index1, bd_array_index2, MESSAGE)
  522. # Common routine called to display an IRQ conflict message
  523. # when detected upon entry or exit of the DCU.
  524. # It sets the DCU_EXIT_CODE variable to 3.
  525. # Calling/Exit State:
  526. # During DCU entry the return code is ignored,
  527. # 0 during DCU exit indicates Enter the DCU to resolve conflicts,
  528. # 1 during DCU exit indicates Ignore conflicts and Apply Changes.
  529.  
  530. [ "$DCUDEBUG" -gt 3 ] && {
  531. print -u2 "$0 called"
  532. set -x
  533. }
  534.  
  535. typeset MESSAGE="ERROR:
  536. $boardname=${BDNAME[$1]}, $boardipl=${BDIPL[$1]}, $boarditype=${BDITYPE[$1]}, $boardirq=${BDIRQ[$1]}.
  537. ${IM_A_BLANK_LINE_DONT_TOUCH}
  538. $3
  539. ${IM_A_BLANK_LINE_DONT_TOUCH}
  540. $boardname=${BDNAME[$2]}, $boardipl=${BDIPL[$2]}, $boarditype=${BDITYPE[$2]}, $boardirq=${BDIRQ[$2]}."
  541.  
  542. DCU_EXIT_CODE=3
  543.  
  544. if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  545. then
  546.     display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  547.     _t=$CURWIN
  548.     RMapply_choice
  549.     input_handler
  550.     wclose $_t
  551.     return $APPLY_CONF
  552. fi
  553.  
  554. if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  555. then
  556.     pr_dcu_conf
  557.     display -w "$MESSAGE" -bg $RED -fg $WHITE
  558.     footer $GENERIC_CONTINUE_FOOTER
  559.     call proc_loop
  560. fi
  561. }
  562.  
  563. function RMioaddrconf
  564. {
  565. # RMioaddrconf(bd_array_index1, bd_array_index2)
  566. # Called to check for IOADDR conflicts
  567. # during entry into the dcu, or
  568. # before Applying Changes & Exiting.
  569. # It sets the DCU_EXIT_CODE variable to 3.
  570. # Calling/Exit State:
  571. # During DCU entry the return code is ignored,
  572. # 0 during DCU exit indicates Enter the DCU to resolve conflicts,
  573. # 1 during DCU exit indicates Ignore conflicts and Apply Changes.
  574.  
  575. [ "$DCUDEBUG" -gt 3 ] && {
  576. print -u2 "$0 called"
  577. set -x
  578. }
  579.  
  580. typeset MESSAGE
  581.  
  582. if [ "${BDNAME[$1]}" = "$dash" ] \
  583. || [ "${BDNAME[$2]}" = "$dash" ] \
  584. || [ -z "${BDNAME[$1]}" ] \
  585. || [ -z "${BDNAME[$2]}" ] \
  586. || [ "${BDCNFG[$1]}" = "$N" ] \
  587. || [ "${BDCNFG[$2]}" = "$N" ] \
  588. || [ "${BDNAME[$1]}" = "$unused" ] \
  589. || [ "${BDNAME[$2]}" = "$unused" ] \
  590. || [ "${BDNAME[$1]}" = "$unknown" ] \
  591. || [ "${BDNAME[$2]}" = "$unknown" ] 
  592. then
  593.     return 0
  594. fi
  595.  
  596. if [ "${BDPORTSTART[$1]}" = "$dash" ] \
  597. && [ "${BDPORTEND[$1]}" = "$dash" ] 
  598. then
  599.     return 0
  600. fi
  601.  
  602. if [ "${BDPORTSTART[$1]}" = "0" ] \
  603. && [ "${BDPORTEND[$1]}" = "0" ]
  604. then
  605.     return 0
  606. fi
  607.  
  608. if [ -z "${BDPORTSTART[$1]}" ]  \
  609. && [ -z "${BDPORTEND[$1]}" ] 
  610. then
  611.     return 0
  612. fi
  613.  
  614. if [   "${BDPORTSTART[$1]}" = "$dash" ] \
  615. && [ ! "${BDPORTEND[$1]}" = "$dash" ] 
  616. then
  617.     MESSAGE="ERROR:
  618. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  619. ${IM_A_BLANK_LINE_DONT_TOUCH}
  620. $IOSREQ"
  621.  
  622.     DCU_EXIT_CODE=3
  623.  
  624.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  625.     then
  626.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  627.         _t=$CURWIN
  628.         RMapply_choice
  629.         input_handler
  630.         wclose $_t
  631.         return $APPLY_CONF
  632.     fi
  633.  
  634.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  635.     then
  636.         pr_dcu_conf
  637.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  638.         footer $GENERIC_CONTINUE_FOOTER
  639.         call proc_loop
  640.     fi
  641. fi
  642.     
  643. if [ ! "${BDPORTSTART[$1]}" = "$dash" ] \
  644. && [   "${BDPORTEND[$1]}" = "$dash" ]
  645. then
  646.     MESSAGE="ERROR:
  647. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  648. ${IM_A_BLANK_LINE_DONT_TOUCH}
  649. $IOEREQ" 
  650.  
  651.     DCU_EXIT_CODE=3
  652.  
  653.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  654.     then
  655.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  656.         _t=$CURWIN
  657.         RMapply_choice
  658.         input_handler
  659.         wclose $_t
  660.         return $APPLY_CONF
  661.     fi
  662.  
  663.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  664.     then
  665.         pr_dcu_conf
  666.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  667.         footer $GENERIC_CONTINUE_FOOTER
  668.         call proc_loop
  669.     fi
  670. fi
  671.     
  672. if [ "${BDPORTSTART[$2]}" = "$dash" ] \
  673. && [ "${BDPORTEND[$2]}" = "$dash" ] 
  674. then
  675.     return 0
  676. fi
  677.  
  678. if [ -z "${BDPORTSTART[$2]}" ] \
  679. && [ -z "${BDPORTEND[$2]}" ] 
  680. then
  681.     return 0
  682. fi
  683.  
  684. typeset x ports porte ios ioe
  685. x=${BDPORTEND[$1]}
  686. typeset -i16 porte=16#$x
  687.  
  688. x=${BDPORTSTART[$2]}
  689. typeset -i16 ios=16#$x
  690. x=${BDPORTEND[$2]}
  691. typeset -i16 ioe=16#$x
  692.  
  693. x=${BDPORTSTART[$1]}
  694. typeset -i16 ports=16#$x
  695. if [ porte -lt ports ]
  696. then
  697.     if [ "$1" = "$RMIOCHKD" ]
  698.     then
  699.         return 0
  700.     else
  701.         RMIOCHKD="$1"
  702.     fi
  703.     MESSAGE="ERROR:
  704. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  705. ${IM_A_BLANK_LINE_DONT_TOUCH}
  706. $BD_BAD_PORTE"
  707.  
  708.     DCU_EXIT_CODE=3
  709.  
  710.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  711.     then
  712.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  713.         _t=$CURWIN
  714.         RMapply_choice
  715.         input_handler
  716.         wclose $_t
  717.         return $APPLY_CONF
  718.     fi
  719.  
  720.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  721.     then
  722.         pr_dcu_conf
  723.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  724.         footer $GENERIC_CONTINUE_FOOTER
  725.         call proc_loop
  726.     fi
  727. fi
  728.  
  729. if [ "${BDPORTSTART[$2]}" = "0" ] \
  730. || [ "${BDPORTEND[$2]}" = "0" ]
  731. then
  732.     return 0
  733. fi
  734.  
  735. if [ porte -ge ios -a ports -le ioe ]
  736. then
  737.     typeset allow1 allow2
  738.     allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} O
  739.     allow1=$?
  740.     allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$2]} O
  741.     allow2=$?
  742.     if (( allow1 && allow2 ))
  743.     then
  744.         return 0
  745.     fi
  746.     MESSAGE="ERROR:
  747. $boardname=${BDNAME[$1]}, $boardios=${BDPORTSTART[$1]}, $boardioe=${BDPORTEND[$1]}.
  748. ${IM_A_BLANK_LINE_DONT_TOUCH}
  749. $IOCONF
  750. ${IM_A_BLANK_LINE_DONT_TOUCH}
  751. $boardname=${BDNAME[$2]}, $boardios=${BDPORTSTART[$2]}, $boardioe=${BDPORTEND[$2]}."
  752.  
  753.     DCU_EXIT_CODE=3
  754.  
  755.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  756.     then
  757.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  758.         _t=$CURWIN
  759.         RMapply_choice
  760.         input_handler
  761.         wclose $_t
  762.         return $APPLY_CONF
  763.     fi
  764.  
  765.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  766.     then
  767.         pr_dcu_conf
  768.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  769.         footer $GENERIC_CONTINUE_FOOTER
  770.         call proc_loop
  771.     fi
  772. fi
  773. return 0
  774. }
  775.  
  776. function RMmemaddrconf
  777. {
  778. # RMmemaddrconf(bd_array_index1, bd_array_index2)
  779. # Called to check for MEMADDR conflicts
  780. # during entry into the dcu, or
  781. # before Applying Changes & Exiting.
  782. # It sets the DCU_EXIT_CODE variable to 3.
  783. # Calling/Exit State:
  784. # During DCU entry the return code is ignored,
  785. # 0 during DCU exit indicates Enter the DCU to resolve conflicts,
  786. # 1 during DCU exit indicates Ignore conflicts and Apply Changes.
  787.  
  788. [ "$DCUDEBUG" -gt 3 ] && {
  789. print -u2 "$0 called"
  790. set -x
  791. }
  792.  
  793. typeset MESSAGE
  794.  
  795. if [ "${BDNAME[$1]}" = "$dash" ] \
  796. || [ "${BDNAME[$2]}" = "$dash" ] \
  797. || [ -z "${BDNAME[$1]}" ] \
  798. || [ -z "${BDNAME[$2]}" ] \
  799. || [ "${BDCNFG[$1]}" = "$N" ] \
  800. || [ "${BDCNFG[$2]}" = "$N" ] \
  801. || [ "${BDNAME[$1]}" = "$unused" ] \
  802. || [ "${BDNAME[$2]}" = "$unused" ] \
  803. || [ "${BDNAME[$1]}" = "$unknown" ] \
  804. || [ "${BDNAME[$2]}" = "$unknown" ] 
  805. then
  806.     return 0
  807. fi
  808.  
  809. if [ "${BDADDRSTART[$1]}" = "$dash" ] \
  810. && [ "${BDADDREND[$1]}" = "$dash" ]
  811. then
  812.     return 0
  813. fi
  814.  
  815. if [ "${BDADDRSTART[$1]}" = "0" ] \
  816. && [ "${BDADDREND[$1]}" = "0" ]
  817. then
  818.     return 0
  819. fi
  820.  
  821. if [ -z "${BDADDRSTART[$1]}" ] \
  822. && [ -z "${BDADDRTEND[$1]}" ] 
  823. then
  824.     return 0
  825. fi
  826.  
  827. typeset allow1 allow2
  828. allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} M
  829. allow1=$?
  830. allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$2]} M
  831. allow2=$?
  832. if (( allow1 && allow2 ))
  833. then
  834.     return 0
  835. fi
  836.  
  837. if [ "${BDADDRSTART[$1]}" = "$dash" ] \
  838. && [ ! "${BDADDREND[$1]}" = "$dash" ] 
  839. then
  840.     MESSAGE="ERROR:
  841. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  842. ${IM_A_BLANK_LINE_DONT_TOUCH}
  843. $MEMSREQ"
  844.  
  845.     DCU_EXIT_CODE=3
  846.  
  847.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  848.     then
  849.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  850.         _t=$CURWIN
  851.         RMapply_choice
  852.         input_handler
  853.         wclose $_t
  854.         return $APPLY_CONF
  855.     fi
  856.  
  857.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  858.     then
  859.         pr_dcu_conf
  860.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  861.         footer $GENERIC_CONTINUE_FOOTER
  862.         call proc_loop
  863.     fi
  864. fi
  865.     
  866. if [ ! "${BDADDRSTART[$1]}" = "$dash" ]\
  867. && [ "${BDADDREND[$1]}" = "$dash" ]
  868. then
  869.     MESSAGE="ERROR:
  870. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  871. ${IM_A_BLANK_LINE_DONT_TOUCH}
  872. $MEMEREQ"
  873.  
  874.     DCU_EXIT_CODE=3
  875.  
  876.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  877.     then
  878.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  879.         _t=$CURWIN
  880.         RMapply_choice
  881.         input_handler
  882.         wclose $_t
  883.         return $APPLY_CONF
  884.     fi
  885.  
  886.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  887.     then
  888.         pr_dcu_conf
  889.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  890.         footer $GENERIC_CONTINUE_FOOTER
  891.         call proc_loop
  892.     fi
  893. fi
  894.     
  895. if [ "${BDADDRSTART[$2]}" = "$dash" ]\
  896. && [ "${BDADDREND[$2]}" = "$dash" ] 
  897. then
  898.     return 0
  899. fi
  900.  
  901. if [ -z "${BDADDRSTART[$2]}" ] \
  902. && [ -z "${BDADDREND[$2]}" ] 
  903. then
  904.     return 0
  905. fi
  906.  
  907. typeset x addrs addre mems meme
  908. x=${BDADDREND[$1]}
  909. typeset -i16 addre=16#$x
  910.  
  911. x=${BDADDRSTART[$2]}
  912. typeset -i16 mems=16#$x
  913. x=${BDADDREND[$2]}
  914. typeset -i16 meme=16#$x
  915.  
  916. x=${BDADDRSTART[$1]}
  917. typeset -i16 addrs=16#$x
  918. if [ addre -lt addrs ]
  919. then
  920.     if [ "$1" = "$RMMEMCHKD" ]
  921.     then
  922.         return 0
  923.     else
  924.         RMMEMCHKD="$1"
  925.     fi
  926.     MESSAGE="ERROR:
  927. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  928. ${IM_A_BLANK_LINE_DONT_TOUCH}
  929. $BD_BAD_MEME"
  930.  
  931.     DCU_EXIT_CODE=3
  932.  
  933.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  934.     then
  935.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  936.         _t=$CURWIN
  937.         RMapply_choice
  938.         input_handler
  939.         wclose $_t
  940.         return $APPLY_CONF
  941.     fi
  942.  
  943.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  944.     then
  945.         pr_dcu_conf
  946.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  947.         footer $GENERIC_CONTINUE_FOOTER
  948.         call proc_loop
  949.     fi
  950. fi
  951.  
  952. if [ "${BDADDRSTART[$2]}" = "0" ] \
  953. || [ "${BDADDREND[$2]}" = "0" ]
  954. then
  955.     return 0
  956. fi
  957. if [ addre -ge mems -a  addrs -le meme ]
  958. then
  959.     MESSAGE="ERROR:
  960. $boardname=${BDNAME[$1]}, $boardmems=${BDADDRSTART[$1]}, $boardmeme=${BDADDREND[$1]}.
  961. ${IM_A_BLANK_LINE_DONT_TOUCH}
  962. $MEMCONF
  963. ${IM_A_BLANK_LINE_DONT_TOUCH}
  964. $boardname=${BDNAME[$2]}, $boardmems=${BDADDRSTART[$2]}, $boardmeme=${BDADDREND[$2]}."
  965.  
  966.     DCU_EXIT_CODE=3
  967.  
  968.     if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  969.     then
  970.         display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  971.         _t=$CURWIN
  972.         RMapply_choice
  973.         input_handler
  974.         wclose $_t
  975.         return $APPLY_CONF
  976.     fi
  977.  
  978.     if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  979.     then
  980.         pr_dcu_conf
  981.         display -w "$MESSAGE" -bg $RED -fg $WHITE
  982.         footer $GENERIC_CONTINUE_FOOTER
  983.         call proc_loop
  984.     fi
  985. fi
  986. return 0
  987. }
  988.  
  989. function RMdmaconf
  990. {
  991. # RMdmaconf(bd_array_index1, bd_array_index2)
  992. # Called to check for DMA conflicts
  993. # during entry into the dcu, or
  994. # before Applying Changes & Exiting.
  995. # It sets the DCU_EXIT_CODE variable to 3.
  996. # Calling/Exit State:
  997. # During DCU entry the return code is ignored,
  998. # 0 during DCU exit indicates Enter the DCU to resolve conflicts,
  999. # 1 during DCU exit indicates Ignore conflicts and Apply Changes.
  1000.  
  1001. [ "$DCUDEBUG" -gt 3 ] && {
  1002. print -u2 "$0 called"
  1003. set -x
  1004. }
  1005.  
  1006. integer _t
  1007. typeset MESSAGE
  1008.  
  1009. if [ ! "${BDDMA[$2]}" = "${BDDMA[$1]}" ] \
  1010. || [ -z "${BDNAME[$1]}" ] \
  1011. || [ -z "${BDNAME[$2]}" ] \
  1012. || [ "${BDCNFG[$1]}" = "$N" ] \
  1013. || [ "${BDCNFG[$2]}" = "$N" ] \
  1014. || [ "${BDDMA[$1]}" = "$dash" ] \
  1015. || [ "${BDDMA[$2]}" = "$dash" ] \
  1016. || [ "${BDDMA[$1]}" = "-1" ] \
  1017. || [ "${BDDMA[$2]}" = "-1" ] \
  1018. || [ "${BDNAME[$1]}" = "$dash" ] \
  1019. || [ "${BDNAME[$2]}" = "$dash" ] \
  1020. || [ "${BDNAME[$1]}" = "$unused" ] \
  1021. || [ "${BDNAME[$2]}" = "$unused" ] \
  1022. || [ "${BDNAME[$1]}" = "$unknown" ] \
  1023. || [ "${BDNAME[$2]}" = "$unknown" ] 
  1024. then
  1025.     return 0
  1026. fi
  1027.  
  1028. typeset allow1 allow2
  1029. allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$1]} D
  1030. allow1=$?
  1031. allow_conflict ${ROOT}/etc/conf/mdevice.d/${BDMODNAME[$2]} D
  1032. allow2=$?
  1033. if (( allow1 && allow2 ))
  1034. then
  1035.     return 0
  1036. fi
  1037.  
  1038. MESSAGE="ERROR: 
  1039. $DMACONF
  1040. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1041. $boardname=${BDNAME[$1]}, $boarddma=${BDDMA[$1]},
  1042. ${IM_A_BLANK_LINE_DONT_TOUCH}
  1043. $boardname=${BDNAME[$2]}, $boarddma=${BDDMA[$2]}."
  1044.  
  1045. DCU_EXIT_CODE=3
  1046.  
  1047. if [ "$DCU_CONF_TYPE" = "$DCU_EXIT" ]
  1048. then
  1049.     display "$MESSAGE" -above 0 -bg $RED -fg $WHITE
  1050.     _t=$CURWIN
  1051.     RMapply_choice
  1052.     input_handler
  1053.     wclose $_t
  1054.     return $APPLY_CONF
  1055. fi
  1056.  
  1057. if [ "$DCU_CONF_TYPE" = "$DCU_ENTRY" ]
  1058. then
  1059.     pr_dcu_conf
  1060.     display -w "$MESSAGE" -bg $RED -fg $WHITE
  1061.     footer $GENERIC_CONTINUE_FOOTER
  1062.     call proc_loop
  1063. fi
  1064. return 0
  1065. }
  1066.  
  1067.  
  1068. function RMentryconf
  1069. {
  1070. # RMentryconf()
  1071. # Called upon entry into the dcu
  1072. # in order to perform conflict detection
  1073. # Calling/Exit State: void.
  1074.  
  1075. [ "$DCUDEBUG" -gt 3 ] && {
  1076. print -u2 "$0 called"
  1077. set -x
  1078. }
  1079.  
  1080. integer i=1 brd
  1081. DCU_CONF_TYPE="$DCU_ENTRY"
  1082. while (( $i < $LASTBOARD ))
  1083. do
  1084.     if [ ${DCUMODE} = DCUSCREENS ]
  1085.     then
  1086.         footer $DCUGENERIC_WAIT_FOOTER
  1087.     fi
  1088.     brd=i+1
  1089.     while (( $brd <= $LASTBOARD ))
  1090.     do
  1091.         if [ "${BDINTERPSM[i]}" != "Y" ] \
  1092.         || [ "${BDINTERPSM[brd]}" != "Y" ]
  1093.         then
  1094.             RMirqconf $i $brd
  1095.             if [ "$?" = "2" ]; then
  1096.                 let brd+=1
  1097.                 continue
  1098.             fi
  1099.             if [ ${DCUMODE} = DCUSCREENS ]
  1100.             then
  1101.                 footer $DCUGENERIC_WAIT_FOOTER
  1102.             fi
  1103.     
  1104.             RMioaddrconf $i $brd
  1105.             if [ ${DCUMODE} = DCUSCREENS ]
  1106.             then
  1107.                 footer $DCUGENERIC_WAIT_FOOTER
  1108.             fi
  1109.     
  1110.             RMmemaddrconf $i $brd
  1111.             if [ ${DCUMODE} = DCUSCREENS ]
  1112.             then
  1113.                 footer $DCUGENERIC_WAIT_FOOTER
  1114.             fi
  1115.  
  1116.             RMdmaconf $i $brd
  1117.             if [ ${DCUMODE} = DCUSCREENS ]
  1118.             then
  1119.                 footer $DCUGENERIC_WAIT_FOOTER
  1120.             fi
  1121.         fi
  1122.  
  1123.         let brd+=1
  1124.     done
  1125.     let i+=1
  1126. done
  1127. }
  1128.  
  1129. function addloadmods
  1130. {
  1131. # addloadmods(mod)
  1132. # mod = module name
  1133. # Array of mods that need to be built with "idbuild -M"
  1134. # mod can only be in the array once.
  1135. # Calling/Exit State: void.
  1136.  
  1137. [ "$DCUDEBUG" -gt 3 ] && {
  1138. print -u2 "$0 called"
  1139. set -x
  1140. }
  1141.     integer i=0
  1142.     mod=$1
  1143.  
  1144.     while (( i < ${#LOADMODS[@]} ))
  1145.     do
  1146.         [ "$mod" = "${LOADMODS[$i]}" ] && return
  1147.         let i+=1
  1148.     done
  1149.  
  1150.     LOADMODS[$i]=$mod
  1151. }
  1152.  
  1153. function RMupdate
  1154. {
  1155. # RMupdate()
  1156. # Called to update the resmgr database when "Apply Changes & Exit DCU"
  1157. # is selected.
  1158. # It performs the following actions:
  1159. #       - Conflict checking with EXIT flag set,
  1160. #       - if UNIX_INSTALL, then update and add appropriate resmgr entries,
  1161. #       - Delete any deconfigured entries,
  1162. #       - Write any modified entries, clearing default entry type flag,
  1163. #       - If !UNIX_INSTALL and DRVAUTOCONFIG=N, display DCUrebuild message,
  1164. #       - Write any Board Specific Parameter changes,
  1165. #       - Close resmgr database,
  1166. #       - Set flag to indicate that idconfupdate should be run.
  1167. # Calling/Exit State: 0 for success and 1 for failure.
  1168.  
  1169. [ "$DCUDEBUG" -gt 3 ] && {
  1170. print -u2 "$0 called"
  1171. set -x
  1172. }
  1173.  
  1174. if [ ${DCUMODE} = DCUSCREENS ]
  1175. then
  1176.     DCU_EXIT_CODE=0
  1177.     footer "" 
  1178.     msgnoerr
  1179.     DCU_CONF_TYPE="$DCU_EXIT"
  1180.     integer i=1 brd
  1181.     while (( $i <= $LASTBOARD ))
  1182.     do
  1183.         if [ "${BDCNFG[i]}" != "$Y" ] || [ -z "${BDCHGS[i]}" ]
  1184.         then
  1185.             let i+=1
  1186.             continue;
  1187.         fi
  1188.         let brd=1
  1189.         while (( $brd <= $LASTBOARD ))
  1190.         do
  1191.             if [ "${BDCNFG[brd]}" != "$Y" ] \
  1192.             || [ "${BDKEY[i]}" = "${BDKEY[brd]}" ]
  1193.             then
  1194.                 let brd+=1
  1195.                 continue
  1196.             fi
  1197.             if [ "${BDINTERPSM[i]}" = "Y" ] && [ "${BDINTERPSM[brd]}" = "Y" ]
  1198.             then
  1199.                 let brd+=1
  1200.                 continue
  1201.             fi
  1202.             RMirqconf $i $brd
  1203.             if [ "$?" = "1" ]
  1204.             then
  1205.                 dcumain
  1206.                 return 0
  1207.             fi
  1208.             RMioaddrconf $i $brd
  1209.             if [ "$?" = "1" ]
  1210.             then
  1211.                 dcumain
  1212.                 return 0
  1213.             fi
  1214.             RMmemaddrconf $i $brd
  1215.             if [ "$?" = "1" ]
  1216.             then
  1217.                 dcumain
  1218.                 return 0
  1219.             fi
  1220.             RMdmaconf $i $brd
  1221.             if [ "$?" = "1" ]
  1222.             then
  1223.                 dcumain
  1224.                 return 0
  1225.             fi
  1226.             let brd+=1
  1227.         done
  1228.         let i+=1
  1229.     done
  1230. fi
  1231.     
  1232. if [ "$UNIX_INSTALL" = Y ]
  1233. then
  1234.     IHVupdate
  1235.     IHVaddresmgr
  1236. fi
  1237.  
  1238. #update resmgr database
  1239. if [ ${DCUMODE} = DCUSCREENS ]
  1240. then
  1241.     footer "" 
  1242.     msgnoerr
  1243. fi
  1244.  
  1245. integer err=0
  1246. integer idboot=0
  1247. integer rebuild=0
  1248. integer drv
  1249.  
  1250. i=0
  1251. while (( i+=1 ))
  1252. do
  1253.     if [ "${BDTYPE[$i]}" = $none ]
  1254.     then
  1255.         break
  1256.     fi
  1257.     if [ "${BDTYPE[$i]}" = $unused ]
  1258.     then
  1259.         continue
  1260.     fi
  1261.     if (( ${BDCHGS[$i]} ))
  1262.     then
  1263.         if [ "${BDCNFG[$i]}" = "$N" ]
  1264.         then
  1265.             RMdelkey ${BDKEY[$i]}
  1266.             err=$?
  1267.         else
  1268.             BDENTRYTYPE[$i]=""
  1269.             wrtRM_key $i
  1270.             err=$?
  1271.             if (( !err )) && [ "$UNIX_INSTALL" = "N" ]
  1272.             then
  1273.                 lookupdrv $i
  1274.                 if (( drv=$? ))
  1275.                 then
  1276.                     if [ "${DRVAUTOCONFIG[$drv]}" = "N" ] && (( !rebuild ))
  1277.                     then
  1278.                         rebuild=1
  1279.                         display -w "$DCUrebuild" -bg $BLUE -fg $WHITE
  1280.                         footer $GENERIC_CONTINUE_FOOTER
  1281.                         call proc_loop
  1282.                     else
  1283.                         if [ "${DRVSTATIC[$drv]}" != "Y" ] && \
  1284.                             [ ! -f ${ROOT}/etc/conf/mod.d/${BDMODNAME[$i]} ] 
  1285.                         then
  1286.                             addloadmods ${BDMODNAME[$i]}
  1287.  
  1288.                             if (( !idboot )) && (( !rebuild ))
  1289.                             then
  1290.                                 idboot=1
  1291.                                 display -w "$DCUidboot" -bg $BLUE -fg $WHITE
  1292.                                 footer $GENERIC_CONTINUE_FOOTER
  1293.                                 call proc_loop
  1294.                             fi
  1295.                         fi
  1296.                     fi
  1297.                 fi
  1298.             fi
  1299.         fi
  1300.     fi
  1301.     # Write out any board specific parameters
  1302.     if (( !err ))
  1303.     then
  1304.         if [ -n "${BDHASBSP[$i]}" ]
  1305.         then
  1306.             wrtBSP_key $i
  1307.             err=$?
  1308.         fi
  1309.     fi
  1310. done
  1311. if (( err ))
  1312. then
  1313.     [ "$DCUSILENT" = N ] && msgnoerr "$BAD_UPDATE"
  1314.     return 1
  1315. else
  1316.     RMclose
  1317.     RSMGR_UPDATE=Y
  1318.     [ -n "$1" ] && wclose $1
  1319.     return 0
  1320. fi
  1321. }
  1322.  
  1323. function IHVupdate
  1324. {
  1325. # IHVupdate()
  1326. # During the Installation process,
  1327. # the DCU can update the IHVHBAMODS[] array according to its list
  1328. # of chosen HBAs.
  1329. # Calling/Exit State: void.
  1330.  
  1331. [ "$DCUDEBUG" -gt 3 ] && {
  1332. print -u2 "$0 called"
  1333. set -x
  1334. }
  1335.  
  1336. typeset _m mod i
  1337. integer n=0 inst
  1338.  
  1339. load_ihv_info
  1340. (( ${#IHVHBAS[*]} )) || return
  1341. while [ "${IHVHBAS[n]}" != END ]
  1342. do
  1343.     _m=""
  1344.     for mod in ${IHVHBAMODS[n]}
  1345.     do
  1346.         for i in $ALLDRIVERS
  1347.         do
  1348.             if [ "$mod" = "${MODNAME[i]}" ]
  1349.             then
  1350.                 eval mn=\$"${MODNAME[i]}"
  1351.                 [ -n "$mn" ] && _m="$_m $mod"
  1352.                 break
  1353.             fi
  1354.         done
  1355.     done
  1356.     IHVHBAMODS[n]="$_m"
  1357.     let n+=1
  1358. done
  1359. save_ihv_info
  1360. }
  1361.  
  1362. function IHVnotPCU
  1363. {
  1364. # IHVnotPCU(MODNAME)
  1365. # Check drvmap file for ISA or NULL bustype
  1366. # in order to determine whether to create a default entry.
  1367. # Calling/Exit State: 0 does create a default entry,
  1368. # 1 does not create a default entry.
  1369.  
  1370. [ "$DCUDEBUG" -gt 3 ] && {
  1371. print -u2 "$0 called"
  1372. set -x
  1373. }
  1374.  
  1375. typeset drvname autoconfig verify category brand
  1376. typeset throaway bustype bdid bdname bcfgfile
  1377. typeset ifs="$IFS"
  1378.  
  1379. if [ ! -f ${ROOT}/etc/conf/drvmap.d/$1 ]
  1380. then
  1381.     return 0
  1382. fi
  1383. IFS="$PIPE"
  1384. while read drvname autoconfig verify category brand
  1385. do
  1386.     if [ "$drvname" != "$1" ]
  1387.     then
  1388.         continue
  1389.     fi
  1390.     while read throaway bustype bdid bdname bcfgfile
  1391.     do
  1392.         if [ "$bustype" = "$isa" ] \
  1393.         || [ "$bustype" = "" ]
  1394.         then
  1395.             IFS="$ifs"
  1396.             return 0
  1397.         fi
  1398.     done
  1399. done <${ROOT}/etc/conf/drvmap.d/$1
  1400. IFS="$ifs"
  1401. return 1
  1402. }
  1403. function chkdrvmap
  1404. {
  1405. # chkdrvmap
  1406. # check drvmap file for 'V' flag
  1407. # Calling/Exit state: returns 0 on success, -1 on failure. $1 is 
  1408. # the modname file
  1409. typeset drvname autoconfig verify category brand
  1410. typeset throaway bustype bdid bdname bcfgfile
  1411. typeset ifs="$IFS"
  1412.  
  1413. if [ ! -f ${ROOT}/etc/conf/drvmap.d/$1 ]
  1414. then
  1415.     return -1
  1416. fi
  1417.  
  1418. IFS="$PIPE"
  1419. while read drvname autoconfig verify category brand
  1420. do
  1421.     if [ "$drvname" != "$1" ]
  1422.     then
  1423.         continue
  1424.     fi
  1425.     if [ "$verify" = "V" ]
  1426.     then
  1427.         IFS="$ifs"
  1428.         return 0
  1429.     else
  1430.         break
  1431.     fi
  1432. done< ${ROOT}/etc/conf/drvmap.d/$1
  1433. IFS="$ifs"
  1434. return -1
  1435. }
  1436. function IHVbd
  1437. {
  1438. # IHVbd(MODNAME)
  1439. # Create a new key and board entry for designated module
  1440. # based upon the contents of its sdevice.d file.
  1441. # Calling/Exit State: returns number of boards for which a resmgr entry
  1442. #    is actually added for
  1443.  
  1444. [ "$DCUDEBUG" -gt 3 ] && {
  1445. print -u2 "$0 called"
  1446. set -x
  1447. }
  1448.  
  1449. typeset drvname isc unit ipl itype irq ports porte mems meme dma cpu
  1450. integer x i nbrds v
  1451.  
  1452. if [ ! -f ${ROOT}/etc/conf/sdevice.d/$1 ]
  1453. then
  1454.     return 0
  1455. fi
  1456. nbrds=0
  1457. while read drvname isc unit ipl itype irq ports porte mems meme dma cpu
  1458. do
  1459.     if [ ! "$drvname" = "$1" ]
  1460.     then
  1461.         continue
  1462.     fi
  1463.     v=0
  1464.     chkdrvmap "$1"
  1465.     if [ $? -ne 0 ]
  1466.     then
  1467.         v=1
  1468.     fi
  1469.     if [ "${isc}" = Y ]; then
  1470.         popfree
  1471.         i=$?
  1472.         RMnewkey
  1473.         BDKEY[$i]=$?
  1474.         BDMODNAME[$i]="$dash"
  1475.         BDNAME[$i]="$1"
  1476.         let x\|=$ADD_DEL_CHG
  1477.         BDCHGS[$i]=$x
  1478.         BDTYPE[$i]=$changed
  1479.         BDCNFG[$i]="$Y"
  1480.         BDIPL[$i]="$ipl"
  1481.         BDITYPE[$i]="$itype"
  1482.         BDIRQ[$i]="$irq"
  1483.         BDPORTSTART[$i]="$ports"
  1484.         BDPORTEND[$i]="$porte"
  1485.         BDADDRSTART[$i]="$mems"
  1486.         BDADDREND[$i]="$meme"
  1487.         BDDMA[$i]="$dma"
  1488.         BDCPU[$i]="$cpu"
  1489.         BDENTRYTYPE[$i]=1
  1490.     fi
  1491.     RMadd "$i"
  1492.     if [ $v -eq 0 ] #have V in drvmap file
  1493.     then
  1494.         verifym $i $1
  1495.         if [ $? -ne 0 ]; then #ENODEV
  1496.             cdecl intp sv_errno='&Xk_errno'
  1497.             cprint -v sv_errno sv_errno
  1498.             if [ "$sv_errno" -eq 19 ]; then #ENODEV
  1499.                 BDCNFG[$i]="$N"
  1500.                 continue #RMupdate will delete key
  1501.             fi
  1502.         fi
  1503.     fi
  1504.     RMdelkey "${BDKEY[$i]}"
  1505.     RMnewkey
  1506.     BDKEY[$i]=$?
  1507.     BDMODNAME[$i]=$1
  1508.     let nbrds+=1
  1509. done <${ROOT}/etc/conf/sdevice.d/$1
  1510.  
  1511. return $nbrds
  1512. }
  1513.  
  1514. function IHVaddresmgr
  1515. {
  1516. # IHVaddresmgr()
  1517. # Read the IHVHBAS and IHVHBAMODS arrays that are shared between
  1518. # the Installation Process and the DCU.
  1519. # If the entry is not a PCU only type driver, then invoke
  1520. # IHVbd to create a board entry within the DCU.
  1521. # Calling/Exit State: void.
  1522.  
  1523. [ "$DCUDEBUG" -gt 3 ] && {
  1524. print -u2 "$0 called"
  1525. set -x
  1526. }
  1527.  
  1528. typeset mod _m
  1529. integer n=0 i
  1530.  
  1531. load_ihv_info
  1532. (( ${#IHVHBAS[*]} )) || return
  1533. while [ "${IHVHBAS[n]}" != END ]
  1534. do
  1535.     _m=""
  1536.     for mod in ${IHVHBAMODS[n]}
  1537.     do
  1538.         i=1
  1539.         while [ "${BDTYPE[i]}" != $none  ]
  1540.         do
  1541.              if [ "${BDTYPE[i]}" != $unused ]
  1542.             then
  1543.                 [ "${BDMODNAME[i]}" = "$mod" ] && break
  1544.             fi
  1545.             let i+=1
  1546.         done
  1547.         if [ "${BDTYPE[i]}" = "$none" ]
  1548.         then
  1549.             IHVnotPCU $mod
  1550.             if [ "$?" = "0" ]
  1551.             then
  1552.                 IHVbd $mod
  1553.                 [ "$?" = "0" ] && continue
  1554.             fi
  1555.         fi
  1556.  
  1557.         _m="$_m $mod"
  1558.     done
  1559.     IHVHBAMODS[n]="$_m"
  1560.     let n+=1
  1561. done
  1562. save_ihv_info
  1563. }
  1564.  
  1565. function IHVdelete
  1566. {
  1567. # IHVdelete(MODNAMES)
  1568. # Delete all entries for the corresponding list of MODNAMES.
  1569. # Calling/Exit State: void.
  1570.  
  1571. [ "$DCUDEBUG" -gt 3 ] && {
  1572. print -u2 "$0 called"
  1573. set -x
  1574. }
  1575.  
  1576. typeset mod
  1577. integer i
  1578.  
  1579. for mod in $*
  1580. do
  1581.     i=1
  1582.     while [ "${BDTYPE[i]}" != $none  ]
  1583.     do
  1584.         if [ "${BDTYPE[i]}" != $unused ]
  1585.         then
  1586.             [ "${BDMODNAME[i]}" = "$mod" ] && RMdelkey ${BDKEY[i]}
  1587.         fi
  1588.         let i+=1
  1589.     done
  1590. done
  1591.  
  1592. }
  1593.  
  1594. function pr_dcu_conf
  1595. {
  1596. # pr_dcu_conf()
  1597. # Called to display a message before the conflict message is displayed
  1598. # and system rebooted.
  1599. # Calling/Exit State: void.
  1600.  
  1601. [ "$DCUDEBUG" -gt 3 ] && {
  1602. print -u2 "$0 called"
  1603. set -x
  1604. }
  1605.  
  1606. if [ "$DCUCONFLICT" = Y ]
  1607. then
  1608.     if [ "$DCU_HALT" = N ]
  1609.     then
  1610.         DCU_HALT="Y"
  1611.         display -w "$DCUconflict" -bg $RED -fg $WHITE
  1612.         footer $GENERIC_CONTINUE_FOOTER
  1613.         call proc_loop
  1614.     fi
  1615. fi
  1616. }
  1617.