Add changes from the Linux-2.6 tree.

[linux-2.6.git] / drivers / atm / fore200e.c

diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
index 5f70219..4aeb3d0 100644 (file)
--- a/drivers/atm/fore200e.c
+++ b/drivers/atm/fore200e.c
@@ -25,7 +25,6 @@
 */
 
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/init.h>
@@ -167,34 +166,9 @@ fore200e_atm2fore_aal(int aal)
 static char*
 fore200e_irq_itoa(int irq)
 {
-#if defined(__sparc_v9__)
-    return __irq_itoa(irq);
-#else
     static char str[8];
     sprintf(str, "%d", irq);
     return str;
-#endif
-}
-
-
-static void*
-fore200e_kmalloc(int size, int flags)
-{
-    void* chunk = kmalloc(size, flags);
-
-    if (chunk)
-       memset(chunk, 0x00, size);
-    else
-       printk(FORE200E "kmalloc() failed, requested size = %d, flags = 0x%x\n", size, flags);
-    
-    return chunk;
-}
-
-
-static void
-fore200e_kfree(void* chunk)
-{
-    kfree(chunk);
 }
 
 
@@ -213,7 +187,7 @@ fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, i
     chunk->align_size = size;
     chunk->direction  = direction;
 
-    chunk->alloc_addr = fore200e_kmalloc(chunk->alloc_size, GFP_KERNEL | GFP_DMA);
+    chunk->alloc_addr = kzalloc(chunk->alloc_size, GFP_KERNEL | GFP_DMA);
     if (chunk->alloc_addr == NULL)
        return -ENOMEM;
 
@@ -235,7 +209,7 @@ fore200e_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
 {
     fore200e->bus->dma_unmap(fore200e, chunk->dma_addr, chunk->dma_size, chunk->direction);
 
-    fore200e_kfree(chunk->alloc_addr);
+    kfree(chunk->alloc_addr);
 }
 
 
@@ -557,7 +531,7 @@ fore200e_pca_reset(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_pca_map(struct fore200e* fore200e)
 {
     DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
@@ -591,7 +565,7 @@ fore200e_pca_unmap(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_pca_configure(struct fore200e* fore200e)
 {
     struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
@@ -889,7 +863,7 @@ fore200e_sba_detect(const struct fore200e_bus* bus, int index)
        return NULL;
     }
 
-    fore200e = fore200e_kmalloc(sizeof(struct fore200e), GFP_KERNEL);
+    fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
     if (fore200e == NULL)
        return NULL;
 
@@ -1176,7 +1150,7 @@ fore200e_push_rpd(struct fore200e* fore200e, struct atm_vcc* vcc, struct rpd* rp
        return -ENOMEM;
     } 
 
-    do_gettimeofday(&skb->stamp);
+    __net_timestamp(skb);
     
 #ifdef FORE200E_52BYTE_AAL0_SDU
     if (cell_header) {
@@ -1335,7 +1309,7 @@ fore200e_irq(struct fore200e* fore200e)
 
 
 static irqreturn_t
-fore200e_interrupt(int irq, void* dev, struct pt_regs* regs)
+fore200e_interrupt(int irq, void* dev)
 {
     struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);
 
@@ -1512,7 +1486,7 @@ fore200e_open(struct atm_vcc *vcc)
 
     spin_unlock_irqrestore(&fore200e->q_lock, flags);
 
-    fore200e_vcc = fore200e_kmalloc(sizeof(struct fore200e_vcc), GFP_ATOMIC);
+    fore200e_vcc = kzalloc(sizeof(struct fore200e_vcc), GFP_ATOMIC);
     if (fore200e_vcc == NULL) {
        vc_map->vcc = NULL;
        return -ENOMEM;
@@ -1533,7 +1507,7 @@ fore200e_open(struct atm_vcc *vcc)
        if (fore200e->available_cell_rate < vcc->qos.txtp.max_pcr) {
            up(&fore200e->rate_sf);
 
-           fore200e_kfree(fore200e_vcc);
+           kfree(fore200e_vcc);
            vc_map->vcc = NULL;
            return -EAGAIN;
        }
@@ -1561,7 +1535,7 @@ fore200e_open(struct atm_vcc *vcc)
 
        fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
 
-       fore200e_kfree(fore200e_vcc);
+       kfree(fore200e_vcc);
        return -EINVAL;
     }
     
@@ -1637,7 +1611,7 @@ fore200e_close(struct atm_vcc* vcc)
     clear_bit(ATM_VF_PARTIAL,&vcc->flags);
 
     ASSERT(fore200e_vcc);
-    fore200e_kfree(fore200e_vcc);
+    kfree(fore200e_vcc);
 }
 
 
@@ -1838,7 +1812,7 @@ fore200e_getstats(struct fore200e* fore200e)
     u32                     stats_dma_addr;
 
     if (fore200e->stats == NULL) {
-       fore200e->stats = fore200e_kmalloc(sizeof(struct stats), GFP_KERNEL | GFP_DMA);
+       fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL | GFP_DMA);
        if (fore200e->stats == NULL)
            return -ENOMEM;
     }
@@ -2009,17 +1983,6 @@ fore200e_setloop(struct fore200e* fore200e, int loop_mode)
 }
 
 
-static inline unsigned int
-fore200e_swap(unsigned int in)
-{
-#if defined(__LITTLE_ENDIAN)
-    return swab32(in);
-#else
-    return in;
-#endif
-}
-
-
 static int
 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
 {
@@ -2028,19 +1991,19 @@ fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
     if (fore200e_getstats(fore200e) < 0)
        return -EIO;
 
-    tmp.section_bip = fore200e_swap(fore200e->stats->oc3.section_bip8_errors);
-    tmp.line_bip    = fore200e_swap(fore200e->stats->oc3.line_bip24_errors);
-    tmp.path_bip    = fore200e_swap(fore200e->stats->oc3.path_bip8_errors);
-    tmp.line_febe   = fore200e_swap(fore200e->stats->oc3.line_febe_errors);
-    tmp.path_febe   = fore200e_swap(fore200e->stats->oc3.path_febe_errors);
-    tmp.corr_hcs    = fore200e_swap(fore200e->stats->oc3.corr_hcs_errors);
-    tmp.uncorr_hcs  = fore200e_swap(fore200e->stats->oc3.ucorr_hcs_errors);
-    tmp.tx_cells    = fore200e_swap(fore200e->stats->aal0.cells_transmitted)  +
-                     fore200e_swap(fore200e->stats->aal34.cells_transmitted) +
-                     fore200e_swap(fore200e->stats->aal5.cells_transmitted);
-    tmp.rx_cells    = fore200e_swap(fore200e->stats->aal0.cells_received)     +
-                     fore200e_swap(fore200e->stats->aal34.cells_received)    +
-                     fore200e_swap(fore200e->stats->aal5.cells_received);
+    tmp.section_bip = cpu_to_be32(fore200e->stats->oc3.section_bip8_errors);
+    tmp.line_bip    = cpu_to_be32(fore200e->stats->oc3.line_bip24_errors);
+    tmp.path_bip    = cpu_to_be32(fore200e->stats->oc3.path_bip8_errors);
+    tmp.line_febe   = cpu_to_be32(fore200e->stats->oc3.line_febe_errors);
+    tmp.path_febe   = cpu_to_be32(fore200e->stats->oc3.path_febe_errors);
+    tmp.corr_hcs    = cpu_to_be32(fore200e->stats->oc3.corr_hcs_errors);
+    tmp.uncorr_hcs  = cpu_to_be32(fore200e->stats->oc3.ucorr_hcs_errors);
+    tmp.tx_cells    = cpu_to_be32(fore200e->stats->aal0.cells_transmitted)  +
+                     cpu_to_be32(fore200e->stats->aal34.cells_transmitted) +
+                     cpu_to_be32(fore200e->stats->aal5.cells_transmitted);
+    tmp.rx_cells    = cpu_to_be32(fore200e->stats->aal0.cells_received)     +
+                     cpu_to_be32(fore200e->stats->aal34.cells_received)    +
+                     cpu_to_be32(fore200e->stats->aal5.cells_received);
 
     if (arg)
        return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;       
@@ -2127,10 +2090,10 @@ fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
 }
     
 
-static int __init
+static int __devinit
 fore200e_irq_request(struct fore200e* fore200e)
 {
-    if (request_irq(fore200e->irq, fore200e_interrupt, SA_SHIRQ, fore200e->name, fore200e->atm_dev) < 0) {
+    if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
 
        printk(FORE200E "unable to reserve IRQ %s for device %s\n",
               fore200e_irq_itoa(fore200e->irq), fore200e->name);
@@ -2150,10 +2113,10 @@ fore200e_irq_request(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_get_esi(struct fore200e* fore200e)
 {
-    struct prom_data* prom = fore200e_kmalloc(sizeof(struct prom_data), GFP_KERNEL | GFP_DMA);
+    struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL | GFP_DMA);
     int ok, i;
 
     if (!prom)
@@ -2161,7 +2124,7 @@ fore200e_get_esi(struct fore200e* fore200e)
 
     ok = fore200e->bus->prom_read(fore200e, prom);
     if (ok < 0) {
-       fore200e_kfree(prom);
+       kfree(prom);
        return -EBUSY;
     }
        
@@ -2176,13 +2139,13 @@ fore200e_get_esi(struct fore200e* fore200e)
        fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
     }
     
-    fore200e_kfree(prom);
+    kfree(prom);
 
     return 0;
 }
 
 
-static int __init
+static int __devinit
 fore200e_alloc_rx_buf(struct fore200e* fore200e)
 {
     int scheme, magn, nbr, size, i;
@@ -2201,7 +2164,7 @@ fore200e_alloc_rx_buf(struct fore200e* fore200e)
            DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
 
            /* allocate the array of receive buffers */
-           buffer = bsq->buffer = fore200e_kmalloc(nbr * sizeof(struct buffer), GFP_KERNEL);
+           buffer = bsq->buffer = kzalloc(nbr * sizeof(struct buffer), GFP_KERNEL);
 
            if (buffer == NULL)
                return -ENOMEM;
@@ -2224,7 +2187,7 @@ fore200e_alloc_rx_buf(struct fore200e* fore200e)
                    
                    while (i > 0)
                        fore200e_chunk_free(fore200e, &buffer[ --i ].data);
-                   fore200e_kfree(buffer);
+                   kfree(buffer);
                    
                    return -ENOMEM;
                }
@@ -2247,7 +2210,7 @@ fore200e_alloc_rx_buf(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_init_bs_queue(struct fore200e* fore200e)
 {
     int scheme, magn, i;
@@ -2310,7 +2273,7 @@ fore200e_init_bs_queue(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_init_rx_queue(struct fore200e* fore200e)
 {
     struct host_rxq*     rxq =  &fore200e->host_rxq;
@@ -2370,7 +2333,7 @@ fore200e_init_rx_queue(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_init_tx_queue(struct fore200e* fore200e)
 {
     struct host_txq*     txq =  &fore200e->host_txq;
@@ -2433,7 +2396,7 @@ fore200e_init_tx_queue(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_init_cmd_queue(struct fore200e* fore200e)
 {
     struct host_cmdq*     cmdq =  &fore200e->host_cmdq;
@@ -2489,7 +2452,7 @@ fore200e_param_bs_queue(struct fore200e* fore200e,
 }
 
 
-static int __init
+static int __devinit
 fore200e_initialize(struct fore200e* fore200e)
 {
     struct cp_queues __iomem * cpq;
@@ -2541,7 +2504,7 @@ fore200e_initialize(struct fore200e* fore200e)
 }
 
 
-static void __init
+static void __devinit
 fore200e_monitor_putc(struct fore200e* fore200e, char c)
 {
     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
@@ -2553,7 +2516,7 @@ fore200e_monitor_putc(struct fore200e* fore200e, char c)
 }
 
 
-static int __init
+static int __devinit
 fore200e_monitor_getc(struct fore200e* fore200e)
 {
     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
@@ -2578,7 +2541,7 @@ fore200e_monitor_getc(struct fore200e* fore200e)
 }
 
 
-static void __init
+static void __devinit
 fore200e_monitor_puts(struct fore200e* fore200e, char* str)
 {
     while (*str) {
@@ -2593,7 +2556,7 @@ fore200e_monitor_puts(struct fore200e* fore200e, char* str)
 }
 
 
-static int __init
+static int __devinit
 fore200e_start_fw(struct fore200e* fore200e)
 {
     int               ok;
@@ -2624,7 +2587,7 @@ fore200e_start_fw(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_load_fw(struct fore200e* fore200e)
 {
     u32* fw_data = (u32*) fore200e->bus->fw_data;
@@ -2650,7 +2613,7 @@ fore200e_load_fw(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_register(struct fore200e* fore200e)
 {
     struct atm_dev* atm_dev;
@@ -2677,7 +2640,7 @@ fore200e_register(struct fore200e* fore200e)
 }
 
 
-static int __init
+static int __devinit
 fore200e_init(struct fore200e* fore200e)
 {
     if (fore200e_register(fore200e) < 0)
@@ -2723,7 +2686,7 @@ fore200e_init(struct fore200e* fore200e)
        return -EBUSY;
 
     fore200e_supply(fore200e);
-    
+
     /* all done, board initialization is now complete */
     fore200e->state = FORE200E_STATE_COMPLETE;
     return 0;
@@ -2743,7 +2706,7 @@ fore200e_pca_detect(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent
        goto out;
     }
     
-    fore200e = fore200e_kmalloc(sizeof(struct fore200e), GFP_KERNEL);
+    fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
     if (fore200e == NULL) {
        err = -ENOMEM;
        goto out_disable;
@@ -3006,8 +2969,8 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "  4b5b:\n"
                       "     crc_header_errors:\t\t%10u\n"
                       "     framing_errors:\t\t%10u\n",
-                      fore200e_swap(fore200e->stats->phy.crc_header_errors),
-                      fore200e_swap(fore200e->stats->phy.framing_errors));
+                      cpu_to_be32(fore200e->stats->phy.crc_header_errors),
+                      cpu_to_be32(fore200e->stats->phy.framing_errors));
     
     if (!left--)
        return sprintf(page, "\n"
@@ -3019,13 +2982,13 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "     path_febe_errors:\t\t%10u\n"
                       "     corr_hcs_errors:\t\t%10u\n"
                       "     ucorr_hcs_errors:\t\t%10u\n",
-                      fore200e_swap(fore200e->stats->oc3.section_bip8_errors),
-                      fore200e_swap(fore200e->stats->oc3.path_bip8_errors),
-                      fore200e_swap(fore200e->stats->oc3.line_bip24_errors),
-                      fore200e_swap(fore200e->stats->oc3.line_febe_errors),
-                      fore200e_swap(fore200e->stats->oc3.path_febe_errors),
-                      fore200e_swap(fore200e->stats->oc3.corr_hcs_errors),
-                      fore200e_swap(fore200e->stats->oc3.ucorr_hcs_errors));
+                      cpu_to_be32(fore200e->stats->oc3.section_bip8_errors),
+                      cpu_to_be32(fore200e->stats->oc3.path_bip8_errors),
+                      cpu_to_be32(fore200e->stats->oc3.line_bip24_errors),
+                      cpu_to_be32(fore200e->stats->oc3.line_febe_errors),
+                      cpu_to_be32(fore200e->stats->oc3.path_febe_errors),
+                      cpu_to_be32(fore200e->stats->oc3.corr_hcs_errors),
+                      cpu_to_be32(fore200e->stats->oc3.ucorr_hcs_errors));
 
     if (!left--)
        return sprintf(page,"\n"
@@ -3036,12 +2999,12 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "     vpi no conn:\t\t%10u\n"
                       "     vci out of range:\t\t%10u\n"
                       "     vci no conn:\t\t%10u\n",
-                      fore200e_swap(fore200e->stats->atm.cells_transmitted),
-                      fore200e_swap(fore200e->stats->atm.cells_received),
-                      fore200e_swap(fore200e->stats->atm.vpi_bad_range),
-                      fore200e_swap(fore200e->stats->atm.vpi_no_conn),
-                      fore200e_swap(fore200e->stats->atm.vci_bad_range),
-                      fore200e_swap(fore200e->stats->atm.vci_no_conn));
+                      cpu_to_be32(fore200e->stats->atm.cells_transmitted),
+                      cpu_to_be32(fore200e->stats->atm.cells_received),
+                      cpu_to_be32(fore200e->stats->atm.vpi_bad_range),
+                      cpu_to_be32(fore200e->stats->atm.vpi_no_conn),
+                      cpu_to_be32(fore200e->stats->atm.vci_bad_range),
+                      cpu_to_be32(fore200e->stats->atm.vci_no_conn));
     
     if (!left--)
        return sprintf(page,"\n"
@@ -3049,9 +3012,9 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "     TX:\t\t\t%10u\n"
                       "     RX:\t\t\t%10u\n"
                       "     dropped:\t\t\t%10u\n",
-                      fore200e_swap(fore200e->stats->aal0.cells_transmitted),
-                      fore200e_swap(fore200e->stats->aal0.cells_received),
-                      fore200e_swap(fore200e->stats->aal0.cells_dropped));
+                      cpu_to_be32(fore200e->stats->aal0.cells_transmitted),
+                      cpu_to_be32(fore200e->stats->aal0.cells_received),
+                      cpu_to_be32(fore200e->stats->aal0.cells_dropped));
     
     if (!left--)
        return sprintf(page,"\n"
@@ -3067,15 +3030,15 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "       RX:\t\t\t%10u\n"
                       "       dropped:\t\t\t%10u\n"
                       "       protocol errors:\t\t%10u\n",
-                      fore200e_swap(fore200e->stats->aal34.cells_transmitted),
-                      fore200e_swap(fore200e->stats->aal34.cells_received),
-                      fore200e_swap(fore200e->stats->aal34.cells_dropped),
-                      fore200e_swap(fore200e->stats->aal34.cells_crc_errors),
-                      fore200e_swap(fore200e->stats->aal34.cells_protocol_errors),
-                      fore200e_swap(fore200e->stats->aal34.cspdus_transmitted),
-                      fore200e_swap(fore200e->stats->aal34.cspdus_received),
-                      fore200e_swap(fore200e->stats->aal34.cspdus_dropped),
-                      fore200e_swap(fore200e->stats->aal34.cspdus_protocol_errors));
+                      cpu_to_be32(fore200e->stats->aal34.cells_transmitted),
+                      cpu_to_be32(fore200e->stats->aal34.cells_received),
+                      cpu_to_be32(fore200e->stats->aal34.cells_dropped),
+                      cpu_to_be32(fore200e->stats->aal34.cells_crc_errors),
+                      cpu_to_be32(fore200e->stats->aal34.cells_protocol_errors),
+                      cpu_to_be32(fore200e->stats->aal34.cspdus_transmitted),
+                      cpu_to_be32(fore200e->stats->aal34.cspdus_received),
+                      cpu_to_be32(fore200e->stats->aal34.cspdus_dropped),
+                      cpu_to_be32(fore200e->stats->aal34.cspdus_protocol_errors));
     
     if (!left--)
        return sprintf(page,"\n"
@@ -3091,15 +3054,15 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "       dropped:\t\t\t%10u\n"
                       "       CRC errors:\t\t%10u\n"
                       "       protocol errors:\t\t%10u\n",
-                      fore200e_swap(fore200e->stats->aal5.cells_transmitted),
-                      fore200e_swap(fore200e->stats->aal5.cells_received),
-                      fore200e_swap(fore200e->stats->aal5.cells_dropped),
-                      fore200e_swap(fore200e->stats->aal5.congestion_experienced),
-                      fore200e_swap(fore200e->stats->aal5.cspdus_transmitted),
-                      fore200e_swap(fore200e->stats->aal5.cspdus_received),
-                      fore200e_swap(fore200e->stats->aal5.cspdus_dropped),
-                      fore200e_swap(fore200e->stats->aal5.cspdus_crc_errors),
-                      fore200e_swap(fore200e->stats->aal5.cspdus_protocol_errors));
+                      cpu_to_be32(fore200e->stats->aal5.cells_transmitted),
+                      cpu_to_be32(fore200e->stats->aal5.cells_received),
+                      cpu_to_be32(fore200e->stats->aal5.cells_dropped),
+                      cpu_to_be32(fore200e->stats->aal5.congestion_experienced),
+                      cpu_to_be32(fore200e->stats->aal5.cspdus_transmitted),
+                      cpu_to_be32(fore200e->stats->aal5.cspdus_received),
+                      cpu_to_be32(fore200e->stats->aal5.cspdus_dropped),
+                      cpu_to_be32(fore200e->stats->aal5.cspdus_crc_errors),
+                      cpu_to_be32(fore200e->stats->aal5.cspdus_protocol_errors));
     
     if (!left--)
        return sprintf(page,"\n"
@@ -3110,11 +3073,11 @@ fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
                       "     large b2:\t\t\t%10u\n"
                       "     RX PDUs:\t\t\t%10u\n"
                       "     TX PDUs:\t\t\t%10lu\n",
-                      fore200e_swap(fore200e->stats->aux.small_b1_failed),
-                      fore200e_swap(fore200e->stats->aux.large_b1_failed),
-                      fore200e_swap(fore200e->stats->aux.small_b2_failed),
-                      fore200e_swap(fore200e->stats->aux.large_b2_failed),
-                      fore200e_swap(fore200e->stats->aux.rpd_alloc_failed),
+                      cpu_to_be32(fore200e->stats->aux.small_b1_failed),
+                      cpu_to_be32(fore200e->stats->aux.large_b1_failed),
+                      cpu_to_be32(fore200e->stats->aux.small_b2_failed),
+                      cpu_to_be32(fore200e->stats->aux.large_b2_failed),
+                      cpu_to_be32(fore200e->stats->aux.rpd_alloc_failed),
                       fore200e->tx_sat);
     
     if (!left--)