Changeset 9cb7e5d in rtems


Ignore:
Timestamp:
Mar 22, 2016, 3:41:51 PM (4 years ago)
Author:
Daniel Hellstrom <daniel@…>
Branches:
master
Children:
36c3fbbd
Parents:
57e1f4c3
git-author:
Daniel Hellstrom <daniel@…> (03/22/16 15:41:51)
git-committer:
Daniel Hellstrom <daniel@…> (03/06/17 06:54:55)
Message:

leon, grspw_pkt: fixed and improved RX/TX wait

Location:
c/src/lib/libbsp/sparc/shared
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/sparc/shared/include/grspw_pkt.h

    r57e1f4c3 r9cb7e5d  
    488488#define GRSPW_OP_AND 0
    489489#define GRSPW_OP_OR 1
    490 /* Block until ready_cnt or fewer packets are Queued in "Send and Scheduled" Q,
     490/* Block until send_cnt or fewer packets are Queued in "Send and Scheduled" Q,
    491491 * op (AND or OR), sent_cnt or more packet "have been sent" (Sent Q) condition
    492492 * is met.
     
    505505 *  1    DMA stopped
    506506 *  2    Timeout, conditions are not met
     507 *  3    Another task is already waiting. Service is Busy.
    507508 */
    508509extern int grspw_dma_tx_wait(void *c, int send_cnt, int op, int sent_cnt, int timeout);
     
    566567 * until the condition is satisfied.
    567568 *
    568  * NOTE: if IRQ of TX descriptors are not enabled conditions are never
     569 * NOTE: if IRQ of RX descriptors are not enabled conditions are never
    569570 *       checked, this may hang infinitely unless a timeout has been specified
    570571 *
     
    574575 *  1    DMA stopped
    575576 *  2    Timeout, conditions are not met
     577 *  3    Another task is already waiting. Service is Busy.
    576578 */
    577579extern int grspw_dma_rx_wait(void *c, int recv_cnt, int op, int ready_cnt, int timeout);
  • c/src/lib/libbsp/sparc/shared/spw/grspw_pkt.c

    r57e1f4c3 r9cb7e5d  
    19271927{
    19281928        struct grspw_dma_priv *dma = c;
    1929         int ret, rc;
     1929        int ret, rc, initialized = 0;
    19301930
    19311931        if (timeout == 0)
     
    19421942         * one waiter at a time.
    19431943         */
    1944         if (dma->tx_wait.waiting) {
    1945                 ret = -1;
    1946                 goto out;
    1947         }
    1948 
    1949         /* Stop if link error or similar, abort */
     1944        if (initialized == 0 && dma->tx_wait.waiting) {
     1945                ret = 3;
     1946                goto out_release;
     1947        }
     1948
     1949        /* Stop if link error or similar (DMA stopped), abort */
    19501950        if (dma->started == 0) {
    19511951                ret = 1;
    1952                 goto out;
     1952                goto out_release;
    19531953        }
    19541954
     
    19601960        if (grspw_tx_wait_eval(dma) == 0) {
    19611961                /* Prepare Wait */
     1962                initialized = 1;
    19621963                dma->tx_wait.waiting = 1;
    19631964
     
    19711972                                                timeout);
    19721973                if (rc == RTEMS_TIMEOUT) {
    1973                         dma->tx_wait.waiting = 0;
    1974                         return 2;
     1974                        ret = 2;
     1975                        goto out;
    19751976                } else if (rc == RTEMS_UNSATISFIED ||
    19761977                           rc == RTEMS_OBJECT_WAS_DELETED) {
    1977                         dma->tx_wait.waiting = 0;
    1978                         return 1; /* sem was flushed/deleted, means DMA stop */
    1979                 } else if (rc != RTEMS_SUCCESSFUL)
    1980                         return -1;
     1978                        ret = 1; /* sem was flushed/deleted, means DMA stop */
     1979                        goto out;
     1980                } else if (rc != RTEMS_SUCCESSFUL) {
     1981                        /* Unknown Error */
     1982                        ret = -1;
     1983                        goto out;
     1984                } else if (dma->started == 0) {
     1985                        ret = 1;
     1986                        goto out;
     1987                }
    19811988
    19821989                /* Check condition once more */
    19831990                goto check_condition;
    1984         } else {
    1985                 /* No Wait needed */
    1986                 dma->tx_wait.waiting = 0;
    19871991        }
    19881992
    19891993        ret = 0;
    1990 out:
     1994
     1995out_release:
    19911996        /* Unlock DMA channel */
    19921997        rtems_semaphore_release(dma->sem_dma);
    19931998
     1999out:
     2000        if (initialized)
     2001                dma->tx_wait.waiting = 0;
    19942002        return ret;
    19952003}
     
    21332141{
    21342142        struct grspw_dma_priv *dma = c;
    2135         int ret, rc;
     2143        int ret, rc, initialized = 0;
    21362144
    21372145        if (timeout == 0)
     
    21482156         * one waiter at a time.
    21492157         */
    2150         if (dma->rx_wait.waiting) {
    2151                 ret = -1;
    2152                 goto out;
    2153         }
    2154 
    2155         /* Stop if link error or similar (MDA stopped) */
     2158        if (initialized == 0 && dma->rx_wait.waiting) {
     2159                ret = 3;
     2160                goto out_release;
     2161        }
     2162
     2163        /* Stop if link error or similar (DMA stopped), abort */
    21562164        if (dma->started == 0) {
    21572165                ret = 1;
    2158                 goto out;
     2166                goto out_release;
    21592167        }
    21602168
     
    21662174        if (grspw_rx_wait_eval(dma) == 0) {
    21672175                /* Prepare Wait */
     2176                initialized = 1;
    21682177                dma->rx_wait.waiting = 1;
    21692178
     
    21772186                                           timeout);
    21782187                if (rc == RTEMS_TIMEOUT) {
    2179                         dma->rx_wait.waiting = 0;
    2180                         return 2;
     2188                        ret = 2;
     2189                        goto out;
    21812190                } else if (rc == RTEMS_UNSATISFIED ||
    21822191                           rc == RTEMS_OBJECT_WAS_DELETED) {
    2183                         dma->rx_wait.waiting = 0;
    2184                         return 1; /* sem was flushed/deleted, means DMA stop */
    2185                 } else if (rc != RTEMS_SUCCESSFUL)
    2186                         return -1;
     2192                        ret = 1; /* sem was flushed/deleted, means DMA stop */
     2193                        goto out;
     2194                } else if (rc != RTEMS_SUCCESSFUL) {
     2195                        /* Unknown Error */
     2196                        ret = -1;
     2197                        goto out;
     2198                } else if (dma->started == 0) {
     2199                        ret = 1;
     2200                        goto out;
     2201                }
    21872202
    21882203                /* Check condition once more */
    21892204                goto check_condition;
    2190         } else {
    2191                 /* No Wait needed */
    2192                 dma->rx_wait.waiting = 0;
    2193         }
     2205        }
     2206
    21942207        ret = 0;
    21952208
    2196 out:
     2209out_release:
    21972210        /* Unlock DMA channel */
    21982211        rtems_semaphore_release(dma->sem_dma);
    21992212
     2213out:
     2214        if (initialized)
     2215                dma->rx_wait.waiting = 0;
    22002216        return ret;
    22012217}
     
    23992415
    24002416        /* Link is down for some reason, and the user has configured
    2401          * that we stop all DMA channels and throw out all blocked
    2402          * threads.
     2417         * that we stop all (open) DMA channels and throw out all their
     2418         * blocked threads.
    24032419         */
    24042420        for (i=0; i<priv->hwsup.ndma_chans; i++)
     
    24222438            != RTEMS_SUCCESSFUL)
    24232439                return;
     2440
     2441        /* If closing DMA channel or just shut down */
     2442        if (dma->started == 0)
     2443                goto out;
    24242444
    24252445        /* Look at cause we were woken up and clear source */
     
    24492469                         * task is fullfilled.
    24502470                         */
    2451                         if (dma->rx_wait.waiting) {
     2471                        if (dma->rx_wait.waiting)
    24522472                                rx_cond_true = grspw_rx_wait_eval(dma);
    2453                                 if (rx_cond_true)
    2454                                         dma->rx_wait.waiting = 0;
    2455                         }
    24562473                }
    24572474                if (ctrl & GRSPW_DMACTRL_PS) {
     
    24602477                        grspw_tx_process_scheduled(dma);
    24612478                        dma->stats.tx_work_enabled += grspw_tx_schedule_send(dma);
    2462                         if (dma->tx_wait.waiting) {
     2479                        if (dma->tx_wait.waiting)
    24632480                                tx_cond_true = grspw_tx_wait_eval(dma);
    2464                                 if (tx_cond_true)
    2465                                         dma->tx_wait.waiting = 0;
    2466                         }
    24672481                }
    24682482        } else
    24692483                SPIN_UNLOCK_IRQ(&priv->devlock, irqflags);
    24702484
     2485out:
    24712486        /* Release lock */
    24722487        rtems_semaphore_release(dma->sem_dma);
Note: See TracChangeset for help on using the changeset viewer.