Merge branch 'irq-fix' of git://www.modarm9.com/gitsrc/pub/people/ukleinek/linux...
[linux-2.6] / drivers / net / sfc / tx.c
1 /****************************************************************************
2  * Driver for Solarflare Solarstorm network controllers and boards
3  * Copyright 2005-2006 Fen Systems Ltd.
4  * Copyright 2005-2008 Solarflare Communications Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published
8  * by the Free Software Foundation, incorporated herein by reference.
9  */
10
11 #include <linux/pci.h>
12 #include <linux/tcp.h>
13 #include <linux/ip.h>
14 #include <linux/in.h>
15 #include <linux/if_ether.h>
16 #include <linux/highmem.h>
17 #include "net_driver.h"
18 #include "tx.h"
19 #include "efx.h"
20 #include "falcon.h"
21 #include "workarounds.h"
22
23 /*
24  * TX descriptor ring full threshold
25  *
26  * The tx_queue descriptor ring fill-level must fall below this value
27  * before we restart the netif queue
28  */
29 #define EFX_NETDEV_TX_THRESHOLD(_tx_queue)      \
30         (_tx_queue->efx->type->txd_ring_mask / 2u)
31
32 /* We want to be able to nest calls to netif_stop_queue(), since each
33  * channel can have an individual stop on the queue.
34  */
35 void efx_stop_queue(struct efx_nic *efx)
36 {
37         spin_lock_bh(&efx->netif_stop_lock);
38         EFX_TRACE(efx, "stop TX queue\n");
39
40         atomic_inc(&efx->netif_stop_count);
41         netif_stop_queue(efx->net_dev);
42
43         spin_unlock_bh(&efx->netif_stop_lock);
44 }
45
46 /* Wake netif's TX queue
47  * We want to be able to nest calls to netif_stop_queue(), since each
48  * channel can have an individual stop on the queue.
49  */
50 inline void efx_wake_queue(struct efx_nic *efx)
51 {
52         local_bh_disable();
53         if (atomic_dec_and_lock(&efx->netif_stop_count,
54                                 &efx->netif_stop_lock)) {
55                 EFX_TRACE(efx, "waking TX queue\n");
56                 netif_wake_queue(efx->net_dev);
57                 spin_unlock(&efx->netif_stop_lock);
58         }
59         local_bh_enable();
60 }
61
62 static inline void efx_dequeue_buffer(struct efx_tx_queue *tx_queue,
63                                       struct efx_tx_buffer *buffer)
64 {
65         if (buffer->unmap_len) {
66                 struct pci_dev *pci_dev = tx_queue->efx->pci_dev;
67                 if (buffer->unmap_single)
68                         pci_unmap_single(pci_dev, buffer->unmap_addr,
69                                          buffer->unmap_len, PCI_DMA_TODEVICE);
70                 else
71                         pci_unmap_page(pci_dev, buffer->unmap_addr,
72                                        buffer->unmap_len, PCI_DMA_TODEVICE);
73                 buffer->unmap_len = 0;
74                 buffer->unmap_single = 0;
75         }
76
77         if (buffer->skb) {
78                 dev_kfree_skb_any((struct sk_buff *) buffer->skb);
79                 buffer->skb = NULL;
80                 EFX_TRACE(tx_queue->efx, "TX queue %d transmission id %x "
81                           "complete\n", tx_queue->queue, read_ptr);
82         }
83 }
84
85
86 /*
87  * Add a socket buffer to a TX queue
88  *
89  * This maps all fragments of a socket buffer for DMA and adds them to
90  * the TX queue.  The queue's insert pointer will be incremented by
91  * the number of fragments in the socket buffer.
92  *
93  * If any DMA mapping fails, any mapped fragments will be unmapped,
94  * the queue's insert pointer will be restored to its original value.
95  *
96  * Returns NETDEV_TX_OK or NETDEV_TX_BUSY
97  * You must hold netif_tx_lock() to call this function.
98  */
99 static inline int efx_enqueue_skb(struct efx_tx_queue *tx_queue,
100                                   const struct sk_buff *skb)
101 {
102         struct efx_nic *efx = tx_queue->efx;
103         struct pci_dev *pci_dev = efx->pci_dev;
104         struct efx_tx_buffer *buffer;
105         skb_frag_t *fragment;
106         struct page *page;
107         int page_offset;
108         unsigned int len, unmap_len = 0, fill_level, insert_ptr, misalign;
109         dma_addr_t dma_addr, unmap_addr = 0;
110         unsigned int dma_len;
111         unsigned unmap_single;
112         int q_space, i = 0;
113         int rc = NETDEV_TX_OK;
114
115         EFX_BUG_ON_PARANOID(tx_queue->write_count != tx_queue->insert_count);
116
117         /* Get size of the initial fragment */
118         len = skb_headlen(skb);
119
120         fill_level = tx_queue->insert_count - tx_queue->old_read_count;
121         q_space = efx->type->txd_ring_mask - 1 - fill_level;
122
123         /* Map for DMA.  Use pci_map_single rather than pci_map_page
124          * since this is more efficient on machines with sparse
125          * memory.
126          */
127         unmap_single = 1;
128         dma_addr = pci_map_single(pci_dev, skb->data, len, PCI_DMA_TODEVICE);
129
130         /* Process all fragments */
131         while (1) {
132                 if (unlikely(pci_dma_mapping_error(dma_addr)))
133                         goto pci_err;
134
135                 /* Store fields for marking in the per-fragment final
136                  * descriptor */
137                 unmap_len = len;
138                 unmap_addr = dma_addr;
139
140                 /* Add to TX queue, splitting across DMA boundaries */
141                 do {
142                         if (unlikely(q_space-- <= 0)) {
143                                 /* It might be that completions have
144                                  * happened since the xmit path last
145                                  * checked.  Update the xmit path's
146                                  * copy of read_count.
147                                  */
148                                 ++tx_queue->stopped;
149                                 /* This memory barrier protects the
150                                  * change of stopped from the access
151                                  * of read_count. */
152                                 smp_mb();
153                                 tx_queue->old_read_count =
154                                         *(volatile unsigned *)
155                                         &tx_queue->read_count;
156                                 fill_level = (tx_queue->insert_count
157                                               - tx_queue->old_read_count);
158                                 q_space = (efx->type->txd_ring_mask - 1 -
159                                            fill_level);
160                                 if (unlikely(q_space-- <= 0))
161                                         goto stop;
162                                 smp_mb();
163                                 --tx_queue->stopped;
164                         }
165
166                         insert_ptr = (tx_queue->insert_count &
167                                       efx->type->txd_ring_mask);
168                         buffer = &tx_queue->buffer[insert_ptr];
169                         EFX_BUG_ON_PARANOID(buffer->skb);
170                         EFX_BUG_ON_PARANOID(buffer->len);
171                         EFX_BUG_ON_PARANOID(buffer->continuation != 1);
172                         EFX_BUG_ON_PARANOID(buffer->unmap_len);
173
174                         dma_len = (((~dma_addr) & efx->type->tx_dma_mask) + 1);
175                         if (likely(dma_len > len))
176                                 dma_len = len;
177
178                         misalign = (unsigned)dma_addr & efx->type->bug5391_mask;
179                         if (misalign && dma_len + misalign > 512)
180                                 dma_len = 512 - misalign;
181
182                         /* Fill out per descriptor fields */
183                         buffer->len = dma_len;
184                         buffer->dma_addr = dma_addr;
185                         len -= dma_len;
186                         dma_addr += dma_len;
187                         ++tx_queue->insert_count;
188                 } while (len);
189
190                 /* Transfer ownership of the unmapping to the final buffer */
191                 buffer->unmap_addr = unmap_addr;
192                 buffer->unmap_single = unmap_single;
193                 buffer->unmap_len = unmap_len;
194                 unmap_len = 0;
195
196                 /* Get address and size of next fragment */
197                 if (i >= skb_shinfo(skb)->nr_frags)
198                         break;
199                 fragment = &skb_shinfo(skb)->frags[i];
200                 len = fragment->size;
201                 page = fragment->page;
202                 page_offset = fragment->page_offset;
203                 i++;
204                 /* Map for DMA */
205                 unmap_single = 0;
206                 dma_addr = pci_map_page(pci_dev, page, page_offset, len,
207                                         PCI_DMA_TODEVICE);
208         }
209
210         /* Transfer ownership of the skb to the final buffer */
211         buffer->skb = skb;
212         buffer->continuation = 0;
213
214         /* Pass off to hardware */
215         falcon_push_buffers(tx_queue);
216
217         return NETDEV_TX_OK;
218
219  pci_err:
220         EFX_ERR_RL(efx, " TX queue %d could not map skb with %d bytes %d "
221                    "fragments for DMA\n", tx_queue->queue, skb->len,
222                    skb_shinfo(skb)->nr_frags + 1);
223
224         /* Mark the packet as transmitted, and free the SKB ourselves */
225         dev_kfree_skb_any((struct sk_buff *)skb);
226         goto unwind;
227
228  stop:
229         rc = NETDEV_TX_BUSY;
230
231         if (tx_queue->stopped == 1)
232                 efx_stop_queue(efx);
233
234  unwind:
235         /* Work backwards until we hit the original insert pointer value */
236         while (tx_queue->insert_count != tx_queue->write_count) {
237                 --tx_queue->insert_count;
238                 insert_ptr = tx_queue->insert_count & efx->type->txd_ring_mask;
239                 buffer = &tx_queue->buffer[insert_ptr];
240                 efx_dequeue_buffer(tx_queue, buffer);
241                 buffer->len = 0;
242         }
243
244         /* Free the fragment we were mid-way through pushing */
245         if (unmap_len)
246                 pci_unmap_page(pci_dev, unmap_addr, unmap_len,
247                                PCI_DMA_TODEVICE);
248
249         return rc;
250 }
251
252 /* Remove packets from the TX queue
253  *
254  * This removes packets from the TX queue, up to and including the
255  * specified index.
256  */
257 static inline void efx_dequeue_buffers(struct efx_tx_queue *tx_queue,
258                                        unsigned int index)
259 {
260         struct efx_nic *efx = tx_queue->efx;
261         unsigned int stop_index, read_ptr;
262         unsigned int mask = tx_queue->efx->type->txd_ring_mask;
263
264         stop_index = (index + 1) & mask;
265         read_ptr = tx_queue->read_count & mask;
266
267         while (read_ptr != stop_index) {
268                 struct efx_tx_buffer *buffer = &tx_queue->buffer[read_ptr];
269                 if (unlikely(buffer->len == 0)) {
270                         EFX_ERR(tx_queue->efx, "TX queue %d spurious TX "
271                                 "completion id %x\n", tx_queue->queue,
272                                 read_ptr);
273                         efx_schedule_reset(efx, RESET_TYPE_TX_SKIP);
274                         return;
275                 }
276
277                 efx_dequeue_buffer(tx_queue, buffer);
278                 buffer->continuation = 1;
279                 buffer->len = 0;
280
281                 ++tx_queue->read_count;
282                 read_ptr = tx_queue->read_count & mask;
283         }
284 }
285
286 /* Initiate a packet transmission on the specified TX queue.
287  * Note that returning anything other than NETDEV_TX_OK will cause the
288  * OS to free the skb.
289  *
290  * This function is split out from efx_hard_start_xmit to allow the
291  * loopback test to direct packets via specific TX queues.  It is
292  * therefore a non-static inline, so as not to penalise performance
293  * for non-loopback transmissions.
294  *
295  * Context: netif_tx_lock held
296  */
297 inline int efx_xmit(struct efx_nic *efx,
298                     struct efx_tx_queue *tx_queue, struct sk_buff *skb)
299 {
300         int rc;
301
302         /* Map fragments for DMA and add to TX queue */
303         rc = efx_enqueue_skb(tx_queue, skb);
304         if (unlikely(rc != NETDEV_TX_OK))
305                 goto out;
306
307         /* Update last TX timer */
308         efx->net_dev->trans_start = jiffies;
309
310  out:
311         return rc;
312 }
313
314 /* Initiate a packet transmission.  We use one channel per CPU
315  * (sharing when we have more CPUs than channels).  On Falcon, the TX
316  * completion events will be directed back to the CPU that transmitted
317  * the packet, which should be cache-efficient.
318  *
319  * Context: non-blocking.
320  * Note that returning anything other than NETDEV_TX_OK will cause the
321  * OS to free the skb.
322  */
323 int efx_hard_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
324 {
325         struct efx_nic *efx = net_dev->priv;
326         return efx_xmit(efx, &efx->tx_queue[0], skb);
327 }
328
329 void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index)
330 {
331         unsigned fill_level;
332         struct efx_nic *efx = tx_queue->efx;
333
334         EFX_BUG_ON_PARANOID(index > efx->type->txd_ring_mask);
335
336         efx_dequeue_buffers(tx_queue, index);
337
338         /* See if we need to restart the netif queue.  This barrier
339          * separates the update of read_count from the test of
340          * stopped. */
341         smp_mb();
342         if (unlikely(tx_queue->stopped)) {
343                 fill_level = tx_queue->insert_count - tx_queue->read_count;
344                 if (fill_level < EFX_NETDEV_TX_THRESHOLD(tx_queue)) {
345                         EFX_BUG_ON_PARANOID(!NET_DEV_REGISTERED(efx));
346
347                         /* Do this under netif_tx_lock(), to avoid racing
348                          * with efx_xmit(). */
349                         netif_tx_lock(efx->net_dev);
350                         if (tx_queue->stopped) {
351                                 tx_queue->stopped = 0;
352                                 efx_wake_queue(efx);
353                         }
354                         netif_tx_unlock(efx->net_dev);
355                 }
356         }
357 }
358
359 int efx_probe_tx_queue(struct efx_tx_queue *tx_queue)
360 {
361         struct efx_nic *efx = tx_queue->efx;
362         unsigned int txq_size;
363         int i, rc;
364
365         EFX_LOG(efx, "creating TX queue %d\n", tx_queue->queue);
366
367         /* Allocate software ring */
368         txq_size = (efx->type->txd_ring_mask + 1) * sizeof(*tx_queue->buffer);
369         tx_queue->buffer = kzalloc(txq_size, GFP_KERNEL);
370         if (!tx_queue->buffer) {
371                 rc = -ENOMEM;
372                 goto fail1;
373         }
374         for (i = 0; i <= efx->type->txd_ring_mask; ++i)
375                 tx_queue->buffer[i].continuation = 1;
376
377         /* Allocate hardware ring */
378         rc = falcon_probe_tx(tx_queue);
379         if (rc)
380                 goto fail2;
381
382         return 0;
383
384  fail2:
385         kfree(tx_queue->buffer);
386         tx_queue->buffer = NULL;
387  fail1:
388         tx_queue->used = 0;
389
390         return rc;
391 }
392
393 int efx_init_tx_queue(struct efx_tx_queue *tx_queue)
394 {
395         EFX_LOG(tx_queue->efx, "initialising TX queue %d\n", tx_queue->queue);
396
397         tx_queue->insert_count = 0;
398         tx_queue->write_count = 0;
399         tx_queue->read_count = 0;
400         tx_queue->old_read_count = 0;
401         BUG_ON(tx_queue->stopped);
402
403         /* Set up TX descriptor ring */
404         return falcon_init_tx(tx_queue);
405 }
406
407 void efx_release_tx_buffers(struct efx_tx_queue *tx_queue)
408 {
409         struct efx_tx_buffer *buffer;
410
411         if (!tx_queue->buffer)
412                 return;
413
414         /* Free any buffers left in the ring */
415         while (tx_queue->read_count != tx_queue->write_count) {
416                 buffer = &tx_queue->buffer[tx_queue->read_count &
417                                            tx_queue->efx->type->txd_ring_mask];
418                 efx_dequeue_buffer(tx_queue, buffer);
419                 buffer->continuation = 1;
420                 buffer->len = 0;
421
422                 ++tx_queue->read_count;
423         }
424 }
425
426 void efx_fini_tx_queue(struct efx_tx_queue *tx_queue)
427 {
428         EFX_LOG(tx_queue->efx, "shutting down TX queue %d\n", tx_queue->queue);
429
430         /* Flush TX queue, remove descriptor ring */
431         falcon_fini_tx(tx_queue);
432
433         efx_release_tx_buffers(tx_queue);
434
435         /* Release queue's stop on port, if any */
436         if (tx_queue->stopped) {
437                 tx_queue->stopped = 0;
438                 efx_wake_queue(tx_queue->efx);
439         }
440 }
441
442 void efx_remove_tx_queue(struct efx_tx_queue *tx_queue)
443 {
444         EFX_LOG(tx_queue->efx, "destroying TX queue %d\n", tx_queue->queue);
445         falcon_remove_tx(tx_queue);
446
447         kfree(tx_queue->buffer);
448         tx_queue->buffer = NULL;
449         tx_queue->used = 0;
450 }
451
452