开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
c64xx_pci.c
资源名称：DSP-C6000-DM642DEMO.rar　[点击查看]
上传用户：dahaojd
上传日期：2008-01-29
资源大小：14357k
文件大小：22k
源码类别：

DSP编程

开发平台：

C/C++

c64xx_pci.c：源码内容
  1. /*
  2.  *  Copyright 2003 by Texas Instruments Incorporated.
  3.  *  All rights reserved. Property of Texas Instruments Incorporated.
  4.  *  Restricted rights to use, duplicate or disclose this code are
  5.  *  granted through contract.
  6.  *  
  7.  */
  8. /* "@(#) DDK 1.10.00.23 07-02-03 (ddk-b12)" */
  9. /*
  10.  *  ======== c64xx_pci.c ========
  11.  * 
  12.  *  DSP/BIOS PCI IOM mini-driver for the c64xx DSPs
  13.  *  Uses the  BIOS PCI Chip Support Library(CSL).
  14.  */
  15. #include <std.h>
  16. #include <csl_pci.h>
  17. #include <hwi.h>
  18. #include <mem.h>
  19. #include <que.h>
  21. #include <iom.h>
  22. #include <c64xx_pci.h>
  26. /* PCI Interrupt mapped to HWI Vector 4 */
  27. #define ISR_VECTOR_ID   4
  29. #define GET_BYTE_COUNT(count) 
  30.         (((count)<< 16) & C64XX_PCI_MASK_PCIMC_CNT)
  32. #define CALLBACK(chan, packet, result) { (packet)->status = (result);
  33.             ((chan)->callback)((Ptr)(chan)->callbackArg, (packet));}
  35. /* Channel variables */
  36. typedef struct ChanObj {
  37.     QUE_Handle          queue; /* priority queue */
  38.     Uns                 writeCount; /* count for number of IOM_WRITE IOPs */ 
  39.     IOM_Packet          *flushAbortIop; /* hold IOM_FLUSH/IOM_ABORT IOP */ 
  40.     /* callback used to notify client when I/O complete */ 
  41.     IOM_TiomCallback    callback;
  42.     Ptr                 callbackArg;
  43. } ChanObj, *ChanHandle;
  45. /* Device object */
  46. typedef struct PCIDeviceObj 
  47. {
  48.     IOM_Packet                  *curPacket; /* current packet in process */
  49.     QUE_Obj                     highPrioQue;
  50.     QUE_Obj                     lowPrioQue; 
  51.     C64XX_PCI_TerrCallback      errCallback; /* async error callback */
  52.     Uns                         evtMask; /* registered events ored together */ 
  53.     C64XX_PCI_ErrInfo           *errInfo; /* detailed info for async error */ 
  54.     Int                         openCount; /* count number of open channels */
  55. } PCIDeviceObj, PCIDeviceHandle;
  57. /* static device object */
  58. static PCIDeviceObj device;
  60. static Void doTransfer(C64XX_PCI_Request *request);
  61. static Void isr();
  62. #ifdef PCI_ERROR_ISR_IMPL
  63. static Void pciErrorIsr();
  64. #endif
  65. static Void processQueue();
  66. static Void removePackets(Ptr chanp, Int cmd);
  67. static Void resetChannel(Ptr chanp);
  68. static Void resetDevice();
  70. /*
  71.  * Forward declaration of mini driver interface functions. They are only 
  72.  * exposed via the IOM_Fxns function table to avoid namespace pollution.
  73.  */
  74. static Int      mdBindDev(Ptr *devp, Int devid, Ptr devParams);
  75. static Int      mdControlChan(Ptr chanp, Uns command, Ptr arg);
  76. static Int      mdCreateChan(Ptr *chanp, Ptr devp, String name, Int mode,
  77.         Ptr chanParams, IOM_TiomCallback cbFxn, Ptr cbArg);
  78. static Int      mdDeleteChan(Ptr chanp);
  79. static Int      mdSubmitChan(Ptr chanp, IOM_Packet* pPacket);
  80. static Int      mdUnBindDev(Ptr devp);
  82. /*
  83.  * Public mini driver interface table.
  84.  */
  85. IOM_Fxns C64XX_PCI_FXNS = {
  86.     &mdBindDev,
  87.     &mdUnBindDev,
  88.     &mdControlChan,
  89.     &mdCreateChan,
  90.     &mdDeleteChan,
  91.     &mdSubmitChan
  92. };
  94. /*
  95.  *  ======== mdBindDev ========
  96.  *  This function will init the queues, set up interrupt.
  97.  *  it does not allocate memory, so return NULL.  
  98.  */
  99. static Int mdBindDev(Ptr *devp, Int devid, Ptr devParams)
  100. {
  101.     Int intrId;
  102.     C64XX_PCI_DevParams *pciDevParams = (C64XX_PCI_DevParams *)devParams;
  103.     HWI_Attrs hwiAttrs;
  105.     QUE_new(&device.highPrioQue);
  106.     QUE_new(&device.lowPrioQue); 
  107.     
  108.     device.curPacket = NULL;
  109.     device.openCount = 0;
  110.     
  111.     if (pciDevParams != NULL) {
  112.         /* Check the version number */
  113.         if (pciDevParams->versionId != C64XX_PCI_VERSION_1){
  114.            /* Unsupported version */
  115.            return(IOM_EBADARGS);
  116.         }
  117.         if (pciDevParams->pciIntrId > 0) {
  118.            intrId = pciDevParams->pciIntrId;
  119.         }
  120.         else {
  121.            intrId = ISR_VECTOR_ID;
  122.         }
  123.         
  124.         hwiAttrs.intrMask = pciDevParams->intrMask;
  126.         if (pciDevParams->errCallback != NULL) {
  127.             device.errCallback = pciDevParams->errCallback->errFxn;
  128.             device.evtMask = pciDevParams->errCallback->evtMask;
  129.             device.errInfo = pciDevParams->errCallback->errInfo;
  130.         }
  131.         else {
  132.             device.errCallback = NULL;
  133.         }
  135. #ifdef PCI_ERROR_ISR_IMPL
  136.         /* 
  137.          *  pciErrIntrId plug in depend on board hardware design.
  138.          *  ERR_ISR_VECTOR_ID: TBD. 
  139.          */
  140.         
  141.         Int pciErrIntrId;
  142.         if (pciDevParams->pciErrIntrId > 0) {
  143.             pciErrIntrId = pciDevParams->pciErrIntrId;
  144.         }
  145.         else {
  146.             pciErrIntrId = ERR_ISR_VECTOR_ID; 
  147.         }
  148. #endif
  149.     }
  150.     else {
  151.         intrId = ISR_VECTOR_ID;
  152.         hwiAttrs.intrMask = C64XX_PCI_INTR_MASK_DEFAULT;
  153.         device.errCallback = NULL;
  154.     }
  155.     
  156.     hwiAttrs.ccMask = IRQ_CCMASK_NONE; /* the default value */
  157.     hwiAttrs.arg = NULL;
  159.     /* plug in normal pci isr routine */
  160.     IRQ_map(IRQ_EVT_DSPINT, intrId); 
  161.     /* dmachan parameter set to -1 since 6416 has EDMA instead of DMA */  
  162.     HWI_dispatchPlug(intrId, (Fxn)isr, -1, &hwiAttrs);
  164. #ifdef PCI_ERROR_ISR_IMPL
  165.     /* plug in error pci isr routine if registered. IRQ_EVT_XXX: TBD.  
  166.      * need to enable two bits in PCI Command Register: TBD 
  167.      *          bit6 - parity error reporting enable bit
  168.      *          bit8 - system error reporting ebable bit
  169.      */
  170.     IRQ_map(IRQ_EVT_XXX, pciErrIntrId); 
  171.     HWI_dispatchPlug(pciErrIntrId, (Fxn)pciErrIsr, -1, NULL);
  172.     IRQ_enable(IRQ_EVT_XXX);
  173. #endif
  175.     return (IOM_COMPLETED);
  176.     
  177. }
  179. /*
  180.  *  ======== mdControlChan ========
  181.  *  This function could be implemented by using function table, avoid complier
  182.  *  link each function and also avoid using "switch" call. 
  183.  *  return status  
  184.  */
  185. static Int mdControlChan(Ptr chanp, Uns command, Ptr arg)
  186. {
  187.     C64XX_PCI_EEPROMData *promData = (C64XX_PCI_EEPROMData *)arg;
  188.     Uns                   result; 
  189.     Uns                   imask;
  190.     
  191. #ifdef TEST_ERROR_HANDLER
  192.     Bool report;
  193.     C64XX_PCI_Request *req;
  194.     IOM_Packet *packet;
  195.     Uns error;
  196.     Uns event;
  197. #endif
  198.     
  199.     switch (command) {
  200.         /* EEPROM call. */
  201.         case C64XX_PCI_EEPROM_ERASE: 
  202.             promData->eeData = PCI_eepromErase((Uns)promData->eeAddr);
  203.             return (IOM_COMPLETED); 
  204.         case C64XX_PCI_EEPROM_ERASE_ALL:
  205.             promData->eeData = PCI_eepromEraseAll();
  206.             return (IOM_COMPLETED); 
  207.         case C64XX_PCI_EEPROM_IS_AUTO_CFG:
  208.             promData->eeData = PCI_eepromIsAutoCfg();
  209.             return (IOM_COMPLETED); 
  210.         case C64XX_PCI_EEPROM_READ:
  211.             promData->eeData = PCI_eepromRead((Uns)promData->eeAddr);
  212.             return (IOM_COMPLETED); 
  213.         case C64XX_PCI_EEPROM_SIZE:
  214.             promData->eeData = PCI_eepromSize();
  215.             return (IOM_COMPLETED); 
  216.         case C64XX_PCI_EEPROM_TEST:
  217.             promData->eeData = PCI_eepromTest();
  218.             return (IOM_COMPLETED); 
  219.         case C64XX_PCI_EEPROM_WRITE:
  220.             result = PCI_eepromWrite((Uns)promData->eeAddr, promData->eeData);
  221.             promData->eeData = result;
  222.             return (IOM_COMPLETED); 
  223.         case C64XX_PCI_EEPROM_WRITE_ALL:
  224.             result = PCI_eepromWriteAll(promData->eeData);
  225.             promData->eeData = result;
  226.             return (IOM_COMPLETED); 
  228.         /* Host interrupt call */
  229.         case C64XX_PCI_DSP_INT_REQ_SET:
  230.             PCI_dspIntReqSet();
  231.             return (IOM_COMPLETED);
  232.         case C64XX_PCI_DSP_INT_REQ_CLEAR:
  233.             PCI_dspIntReqClear();
  234.             return (IOM_COMPLETED);
  236.         /* reset calls */
  237.         case C64XX_PCI_RESET_CHANNEL:
  238.             resetChannel(chanp);
  239.             return (IOM_COMPLETED);      
  240.         case C64XX_PCI_RESET_ALL_CHANNELS:
  241.             resetDevice();
  242.             return (IOM_COMPLETED);            
  243. #ifdef TEST_ERROR_HANDLER
  244.         case C64XX_PCI_TEST_ERROR_HANDLER:
  245.     error = 0;
  246.     report = FALSE;
  247.     event = *((Uns *)arg);
  248.     imask = HWI_disable();
  249.     if (device.errCallback == NULL) {
  250.         HWI_restore(imask);
  251.         return (IOM_COMPLETED);        
  252.     }
  253.     if ((event == C64XX_PCI_EVT_PARITY_ERR) && 
  254.             (device.evtMask & C64XX_PCI_EVT_PARITY_ERR)) {
  255.         error = error | C64XX_PCI_EVT_PARITY_ERR;
  256.         report = TRUE;
  257.     } 
  258.     else if ((event == C64XX_PCI_EVT_SYSTEM_ERR) && 
  259.             (device.evtMask & C64XX_PCI_EVT_SYSTEM_ERR)) {
  260.         error = error | C64XX_PCI_EVT_SYSTEM_ERR;
  261.         report = TRUE;
  262.     } 
  264.     if (!report) {
  265.         HWI_restore(imask);
  266.         return (IOM_COMPLETED);
  267.     }
  269.     if (device.curPacket != NULL) {
  270.         packet = device.curPacket;
  271.         req = (C64XX_PCI_Request *)packet->addr;
  272.         device.errInfo->inprogressDstAddr = req->dstAddr;
  273.         device.errInfo->inprogressSrcAddr = req->srcAddr;
  274.         /* device.errInfo->statusReg = PCI_STATUS_REGISTER; */
  275.     } 
  276.     else {
  277.         device.errInfo->inprogressDstAddr = NULL;
  278.         device.errInfo->inprogressSrcAddr = NULL;
  279.         /* device.errInfo->statusReg = PCI_STATUS_REGISTER; */
  280.     }
  282.     (device.errCallback)(error, (Ptr)device.errInfo);
  283.     HWI_restore(imask);
  284.     return (IOM_COMPLETED);
  285. #endif 
  286.         default:
  287.             break;
  288.     }
  289.     
  290.     return (IOM_ENOTIMPL);      
  291. }
  294. /*
  295.  *  ======== mdCreateChan ========
  296.  *  This function allocates memory for channel object and initializes it.
  297.  *  return IOM_COMPLETED if success return IOM_EALLOC if fails
  298.  */
  299. static Int mdCreateChan(Ptr *chanp, Ptr devp, String name, Int mode,
  300.         Ptr chanParams, IOM_TiomCallback cbFxn, Ptr cbArg)
  301. {
  302.     ChanHandle          chan;   
  303.     C64XX_PCI_Attrs     *pciAttrs = (C64XX_PCI_Attrs *)chanParams;
  304.     Uns                 imask;
  305.     
  306.     chan = MEM_alloc(0, sizeof(ChanObj), 0);
  307.     if ( chan == MEM_ILLEGAL ) { 
  308.         return (IOM_EALLOC);
  309.     }
  310.   
  311.     if (mode != IOM_INOUT) {
  312.         return (IOM_EBADMODE);
  313.     }
  315.     /* Initialize the channel structure */
  316.     if ( pciAttrs != NULL && 
  317.             pciAttrs->queuePriority == C64XX_PCI_QUEUE_PRIORITY_HIGH) {
  318.         chan->queue = &device.highPrioQue;
  319.     }
  320.     else {
  321.         chan->queue = &device.lowPrioQue;    
  322.     }
  323.     
  324.     chan->writeCount = 0;
  325.     chan->flushAbortIop = NULL;
  326.     chan->callback = cbFxn;
  327.     chan->callbackArg = cbArg; 
  328.          
  329.     imask = HWI_disable();
  330.     if (device.openCount == 0) {
  331.         /* enable PCI events */
  332.         PCI_intEnable(PCI_EVT_PCIMASTER);
  333.         PCI_intEnable(PCI_EVT_PCITARGET);
  334.         PCI_intEnable(PCI_EVT_MASTEROK);
  336.         IRQ_enable(IRQ_EVT_DSPINT);
  337.     }
  338.     device.openCount++;
  339.     HWI_restore(imask);
  341.     *chanp = chan;
  343.     return (IOM_COMPLETED);
  344. }
  346. /*
  347.  *  ======== mdDeleteChan ========
  348.  *  frees memory
  349.  *  return status
  350.  */
  351. static Int mdDeleteChan(Ptr chanp)
  352. {
  353.     ChanHandle  chan = (ChanHandle)chanp;
  354.     Uns                 imask;
  356.     MEM_free(0, chan, sizeof(ChanObj));
  358.     imask = HWI_disable();
  359.     device.openCount--;
  360.     if (device.openCount == 0) {
  361.         /* disable PCI events */
  362.         PCI_intDisable(PCI_EVT_PCIMASTER);
  363.         PCI_intDisable(PCI_EVT_PCITARGET);
  364.         PCI_intDisable(PCI_EVT_MASTEROK);
  366.         IRQ_disable(IRQ_EVT_DSPINT);
  367.     }
  368.     HWI_restore(imask);
  370.     return (IOM_COMPLETED); 
  371. }
  373. /*
  374.  *  ======== mdSubmitChan ========
  375.  *  return submit status
  376.  */
  377. static Int mdSubmitChan(Ptr chanp, IOM_Packet *pPacket)
  378. {
  379.     ChanHandle          chan = (ChanHandle)chanp;
  380.     IOM_Packet*         packet = pPacket;
  381.     Uns                 imask;
  382.     C64XX_PCI_Request  *req;    
  383.     C64XX_PCI_Request  *curReq; 
  385.     req = (C64XX_PCI_Request *)packet->addr;
  386.     req->reserved = chan;
  387.     
  388.     /* IOM_READ or IOM_WRITE command handle in the same way */ 
  389.     if (packet->cmd == IOM_READ || packet->cmd == IOM_WRITE) {
  391.         imask = HWI_disable();
  392.         QUE_enqueue(chan->queue, packet);
  394.         if (device.curPacket == NULL) {
  395. #ifndef TEST_RESET
  396.             processQueue();
  397. #endif
  398.         }
  399.         HWI_restore(imask);
  400.         return (IOM_PENDING);
  401.     } 
  403.     if (packet->cmd == IOM_FLUSH || packet->cmd == IOM_ABORT) { 
  404.         
  405.         imask = HWI_disable();
  406.         chan->flushAbortIop = packet;
  408.         /* check the channel of pending packet */ 
  409.         if (device.curPacket != NULL) {
  410.                 curReq = (C64XX_PCI_Request *)device.curPacket->addr;
  412.             /* The pending packet is this channel. Let isr handles it */
  413.             if ((ChanHandle)curReq->reserved == chan) {
  414.                 HWI_restore(imask);         
  415.                 return (IOM_PENDING);
  416.             } 
  417.         }         
  418.         
  419.         /* the pending packet is not FLUSH/ABORT channel */
  420.         removePackets(chan, packet->cmd);
  422.         /* FLUSH/ABORT done */
  423.         if (chan->writeCount == 0) {
  424.             chan->flushAbortIop = NULL;
  425.             HWI_restore(imask); 
  426.             return (IOM_COMPLETED);
  427.         }                   
  429.         HWI_restore(imask);         
  430.         return (IOM_PENDING);
  431.     }   
  432.     return (IOM_EBADIO); 
  433. }
  435. /*
  436.  *  ======== mdUnBindDev ========
  437.  *  return status
  438.  */
  440. static Int mdUnBindDev(Ptr devp)
  441. {
  442.     /* empty for now */
  443.     return (IOM_COMPLETED);
  444. }
  446. /*
  447.  *  ======== C64XX_PCI_init ========
  448.  */
  449. Void C64XX_PCI_init(Void)
  450. {
  451.     /* empty for now */
  452. }
  455. /*
  456.  *  ======== isr ========
  457.  *  interrupt service routine is runtime pluged in
  458.  */
  459. static Void isr(Void)
  460. {
  461.     ChanHandle          chan;
  462.     IOM_Packet          *oldPacket;
  463.     C64XX_PCI_Request   *oldReq;         
  464.     Int                 status = IOM_EBADIO;
  465.     
  466.     if (PCI_FGET(PCIIS, MASTEROK)) {
  467.         /* pci master transfer complete */       
  468.         PCI_FSET(PCIIS, MASTEROK, 1);
  469.         status = IOM_COMPLETED;
  470.         
  471.     } 
  472.     else if (PCI_FGET(PCIIS, PCIMASTER)) { 
  473.         /* pci master abort */
  474.         PCI_FSET(PCIIS, PCIMASTER, 1);
  475.         
  476.     } 
  477.     else if (PCI_FGET(PCIIS, PCITARGET)) {
  478.         /* pci target abort */
  479.         PCI_FSET(PCIIS, PCITARGET, 1);
  480.         
  481.     } 
  482.     else {
  483.         /* not registered interrupt, clear intr here */
  484.         PCI_RSET(PCIIS, 0x00000FFF);
  485.         /* error handling TBD */
  486.         return;
  487.     }
  489.     if (device.curPacket != NULL) {
  490.         oldPacket = device.curPacket;
  491.         oldReq = (C64XX_PCI_Request *)oldPacket->addr; 
  492.         chan = (ChanHandle)oldReq->reserved;
  493.          
  494.         device.curPacket = NULL;
  496.         if (chan->flushAbortIop == NULL) {
  497.             /* normal. process next request in the queues */
  498.             processQueue();
  499.             
  500.             /* callback */
  501.             CALLBACK(chan,oldPacket,status);   
  502.             return;
  503.         } 
  504.         
  505.         /* flush or abort cmd */
  506.         /* first do callback */
  507.         CALLBACK(chan,oldPacket,status); 
  508.                      
  509.         if (chan->writeCount) { 
  510.            chan->writeCount--;              
  511.         } 
  512.         else {
  513.            removePackets(chan, chan->flushAbortIop->cmd);
  514.         }
  515.             
  516.         /* process next request in the queues */
  517.         processQueue();    
  519.         /* if all write IOPs are done, call the callback for the FLUSH IOP */
  520.         if (chan->writeCount == 0) {
  521.            CALLBACK(chan,chan->flushAbortIop,IOM_COMPLETED);
  522.            chan->flushAbortIop = NULL;   
  523.         } 
  524.         return; 
  525.     } 
  527.     /* process next request in the queues */
  528.     processQueue(); 
  529. }
  531. /*
  532.  *  ======== pciErrorIsr ========
  533.  *  interrupt service routine is runtime pluged in for asynchronous error TBD
  534.  */
  535. #ifdef PCI_ERROR_ISR_IMPL
  536. static Void pciErrorIsr(Void)
  537. {
  538.     /* How to check PCI status register to identify the error source --
  539.     parity/system: TBD (on C6416, not accessable) use 'event' here to 
  540.     represent the status register related content */ 
  541.     
  542.     Bool report = FALSE;
  543.     Uns error = 0;
  544.     C64XX_PCI_Request *req;
  545.     IOM_Packet *packet;
  547.     if (device.errCallback == NULL) {
  548.         return;
  549.     }
  550.     if ((event == C64XX_PCI_EVT_PARITY_ERR) && 
  551.             (device.evtMask & C64XX_PCI_EVT_PARITY_ERR)) {
  552.         error = error | C64XX_PCI_EVT_PARITY_ERR;
  553.         report = TRUE;
  554.     } 
  555.     else if ((event == C64XX_PCI_EVT_SYSTEM_ERR) && 
  556.             (device.evtMask & C64XX_PCI_EVT_SYSTEM_ERR)) {
  557.         error = error | C64XX_PCI_EVT_SYSTEM_ERR;
  558.         report = TRUE;
  559.     } 
  561.     if (!report) {
  562.         return;
  563.     }
  565.     if (device.curPacket != NULL) {
  566.         packet = device.curPacket;
  567.         req = (C64XX_PCI_Request *)packet->addr;
  568.         device.errInfo->inprogressDstAddr = req->dstAddr;
  569.         device.errInfo->inprogressSrcAddr = req->srcAddr;
  570.         device.errInfo->statusReg = PCI_STATUS_REGISTER;
  571.     } 
  572.     else {
  573.         device.errInfo->inprogressDstAddr = NULL;
  574.         device.errInfo->inprogressSrcAddr = NULL;
  575.         device.errInfo->statusReg = PCI_STATUS_REGISTER;
  576.     }
  578.     (device.errCallback)(error, (Ptr)device.errorInfo);
  579.      
  580. }
  581. #endif
  584. /*
  585.  *  ======== doTransfer ========
  586.  */
  587. static Void doTransfer(C64XX_PCI_Request *request)
  588. {
  589.     C64XX_PCI_Request   *req = request;
  590.     PCI_ConfigXfr       config;
  591.     Uns                 xfrMode;
  592.          
  593.     xfrMode = C64XX_PCI_GETXFERMODE(request->options);
  594.         
  595.     if (xfrMode == PCI_WRITE) {
  596.         config.dspma = (Uns)req->srcAddr;
  597.         config.pcima = (Uns)req->dstAddr; 
  598.         config.pcimc = GET_BYTE_COUNT(req->byteCnt);
  599.                                   
  600.     } 
  601.     else if (xfrMode ==  PCI_READ_PREF || xfrMode ==  PCI_READ_NOPREF) {
  602.         config.dspma = (Uns)req->dstAddr;
  603.         config.pcima = (Uns)req->srcAddr; 
  604.         config.pcimc = GET_BYTE_COUNT(req->byteCnt);                    
  605.     }
  606.         
  607.     PCI_xfrConfig(&config);
  608.     PCI_xfrStart(xfrMode);      
  609. }
  612. /*
  613.  *  ======== processQueue ========
  614.  */
  615. static Void processQueue()
  616. {
  617.     QUE_Handle          que;
  618.     C64XX_PCI_Request   *req;
  620.     que = &device.highPrioQue;
  621.     /* process next packet in queue */  
  622.     if (QUE_empty(que)) {
  623.         que = &device.lowPrioQue;
  624.         if (QUE_empty(que)) {
  625.             return;
  626.         }
  627.     } 
  628.     device.curPacket = QUE_dequeue(que);
  629.     req = (C64XX_PCI_Request *)device.curPacket->addr;
  630.     doTransfer(req);                     
  631. }
  633. /*
  634.  *  ======== removePackets ========
  635.  */
  636. static Void removePackets(Ptr chanp, Int cmd) 
  637. {           
  638.     ChanHandle          chan = (ChanHandle)chanp;
  639.     QUE_Elem            *next;
  640.     QUE_Elem            *current;
  641.     C64XX_PCI_Request  *curReq;  
  642.     Int                 status;
  644.     if (cmd != IOM_FLUSH && cmd != IOM_ABORT) {
  645.         return;
  646.     } 
  647.     
  648.     current = QUE_head(chan->queue);
  649.     curReq = (C64XX_PCI_Request *)((IOM_Packet *)current)->addr;
  650.    
  651.     while (chan->queue != current) {
  652.         next = QUE_next(current);
  653.           
  654.         /* check the channel of the each IOM_Packet in the queue */
  655.         /* find the match. The packet and remove channels are identical */ 
  656.         if ((ChanHandle)curReq->reserved == chan) {
  657.             /* for write flush wait for complete */
  658.             if ( cmd == IOM_FLUSH && 
  659.                     ((IOM_Packet *)current)->cmd == IOM_WRITE ) {
  660.                 chan->writeCount++;
  661.             } else {
  662.                 /* for read flush or abort, do flush */
  663.                 if (cmd == IOM_FLUSH) {
  664.                     status = IOM_FLUSHED;
  665.                 }
  666.                 else {
  667.                     status = IOM_ABORTED;
  668.                 }
  669.                 QUE_remove(current);
  670.                 CALLBACK(chan, (IOM_Packet *)current, status); 
  671.             }
  672.         } 
  673.           
  674.         current = next;
  675.         curReq = (C64XX_PCI_Request*)((IOM_Packet *)current)->addr;      
  676.     } /* end while */
  677. }
  679. /*
  680.  *  ======== resetChannel ========
  681.  */
  682. static Void resetChannel(Ptr chanp)
  683. {
  684.     ChanHandle          chan = (ChanHandle)chanp;
  685.     C64XX_PCI_Request  *curReq;
  686.     Uns                 imask;
  687.     
  688.     imask = HWI_disable();
  689.     /* assume reset async ? */
  690.     if (device.curPacket != NULL) {       
  691.         curReq = (C64XX_PCI_Request *)((IOM_Packet *)device.curPacket)->addr; 
  692.         if ((ChanHandle)curReq->reserved == chan) {
  693.             CALLBACK((ChanHandle)curReq->reserved, 
  694.                     (IOM_Packet *)device.curPacket, IOM_ABORTED); 
  695.             device.curPacket = NULL; 
  696.         }     
  697.     }
  698.     
  699.     removePackets(chanp, IOM_ABORT);
  700.     HWI_restore(imask); 
  701. }
  703. /*
  704.  *  ======== resetDevice ========
  705.  */
  706. static Void resetDevice()
  707. {
  708.     QUE_Elem            *next;
  709.     QUE_Elem            *current;
  710.     QUE_Handle          queue;
  711.     C64XX_PCI_Request  *curReq;
  712.     Int                 i;  
  713.     Uns                 imask;
  714.     
  715.     imask = HWI_disable();
  716.     /* assume reset async ? */
  717.     if (device.curPacket != NULL) {       
  718.         curReq = (C64XX_PCI_Request *)((IOM_Packet *)device.curPacket)->addr; 
  719.          CALLBACK((ChanHandle)curReq->reserved, 
  720.                     (IOM_Packet *)device.curPacket, IOM_ABORTED); 
  721.         device.curPacket = NULL;      
  722.     }
  723.     
  724.     for (i = 0; i < 2; i++) {
  725.         if (i == 0 ) {
  726.             queue = &device.highPrioQue;      
  727.         } 
  728.         else {
  729.             queue = &device.lowPrioQue; 
  730.         }
  731.         /* remove all the elements in the high/low priority queue */
  732.         current = QUE_head(queue);
  733.         curReq = (C64XX_PCI_Request *)((IOM_Packet *)current)->addr;
  734.     
  735.         while (queue != current) {
  736.             next = QUE_next(current);
  737.           
  738.             QUE_remove(current);
  739.             CALLBACK((ChanHandle)curReq->reserved, 
  740.                     (IOM_Packet *)current, IOM_ABORTED);
  741.                  
  742.             current = next;
  743.             curReq = (C64XX_PCI_Request*)((IOM_Packet *)current)->addr; 
  744.         } /* end while */        
  745.     } /* end for */
  746.     
  747.     HWI_restore(imask); 
  748. }