Ignore:
Timestamp:
Mar 15, 2017, 2:42:58 AM (5 months ago)
Author:
brainslayer
Message:

use new squashfs in all kernels

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-4.4/drivers/tty/n_hdlc.c

    r29817 r31662  
    115115
    116116struct n_hdlc_buf {
    117         struct n_hdlc_buf *link;
     117        struct list_head  list_item;
    118118        int               count;
    119119        char              buf[1];
     
    123123
    124124struct n_hdlc_buf_list {
    125         struct n_hdlc_buf *head;
    126         struct n_hdlc_buf *tail;
     125        struct list_head  list;
    127126        int               count;
    128127        spinlock_t        spinlock;
     
    137136 * @tbusy - reentrancy flag for tx wakeup code
    138137 * @woke_up - FIXME: describe this field
    139  * @tbuf - currently transmitting tx buffer
    140138 * @tx_buf_list - list of pending transmit frame buffers
    141139 * @rx_buf_list - list of received frame buffers
     
    150148        int                     tbusy;
    151149        int                     woke_up;
    152         struct n_hdlc_buf       *tbuf;
    153150        struct n_hdlc_buf_list  tx_buf_list;
    154151        struct n_hdlc_buf_list  rx_buf_list;
     
    160157 * HDLC buffer list manipulation functions
    161158 */
    162 static void n_hdlc_buf_list_init(struct n_hdlc_buf_list *list);
     159static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list,
     160                                                struct n_hdlc_buf *buf);
    163161static void n_hdlc_buf_put(struct n_hdlc_buf_list *list,
    164162                           struct n_hdlc_buf *buf);
     
    210208        struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
    211209        struct n_hdlc_buf *buf;
    212         unsigned long flags;
    213210
    214211        while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list)))
    215212                n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf);
    216         spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);
    217         if (n_hdlc->tbuf) {
    218                 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, n_hdlc->tbuf);
    219                 n_hdlc->tbuf = NULL;
    220         }
    221         spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
    222213}
    223214
     
    285276                        break;
    286277        }
    287         kfree(n_hdlc->tbuf);
    288278        kfree(n_hdlc);
    289279       
     
    404394        spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
    405395
    406         /* get current transmit buffer or get new transmit */
    407         /* buffer from list of pending transmit buffers */
    408                
    409         tbuf = n_hdlc->tbuf;
    410         if (!tbuf)
    411                 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
    412                
     396        tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
    413397        while (tbuf) {
    414398                if (debuglevel >= DEBUG_LEVEL_INFO)     
     
    422406                /* rollback was possible and has been done */
    423407                if (actual == -ERESTARTSYS) {
    424                         n_hdlc->tbuf = tbuf;
     408                        n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf);
    425409                        break;
    426410                }
     
    437421                        /* free current transmit buffer */
    438422                        n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, tbuf);
    439                        
    440                         /* this tx buffer is done */
    441                         n_hdlc->tbuf = NULL;
    442                        
     423
    443424                        /* wait up sleeping writers */
    444425                        wake_up_interruptible(&tty->write_wait);
     
    450431                                printk("%s(%d)frame %p pending\n",
    451432                                        __FILE__,__LINE__,tbuf);
    452                                        
    453                         /* buffer not accepted by driver */
    454                         /* set this buffer as pending buffer */
    455                         n_hdlc->tbuf = tbuf;
     433
     434                        /*
     435                         * the buffer was not accepted by driver,
     436                         * return it back into tx queue
     437                         */
     438                        n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf);
    456439                        break;
    457440                }
     
    751734        int count;
    752735        unsigned long flags;
    753        
     736        struct n_hdlc_buf *buf = NULL;
     737
    754738        if (debuglevel >= DEBUG_LEVEL_INFO)     
    755739                printk("%s(%d)n_hdlc_tty_ioctl() called %d\n",
     
    765749                /* in next available frame (if any) */
    766750                spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags);
    767                 if (n_hdlc->rx_buf_list.head)
    768                         count = n_hdlc->rx_buf_list.head->count;
     751                buf = list_first_entry_or_null(&n_hdlc->rx_buf_list.list,
     752                                                struct n_hdlc_buf, list_item);
     753                if (buf)
     754                        count = buf->count;
    769755                else
    770756                        count = 0;
     
    778764                /* add size of next output frame in queue */
    779765                spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);
    780                 if (n_hdlc->tx_buf_list.head)
    781                         count += n_hdlc->tx_buf_list.head->count;
     766                buf = list_first_entry_or_null(&n_hdlc->tx_buf_list.list,
     767                                                struct n_hdlc_buf, list_item);
     768                if (buf)
     769                        count += buf->count;
    782770                spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags);
    783771                error = put_user(count, (int __user *)arg);
     
    827815
    828816                /* set bits for operations that won't block */
    829                 if (n_hdlc->rx_buf_list.head)
     817                if (!list_empty(&n_hdlc->rx_buf_list.list))
    830818                        mask |= POLLIN | POLLRDNORM;    /* readable */
    831819                if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
     
    834822                        mask |= POLLHUP;
    835823                if (!tty_is_writelocked(tty) &&
    836                                 n_hdlc->tx_free_buf_list.head)
     824                                !list_empty(&n_hdlc->tx_free_buf_list.list))
    837825                        mask |= POLLOUT | POLLWRNORM;   /* writable */
    838826        }
     
    854842                return NULL;
    855843
    856         n_hdlc_buf_list_init(&n_hdlc->rx_free_buf_list);
    857         n_hdlc_buf_list_init(&n_hdlc->tx_free_buf_list);
    858         n_hdlc_buf_list_init(&n_hdlc->rx_buf_list);
    859         n_hdlc_buf_list_init(&n_hdlc->tx_buf_list);
    860        
     844        spin_lock_init(&n_hdlc->rx_free_buf_list.spinlock);
     845        spin_lock_init(&n_hdlc->tx_free_buf_list.spinlock);
     846        spin_lock_init(&n_hdlc->rx_buf_list.spinlock);
     847        spin_lock_init(&n_hdlc->tx_buf_list.spinlock);
     848
     849        INIT_LIST_HEAD(&n_hdlc->rx_free_buf_list.list);
     850        INIT_LIST_HEAD(&n_hdlc->tx_free_buf_list.list);
     851        INIT_LIST_HEAD(&n_hdlc->rx_buf_list.list);
     852        INIT_LIST_HEAD(&n_hdlc->tx_buf_list.list);
     853
    861854        /* allocate free rx buffer list */
    862855        for(i=0;i<DEFAULT_RX_BUF_COUNT;i++) {
     
    886879
    887880/**
    888  * n_hdlc_buf_list_init - initialize specified HDLC buffer list
    889  * @list - pointer to buffer list
    890  */
    891 static void n_hdlc_buf_list_init(struct n_hdlc_buf_list *list)
    892 {
    893         memset(list, 0, sizeof(*list));
    894         spin_lock_init(&list->spinlock);
    895 }       /* end of n_hdlc_buf_list_init() */
     881 * n_hdlc_buf_return - put the HDLC buffer after the head of the specified list
     882 * @buf_list - pointer to the buffer list
     883 * @buf - pointer to the buffer
     884 */
     885static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list,
     886                                                struct n_hdlc_buf *buf)
     887{
     888        unsigned long flags;
     889
     890        spin_lock_irqsave(&buf_list->spinlock, flags);
     891
     892        list_add(&buf->list_item, &buf_list->list);
     893        buf_list->count++;
     894
     895        spin_unlock_irqrestore(&buf_list->spinlock, flags);
     896}
    896897
    897898/**
    898899 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list
    899  * @list - pointer to buffer list
     900 * @buf_list - pointer to buffer list
    900901 * @buf - pointer to buffer
    901902 */
    902 static void n_hdlc_buf_put(struct n_hdlc_buf_list *list,
     903static void n_hdlc_buf_put(struct n_hdlc_buf_list *buf_list,
    903904                           struct n_hdlc_buf *buf)
    904905{
    905906        unsigned long flags;
    906         spin_lock_irqsave(&list->spinlock,flags);
    907        
    908         buf->link=NULL;
    909         if (list->tail)
    910                 list->tail->link = buf;
    911         else
    912                 list->head = buf;
    913         list->tail = buf;
    914         (list->count)++;
    915        
    916         spin_unlock_irqrestore(&list->spinlock,flags);
    917        
     907
     908        spin_lock_irqsave(&buf_list->spinlock, flags);
     909
     910        list_add_tail(&buf->list_item, &buf_list->list);
     911        buf_list->count++;
     912
     913        spin_unlock_irqrestore(&buf_list->spinlock, flags);
    918914}       /* end of n_hdlc_buf_put() */
    919915
    920916/**
    921917 * n_hdlc_buf_get - remove and return an HDLC buffer from list
    922  * @list - pointer to HDLC buffer list
     918 * @buf_list - pointer to HDLC buffer list
    923919 *
    924920 * Remove and return an HDLC buffer from the head of the specified HDLC buffer
     
    926922 * Returns a pointer to HDLC buffer if available, otherwise %NULL.
    927923 */
    928 static struct n_hdlc_buf* n_hdlc_buf_get(struct n_hdlc_buf_list *list)
     924static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *buf_list)
    929925{
    930926        unsigned long flags;
    931927        struct n_hdlc_buf *buf;
    932         spin_lock_irqsave(&list->spinlock,flags);
    933        
    934         buf = list->head;
     928
     929        spin_lock_irqsave(&buf_list->spinlock, flags);
     930
     931        buf = list_first_entry_or_null(&buf_list->list,
     932                                                struct n_hdlc_buf, list_item);
    935933        if (buf) {
    936                 list->head = buf->link;
    937                 (list->count)--;
    938         }
    939         if (!list->head)
    940                 list->tail = NULL;
    941        
    942         spin_unlock_irqrestore(&list->spinlock,flags);
     934                list_del(&buf->list_item);
     935                buf_list->count--;
     936        }
     937
     938        spin_unlock_irqrestore(&buf_list->spinlock, flags);
    943939        return buf;
    944        
    945940}       /* end of n_hdlc_buf_get() */
    946941
Note: See TracChangeset for help on using the changeset viewer.