16 files changed, 257 insertions, 217 deletions

diff --git a/drivers/isdn/hardware/avm/c4.c b/drivers/isdn/hardware/avm/c4.c
index 7715d3242ec8..d3530f6e8115 100644
--- a/drivers/isdn/hardware/avm/c4.c
+++ b/drivers/isdn/hardware/avm/c4.c
@@ -1273,6 +1273,7 @@ static int __devinit c4_probe(struct pci_dev *dev,
         if (retval != 0) {
                 printk(KERN_ERR "c4: no AVM-C%d at i/o %#x, irq %d detected, mem %#x\n",
                        nr, param.port, param.irq, param.membase);
+                pci_disable_device(dev);
                 return -ENODEV;
         }
         return 0;
diff --git a/drivers/isdn/hardware/avm/t1pci.c b/drivers/isdn/hardware/avm/t1pci.c
index 5a3f83098018..a79eb5afb92d 100644
--- a/drivers/isdn/hardware/avm/t1pci.c
+++ b/drivers/isdn/hardware/avm/t1pci.c
@@ -210,6 +210,7 @@ static int __devinit t1pci_probe(struct pci_dev *dev,
         if (retval != 0) {
                 printk(KERN_ERR "t1pci: no AVM-T1-PCI at i/o %#x, irq %d detected, mem %#x\n",
                        param.port, param.irq, param.membase);
+                pci_disable_device(dev);
                 return -ENODEV;
         }
         return 0;
diff --git a/drivers/isdn/hardware/mISDN/mISDNinfineon.c b/drivers/isdn/hardware/mISDN/mISDNinfineon.c
index d2dd61d65d51..af25e1f3efd4 100644
--- a/drivers/isdn/hardware/mISDN/mISDNinfineon.c
+++ b/drivers/isdn/hardware/mISDN/mISDNinfineon.c
@@ -1094,6 +1094,7 @@ inf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 pr_info("mISDN: do not have informations about adapter at %s\n",
                         pci_name(pdev));
                 kfree(card);
+                pci_disable_device(pdev);
                 return -EINVAL;
         } else
                 pr_notice("mISDN: found adapter %s at %s\n",
@@ -1103,7 +1104,7 @@ inf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         pci_set_drvdata(pdev, card);
         err = setup_instance(card);
         if (err) {
-                pci_disable_device(card->pdev);
+                pci_disable_device(pdev);
                 kfree(card);
                 pci_set_drvdata(pdev, NULL);
         } else if (ent->driver_data == INF_SCT_1) {
@@ -1114,6 +1115,7 @@ inf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         sc = kzalloc(sizeof(struct inf_hw), GFP_KERNEL);
                         if (!sc) {
                                 release_card(card);
+                                pci_disable_device(pdev);
                                 return -ENOMEM;
                         }
                         sc->irq = card->irq;
@@ -1121,6 +1123,7 @@ inf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         sc->ci = card->ci + i;
                         err = setup_instance(sc);
                         if (err) {
+                                pci_disable_device(pdev);
                                 kfree(sc);
                                 release_card(card);
                                 break;
diff --git a/drivers/net/caif/caif_spi_slave.c b/drivers/net/caif/caif_spi_slave.c
index 077ccf840edf..2111dbfea6fe 100644
--- a/drivers/net/caif/caif_spi_slave.c
+++ b/drivers/net/caif/caif_spi_slave.c
@@ -22,13 +22,13 @@
 #include <net/caif/caif_spi.h>
 
 #ifndef CONFIG_CAIF_SPI_SYNC
-#define SPI_DATA_POS SPI_CMD_SZ
+#define SPI_DATA_POS 0
 static inline int forward_to_spi_cmd(struct cfspi *cfspi)
 {
         return cfspi->rx_cpck_len;
 }
 #else
-#define SPI_DATA_POS 0
+#define SPI_DATA_POS SPI_CMD_SZ
 static inline int forward_to_spi_cmd(struct cfspi *cfspi)
 {
         return 0;
diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig
index a527e37728cd..eb799b36c86a 100644
--- a/drivers/net/phy/Kconfig
+++ b/drivers/net/phy/Kconfig
@@ -5,7 +5,7 @@
 menuconfig PHYLIB
         tristate "PHY Device support and infrastructure"
         depends on !S390
-        depends on NET_ETHERNET
+        depends on NETDEVICES
         help
           Ethernet controllers are usually attached to PHY
           devices.  This option provides infrastructure for
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index 5130db8f5c4e..1bb16cb79433 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -301,7 +301,7 @@ EXPORT_SYMBOL(phy_ethtool_gset);
 /**
  * phy_mii_ioctl - generic PHY MII ioctl interface
  * @phydev: the phy_device struct
- * @mii_data: MII ioctl data
+ * @ifr: &struct ifreq for socket ioctl's
  * @cmd: ioctl cmd to execute
  *
  * Note that this function is currently incompatible with the
diff --git a/drivers/net/qlcnic/qlcnic_main.c b/drivers/net/qlcnic/qlcnic_main.c
index b9615bd745ea..bf6d87adda4f 100644
--- a/drivers/net/qlcnic/qlcnic_main.c
+++ b/drivers/net/qlcnic/qlcnic_main.c
@@ -473,48 +473,58 @@ qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
 static int
 qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 {
-        struct qlcnic_pci_info pci_info[QLCNIC_MAX_PCI_FUNC];
+        struct qlcnic_pci_info *pci_info;
         int i, ret = 0, err;
         u8 pfn;
 
-        if (!adapter->npars)
-                adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
-                                QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
-        if (!adapter->npars)
+        pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
+        if (!pci_info)
                 return -ENOMEM;
 
-        if (!adapter->eswitch)
-                adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
+        adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
+                                QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
+        if (!adapter->npars) {
+                err = -ENOMEM;
+                goto err_pci_info;
+        }
+
+        adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
                                 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
         if (!adapter->eswitch) {
                 err = -ENOMEM;
-                goto err_eswitch;
+                goto err_npars;
         }
 
         ret = qlcnic_get_pci_info(adapter, pci_info);
-        if (!ret) {
-                for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
-                        pfn = pci_info[i].id;
-                        if (pfn > QLCNIC_MAX_PCI_FUNC)
-                                return QL_STATUS_INVALID_PARAM;
-                        adapter->npars[pfn].active = pci_info[i].active;
-                        adapter->npars[pfn].type = pci_info[i].type;
-                        adapter->npars[pfn].phy_port = pci_info[i].default_port;
-                        adapter->npars[pfn].mac_learning = DEFAULT_MAC_LEARN;
-                        adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
-                        adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
-                }
-
-                for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
-                        adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
+        if (ret)
+                goto err_eswitch;
 
-                return ret;
+        for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
+                pfn = pci_info[i].id;
+                if (pfn > QLCNIC_MAX_PCI_FUNC)
+                        return QL_STATUS_INVALID_PARAM;
+                adapter->npars[pfn].active = pci_info[i].active;
+                adapter->npars[pfn].type = pci_info[i].type;
+                adapter->npars[pfn].phy_port = pci_info[i].default_port;
+                adapter->npars[pfn].mac_learning = DEFAULT_MAC_LEARN;
+                adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
+                adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
         }
 
+        for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
+                adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
+
+        kfree(pci_info);
+        return 0;
+
+err_eswitch:
         kfree(adapter->eswitch);
         adapter->eswitch = NULL;
-err_eswitch:
+err_npars:
         kfree(adapter->npars);
+        adapter->npars = NULL;
+err_pci_info:
+        kfree(pci_info);
 
         return ret;
 }
@@ -3361,15 +3371,21 @@ qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
         struct device *dev = container_of(kobj, struct device, kobj);
         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
         struct qlcnic_pci_func_cfg pci_cfg[QLCNIC_MAX_PCI_FUNC];
-        struct qlcnic_pci_info  pci_info[QLCNIC_MAX_PCI_FUNC];
+        struct qlcnic_pci_info *pci_info;
         int i, ret;
 
         if (size != sizeof(pci_cfg))
                 return QL_STATUS_INVALID_PARAM;
 
+        pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
+        if (!pci_info)
+                return -ENOMEM;
+
         ret = qlcnic_get_pci_info(adapter, pci_info);
-        if (ret)
+        if (ret) {
+                kfree(pci_info);
                 return ret;
+        }
 
         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
                 pci_cfg[i].pci_func = pci_info[i].id;
@@ -3380,8 +3396,8 @@ qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
                 memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
         }
         memcpy(buf, &pci_cfg, size);
+        kfree(pci_info);
         return size;
-
 }
 static struct bin_attribute bin_attr_npar_config = {
         .attr = {.name = "npar_config", .mode = (S_IRUGO | S_IWUSR)},
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index 7f62e2dea28f..ca7fc9df1ccf 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -315,7 +315,7 @@ EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
 
 static void rx_complete (struct urb *urb);
 
-static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
+static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
 {
         struct sk_buff          *skb;
         struct skb_data         *entry;
@@ -327,7 +327,7 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                 netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
                 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
                 usb_free_urb (urb);
-                return;
+                return -ENOMEM;
         }
         skb_reserve (skb, NET_IP_ALIGN);
 
@@ -357,6 +357,9 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                         netif_dbg(dev, ifdown, dev->net, "device gone\n");
                         netif_device_detach (dev->net);
                         break;
+                case -EHOSTUNREACH:
+                        retval = -ENOLINK;
+                        break;
                 default:
                         netif_dbg(dev, rx_err, dev->net,
                                   "rx submit, %d\n", retval);
@@ -374,6 +377,7 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                 dev_kfree_skb_any (skb);
                 usb_free_urb (urb);
         }
+        return retval;
 }
 
 
@@ -912,6 +916,7 @@ fail_halt:
         /* tasklet could resubmit itself forever if memory is tight */
         if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
                 struct urb      *urb = NULL;
+                int resched = 1;
 
                 if (netif_running (dev->net))
                         urb = usb_alloc_urb (0, GFP_KERNEL);
@@ -922,10 +927,12 @@ fail_halt:
                         status = usb_autopm_get_interface(dev->intf);
                         if (status < 0)
                                 goto fail_lowmem;
-                        rx_submit (dev, urb, GFP_KERNEL);
+                        if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
+                                resched = 0;
                         usb_autopm_put_interface(dev->intf);
 fail_lowmem:
-                        tasklet_schedule (&dev->bh);
+                        if (resched)
+                                tasklet_schedule (&dev->bh);
                 }
         }
 
@@ -1175,8 +1182,11 @@ static void usbnet_bh (unsigned long param)
                         // don't refill the queue all at once
                         for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) {
                                 urb = usb_alloc_urb (0, GFP_ATOMIC);
-                                if (urb != NULL)
-                                        rx_submit (dev, urb, GFP_ATOMIC);
+                                if (urb != NULL) {
+                                        if (rx_submit (dev, urb, GFP_ATOMIC) ==
+                                            -ENOLINK)
+                                                return;
+                                }
                         }
                         if (temp != dev->rxq.qlen)
                                 netif_dbg(dev, link, dev->net,
diff --git a/drivers/net/wan/farsync.c b/drivers/net/wan/farsync.c
index ad7719fe6d0a..e050bd65e037 100644
--- a/drivers/net/wan/farsync.c
+++ b/drivers/net/wan/farsync.c
@@ -885,20 +885,21 @@ fst_rx_dma_complete(struct fst_card_info *card, struct fst_port_info *port,
  *      Receive a frame through the DMA
  */
 static inline void
-fst_rx_dma(struct fst_card_info *card, unsigned char *skb,
-           unsigned char *mem, int len)
+fst_rx_dma(struct fst_card_info *card, dma_addr_t skb,
+           dma_addr_t mem, int len)
 {
         /*
          * This routine will setup the DMA and start it
          */
 
-        dbg(DBG_RX, "In fst_rx_dma %p %p %d\n", skb, mem, len);
+        dbg(DBG_RX, "In fst_rx_dma %lx %lx %d\n",
+            (unsigned long) skb, (unsigned long) mem, len);
         if (card->dmarx_in_progress) {
                 dbg(DBG_ASS, "In fst_rx_dma while dma in progress\n");
         }
 
-        outl((unsigned long) skb, card->pci_conf + DMAPADR0);   /* Copy to here */
-        outl((unsigned long) mem, card->pci_conf + DMALADR0);   /* from here */
+        outl(skb, card->pci_conf + DMAPADR0);   /* Copy to here */
+        outl(mem, card->pci_conf + DMALADR0);   /* from here */
         outl(len, card->pci_conf + DMASIZ0);    /* for this length */
         outl(0x00000000c, card->pci_conf + DMADPR0);    /* In this direction */
 
@@ -1309,8 +1310,8 @@ fst_intr_rx(struct fst_card_info *card, struct fst_port_info *port)
                 card->dma_port_rx = port;
                 card->dma_len_rx = len;
                 card->dma_rxpos = rxp;
-                fst_rx_dma(card, (char *) card->rx_dma_handle_card,
-                           (char *) BUF_OFFSET(rxBuffer[pi][rxp][0]), len);
+                fst_rx_dma(card, card->rx_dma_handle_card,
+                           BUF_OFFSET(rxBuffer[pi][rxp][0]), len);
         }
         if (rxp != port->rxpos) {
                 dbg(DBG_ASS, "About to increment rxpos by more than 1\n");
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index a75ed3083a6a..8e4153d740f3 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -386,7 +386,7 @@ claw_tx(struct sk_buff *skb, struct net_device *dev)
         struct chbk *p_ch;
 
         CLAW_DBF_TEXT(4, trace, "claw_tx");
-        p_ch=&privptr->channel[WRITE];
+        p_ch = &privptr->channel[WRITE_CHANNEL];
         spin_lock_irqsave(get_ccwdev_lock(p_ch->cdev), saveflags);
         rc=claw_hw_tx( skb, dev, 1 );
         spin_unlock_irqrestore(get_ccwdev_lock(p_ch->cdev), saveflags);
@@ -407,7 +407,7 @@ static struct sk_buff *
 claw_pack_skb(struct claw_privbk *privptr)
 {
         struct sk_buff *new_skb,*held_skb;
-        struct chbk *p_ch = &privptr->channel[WRITE];
+        struct chbk *p_ch = &privptr->channel[WRITE_CHANNEL];
         struct claw_env  *p_env = privptr->p_env;
         int     pkt_cnt,pk_ind,so_far;
 
@@ -515,15 +515,15 @@ claw_open(struct net_device *dev)
                 privptr->p_env->write_size=CLAW_FRAME_SIZE;
         }
         claw_set_busy(dev);
-        tasklet_init(&privptr->channel[READ].tasklet, claw_irq_tasklet,
-                (unsigned long) &privptr->channel[READ]);
+        tasklet_init(&privptr->channel[READ_CHANNEL].tasklet, claw_irq_tasklet,
+                (unsigned long) &privptr->channel[READ_CHANNEL]);
         for ( i = 0; i < 2;  i++) {
                 CLAW_DBF_TEXT_(2, trace, "opn_ch%d", i);
                 init_waitqueue_head(&privptr->channel[i].wait);
                 /* skb_queue_head_init(&p_ch->io_queue); */
-                if (i == WRITE)
+                if (i == WRITE_CHANNEL)
                         skb_queue_head_init(
-                                &privptr->channel[WRITE].collect_queue);
+                                &privptr->channel[WRITE_CHANNEL].collect_queue);
                 privptr->channel[i].flag_a = 0;
                 privptr->channel[i].IO_active = 0;
                 privptr->channel[i].flag  &= ~CLAW_TIMER;
@@ -551,12 +551,12 @@ claw_open(struct net_device *dev)
                 if((privptr->channel[i].flag & CLAW_TIMER) == 0x00)
                         del_timer(&timer);
         }
-        if ((((privptr->channel[READ].last_dstat |
-                privptr->channel[WRITE].last_dstat) &
+        if ((((privptr->channel[READ_CHANNEL].last_dstat |
+                privptr->channel[WRITE_CHANNEL].last_dstat) &
            ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) != 0x00) ||
-           (((privptr->channel[READ].flag |
-                privptr->channel[WRITE].flag) & CLAW_TIMER) != 0x00)) {
-                dev_info(&privptr->channel[READ].cdev->dev,
+           (((privptr->channel[READ_CHANNEL].flag |
+                privptr->channel[WRITE_CHANNEL].flag) & CLAW_TIMER) != 0x00)) {
+                dev_info(&privptr->channel[READ_CHANNEL].cdev->dev,
                         "%s: remote side is not ready\n", dev->name);
                 CLAW_DBF_TEXT(2, trace, "notrdy");
 
@@ -608,8 +608,8 @@ claw_open(struct net_device *dev)
                         }
                 }
                 privptr->buffs_alloc = 0;
-                privptr->channel[READ].flag= 0x00;
-                privptr->channel[WRITE].flag = 0x00;
+                privptr->channel[READ_CHANNEL].flag = 0x00;
+                privptr->channel[WRITE_CHANNEL].flag = 0x00;
                 privptr->p_buff_ccw=NULL;
                 privptr->p_buff_read=NULL;
                 privptr->p_buff_write=NULL;
@@ -652,10 +652,10 @@ claw_irq_handler(struct ccw_device *cdev,
         }
 
         /* Try to extract channel from driver data. */
-        if (privptr->channel[READ].cdev == cdev)
-                p_ch = &privptr->channel[READ];
-        else if (privptr->channel[WRITE].cdev == cdev)
-                p_ch = &privptr->channel[WRITE];
+        if (privptr->channel[READ_CHANNEL].cdev == cdev)
+                p_ch = &privptr->channel[READ_CHANNEL];
+        else if (privptr->channel[WRITE_CHANNEL].cdev == cdev)
+                p_ch = &privptr->channel[WRITE_CHANNEL];
         else {
                 dev_warn(&cdev->dev, "The device is not a CLAW device\n");
                 CLAW_DBF_TEXT(2, trace, "badchan");
@@ -813,7 +813,7 @@ claw_irq_handler(struct ccw_device *cdev,
                         claw_clearbit_busy(TB_TX, dev);
                         claw_clear_busy(dev);
                 }
-                p_ch_r = (struct chbk *)&privptr->channel[READ];
+                p_ch_r = (struct chbk *)&privptr->channel[READ_CHANNEL];
                 if (test_and_set_bit(CLAW_BH_ACTIVE,
                         (void *)&p_ch_r->flag_a) == 0)
                         tasklet_schedule(&p_ch_r->tasklet);
@@ -878,13 +878,13 @@ claw_release(struct net_device *dev)
         for ( i = 1; i >=0 ;  i--) {
                 spin_lock_irqsave(
                         get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
-             /*   del_timer(&privptr->channel[READ].timer);  */
+             /*   del_timer(&privptr->channel[READ_CHANNEL].timer);  */
                 privptr->channel[i].claw_state = CLAW_STOP;
                 privptr->channel[i].IO_active = 0;
                 parm = (unsigned long) &privptr->channel[i];
-                if (i == WRITE)
+                if (i == WRITE_CHANNEL)
                         claw_purge_skb_queue(
-                                &privptr->channel[WRITE].collect_queue);
+                                &privptr->channel[WRITE_CHANNEL].collect_queue);
                 rc = ccw_device_halt (privptr->channel[i].cdev, parm);
                 if (privptr->system_validate_comp==0x00)  /* never opened? */
                    init_waitqueue_head(&privptr->channel[i].wait);
@@ -971,16 +971,16 @@ claw_release(struct net_device *dev)
         privptr->mtc_skipping = 1;
         privptr->mtc_offset=0;
 
-        if (((privptr->channel[READ].last_dstat |
-                privptr->channel[WRITE].last_dstat) &
+        if (((privptr->channel[READ_CHANNEL].last_dstat |
+                privptr->channel[WRITE_CHANNEL].last_dstat) &
                 ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) != 0x00) {
-                dev_warn(&privptr->channel[READ].cdev->dev,
+                dev_warn(&privptr->channel[READ_CHANNEL].cdev->dev,
                         "Deactivating %s completed with incorrect"
                         " subchannel status "
                         "(read %02x, write %02x)\n",
                 dev->name,
-                privptr->channel[READ].last_dstat,
-                privptr->channel[WRITE].last_dstat);
+                privptr->channel[READ_CHANNEL].last_dstat,
+                privptr->channel[WRITE_CHANNEL].last_dstat);
                  CLAW_DBF_TEXT(2, trace, "badclose");
         }
         CLAW_DBF_TEXT(4, trace, "rlsexit");
@@ -1324,7 +1324,7 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
 
         CLAW_DBF_TEXT(4, trace, "hw_tx");
         privptr = (struct claw_privbk *)(dev->ml_priv);
-        p_ch=(struct chbk *)&privptr->channel[WRITE];
+        p_ch = (struct chbk *)&privptr->channel[WRITE_CHANNEL];
         p_env =privptr->p_env;
         claw_free_wrt_buf(dev); /* Clean up free chain if posible */
         /*  scan the write queue to free any completed write packets   */
@@ -1357,7 +1357,7 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
                                 claw_strt_out_IO(dev );
                                 claw_free_wrt_buf( dev );
                                 if (privptr->write_free_count==0) {
-                                        ch = &privptr->channel[WRITE];
+                                        ch = &privptr->channel[WRITE_CHANNEL];
                                         atomic_inc(&skb->users);
                                         skb_queue_tail(&ch->collect_queue, skb);
                                         goto Done;
@@ -1369,7 +1369,7 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
                 }
                 /*  tx lock  */
                 if (claw_test_and_setbit_busy(TB_TX,dev)) { /* set to busy */
-                        ch = &privptr->channel[WRITE];
+                        ch = &privptr->channel[WRITE_CHANNEL];
                         atomic_inc(&skb->users);
                         skb_queue_tail(&ch->collect_queue, skb);
                         claw_strt_out_IO(dev );
@@ -1385,7 +1385,7 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
             privptr->p_write_free_chain == NULL ) {
 
                 claw_setbit_busy(TB_NOBUFFER,dev);
-                ch = &privptr->channel[WRITE];
+                ch = &privptr->channel[WRITE_CHANNEL];
                 atomic_inc(&skb->users);
                 skb_queue_tail(&ch->collect_queue, skb);
                 CLAW_DBF_TEXT(2, trace, "clawbusy");
@@ -1397,7 +1397,7 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
         while (len_of_data > 0) {
                 p_this_ccw=privptr->p_write_free_chain;  /* get a block */
                 if (p_this_ccw == NULL) { /* lost the race */
-                        ch = &privptr->channel[WRITE];
+                        ch = &privptr->channel[WRITE_CHANNEL];
                         atomic_inc(&skb->users);
                         skb_queue_tail(&ch->collect_queue, skb);
                         goto Done2;
@@ -2067,7 +2067,7 @@ claw_process_control( struct net_device *dev, struct ccwbk * p_ccw)
                         *catch up to each other */
         privptr = dev->ml_priv;
         p_env=privptr->p_env;
-        tdev = &privptr->channel[READ].cdev->dev;
+        tdev = &privptr->channel[READ_CHANNEL].cdev->dev;
         memcpy( &temp_host_name, p_env->host_name, 8);
         memcpy( &temp_ws_name, p_env->adapter_name , 8);
         dev_info(tdev, "%s: CLAW device %.8s: "
@@ -2245,7 +2245,7 @@ claw_process_control( struct net_device *dev, struct ccwbk * p_ccw)
                         dev->name, temp_ws_name,
                         p_ctlbk->linkid);
                         privptr->active_link_ID = p_ctlbk->linkid;
-                        p_ch = &privptr->channel[WRITE];
+                        p_ch = &privptr->channel[WRITE_CHANNEL];
                         wake_up(&p_ch->wait);  /* wake up claw_open ( WRITE) */
                 break;
         case CONNECTION_RESPONSE:
@@ -2296,7 +2296,7 @@ claw_process_control( struct net_device *dev, struct ccwbk * p_ccw)
                                 "%s: Confirmed Now packing\n", dev->name);
                                 p_env->packing = DO_PACKED;
                         }
-                        p_ch = &privptr->channel[WRITE];
+                        p_ch = &privptr->channel[WRITE_CHANNEL];
                         wake_up(&p_ch->wait);
                 } else {
                         dev_warn(tdev, "Activating %s failed because of"
@@ -2556,7 +2556,7 @@ unpack_read(struct net_device *dev )
         p_packd=NULL;
         privptr = dev->ml_priv;
 
-        p_dev = &privptr->channel[READ].cdev->dev;
+        p_dev = &privptr->channel[READ_CHANNEL].cdev->dev;
         p_env = privptr->p_env;
         p_this_ccw=privptr->p_read_active_first;
         while (p_this_ccw!=NULL && p_this_ccw->header.flag!=CLAW_PENDING) {
@@ -2728,7 +2728,7 @@ claw_strt_read (struct net_device *dev, int lock )
         struct ccwbk*p_ccwbk;
         struct chbk *p_ch;
         struct clawh *p_clawh;
-        p_ch=&privptr->channel[READ];
+        p_ch = &privptr->channel[READ_CHANNEL];
 
         CLAW_DBF_TEXT(4, trace, "StRdNter");
         p_clawh=(struct clawh *)privptr->p_claw_signal_blk;
@@ -2782,7 +2782,7 @@ claw_strt_out_IO( struct net_device *dev )
                 return;
         }
         privptr = (struct claw_privbk *)dev->ml_priv;
-        p_ch=&privptr->channel[WRITE];
+        p_ch = &privptr->channel[WRITE_CHANNEL];
 
         CLAW_DBF_TEXT(4, trace, "strt_io");
         p_first_ccw=privptr->p_write_active_first;
@@ -2875,7 +2875,7 @@ claw_free_netdevice(struct net_device * dev, int free_dev)
         if (dev->flags & IFF_RUNNING)
                 claw_release(dev);
         if (privptr) {
-                privptr->channel[READ].ndev = NULL;  /* say it's free */
+                privptr->channel[READ_CHANNEL].ndev = NULL;  /* say it's free */
         }
         dev->ml_priv = NULL;
 #ifdef MODULE
@@ -2960,18 +2960,18 @@ claw_new_device(struct ccwgroup_device *cgdev)
         struct ccw_dev_id dev_id;
 
         dev_info(&cgdev->dev, "add for %s\n",
-                 dev_name(&cgdev->cdev[READ]->dev));
+                 dev_name(&cgdev->cdev[READ_CHANNEL]->dev));
         CLAW_DBF_TEXT(2, setup, "new_dev");
         privptr = dev_get_drvdata(&cgdev->dev);
-        dev_set_drvdata(&cgdev->cdev[READ]->dev, privptr);
-        dev_set_drvdata(&cgdev->cdev[WRITE]->dev, privptr);
+        dev_set_drvdata(&cgdev->cdev[READ_CHANNEL]->dev, privptr);
+        dev_set_drvdata(&cgdev->cdev[WRITE_CHANNEL]->dev, privptr);
         if (!privptr)
                 return -ENODEV;
         p_env = privptr->p_env;
-        ccw_device_get_id(cgdev->cdev[READ], &dev_id);
-        p_env->devno[READ] = dev_id.devno;
-        ccw_device_get_id(cgdev->cdev[WRITE], &dev_id);
-        p_env->devno[WRITE] = dev_id.devno;
+        ccw_device_get_id(cgdev->cdev[READ_CHANNEL], &dev_id);
+        p_env->devno[READ_CHANNEL] = dev_id.devno;
+        ccw_device_get_id(cgdev->cdev[WRITE_CHANNEL], &dev_id);
+        p_env->devno[WRITE_CHANNEL] = dev_id.devno;
         ret = add_channel(cgdev->cdev[0],0,privptr);
         if (ret == 0)
                 ret = add_channel(cgdev->cdev[1],1,privptr);
@@ -2980,14 +2980,14 @@ claw_new_device(struct ccwgroup_device *cgdev)
                         " failed with error code %d\n", ret);
                 goto out;
         }
-        ret = ccw_device_set_online(cgdev->cdev[READ]);
+        ret = ccw_device_set_online(cgdev->cdev[READ_CHANNEL]);
         if (ret != 0) {
                 dev_warn(&cgdev->dev,
                         "Setting the read subchannel online"
                         " failed with error code %d\n", ret);
                 goto out;
         }
-        ret = ccw_device_set_online(cgdev->cdev[WRITE]);
+        ret = ccw_device_set_online(cgdev->cdev[WRITE_CHANNEL]);
         if (ret != 0) {
                 dev_warn(&cgdev->dev,
                         "Setting the write subchannel online "
@@ -3002,8 +3002,8 @@ claw_new_device(struct ccwgroup_device *cgdev)
         }
         dev->ml_priv = privptr;
         dev_set_drvdata(&cgdev->dev, privptr);
-        dev_set_drvdata(&cgdev->cdev[READ]->dev, privptr);
-        dev_set_drvdata(&cgdev->cdev[WRITE]->dev, privptr);
+        dev_set_drvdata(&cgdev->cdev[READ_CHANNEL]->dev, privptr);
+        dev_set_drvdata(&cgdev->cdev[WRITE_CHANNEL]->dev, privptr);
         /* sysfs magic */
         SET_NETDEV_DEV(dev, &cgdev->dev);
         if (register_netdev(dev) != 0) {
@@ -3021,16 +3021,16 @@ claw_new_device(struct ccwgroup_device *cgdev)
                         goto out;
                 }
         }
-        privptr->channel[READ].ndev = dev;
-        privptr->channel[WRITE].ndev = dev;
+        privptr->channel[READ_CHANNEL].ndev = dev;
+        privptr->channel[WRITE_CHANNEL].ndev = dev;
         privptr->p_env->ndev = dev;
 
         dev_info(&cgdev->dev, "%s:readsize=%d  writesize=%d "
                 "readbuffer=%d writebuffer=%d read=0x%04x write=0x%04x\n",
                 dev->name, p_env->read_size,
                 p_env->write_size, p_env->read_buffers,
-                p_env->write_buffers, p_env->devno[READ],
-                p_env->devno[WRITE]);
+                p_env->write_buffers, p_env->devno[READ_CHANNEL],
+                p_env->devno[WRITE_CHANNEL]);
         dev_info(&cgdev->dev, "%s:host_name:%.8s, adapter_name "
                 ":%.8s api_type: %.8s\n",
                 dev->name, p_env->host_name,
@@ -3072,10 +3072,10 @@ claw_shutdown_device(struct ccwgroup_device *cgdev)
         priv = dev_get_drvdata(&cgdev->dev);
         if (!priv)
                 return -ENODEV;
-        ndev = priv->channel[READ].ndev;
+        ndev = priv->channel[READ_CHANNEL].ndev;
         if (ndev) {
                 /* Close the device */
-                dev_info(&cgdev->dev, "%s: shutting down \n",
+                dev_info(&cgdev->dev, "%s: shutting down\n",
                         ndev->name);
                 if (ndev->flags & IFF_RUNNING)
                         ret = claw_release(ndev);
@@ -3083,8 +3083,8 @@ claw_shutdown_device(struct ccwgroup_device *cgdev)
                 unregister_netdev(ndev);
                 ndev->ml_priv = NULL;  /* cgdev data, not ndev's to free */
                 claw_free_netdevice(ndev, 1);
-                priv->channel[READ].ndev = NULL;
-                priv->channel[WRITE].ndev = NULL;
+                priv->channel[READ_CHANNEL].ndev = NULL;
+                priv->channel[WRITE_CHANNEL].ndev = NULL;
                 priv->p_env->ndev = NULL;
         }
         ccw_device_set_offline(cgdev->cdev[1]);
@@ -3115,8 +3115,8 @@ claw_remove_device(struct ccwgroup_device *cgdev)
         priv->channel[1].irb=NULL;
         kfree(priv);
         dev_set_drvdata(&cgdev->dev, NULL);
-        dev_set_drvdata(&cgdev->cdev[READ]->dev, NULL);
-        dev_set_drvdata(&cgdev->cdev[WRITE]->dev, NULL);
+        dev_set_drvdata(&cgdev->cdev[READ_CHANNEL]->dev, NULL);
+        dev_set_drvdata(&cgdev->cdev[WRITE_CHANNEL]->dev, NULL);
         put_device(&cgdev->dev);
 
         return;
diff --git a/drivers/s390/net/claw.h b/drivers/s390/net/claw.h
index 46d59a13db12..1bc5904df19f 100644
--- a/drivers/s390/net/claw.h
+++ b/drivers/s390/net/claw.h
@@ -74,8 +74,8 @@
 #define MAX_ENVELOPE_SIZE       65536
 #define CLAW_DEFAULT_MTU_SIZE   4096
 #define DEF_PACK_BUFSIZE        32768
-#define READ                    0
-#define WRITE                   1
+#define READ_CHANNEL            0
+#define WRITE_CHANNEL           1
 
 #define TB_TX                   0          /* sk buffer handling in process  */
 #define TB_STOP                 1          /* network device stop in process */
diff --git a/drivers/s390/net/ctcm_fsms.c b/drivers/s390/net/ctcm_fsms.c
index 70eb7f138414..8c921fc3511a 100644
--- a/drivers/s390/net/ctcm_fsms.c
+++ b/drivers/s390/net/ctcm_fsms.c
@@ -454,7 +454,7 @@ static void chx_firstio(fsm_instance *fi, int event, void *arg)
         if ((fsmstate == CTC_STATE_SETUPWAIT) &&
             (ch->protocol == CTCM_PROTO_OS390)) {
                 /* OS/390 resp. z/OS */
-                if (CHANNEL_DIRECTION(ch->flags) == READ) {
+                if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
                         *((__u16 *)ch->trans_skb->data) = CTCM_INITIAL_BLOCKLEN;
                         fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC,
                                      CTC_EVENT_TIMER, ch);
@@ -472,14 +472,14 @@ static void chx_firstio(fsm_instance *fi, int event, void *arg)
          * if in compatibility mode, since VM TCP delays the initial
          * frame until it has some data to send.
          */
-        if ((CHANNEL_DIRECTION(ch->flags) == WRITE) ||
+        if ((CHANNEL_DIRECTION(ch->flags) == CTCM_WRITE) ||
             (ch->protocol != CTCM_PROTO_S390))
                 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
 
         *((__u16 *)ch->trans_skb->data) = CTCM_INITIAL_BLOCKLEN;
         ch->ccw[1].count = 2;   /* Transfer only length */
 
-        fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == READ)
+        fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == CTCM_READ)
                      ? CTC_STATE_RXINIT : CTC_STATE_TXINIT);
         rc = ccw_device_start(ch->cdev, &ch->ccw[0],
                                         (unsigned long)ch, 0xff, 0);
@@ -495,7 +495,7 @@ static void chx_firstio(fsm_instance *fi, int event, void *arg)
          * reply from VM TCP which brings up the RX channel to it's
          * final state.
          */
-        if ((CHANNEL_DIRECTION(ch->flags) == READ) &&
+        if ((CHANNEL_DIRECTION(ch->flags) == CTCM_READ) &&
             (ch->protocol == CTCM_PROTO_S390)) {
                 struct net_device *dev = ch->netdev;
                 struct ctcm_priv *priv = dev->ml_priv;
@@ -600,15 +600,15 @@ static void ctcm_chx_start(fsm_instance *fi, int event, void *arg)
         int rc;
 
         CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO, "%s(%s): %s",
-                        CTCM_FUNTAIL, ch->id,
-                        (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
+                CTCM_FUNTAIL, ch->id,
+                (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ? "RX" : "TX");
 
         if (ch->trans_skb != NULL) {
                 clear_normalized_cda(&ch->ccw[1]);
                 dev_kfree_skb(ch->trans_skb);
                 ch->trans_skb = NULL;
         }
-        if (CHANNEL_DIRECTION(ch->flags) == READ) {
+        if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
                 ch->ccw[1].cmd_code = CCW_CMD_READ;
                 ch->ccw[1].flags = CCW_FLAG_SLI;
                 ch->ccw[1].count = 0;
@@ -622,7 +622,8 @@ static void ctcm_chx_start(fsm_instance *fi, int event, void *arg)
                         "%s(%s): %s trans_skb alloc delayed "
                         "until first transfer",
                         CTCM_FUNTAIL, ch->id,
-                        (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
+                        (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ?
+                                "RX" : "TX");
         }
         ch->ccw[0].cmd_code = CCW_CMD_PREPARE;
         ch->ccw[0].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
@@ -720,7 +721,7 @@ static void ctcm_chx_cleanup(fsm_instance *fi, int state,
 
         ch->th_seg = 0x00;
         ch->th_seq_num = 0x00;
-        if (CHANNEL_DIRECTION(ch->flags) == READ) {
+        if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
                 skb_queue_purge(&ch->io_queue);
                 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev);
         } else {
@@ -799,7 +800,8 @@ static void ctcm_chx_setuperr(fsm_instance *fi, int event, void *arg)
                 fsm_newstate(fi, CTC_STATE_STARTRETRY);
                 fsm_deltimer(&ch->timer);
                 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
-                if (!IS_MPC(ch) && (CHANNEL_DIRECTION(ch->flags) == READ)) {
+                if (!IS_MPC(ch) &&
+                    (CHANNEL_DIRECTION(ch->flags) == CTCM_READ)) {
                         int rc = ccw_device_halt(ch->cdev, (unsigned long)ch);
                         if (rc != 0)
                                 ctcm_ccw_check_rc(ch, rc,
@@ -811,10 +813,10 @@ static void ctcm_chx_setuperr(fsm_instance *fi, int event, void *arg)
         CTCM_DBF_TEXT_(ERROR, CTC_DBF_CRIT,
                 "%s(%s) : %s error during %s channel setup state=%s\n",
                 CTCM_FUNTAIL, dev->name, ctc_ch_event_names[event],
-                (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX",
+                (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ? "RX" : "TX",
                 fsm_getstate_str(fi));
 
-        if (CHANNEL_DIRECTION(ch->flags) == READ) {
+        if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
                 fsm_newstate(fi, CTC_STATE_RXERR);
                 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev);
         } else {
@@ -945,7 +947,7 @@ static void ctcm_chx_rxdisc(fsm_instance *fi, int event, void *arg)
         fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev);
 
         fsm_newstate(fi, CTC_STATE_DTERM);
-        ch2 = priv->channel[WRITE];
+        ch2 = priv->channel[CTCM_WRITE];
         fsm_newstate(ch2->fsm, CTC_STATE_DTERM);
 
         ccw_device_halt(ch->cdev, (unsigned long)ch);
@@ -1074,13 +1076,13 @@ static void ctcm_chx_iofatal(fsm_instance *fi, int event, void *arg)
         fsm_deltimer(&ch->timer);
         CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
                 "%s: %s: %s unrecoverable channel error",
-                        CTCM_FUNTAIL, ch->id, rd == READ ? "RX" : "TX");
+                        CTCM_FUNTAIL, ch->id, rd == CTCM_READ ? "RX" : "TX");
 
         if (IS_MPC(ch)) {
                 priv->stats.tx_dropped++;
                 priv->stats.tx_errors++;
         }
-        if (rd == READ) {
+        if (rd == CTCM_READ) {
                 fsm_newstate(fi, CTC_STATE_RXERR);
                 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev);
         } else {
@@ -1503,7 +1505,7 @@ static void ctcmpc_chx_firstio(fsm_instance *fi, int event, void *arg)
         switch (fsm_getstate(fi)) {
         case CTC_STATE_STARTRETRY:
         case CTC_STATE_SETUPWAIT:
-                if (CHANNEL_DIRECTION(ch->flags) == READ) {
+                if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
                         ctcmpc_chx_rxidle(fi, event, arg);
                 } else {
                         fsm_newstate(fi, CTC_STATE_TXIDLE);
@@ -1514,7 +1516,7 @@ static void ctcmpc_chx_firstio(fsm_instance *fi, int event, void *arg)
                 break;
         };
 
-        fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == READ)
+        fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == CTCM_READ)
                      ? CTC_STATE_RXINIT : CTC_STATE_TXINIT);
 
 done:
@@ -1753,8 +1755,8 @@ static void ctcmpc_chx_send_sweep(fsm_instance *fsm, int event, void *arg)
         struct net_device *dev = ach->netdev;
         struct ctcm_priv *priv = dev->ml_priv;
         struct mpc_group *grp = priv->mpcg;
-        struct channel *wch = priv->channel[WRITE];
-        struct channel *rch = priv->channel[READ];
+        struct channel *wch = priv->channel[CTCM_WRITE];
+        struct channel *rch = priv->channel[CTCM_READ];
         struct sk_buff *skb;
         struct th_sweep *header;
         int rc = 0;
@@ -2070,7 +2072,7 @@ static void dev_action_start(fsm_instance *fi, int event, void *arg)
         fsm_newstate(fi, DEV_STATE_STARTWAIT_RXTX);
         if (IS_MPC(priv))
                 priv->mpcg->channels_terminating = 0;
-        for (direction = READ; direction <= WRITE; direction++) {
+        for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
                 struct channel *ch = priv->channel[direction];
                 fsm_event(ch->fsm, CTC_EVENT_START, ch);
         }
@@ -2092,7 +2094,7 @@ static void dev_action_stop(fsm_instance *fi, int event, void *arg)
         CTCMY_DBF_DEV_NAME(SETUP, dev, "");
 
         fsm_newstate(fi, DEV_STATE_STOPWAIT_RXTX);
-        for (direction = READ; direction <= WRITE; direction++) {
+        for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
                 struct channel *ch = priv->channel[direction];
                 fsm_event(ch->fsm, CTC_EVENT_STOP, ch);
                 ch->th_seq_num = 0x00;
@@ -2183,11 +2185,11 @@ static void dev_action_chup(fsm_instance *fi, int event, void *arg)
 
         if (IS_MPC(priv)) {
                 if (event == DEV_EVENT_RXUP)
-                        mpc_channel_action(priv->channel[READ],
-                                READ, MPC_CHANNEL_ADD);
+                        mpc_channel_action(priv->channel[CTCM_READ],
+                                CTCM_READ, MPC_CHANNEL_ADD);
                 else
-                        mpc_channel_action(priv->channel[WRITE],
-                                WRITE, MPC_CHANNEL_ADD);
+                        mpc_channel_action(priv->channel[CTCM_WRITE],
+                                CTCM_WRITE, MPC_CHANNEL_ADD);
         }
 }
 
@@ -2239,11 +2241,11 @@ static void dev_action_chdown(fsm_instance *fi, int event, void *arg)
         }
         if (IS_MPC(priv)) {
                 if (event == DEV_EVENT_RXDOWN)
-                        mpc_channel_action(priv->channel[READ],
-                                READ, MPC_CHANNEL_REMOVE);
+                        mpc_channel_action(priv->channel[CTCM_READ],
+                                CTCM_READ, MPC_CHANNEL_REMOVE);
                 else
-                        mpc_channel_action(priv->channel[WRITE],
-                                WRITE, MPC_CHANNEL_REMOVE);
+                        mpc_channel_action(priv->channel[CTCM_WRITE],
+                                CTCM_WRITE, MPC_CHANNEL_REMOVE);
         }
 }
 
diff --git a/drivers/s390/net/ctcm_main.c b/drivers/s390/net/ctcm_main.c
index 4ecafbf91211..6edf20b62de5 100644
--- a/drivers/s390/net/ctcm_main.c
+++ b/drivers/s390/net/ctcm_main.c
@@ -267,7 +267,7 @@ static struct channel *channel_get(enum ctcm_channel_types type,
                 else {
                         ch->flags |= CHANNEL_FLAGS_INUSE;
                         ch->flags &= ~CHANNEL_FLAGS_RWMASK;
-                        ch->flags |= (direction == WRITE)
+                        ch->flags |= (direction == CTCM_WRITE)
                             ? CHANNEL_FLAGS_WRITE : CHANNEL_FLAGS_READ;
                         fsm_newstate(ch->fsm, CTC_STATE_STOPPED);
                 }
@@ -388,7 +388,8 @@ int ctcm_ch_alloc_buffer(struct channel *ch)
                 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
                         "%s(%s): %s trans_skb allocation error",
                         CTCM_FUNTAIL, ch->id,
-                        (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
+                        (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ?
+                                "RX" : "TX");
                 return -ENOMEM;
         }
 
@@ -399,7 +400,8 @@ int ctcm_ch_alloc_buffer(struct channel *ch)
                 CTCM_DBF_TEXT_(ERROR, CTC_DBF_ERROR,
                         "%s(%s): %s set norm_cda failed",
                         CTCM_FUNTAIL, ch->id,
-                        (CHANNEL_DIRECTION(ch->flags) == READ) ? "RX" : "TX");
+                        (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ?
+                                "RX" : "TX");
                 return -ENOMEM;
         }
 
@@ -603,14 +605,14 @@ static void ctcmpc_send_sweep_req(struct channel *rch)
 
         priv = dev->ml_priv;
         grp = priv->mpcg;
-        ch = priv->channel[WRITE];
+        ch = priv->channel[CTCM_WRITE];
 
         /* sweep processing is not complete until response and request */
         /* has completed for all read channels in group                */
         if (grp->in_sweep == 0) {
                 grp->in_sweep = 1;
-                grp->sweep_rsp_pend_num = grp->active_channels[READ];
-                grp->sweep_req_pend_num = grp->active_channels[READ];
+                grp->sweep_rsp_pend_num = grp->active_channels[CTCM_READ];
+                grp->sweep_req_pend_num = grp->active_channels[CTCM_READ];
         }
 
         sweep_skb = __dev_alloc_skb(MPC_BUFSIZE_DEFAULT, GFP_ATOMIC|GFP_DMA);
@@ -911,7 +913,7 @@ static int ctcm_tx(struct sk_buff *skb, struct net_device *dev)
                 return NETDEV_TX_BUSY;
 
         dev->trans_start = jiffies;
-        if (ctcm_transmit_skb(priv->channel[WRITE], skb) != 0)
+        if (ctcm_transmit_skb(priv->channel[CTCM_WRITE], skb) != 0)
                 return NETDEV_TX_BUSY;
         return NETDEV_TX_OK;
 }
@@ -994,7 +996,7 @@ static int ctcmpc_tx(struct sk_buff *skb, struct net_device *dev)
         }
 
         dev->trans_start = jiffies;
-        if (ctcmpc_transmit_skb(priv->channel[WRITE], skb) != 0) {
+        if (ctcmpc_transmit_skb(priv->channel[CTCM_WRITE], skb) != 0) {
                 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
                         "%s(%s): device error - dropped",
                                         CTCM_FUNTAIL, dev->name);
@@ -1035,7 +1037,7 @@ static int ctcm_change_mtu(struct net_device *dev, int new_mtu)
                 return -EINVAL;
 
         priv = dev->ml_priv;
-        max_bufsize = priv->channel[READ]->max_bufsize;
+        max_bufsize = priv->channel[CTCM_READ]->max_bufsize;
 
         if (IS_MPC(priv)) {
                 if (new_mtu > max_bufsize - TH_HEADER_LENGTH)
@@ -1226,10 +1228,10 @@ static void ctcm_irq_handler(struct ccw_device *cdev,
         priv = dev_get_drvdata(&cgdev->dev);
 
         /* Try to extract channel from driver data. */
-        if (priv->channel[READ]->cdev == cdev)
-                ch = priv->channel[READ];
-        else if (priv->channel[WRITE]->cdev == cdev)
-                ch = priv->channel[WRITE];
+        if (priv->channel[CTCM_READ]->cdev == cdev)
+                ch = priv->channel[CTCM_READ];
+        else if (priv->channel[CTCM_WRITE]->cdev == cdev)
+                ch = priv->channel[CTCM_WRITE];
         else {
                 dev_err(&cdev->dev,
                         "%s: Internal error: Can't determine channel for "
@@ -1587,13 +1589,13 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev)
                 goto out_ccw2;
         }
 
-        for (direction = READ; direction <= WRITE; direction++) {
+        for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
                 priv->channel[direction] =
-                    channel_get(type, direction == READ ? read_id : write_id,
-                                direction);
+                        channel_get(type, direction == CTCM_READ ?
+                                read_id : write_id, direction);
                 if (priv->channel[direction] == NULL) {
-                        if (direction == WRITE)
-                                channel_free(priv->channel[READ]);
+                        if (direction == CTCM_WRITE)
+                                channel_free(priv->channel[CTCM_READ]);
                         goto out_dev;
                 }
                 priv->channel[direction]->netdev = dev;
@@ -1617,13 +1619,13 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev)
 
         dev_info(&dev->dev,
                 "setup OK : r/w = %s/%s, protocol : %d\n",
-                        priv->channel[READ]->id,
-                        priv->channel[WRITE]->id, priv->protocol);
+                        priv->channel[CTCM_READ]->id,
+                        priv->channel[CTCM_WRITE]->id, priv->protocol);
 
         CTCM_DBF_TEXT_(SETUP, CTC_DBF_INFO,
                 "setup(%s) OK : r/w = %s/%s, protocol : %d", dev->name,
-                        priv->channel[READ]->id,
-                        priv->channel[WRITE]->id, priv->protocol);
+                        priv->channel[CTCM_READ]->id,
+                        priv->channel[CTCM_WRITE]->id, priv->protocol);
 
         return 0;
 out_unregister:
@@ -1635,10 +1637,10 @@ out_ccw2:
 out_ccw1:
         ccw_device_set_offline(cgdev->cdev[0]);
 out_remove_channel2:
-        readc = channel_get(type, read_id, READ);
+        readc = channel_get(type, read_id, CTCM_READ);
         channel_remove(readc);
 out_remove_channel1:
-        writec = channel_get(type, write_id, WRITE);
+        writec = channel_get(type, write_id, CTCM_WRITE);
         channel_remove(writec);
 out_err_result:
         return result;
@@ -1660,19 +1662,19 @@ static int ctcm_shutdown_device(struct ccwgroup_device *cgdev)
         if (!priv)
                 return -ENODEV;
 
-        if (priv->channel[READ]) {
-                dev = priv->channel[READ]->netdev;
+        if (priv->channel[CTCM_READ]) {
+                dev = priv->channel[CTCM_READ]->netdev;
                 CTCM_DBF_DEV(SETUP, dev, "");
                 /* Close the device */
                 ctcm_close(dev);
                 dev->flags &= ~IFF_RUNNING;
                 ctcm_remove_attributes(&cgdev->dev);
-                channel_free(priv->channel[READ]);
+                channel_free(priv->channel[CTCM_READ]);
         } else
                 dev = NULL;
 
-        if (priv->channel[WRITE])
-                channel_free(priv->channel[WRITE]);
+        if (priv->channel[CTCM_WRITE])
+                channel_free(priv->channel[CTCM_WRITE]);
 
         if (dev) {
                 unregister_netdev(dev);
@@ -1685,11 +1687,11 @@ static int ctcm_shutdown_device(struct ccwgroup_device *cgdev)
         ccw_device_set_offline(cgdev->cdev[1]);
         ccw_device_set_offline(cgdev->cdev[0]);
 
-        if (priv->channel[READ])
-                channel_remove(priv->channel[READ]);
-        if (priv->channel[WRITE])
-                channel_remove(priv->channel[WRITE]);
-        priv->channel[READ] = priv->channel[WRITE] = NULL;
+        if (priv->channel[CTCM_READ])
+                channel_remove(priv->channel[CTCM_READ]);
+        if (priv->channel[CTCM_WRITE])
+                channel_remove(priv->channel[CTCM_WRITE]);
+        priv->channel[CTCM_READ] = priv->channel[CTCM_WRITE] = NULL;
 
         return 0;
 
@@ -1720,11 +1722,11 @@ static int ctcm_pm_suspend(struct ccwgroup_device *gdev)
 
         if (gdev->state == CCWGROUP_OFFLINE)
                 return 0;
-        netif_device_detach(priv->channel[READ]->netdev);
-        ctcm_close(priv->channel[READ]->netdev);
+        netif_device_detach(priv->channel[CTCM_READ]->netdev);
+        ctcm_close(priv->channel[CTCM_READ]->netdev);
         if (!wait_event_timeout(priv->fsm->wait_q,
             fsm_getstate(priv->fsm) == DEV_STATE_STOPPED, CTCM_TIME_5_SEC)) {
-                netif_device_attach(priv->channel[READ]->netdev);
+                netif_device_attach(priv->channel[CTCM_READ]->netdev);
                 return -EBUSY;
         }
         ccw_device_set_offline(gdev->cdev[1]);
@@ -1745,9 +1747,9 @@ static int ctcm_pm_resume(struct ccwgroup_device *gdev)
         rc = ccw_device_set_online(gdev->cdev[0]);
         if (rc)
                 goto err_out;
-        ctcm_open(priv->channel[READ]->netdev);
+        ctcm_open(priv->channel[CTCM_READ]->netdev);
 err_out:
-        netif_device_attach(priv->channel[READ]->netdev);
+        netif_device_attach(priv->channel[CTCM_READ]->netdev);
         return rc;
 }
 
diff --git a/drivers/s390/net/ctcm_main.h b/drivers/s390/net/ctcm_main.h
index d34fa14f44e7..24d5215eb0c4 100644
--- a/drivers/s390/net/ctcm_main.h
+++ b/drivers/s390/net/ctcm_main.h
@@ -111,8 +111,8 @@ enum ctcm_channel_types {
 
 #define CTCM_INITIAL_BLOCKLEN   2
 
-#define READ                    0
-#define WRITE                   1
+#define CTCM_READ               0
+#define CTCM_WRITE              1
 
 #define CTCM_ID_SIZE            20+3
 
diff --git a/drivers/s390/net/ctcm_mpc.c b/drivers/s390/net/ctcm_mpc.c
index 87c24d2936d6..2861e78773cb 100644
--- a/drivers/s390/net/ctcm_mpc.c
+++ b/drivers/s390/net/ctcm_mpc.c
@@ -419,8 +419,8 @@ void ctc_mpc_establish_connectivity(int port_num,
                 return;
         priv = dev->ml_priv;
         grp = priv->mpcg;
-        rch = priv->channel[READ];
-        wch = priv->channel[WRITE];
+        rch = priv->channel[CTCM_READ];
+        wch = priv->channel[CTCM_WRITE];
 
         CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_INFO,
                         "%s(%s): state=%s",
@@ -578,7 +578,7 @@ void ctc_mpc_flow_control(int port_num, int flowc)
                         "%s: %s: flowc = %d",
                                 CTCM_FUNTAIL, dev->name, flowc);
 
-        rch = priv->channel[READ];
+        rch = priv->channel[CTCM_READ];
 
         mpcg_state = fsm_getstate(grp->fsm);
         switch (flowc) {
@@ -622,7 +622,7 @@ static void mpc_rcvd_sweep_resp(struct mpcg_info *mpcginfo)
         struct net_device *dev = rch->netdev;
         struct ctcm_priv   *priv = dev->ml_priv;
         struct mpc_group  *grp = priv->mpcg;
-        struct channel    *ch = priv->channel[WRITE];
+        struct channel    *ch = priv->channel[CTCM_WRITE];
 
         CTCM_PR_DEBUG("%s: ch=0x%p id=%s\n", __func__, ch, ch->id);
         CTCM_D3_DUMP((char *)mpcginfo->sweep, TH_SWEEP_LENGTH);
@@ -656,7 +656,7 @@ static void ctcmpc_send_sweep_resp(struct channel *rch)
         int rc = 0;
         struct th_sweep *header;
         struct sk_buff *sweep_skb;
-        struct channel *ch  = priv->channel[WRITE];
+        struct channel *ch  = priv->channel[CTCM_WRITE];
 
         CTCM_PR_DEBUG("%s: ch=0x%p id=%s\n", __func__, rch, rch->id);
 
@@ -712,7 +712,7 @@ static void mpc_rcvd_sweep_req(struct mpcg_info *mpcginfo)
         struct net_device *dev     = rch->netdev;
         struct ctcm_priv  *priv = dev->ml_priv;
         struct mpc_group  *grp  = priv->mpcg;
-        struct channel    *ch      = priv->channel[WRITE];
+        struct channel    *ch      = priv->channel[CTCM_WRITE];
 
         if (do_debug)
                 CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_DEBUG,
@@ -721,8 +721,8 @@ static void mpc_rcvd_sweep_req(struct mpcg_info *mpcginfo)
         if (grp->in_sweep == 0) {
                 grp->in_sweep = 1;
                 ctcm_test_and_set_busy(dev);
-                grp->sweep_req_pend_num = grp->active_channels[READ];
-                grp->sweep_rsp_pend_num = grp->active_channels[READ];
+                grp->sweep_req_pend_num = grp->active_channels[CTCM_READ];
+                grp->sweep_rsp_pend_num = grp->active_channels[CTCM_READ];
         }
 
         CTCM_D3_DUMP((char *)mpcginfo->sweep, TH_SWEEP_LENGTH);
@@ -906,14 +906,14 @@ void mpc_group_ready(unsigned long adev)
         fsm_newstate(grp->fsm, MPCG_STATE_READY);
 
         /* Put up a read on the channel */
-        ch = priv->channel[READ];
+        ch = priv->channel[CTCM_READ];
         ch->pdu_seq = 0;
         CTCM_PR_DBGDATA("ctcmpc: %s() ToDCM_pdu_seq= %08x\n" ,
                         __func__, ch->pdu_seq);
 
         ctcmpc_chx_rxidle(ch->fsm, CTC_EVENT_START, ch);
         /* Put the write channel in idle state */
-        ch = priv->channel[WRITE];
+        ch = priv->channel[CTCM_WRITE];
         if (ch->collect_len > 0) {
                 spin_lock(&ch->collect_lock);
                 ctcm_purge_skb_queue(&ch->collect_queue);
@@ -960,7 +960,8 @@ void mpc_channel_action(struct channel *ch, int direction, int action)
                 "%s: %i / Grp:%s total_channels=%i, active_channels: "
                 "read=%i, write=%i\n", __func__, action,
                 fsm_getstate_str(grp->fsm), grp->num_channel_paths,
-                grp->active_channels[READ], grp->active_channels[WRITE]);
+                grp->active_channels[CTCM_READ],
+                grp->active_channels[CTCM_WRITE]);
 
         if ((action == MPC_CHANNEL_ADD) && (ch->in_mpcgroup == 0)) {
                 grp->num_channel_paths++;
@@ -994,10 +995,11 @@ void mpc_channel_action(struct channel *ch, int direction, int action)
                                 grp->xid_skb->data,
                                 grp->xid_skb->len);
 
-                ch->xid->xid2_dlc_type = ((CHANNEL_DIRECTION(ch->flags) == READ)
+                ch->xid->xid2_dlc_type =
+                        ((CHANNEL_DIRECTION(ch->flags) == CTCM_READ)
                                 ? XID2_READ_SIDE : XID2_WRITE_SIDE);
 
-                if (CHANNEL_DIRECTION(ch->flags) == WRITE)
+                if (CHANNEL_DIRECTION(ch->flags) == CTCM_WRITE)
                         ch->xid->xid2_buf_len = 0x00;
 
                 ch->xid_skb->data = ch->xid_skb_data;
@@ -1006,8 +1008,8 @@ void mpc_channel_action(struct channel *ch, int direction, int action)
 
                 fsm_newstate(ch->fsm, CH_XID0_PENDING);
 
-                if ((grp->active_channels[READ]  > 0) &&
-                    (grp->active_channels[WRITE] > 0) &&
+                if ((grp->active_channels[CTCM_READ] > 0) &&
+                    (grp->active_channels[CTCM_WRITE] > 0) &&
                         (fsm_getstate(grp->fsm) < MPCG_STATE_XID2INITW)) {
                         fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW);
                         CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_NOTICE,
@@ -1027,10 +1029,10 @@ void mpc_channel_action(struct channel *ch, int direction, int action)
                 if (grp->channels_terminating)
                                         goto done;
 
-                if (((grp->active_channels[READ] == 0) &&
-                                        (grp->active_channels[WRITE] > 0))
-                        || ((grp->active_channels[WRITE] == 0) &&
-                                        (grp->active_channels[READ] > 0)))
+                if (((grp->active_channels[CTCM_READ] == 0) &&
+                                        (grp->active_channels[CTCM_WRITE] > 0))
+                        || ((grp->active_channels[CTCM_WRITE] == 0) &&
+                                        (grp->active_channels[CTCM_READ] > 0)))
                         fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
         }
 done:
@@ -1038,7 +1040,8 @@ done:
                 "exit %s: %i / Grp:%s total_channels=%i, active_channels: "
                 "read=%i, write=%i\n", __func__, action,
                 fsm_getstate_str(grp->fsm), grp->num_channel_paths,
-                grp->active_channels[READ], grp->active_channels[WRITE]);
+                grp->active_channels[CTCM_READ],
+                grp->active_channels[CTCM_WRITE]);
 
         CTCM_PR_DEBUG("exit %s: ch=0x%p id=%s\n", __func__, ch, ch->id);
 }
@@ -1392,8 +1395,8 @@ static void mpc_action_go_inop(fsm_instance *fi, int event, void *arg)
                 (grp->port_persist == 0))
                 fsm_deltimer(&priv->restart_timer);
 
-        wch = priv->channel[WRITE];
-        rch = priv->channel[READ];
+        wch = priv->channel[CTCM_WRITE];
+        rch = priv->channel[CTCM_READ];
 
         switch (grp->saved_state) {
         case MPCG_STATE_RESET:
@@ -1480,8 +1483,8 @@ static void mpc_action_timeout(fsm_instance *fi, int event, void *arg)
 
         priv = dev->ml_priv;
         grp = priv->mpcg;
-        wch = priv->channel[WRITE];
-        rch = priv->channel[READ];
+        wch = priv->channel[CTCM_WRITE];
+        rch = priv->channel[CTCM_READ];
 
         switch (fsm_getstate(grp->fsm)) {
         case MPCG_STATE_XID2INITW:
@@ -1586,7 +1589,7 @@ static int mpc_validate_xid(struct mpcg_info *mpcginfo)
         CTCM_D3_DUMP((char *)xid, XID2_LENGTH);
 
         /*the received direction should be the opposite of ours  */
-        if (((CHANNEL_DIRECTION(ch->flags) == READ) ? XID2_WRITE_SIDE :
+        if (((CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ? XID2_WRITE_SIDE :
                                 XID2_READ_SIDE) != xid->xid2_dlc_type) {
                 rc = 2;
                 /* XID REJECTED: r/w channel pairing mismatch */
@@ -1912,7 +1915,7 @@ static void mpc_action_doxid7(fsm_instance *fsm, int event, void *arg)
         if (grp == NULL)
                 return;
 
-        for (direction = READ; direction <= WRITE; direction++) {
+        for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) {
                 struct channel *ch = priv->channel[direction];
                 struct xid2 *thisxid = ch->xid;
                 ch->xid_skb->data = ch->xid_skb_data;
@@ -2152,14 +2155,15 @@ static int mpc_send_qllc_discontact(struct net_device *dev)
                         return -ENOMEM;
                 }
 
-                *((__u32 *)skb_push(skb, 4)) = priv->channel[READ]->pdu_seq;
-                priv->channel[READ]->pdu_seq++;
+                *((__u32 *)skb_push(skb, 4)) =
+                        priv->channel[CTCM_READ]->pdu_seq;
+                priv->channel[CTCM_READ]->pdu_seq++;
                 CTCM_PR_DBGDATA("ctcmpc: %s ToDCM_pdu_seq= %08x\n",
-                                __func__, priv->channel[READ]->pdu_seq);
+                                __func__, priv->channel[CTCM_READ]->pdu_seq);
 
                 /* receipt of CC03 resets anticipated sequence number on
                       receiving side */
-                priv->channel[READ]->pdu_seq = 0x00;
+                priv->channel[CTCM_READ]->pdu_seq = 0x00;
                 skb_reset_mac_header(skb);
                 skb->dev = dev;
                 skb->protocol = htons(ETH_P_SNAP);
diff --git a/drivers/s390/net/ctcm_sysfs.c b/drivers/s390/net/ctcm_sysfs.c
index 2b24550e865e..8305319b2a84 100644
--- a/drivers/s390/net/ctcm_sysfs.c
+++ b/drivers/s390/net/ctcm_sysfs.c
@@ -38,8 +38,8 @@ static ssize_t ctcm_buffer_write(struct device *dev,
         int bs1;
         struct ctcm_priv *priv = dev_get_drvdata(dev);
 
-        if (!(priv && priv->channel[READ] &&
-                        (ndev = priv->channel[READ]->netdev))) {
+        ndev = priv->channel[CTCM_READ]->netdev;
+        if (!(priv && priv->channel[CTCM_READ] && ndev)) {
                 CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, "bfnondev");
                 return -ENODEV;
         }
@@ -55,12 +55,12 @@ static ssize_t ctcm_buffer_write(struct device *dev,
             (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
                                         goto einval;
 
-        priv->channel[READ]->max_bufsize = bs1;
-        priv->channel[WRITE]->max_bufsize = bs1;
+        priv->channel[CTCM_READ]->max_bufsize = bs1;
+        priv->channel[CTCM_WRITE]->max_bufsize = bs1;
         if (!(ndev->flags & IFF_RUNNING))
                 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
-        priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
-        priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
+        priv->channel[CTCM_READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
+        priv->channel[CTCM_WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
 
         CTCM_DBF_DEV(SETUP, ndev, buf);
         return count;
@@ -85,9 +85,9 @@ static void ctcm_print_statistics(struct ctcm_priv *priv)
         p += sprintf(p, "  Device FSM state: %s\n",
                      fsm_getstate_str(priv->fsm));
         p += sprintf(p, "  RX channel FSM state: %s\n",
-                     fsm_getstate_str(priv->channel[READ]->fsm));
+                     fsm_getstate_str(priv->channel[CTCM_READ]->fsm));
         p += sprintf(p, "  TX channel FSM state: %s\n",
-                     fsm_getstate_str(priv->channel[WRITE]->fsm));
+                     fsm_getstate_str(priv->channel[CTCM_WRITE]->fsm));
         p += sprintf(p, "  Max. TX buffer used: %ld\n",
                      priv->channel[WRITE]->prof.maxmulti);
         p += sprintf(p, "  Max. chained SKBs: %ld\n",
@@ -102,7 +102,7 @@ static void ctcm_print_statistics(struct ctcm_priv *priv)
                      priv->channel[WRITE]->prof.tx_time);
 
         printk(KERN_INFO "Statistics for %s:\n%s",
-                                priv->channel[WRITE]->netdev->name, sbuf);
+                                priv->channel[CTCM_WRITE]->netdev->name, sbuf);
         kfree(sbuf);
         return;
 }
@@ -125,7 +125,7 @@ static ssize_t stats_write(struct device *dev, struct device_attribute *attr,
                 return -ENODEV;
         /* Reset statistics */
         memset(&priv->channel[WRITE]->prof, 0,
-                                sizeof(priv->channel[WRITE]->prof));
+                                sizeof(priv->channel[CTCM_WRITE]->prof));
         return count;
 }