int copied;
 
        copied = tty_insert_flip_string(tport, buf, count);
-       if (copied < count) {
-               dev_warn(port->dev, "Rx overrun: dropping %zu bytes\n",
-                        count - copied);
+       if (copied < count)
                port->icount.buf_overrun++;
-       }
 
        port->icount.rx += copied;
 
                if (s->active_rx == s->cookie_rx[i])
                        return i;
 
-       dev_err(s->port.dev, "%s: Rx cookie %d not found!\n", __func__,
-               s->active_rx);
        return -1;
 }
 
 
        dma_async_issue_pending(chan);
 
+       spin_unlock_irqrestore(&port->lock, flags);
        dev_dbg(port->dev, "%s: cookie %d #%d, new active cookie %d\n",
                __func__, s->cookie_rx[active], active, s->active_rx);
-       spin_unlock_irqrestore(&port->lock, flags);
        return;
 
 fail:
                if (dma_submit_error(s->cookie_rx[i]))
                        goto fail;
 
-               dev_dbg(s->port.dev, "%s(): cookie %d to #%d\n", __func__,
-                       s->cookie_rx[i], i);
        }
 
        s->active_rx = s->cookie_rx[0];
        for (i = 0; i < 2; i++)
                s->cookie_rx[i] = -EINVAL;
        s->active_rx = -EINVAL;
-       dev_warn(s->port.dev, "Failed to re-start Rx DMA, using PIO\n");
        sci_rx_dma_release(s, true);
 }
 
        int active, count;
        u16 scr;
 
-       spin_lock_irqsave(&port->lock, flags);
-
        dev_dbg(port->dev, "DMA Rx timed out\n");
 
+       spin_lock_irqsave(&port->lock, flags);
+
        active = sci_dma_rx_find_active(s);
        if (active < 0) {
                spin_unlock_irqrestore(&port->lock, flags);
 
        status = dmaengine_tx_status(s->chan_rx, s->active_rx, &state);
        if (status == DMA_COMPLETE) {
+               spin_unlock_irqrestore(&port->lock, flags);
                dev_dbg(port->dev, "Cookie %d #%d has already completed\n",
                        s->active_rx, active);
-               spin_unlock_irqrestore(&port->lock, flags);
 
                /* Let packet complete handler take care of the packet */
                return;
        /* Handle incomplete DMA receive */
        dmaengine_terminate_all(s->chan_rx);
        read = sg_dma_len(&s->sg_rx[active]) - state.residue;
-       dev_dbg(port->dev, "Read %u bytes with cookie %d\n", read,
-               s->active_rx);
 
        if (read) {
                count = sci_dma_rx_push(s, s->rx_buf[active], read);