return;
 
                ocelot_port_add_txtstamp_skb(ocelot, port, clone);
-               DSA_SKB_CB(skb)->clone = clone;
+               OCELOT_SKB_CB(skb)->clone = clone;
        }
 }
 
 
        struct sk_buff *skb;
 
        while ((skb = skb_dequeue(&sp->xmit_queue)) != NULL) {
-               struct sk_buff *clone = DSA_SKB_CB(skb)->clone;
+               struct sk_buff *clone = SJA1105_SKB_CB(skb)->clone;
 
                mutex_lock(&priv->mgmt_lock);
 
 
 }
 
 /* Called from dsa_skb_tx_timestamp. This callback is just to clone
- * the skb and have it available in DSA_SKB_CB in the .port_deferred_xmit
+ * the skb and have it available in SJA1105_SKB_CB in the .port_deferred_xmit
  * callback, where we will timestamp it synchronously.
  */
 void sja1105_port_txtstamp(struct dsa_switch *ds, int port, struct sk_buff *skb)
        if (!clone)
                return;
 
-       DSA_SKB_CB(skb)->clone = clone;
+       SJA1105_SKB_CB(skb)->clone = clone;
 }
 
 static int sja1105_ptp_reset(struct dsa_switch *ds)
 
        spin_lock(&ocelot_port->ts_id_lock);
 
        skb_shinfo(clone)->tx_flags |= SKBTX_IN_PROGRESS;
-       /* Store timestamp ID in cb[0] of sk_buff */
-       clone->cb[0] = ocelot_port->ts_id;
+       /* Store timestamp ID in OCELOT_SKB_CB(clone)->ts_id */
+       OCELOT_SKB_CB(clone)->ts_id = ocelot_port->ts_id;
        ocelot_port->ts_id = (ocelot_port->ts_id + 1) % 4;
        skb_queue_tail(&ocelot_port->tx_skbs, clone);
 
                spin_lock_irqsave(&port->tx_skbs.lock, flags);
 
                skb_queue_walk_safe(&port->tx_skbs, skb, skb_tmp) {
-                       if (skb->cb[0] != id)
+                       if (OCELOT_SKB_CB(skb)->ts_id != id)
                                continue;
                        __skb_unlink(skb, &port->tx_skbs);
                        skb_match = skb;
 
 
                        ocelot_port_add_txtstamp_skb(ocelot, port, clone);
 
-                       rew_op |= clone->cb[0] << 3;
+                       rew_op |= OCELOT_SKB_CB(clone)->ts_id << 3;
                }
        }
 
 
 };
 
 struct sja1105_skb_cb {
+       struct sk_buff *clone;
        u32 meta_tstamp;
 };
 
 #define SJA1105_SKB_CB(skb) \
-       ((struct sja1105_skb_cb *)DSA_SKB_CB_PRIV(skb))
+       ((struct sja1105_skb_cb *)((skb)->cb))
 
 struct sja1105_port {
        u16 subvlan_map[DSA_8021Q_N_SUBVLAN];
 
 #define MODULE_ALIAS_DSA_TAG_DRIVER(__proto)                           \
        MODULE_ALIAS(DSA_TAG_DRIVER_ALIAS __stringify(__proto##_VALUE))
 
-struct dsa_skb_cb {
-       struct sk_buff *clone;
-};
-
-struct __dsa_skb_cb {
-       struct dsa_skb_cb cb;
-       u8 priv[48 - sizeof(struct dsa_skb_cb)];
-};
-
-#define DSA_SKB_CB(skb) ((struct dsa_skb_cb *)((skb)->cb))
-
-#define DSA_SKB_CB_PRIV(skb)                   \
-       ((void *)(skb)->cb + offsetof(struct __dsa_skb_cb, priv))
-
 struct dsa_switch_tree {
        struct list_head        list;
 
 
        u32 burst; /* bytes */
 };
 
+struct ocelot_skb_cb {
+       struct sk_buff *clone;
+       u8 ts_id;
+};
+
+#define OCELOT_SKB_CB(skb) \
+       ((struct ocelot_skb_cb *)((skb)->cb))
+
 #define ocelot_read_ix(ocelot, reg, gi, ri) __ocelot_read_ix(ocelot, reg, reg##_GSZ * (gi) + reg##_RSZ * (ri))
 #define ocelot_read_gix(ocelot, reg, gi) __ocelot_read_ix(ocelot, reg, reg##_GSZ * (gi))
 #define ocelot_read_rix(ocelot, reg, ri) __ocelot_read_ix(ocelot, reg, reg##_RSZ * (ri))
 
 
        dev_sw_netstats_tx_add(dev, 1, skb->len);
 
-       DSA_SKB_CB(skb)->clone = NULL;
+       memset(skb->cb, 0, sizeof(skb->cb));
 
        /* Handle tx timestamp if any */
        dsa_skb_tx_timestamp(p, skb);
 
        ocelot_port = ocelot->ports[dp->index];
        rew_op = ocelot_port->ptp_cmd;
 
-       /* Retrieve timestamp ID populated inside skb->cb[0] of the
-        * clone by ocelot_port_add_txtstamp_skb
+       /* Retrieve timestamp ID populated inside OCELOT_SKB_CB(clone)->ts_id
+        * by ocelot_port_add_txtstamp_skb
         */
        if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
-               rew_op |= clone->cb[0] << 3;
+               rew_op |= OCELOT_SKB_CB(clone)->ts_id << 3;
 
        ocelot_ifh_set_rew_op(injection, rew_op);
 }
                               __be32 ifh_prefix, void **ifh)
 {
        struct dsa_port *dp = dsa_slave_to_port(netdev);
-       struct sk_buff *clone = DSA_SKB_CB(skb)->clone;
+       struct sk_buff *clone = OCELOT_SKB_CB(skb)->clone;
        struct dsa_switch *ds = dp->ds;
        void *injection;
        __be32 *prefix;
 
        ocelot_port = ocelot->ports[port];
        rew_op = ocelot_port->ptp_cmd;
 
-       /* Retrieve timestamp ID populated inside skb->cb[0] of the
-        * clone by ocelot_port_add_txtstamp_skb
+       /* Retrieve timestamp ID populated inside OCELOT_SKB_CB(clone)->ts_id
+        * by ocelot_port_add_txtstamp_skb
         */
        if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
-               rew_op |= clone->cb[0] << 3;
+               rew_op |= OCELOT_SKB_CB(clone)->ts_id << 3;
 
        ocelot_port_inject_frame(ocelot, port, 0, rew_op, skb);
 
        u16 tx_vid = dsa_8021q_tx_vid(dp->ds, dp->index);
        u16 queue_mapping = skb_get_queue_mapping(skb);
        u8 pcp = netdev_txq_to_tc(netdev, queue_mapping);
-       struct sk_buff *clone = DSA_SKB_CB(skb)->clone;
+       struct sk_buff *clone = OCELOT_SKB_CB(skb)->clone;
 
        /* TX timestamping was requested, so inject through MMIO */
        if (clone)