s390/qeth: add xmit_more support for IQD devices

IQD devices offer limited support for bulking: all frames in a TX buffer
need to have the same target. qeth_iqd_may_bulk() implements this
constraint, and allows us to defer the TX doorbell until
(a) the buffer is full (since each buffer needs its own doorbell), or
(b) the entire TX queue is full, or
(b) we reached the BQL limit.

Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index d5f796380cd0fc1c7e3f1565ab12db772590744e..e4b55f9aa0625b026691b0226428d6fcc69487de 100644 (file)
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -378,6 +378,28 @@ enum qeth_header_ids {
 #define QETH_HDR_EXT_CSUM_TRANSP_REQ  0x20
 #define QETH_HDR_EXT_UDP             0x40 /*bit off for TCP*/
 
+static inline bool qeth_l2_same_vlan(struct qeth_hdr_layer2 *h1,
+                                    struct qeth_hdr_layer2 *h2)
+{
+       return !((h1->flags[2] ^ h2->flags[2]) & QETH_LAYER2_FLAG_VLAN) &&
+              h1->vlan_id == h2->vlan_id;
+}
+
+static inline bool qeth_l3_iqd_same_vlan(struct qeth_hdr_layer3 *h1,
+                                        struct qeth_hdr_layer3 *h2)
+{
+       return !((h1->ext_flags ^ h2->ext_flags) & QETH_HDR_EXT_VLAN_FRAME) &&
+              h1->vlan_id == h2->vlan_id;
+}
+
+static inline bool qeth_l3_same_next_hop(struct qeth_hdr_layer3 *h1,
+                                        struct qeth_hdr_layer3 *h2)
+{
+       return !((h1->flags ^ h2->flags) & QETH_HDR_IPV6) &&
+              ipv6_addr_equal(&h1->next_hop.ipv6_addr,
+                              &h2->next_hop.ipv6_addr);
+}
+
 enum qeth_qdio_info_states {
        QETH_QDIO_UNINITIALIZED,
        QETH_QDIO_ALLOCATED,
@@ -508,6 +530,8 @@ struct qeth_qdio_out_q {
        atomic_t set_pci_flags_count;
        struct napi_struct napi;
        struct timer_list timer;
+       struct qeth_hdr *prev_hdr;
+       u8 bulk_start;
 };
 
 #define qeth_for_each_output_queue(card, q, i)         \

diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index 4c7c7d320c9cce5113c6ab4785fe34b89286433c..8b4ea5f2832bf09d02d73df1e6579b6528befbba 100644 (file)
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -2671,6 +2671,8 @@ int qeth_init_qdio_queues(struct qeth_card *card)
                queue->max_elements = QETH_MAX_BUFFER_ELEMENTS(card);
                queue->next_buf_to_fill = 0;
                queue->do_pack = 0;
+               queue->prev_hdr = NULL;
+               queue->bulk_start = 0;
                atomic_set(&queue->used_buffers, 0);
                atomic_set(&queue->set_pci_flags_count, 0);
                atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED);
@@ -3314,6 +3316,14 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
        }
 }
 
+static void qeth_flush_queue(struct qeth_qdio_out_q *queue)
+{
+       qeth_flush_buffers(queue, queue->bulk_start, 1);
+
+       queue->bulk_start = QDIO_BUFNR(queue->bulk_start + 1);
+       queue->prev_hdr = NULL;
+}
+
 static void qeth_check_outbound_queue(struct qeth_qdio_out_q *queue)
 {
        int index;
@@ -3669,9 +3679,32 @@ check_layout:
        return 0;
 }
 
-static void __qeth_fill_buffer(struct sk_buff *skb,
-                              struct qeth_qdio_out_buffer *buf,
-                              bool is_first_elem, unsigned int offset)
+static bool qeth_iqd_may_bulk(struct qeth_qdio_out_q *queue,
+                             struct qeth_qdio_out_buffer *buffer,
+                             struct sk_buff *curr_skb,
+                             struct qeth_hdr *curr_hdr)
+{
+       struct qeth_hdr *prev_hdr = queue->prev_hdr;
+
+       if (!prev_hdr)
+               return true;
+
+       /* All packets must have the same target: */
+       if (curr_hdr->hdr.l2.id == QETH_HEADER_TYPE_LAYER2) {
+               struct sk_buff *prev_skb = skb_peek(&buffer->skb_list);
+
+               return ether_addr_equal(eth_hdr(prev_skb)->h_dest,
+                                       eth_hdr(curr_skb)->h_dest) &&
+                      qeth_l2_same_vlan(&prev_hdr->hdr.l2, &curr_hdr->hdr.l2);
+       }
+
+       return qeth_l3_same_next_hop(&prev_hdr->hdr.l3, &curr_hdr->hdr.l3) &&
+              qeth_l3_iqd_same_vlan(&prev_hdr->hdr.l3, &curr_hdr->hdr.l3);
+}
+
+static unsigned int __qeth_fill_buffer(struct sk_buff *skb,
+                                      struct qeth_qdio_out_buffer *buf,
+                                      bool is_first_elem, unsigned int offset)
 {
        struct qdio_buffer *buffer = buf->buffer;
        int element = buf->next_element_to_fill;
@@ -3728,24 +3761,21 @@ static void __qeth_fill_buffer(struct sk_buff *skb,
        if (buffer->element[element - 1].eflags)
                buffer->element[element - 1].eflags = SBAL_EFLAGS_LAST_FRAG;
        buf->next_element_to_fill = element;
+       return element;
 }
 
 /**
  * qeth_fill_buffer() - map skb into an output buffer
- * @queue:     QDIO queue to submit the buffer on
  * @buf:       buffer to transport the skb
  * @skb:       skb to map into the buffer
  * @hdr:       qeth_hdr for this skb. Either at skb->data, or allocated
  *             from qeth_core_header_cache.
  * @offset:    when mapping the skb, start at skb->data + offset
  * @hd_len:    if > 0, build a dedicated header element of this size
- * flush:      Prepare the buffer to be flushed, regardless of its fill level.
  */
-static int qeth_fill_buffer(struct qeth_qdio_out_q *queue,
-                           struct qeth_qdio_out_buffer *buf,
-                           struct sk_buff *skb, struct qeth_hdr *hdr,
-                           unsigned int offset, unsigned int hd_len,
-                           bool flush)
+static unsigned int qeth_fill_buffer(struct qeth_qdio_out_buffer *buf,
+                                    struct sk_buff *skb, struct qeth_hdr *hdr,
+                                    unsigned int offset, unsigned int hd_len)
 {
        struct qdio_buffer *buffer = buf->buffer;
        bool is_first_elem = true;
@@ -3765,36 +3795,22 @@ static int qeth_fill_buffer(struct qeth_qdio_out_q *queue,
                buf->next_element_to_fill++;
        }
 
-       __qeth_fill_buffer(skb, buf, is_first_elem, offset);
-
-       if (!queue->do_pack) {
-               QETH_CARD_TEXT(queue->card, 6, "fillbfnp");
-       } else {
-               QETH_CARD_TEXT(queue->card, 6, "fillbfpa");
-
-               QETH_TXQ_STAT_INC(queue, skbs_pack);
-               /* If the buffer still has free elements, keep using it. */
-               if (!flush &&
-                   buf->next_element_to_fill < queue->max_elements)
-                       return 0;
-       }
-
-       /* flush out the buffer */
-       atomic_set(&buf->state, QETH_QDIO_BUF_PRIMED);
-       queue->next_buf_to_fill = (queue->next_buf_to_fill + 1) %
-                                 QDIO_MAX_BUFFERS_PER_Q;
-       return 1;
+       return __qeth_fill_buffer(skb, buf, is_first_elem, offset);
 }
 
-static int qeth_do_send_packet_fast(struct qeth_qdio_out_q *queue,
-                                   struct sk_buff *skb, struct qeth_hdr *hdr,
-                                   unsigned int offset, unsigned int hd_len)
+static int __qeth_xmit(struct qeth_card *card, struct qeth_qdio_out_q *queue,
+                      struct sk_buff *skb, unsigned int elements,
+                      struct qeth_hdr *hdr, unsigned int offset,
+                      unsigned int hd_len)
 {
-       int index = queue->next_buf_to_fill;
-       struct qeth_qdio_out_buffer *buffer = queue->bufs[index];
+       struct qeth_qdio_out_buffer *buffer = queue->bufs[queue->bulk_start];
        unsigned int bytes = qdisc_pkt_len(skb);
+       unsigned int next_element;
        struct netdev_queue *txq;
        bool stopped = false;
+       bool flush;
+
+       txq = netdev_get_tx_queue(card->dev, skb_get_queue_mapping(skb));
 
        /* Just a sanity check, the wake/stop logic should ensure that we always
         * get a free buffer.
@@ -3802,9 +3818,19 @@ static int qeth_do_send_packet_fast(struct qeth_qdio_out_q *queue,
        if (atomic_read(&buffer->state) != QETH_QDIO_BUF_EMPTY)
                return -EBUSY;
 
-       txq = netdev_get_tx_queue(queue->card->dev, skb_get_queue_mapping(skb));
+       if ((buffer->next_element_to_fill + elements > queue->max_elements) ||
+           !qeth_iqd_may_bulk(queue, buffer, skb, hdr)) {
+               atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED);
+               qeth_flush_queue(queue);
+               buffer = queue->bufs[queue->bulk_start];
 
-       if (atomic_inc_return(&queue->used_buffers) >= QDIO_MAX_BUFFERS_PER_Q) {
+               /* Sanity-check again: */
+               if (atomic_read(&buffer->state) != QETH_QDIO_BUF_EMPTY)
+                       return -EBUSY;
+       }
+
+       if (buffer->next_element_to_fill == 0 &&
+           atomic_inc_return(&queue->used_buffers) >= QDIO_MAX_BUFFERS_PER_Q) {
                /* If a TX completion happens right _here_ and misses to wake
                 * the txq, then our re-check below will catch the race.
                 */
@@ -3813,11 +3839,17 @@ static int qeth_do_send_packet_fast(struct qeth_qdio_out_q *queue,
                stopped = true;
        }
 
-       qeth_fill_buffer(queue, buffer, skb, hdr, offset, hd_len, stopped);
-       netdev_tx_sent_queue(txq, bytes);
+       next_element = qeth_fill_buffer(buffer, skb, hdr, offset, hd_len);
        buffer->bytes += bytes;
+       queue->prev_hdr = hdr;
 
-       qeth_flush_buffers(queue, index, 1);
+       flush = __netdev_tx_sent_queue(txq, bytes,
+                                      !stopped && netdev_xmit_more());
+
+       if (flush || next_element >= queue->max_elements) {
+               atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED);
+               qeth_flush_queue(queue);
+       }
 
        if (stopped && !qeth_out_queue_is_full(queue))
                netif_tx_start_queue(txq);
@@ -3830,6 +3862,7 @@ int qeth_do_send_packet(struct qeth_card *card, struct qeth_qdio_out_q *queue,
                        int elements_needed)
 {
        struct qeth_qdio_out_buffer *buffer;
+       unsigned int next_element;
        struct netdev_queue *txq;
        bool stopped = false;
        int start_index;
@@ -3892,8 +3925,17 @@ int qeth_do_send_packet(struct qeth_card *card, struct qeth_qdio_out_q *queue,
                stopped = true;
        }
 
-       flush_count += qeth_fill_buffer(queue, buffer, skb, hdr, offset, hd_len,
-                                       stopped);
+       next_element = qeth_fill_buffer(buffer, skb, hdr, offset, hd_len);
+
+       if (queue->do_pack)
+               QETH_TXQ_STAT_INC(queue, skbs_pack);
+       if (!queue->do_pack || stopped || next_element >= queue->max_elements) {
+               flush_count++;
+               atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED);
+               queue->next_buf_to_fill = (queue->next_buf_to_fill + 1) %
+                                         QDIO_MAX_BUFFERS_PER_Q;
+       }
+
        if (flush_count)
                qeth_flush_buffers(queue, start_index, flush_count);
        else if (!atomic_read(&queue->set_pci_flags_count))
@@ -3989,8 +4031,8 @@ int qeth_xmit(struct qeth_card *card, struct sk_buff *skb,
                                  frame_len - proto_len, skb, proto_len);
 
        if (IS_IQD(card)) {
-               rc = qeth_do_send_packet_fast(queue, skb, hdr, data_offset,
-                                             hd_len);
+               rc = __qeth_xmit(card, queue, skb, elements, hdr, data_offset,
+                                hd_len);
        } else {
                /* TODO: drop skb_orphan() once TX completion is fast enough */
                skb_orphan(skb);