diff --git a/drivers/net/fsl-mc/dpbp.c b/drivers/net/fsl-mc/dpbp.c
index ba9536d..a0552f4 100644
--- a/drivers/net/fsl-mc/dpbp.c
+++ b/drivers/net/fsl-mc/dpbp.c
@@ -1,8 +1,8 @@
 /*
  * Freescale Layerscape MC I/O wrapper
  *
- * Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
- * Author: German Rivera <German.Rivera@freescale.com>
+ * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -50,9 +50,10 @@
 }
 
 int dpbp_create(struct fsl_mc_io *mc_io,
+		uint16_t dprc_token,
 		uint32_t cmd_flags,
 		const struct dpbp_cfg *cfg,
-		uint16_t *token)
+		uint32_t *obj_id)
 {
 	struct mc_command cmd = { 0 };
 	int err;
@@ -62,7 +63,7 @@
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
 					  cmd_flags,
-					  0);
+					  dprc_token);
 
 	/* send command to mc*/
 	err = mc_send_command(mc_io, &cmd);
@@ -70,21 +71,25 @@
 		return err;
 
 	/* retrieve response parameters */
-	*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+	MC_CMD_READ_OBJ_ID(cmd, *obj_id);
 
 	return 0;
 }
 
 int dpbp_destroy(struct fsl_mc_io *mc_io,
+		 uint16_t dprc_token,
 		 uint32_t cmd_flags,
-		 uint16_t token)
+		 uint32_t obj_id)
 {
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY,
 					  cmd_flags,
-					  token);
+					  dprc_token);
+
+	/* set object id to destroy */
+	CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
@@ -157,3 +162,26 @@
 
 	return 0;
 }
+
+int dpbp_get_api_version(struct fsl_mc_io *mc_io,
+			 u32 cmd_flags,
+			 u16 *major_ver,
+			 u16 *minor_ver)
+{
+	struct mc_command cmd = { 0 };
+	int err;
+
+	/* prepare command */
+	cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_API_VERSION,
+					  cmd_flags, 0);
+
+	/* send command to mc */
+	err = mc_send_command(mc_io, &cmd);
+	if (err)
+		return err;
+
+	/* retrieve response parameters */
+	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
+
+	return 0;
+}
diff --git a/drivers/net/fsl-mc/dpio/dpio.c b/drivers/net/fsl-mc/dpio/dpio.c
index b61df52..ccac506 100644
--- a/drivers/net/fsl-mc/dpio/dpio.c
+++ b/drivers/net/fsl-mc/dpio/dpio.c
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2013-2015 Freescale Semiconductor
+ * Copyright (C) 2013-2016 Freescale Semiconductor
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -10,7 +11,7 @@
 
 int dpio_open(struct fsl_mc_io *mc_io,
 	      uint32_t cmd_flags,
-	      int dpio_id,
+	      uint32_t dpio_id,
 	      uint16_t *token)
 {
 	struct mc_command cmd = { 0 };
@@ -49,9 +50,10 @@
 }
 
 int dpio_create(struct fsl_mc_io *mc_io,
+		uint16_t dprc_token,
 		uint32_t cmd_flags,
 		const struct dpio_cfg *cfg,
-		uint16_t *token)
+		uint32_t *obj_id)
 {
 	struct mc_command cmd = { 0 };
 	int err;
@@ -59,7 +61,7 @@
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPIO_CMDID_CREATE,
 					  cmd_flags,
-					  0);
+					  dprc_token);
 	DPIO_CMD_CREATE(cmd, cfg);
 
 	/* send command to mc*/
@@ -68,21 +70,25 @@
 		return err;
 
 	/* retrieve response parameters */
-	*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+	MC_CMD_READ_OBJ_ID(cmd, *obj_id);
 
 	return 0;
 }
 
 int dpio_destroy(struct fsl_mc_io *mc_io,
+		 uint16_t dprc_token,
 		 uint32_t cmd_flags,
-		 uint16_t token)
+		 uint32_t obj_id)
 {
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPIO_CMDID_DESTROY,
 					  cmd_flags,
-					  token);
+					  dprc_token);
+
+	/* set object id to destroy */
+	CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
@@ -156,3 +162,26 @@
 
 	return 0;
 }
+
+int dpio_get_api_version(struct fsl_mc_io *mc_io,
+			 u32 cmd_flags,
+			 u16 *major_ver,
+			 u16 *minor_ver)
+{
+	struct mc_command cmd = { 0 };
+	int err;
+
+	/* prepare command */
+	cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_API_VERSION,
+					  cmd_flags, 0);
+
+	/* send command to mc */
+	err = mc_send_command(mc_io, &cmd);
+	if (err)
+		return err;
+
+	/* retrieve response parameters */
+	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
+
+	return 0;
+}
diff --git a/drivers/net/fsl-mc/dpmac.c b/drivers/net/fsl-mc/dpmac.c
index 072a90d..a719ac1 100644
--- a/drivers/net/fsl-mc/dpmac.c
+++ b/drivers/net/fsl-mc/dpmac.c
@@ -1,7 +1,8 @@
 /*
  * Freescale Layerscape MC I/O wrapper
  *
- * Copyright (C) 2015 Freescale Semiconductor, Inc.
+ * Copyright (C) 2015-2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
  * Author: Prabhakar Kushwaha <prabhakar@freescale.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
@@ -51,9 +52,10 @@
 }
 
 int dpmac_create(struct fsl_mc_io *mc_io,
+		 uint16_t dprc_token,
 		 uint32_t cmd_flags,
 		 const struct dpmac_cfg *cfg,
-		 uint16_t *token)
+		 uint32_t *obj_id)
 {
 	struct mc_command cmd = { 0 };
 	int err;
@@ -61,7 +63,7 @@
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CREATE,
 					  cmd_flags,
-					  0);
+					  dprc_token);
 	DPMAC_CMD_CREATE(cmd, cfg);
 
 	/* send command to mc*/
@@ -70,21 +72,25 @@
 		return err;
 
 	/* retrieve response parameters */
-	*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+	MC_CMD_READ_OBJ_ID(cmd, *obj_id);
 
 	return 0;
 }
 
 int dpmac_destroy(struct fsl_mc_io *mc_io,
+		  uint16_t dprc_token,
 		  uint32_t cmd_flags,
-		  uint16_t token)
+		  uint32_t obj_id)
 {
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPMAC_CMDID_DESTROY,
 					  cmd_flags,
-					  token);
+					  dprc_token);
+
+	/* set object id to destroy */
+	CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
@@ -220,3 +226,26 @@
 
 	return 0;
 }
+
+int dpmac_get_api_version(struct fsl_mc_io *mc_io,
+			 u32 cmd_flags,
+			 u16 *major_ver,
+			 u16 *minor_ver)
+{
+	struct mc_command cmd = { 0 };
+	int err;
+
+	/* prepare command */
+	cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_API_VERSION,
+					  cmd_flags, 0);
+
+	/* send command to mc */
+	err = mc_send_command(mc_io, &cmd);
+	if (err)
+		return err;
+
+	/* retrieve response parameters */
+	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
+
+	return 0;
+}
diff --git a/drivers/net/fsl-mc/dpni.c b/drivers/net/fsl-mc/dpni.c
index 41bf56a..481f9d8 100644
--- a/drivers/net/fsl-mc/dpni.c
+++ b/drivers/net/fsl-mc/dpni.c
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2013-2015 Freescale Semiconductor
+ * Copyright (C) 2013-2016 Freescale Semiconductor
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -8,22 +9,22 @@
 #include <fsl-mc/fsl_mc_cmd.h>
 #include <fsl-mc/fsl_dpni.h>
 
-int dpni_prepare_extended_cfg(const struct dpni_extended_cfg	*cfg,
-			      uint8_t			*ext_cfg_buf)
+int dpni_prepare_cfg(const struct dpni_cfg	*cfg,
+		     uint8_t			*cfg_buf)
 {
-	uint64_t *ext_params = (uint64_t *)ext_cfg_buf;
+	uint64_t *params = (uint64_t *)cfg_buf;
 
-	DPNI_PREP_EXTENDED_CFG(ext_params, cfg);
+	DPNI_PREP_CFG(params, cfg);
 
 	return 0;
 }
 
-int dpni_extract_extended_cfg(struct dpni_extended_cfg	*cfg,
-			      const uint8_t		*ext_cfg_buf)
+int dpni_extract_cfg(struct dpni_cfg	*cfg,
+		     const uint8_t	*cfg_buf)
 {
-	uint64_t *ext_params = (uint64_t *)ext_cfg_buf;
+	uint64_t *params = (uint64_t *)cfg_buf;
 
-	DPNI_EXT_EXTENDED_CFG(ext_params, cfg);
+	DPNI_EXT_CFG(params, cfg);
 
 	return 0;
 }
@@ -69,9 +70,10 @@
 }
 
 int dpni_create(struct fsl_mc_io *mc_io,
+		uint16_t dprc_token,
 		uint32_t cmd_flags,
 		const struct dpni_cfg *cfg,
-		uint16_t *token)
+		uint32_t *obj_id)
 {
 	struct mc_command cmd = { 0 };
 	int err;
@@ -79,7 +81,7 @@
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
 					  cmd_flags,
-					  0);
+					  dprc_token);
 	DPNI_CMD_CREATE(cmd, cfg);
 
 	/* send command to mc*/
@@ -88,21 +90,25 @@
 		return err;
 
 	/* retrieve response parameters */
-	*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+	 MC_CMD_READ_OBJ_ID(cmd, *obj_id);
 
 	return 0;
 }
 
 int dpni_destroy(struct fsl_mc_io *mc_io,
+		 uint16_t dprc_token,
 		 uint32_t cmd_flags,
-		 uint16_t token)
+		 uint32_t obj_id)
 {
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
 					  cmd_flags,
-					  token);
+					  dprc_token);
+
+	/* set object id to destroy */
+	CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
@@ -182,8 +188,6 @@
 	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
 					  cmd_flags,
 					  token);
-	DPNI_CMD_GET_ATTR(cmd, attr);
-
 	/* send command to mc*/
 	err = mc_send_command(mc_io, &cmd);
 	if (err)
@@ -212,129 +216,24 @@
 	return mc_send_command(mc_io, &cmd);
 }
 
-int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io,
-			      uint32_t cmd_flags,
-			      uint16_t token,
-			      struct dpni_buffer_layout *layout)
-{
-	struct mc_command cmd = { 0 };
-	int err;
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_BUFFER_LAYOUT,
-					  cmd_flags,
-					  token);
-
-	/* send command to mc*/
-	err = mc_send_command(mc_io, &cmd);
-	if (err)
-		return err;
-
-	/* retrieve response parameters */
-	DPNI_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout);
-
-	return 0;
-}
-
-int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io,
-			      uint32_t cmd_flags,
-			      uint16_t token,
-			      const struct dpni_buffer_layout *layout)
+int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
+			   uint32_t cmd_flags,
+			   uint16_t token,
+			   const struct dpni_buffer_layout *layout,
+			   enum dpni_queue_type type)
 {
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_BUFFER_LAYOUT,
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
 					  cmd_flags,
 					  token);
-	DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout);
+	DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type);
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
 }
 
-int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io,
-			      uint32_t cmd_flags,
-			      uint16_t token,
-			      struct dpni_buffer_layout *layout)
-{
-	struct mc_command cmd = { 0 };
-	int err;
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_BUFFER_LAYOUT,
-					  cmd_flags,
-					  token);
-
-	/* send command to mc*/
-	err = mc_send_command(mc_io, &cmd);
-	if (err)
-		return err;
-
-	/* retrieve response parameters */
-	DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout);
-
-	return 0;
-}
-
-int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io,
-			      uint32_t cmd_flags,
-			      uint16_t token,
-			      const struct dpni_buffer_layout *layout)
-{
-	struct mc_command cmd = { 0 };
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_BUFFER_LAYOUT,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout);
-
-	/* send command to mc*/
-	return mc_send_command(mc_io, &cmd);
-}
-
-int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
-				   uint32_t cmd_flags,
-				   uint16_t token,
-				   struct dpni_buffer_layout *layout)
-{
-	struct mc_command cmd = { 0 };
-	int err;
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT,
-					  cmd_flags,
-					  token);
-
-	/* send command to mc*/
-	err = mc_send_command(mc_io, &cmd);
-	if (err)
-		return err;
-
-	/* retrieve response parameters */
-	DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
-
-	return 0;
-}
-
-int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
-				   uint32_t cmd_flags,
-				   uint16_t token,
-				   const struct dpni_buffer_layout *layout)
-{
-	struct mc_command cmd = { 0 };
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
-
-	/* send command to mc*/
-	return mc_send_command(mc_io, &cmd);
-}
-
 int dpni_get_qdid(struct fsl_mc_io *mc_io,
 		  uint32_t cmd_flags,
 		  uint16_t token,
@@ -383,50 +282,6 @@
 	return 0;
 }
 
-int dpni_get_counter(struct fsl_mc_io *mc_io,
-		     uint32_t cmd_flags,
-		     uint16_t token,
-		     enum dpni_counter counter,
-		     uint64_t *value)
-{
-	struct mc_command cmd = { 0 };
-	int err;
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_COUNTER,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_GET_COUNTER(cmd, counter);
-
-	/* send command to mc*/
-	err = mc_send_command(mc_io, &cmd);
-	if (err)
-		return err;
-
-	/* retrieve response parameters */
-	DPNI_RSP_GET_COUNTER(cmd, *value);
-
-	return 0;
-}
-
-int dpni_set_counter(struct fsl_mc_io *mc_io,
-		     uint32_t cmd_flags,
-		     uint16_t token,
-		     enum dpni_counter counter,
-		     uint64_t value)
-{
-	struct mc_command cmd = { 0 };
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_COUNTER,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_SET_COUNTER(cmd, counter, value);
-
-	/* send command to mc*/
-	return mc_send_command(mc_io, &cmd);
-}
-
 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
 		      uint32_t cmd_flags,
 		      uint16_t token,
@@ -544,46 +399,64 @@
 	return mc_send_command(mc_io, &cmd);
 }
 
-int dpni_set_tx_flow(struct fsl_mc_io *mc_io,
-		     uint32_t cmd_flags,
-		     uint16_t token,
-		     uint16_t *flow_id,
-		     const struct dpni_tx_flow_cfg *cfg)
+int dpni_get_api_version(struct fsl_mc_io *mc_io,
+			 u32 cmd_flags,
+			 u16 *major_ver,
+			 u16 *minor_ver)
 {
 	struct mc_command cmd = { 0 };
 	int err;
 
 	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_FLOW,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_SET_TX_FLOW(cmd, *flow_id, cfg);
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
+					  cmd_flags, 0);
 
-	/* send command to mc*/
+	/* send command to mc */
 	err = mc_send_command(mc_io, &cmd);
 	if (err)
 		return err;
 
 	/* retrieve response parameters */
-	DPNI_RSP_SET_TX_FLOW(cmd, *flow_id);
+	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
 
 	return 0;
 }
 
+int dpni_set_queue(struct fsl_mc_io *mc_io,
+	uint32_t cmd_flags,
+	uint16_t token,
+	enum dpni_queue_type type,
+	uint8_t tc,
+	uint8_t index,
+	const struct dpni_queue *queue)
+{
+	struct mc_command cmd = { 0 };
+	/* prepare command */
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
+					  cmd_flags,
+					  token);
+	DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue);
+
+	/* send command to mc*/
+	return mc_send_command(mc_io, &cmd);
+}
+
-int dpni_get_tx_flow(struct fsl_mc_io *mc_io,
-		     uint32_t cmd_flags,
-		     uint16_t token,
-		     uint16_t flow_id,
-		     struct dpni_tx_flow_attr *attr)
+int dpni_get_queue(struct fsl_mc_io *mc_io,
+	uint32_t cmd_flags,
+	uint16_t token,
+	enum dpni_queue_type type,
+	uint8_t tc,
+	uint8_t index,
+	struct dpni_queue *queue)
 {
 	struct mc_command cmd = { 0 };
 	int err;
 
 	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_FLOW,
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
 					  cmd_flags,
 					  token);
-	DPNI_CMD_GET_TX_FLOW(cmd, flow_id);
+	DPNI_CMD_GET_QUEUE(cmd, type, tc, index);
 
 	/* send command to mc*/
 	err = mc_send_command(mc_io, &cmd);
@@ -591,44 +464,43 @@
 		return err;
 
 	/* retrieve response parameters */
-	DPNI_RSP_GET_TX_FLOW(cmd, attr);
-
+	DPNI_RSP_GET_QUEUE(cmd, queue);
 	return 0;
 }
 
-int dpni_set_rx_flow(struct fsl_mc_io *mc_io,
-		     uint32_t cmd_flags,
-		     uint16_t token,
-		     uint8_t tc_id,
-		     uint16_t flow_id,
-		     const struct dpni_queue_cfg *cfg)
+int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io,
+	uint32_t cmd_flags,
+	uint16_t token,
+	enum dpni_confirmation_mode mode)
 {
+	struct dpni_tx_confirmation_mode *cmd_params;
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FLOW,
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
 					  cmd_flags,
 					  token);
-	DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg);
+
+	cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params;
+	cmd_params->confirmation_mode = mode;
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
 }
 
-int dpni_get_rx_flow(struct fsl_mc_io *mc_io,
-		     uint32_t cmd_flags,
-		     uint16_t token,
-		     uint8_t tc_id,
-		     uint16_t flow_id,
-		     struct dpni_queue_attr *attr)
+int dpni_get_statistics(struct fsl_mc_io *mc_io,
+			uint32_t cmd_flags,
+			uint16_t token,
+			uint8_t  page,
+			struct dpni_statistics *stat)
 {
 	struct mc_command cmd = { 0 };
 	int err;
+
 	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_FLOW,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id);
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
+					  cmd_flags, token);
+	DPNI_CMD_GET_STATISTICS(cmd, page);
 
 	/* send command to mc*/
 	err = mc_send_command(mc_io, &cmd);
@@ -636,50 +508,22 @@
 		return err;
 
 	/* retrieve response parameters */
-	DPNI_RSP_GET_RX_FLOW(cmd, attr);
+	DPNI_RSP_GET_STATISTICS(cmd, stat);
 
 	return 0;
 }
 
-int dpni_set_tx_conf(struct fsl_mc_io	*mc_io,
-		     uint32_t		cmd_flags,
-		     uint16_t		token,
-		     uint16_t		flow_id,
-		     const struct dpni_tx_conf_cfg	*cfg)
+int dpni_reset_statistics(struct fsl_mc_io *mc_io,
+			  uint32_t cmd_flags,
+			  uint16_t token)
 {
 	struct mc_command cmd = { 0 };
 
 	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_SET_TX_CONF(cmd, flow_id, cfg);
+	cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
+					  cmd_flags, token);
 
 	/* send command to mc*/
 	return mc_send_command(mc_io, &cmd);
 }
 
-int dpni_get_tx_conf(struct fsl_mc_io		*mc_io,
-		     uint32_t			cmd_flags,
-		     uint16_t			token,
-		     uint16_t			flow_id,
-		     struct dpni_tx_conf_attr	*attr)
-{
-	struct mc_command cmd = { 0 };
-	int err;
-
-	/* prepare command */
-	cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF,
-					  cmd_flags,
-					  token);
-	DPNI_CMD_GET_TX_CONF(cmd, flow_id);
-
-	/* send command to mc*/
-	err = mc_send_command(mc_io, &cmd);
-	if (err)
-		return err;
-
-	DPNI_RSP_GET_TX_CONF(cmd, attr);
-
-	return 0;
-}
diff --git a/drivers/net/fsl-mc/dprc.c b/drivers/net/fsl-mc/dprc.c
index 7d34355..be02057 100644
--- a/drivers/net/fsl-mc/dprc.c
+++ b/drivers/net/fsl-mc/dprc.c
@@ -1,8 +1,8 @@
 /*
  * Freescale Layerscape MC I/O wrapper
  *
- * Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
- * Author: German Rivera <German.Rivera@freescale.com>
+ * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -353,3 +353,26 @@
 
 	return 0;
 }
+
+int dprc_get_api_version(struct fsl_mc_io *mc_io,
+			 u32 cmd_flags,
+			 u16 *major_ver,
+			 u16 *minor_ver)
+{
+	struct mc_command cmd = { 0 };
+	int err;
+
+	/* prepare command */
+	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
+					  cmd_flags, 0);
+
+	/* send command to mc */
+	err = mc_send_command(mc_io, &cmd);
+	if (err)
+		return err;
+
+	/* retrieve response parameters */
+	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
+
+	return 0;
+}
diff --git a/drivers/net/fsl-mc/fsl_dpmng_cmd.h b/drivers/net/fsl-mc/fsl_dpmng_cmd.h
index 33f84f3..a91da2b 100644
--- a/drivers/net/fsl-mc/fsl_dpmng_cmd.h
+++ b/drivers/net/fsl-mc/fsl_dpmng_cmd.h
@@ -1,4 +1,5 @@
-/* Copyright 2013-2015 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -6,7 +7,7 @@
 #define __FSL_DPMNG_CMD_H
 
 /* Command IDs */
-#define DPMNG_CMDID_GET_VERSION			0x831
+#define DPMNG_CMDID_GET_VERSION			0x8311
 
 /*                cmd, param, offset, width, type, arg_name */
 #define DPMNG_RSP_GET_VERSION(cmd, mc_ver_info) \
diff --git a/drivers/net/fsl-mc/mc.c b/drivers/net/fsl-mc/mc.c
index c76f582..bf9949b 100644
--- a/drivers/net/fsl-mc/mc.c
+++ b/drivers/net/fsl-mc/mc.c
@@ -854,21 +854,25 @@
 
 static int dprc_version_check(struct fsl_mc_io *mc_io, uint16_t handle)
 {
-	struct dprc_attributes attr;
 	int error;
+	uint16_t major_ver, minor_ver;
 
-	memset(&attr, 0, sizeof(struct dprc_attributes));
-	error = dprc_get_attributes(mc_io, MC_CMD_NO_FLAGS, handle, &attr);
-	if (error == 0) {
-		if ((attr.version.major != DPRC_VER_MAJOR) ||
-		    (attr.version.minor != DPRC_VER_MINOR)) {
-			printf("DPRC version mismatch found %u.%u,",
-			       attr.version.major,
-			       attr.version.minor);
-			printf("supported version is %u.%u\n",
-			       DPRC_VER_MAJOR, DPRC_VER_MINOR);
-		}
+	error = dprc_get_api_version(mc_io, 0,
+				     &major_ver,
+				     &minor_ver);
+	if (error < 0) {
+		printf("dprc_get_api_version() failed: %d\n", error);
+		return error;
 	}
+
+	if (major_ver < DPRC_VER_MAJOR || (major_ver == DPRC_VER_MAJOR &&
+					   minor_ver < DPRC_VER_MINOR)) {
+		printf("DPRC version mismatch found %u.%u,",
+		       major_ver, minor_ver);
+		printf("supported version is %u.%u\n",
+		       DPRC_VER_MAJOR, DPRC_VER_MINOR);
+	}
+
 	return error;
 }
 
@@ -878,6 +882,7 @@
 	struct dpio_attr attr;
 	struct dpio_cfg dpio_cfg;
 	int err = 0;
+	uint16_t major_ver, minor_ver;
 
 	dflt_dpio = (struct fsl_dpio_obj *)calloc(
 					sizeof(struct fsl_dpio_obj), 1);
@@ -886,18 +891,44 @@
 		err = -ENOMEM;
 		goto err_calloc;
 	}
-
 	dpio_cfg.channel_mode = DPIO_LOCAL_CHANNEL;
 	dpio_cfg.num_priorities = 8;
 
-	err = dpio_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpio_cfg,
-			  &dflt_dpio->dpio_handle);
+	err = dpio_create(dflt_mc_io,
+			  dflt_dprc_handle,
+			  MC_CMD_NO_FLAGS,
+			  &dpio_cfg,
+			  &dflt_dpio->dpio_id);
 	if (err < 0) {
 		printf("dpio_create() failed: %d\n", err);
 		err = -ENODEV;
 		goto err_create;
 	}
 
+	err = dpio_get_api_version(dflt_mc_io, 0,
+				   &major_ver,
+				   &minor_ver);
+	if (err < 0) {
+		printf("dpio_get_api_version() failed: %d\n", err);
+		goto err_get_api_ver;
+	}
+
+	if (major_ver < DPIO_VER_MAJOR || (major_ver == DPIO_VER_MAJOR &&
+					   minor_ver < DPIO_VER_MINOR)) {
+		printf("DPRC version mismatch found %u.%u,",
+		       major_ver,
+		       minor_ver);
+	}
+
+	err = dpio_open(dflt_mc_io,
+			MC_CMD_NO_FLAGS,
+			dflt_dpio->dpio_id,
+			&dflt_dpio->dpio_handle);
+	if (err) {
+		printf("dpio_open() failed\n");
+		goto err_open;
+	}
+
 	memset(&attr, 0, sizeof(struct dpio_attr));
 	err = dpio_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
 				  dflt_dpio->dpio_handle, &attr);
@@ -906,15 +937,11 @@
 		goto err_get_attr;
 	}
 
-	if ((attr.version.major != DPIO_VER_MAJOR) ||
-	    (attr.version.minor != DPIO_VER_MINOR)) {
-		printf("DPIO version mismatch found %u.%u,",
-		       attr.version.major, attr.version.minor);
-		printf("supported version is %u.%u\n",
-		       DPIO_VER_MAJOR, DPIO_VER_MINOR);
+	if (dflt_dpio->dpio_id != attr.id) {
+		printf("dnpi object id and attribute id are not same\n");
+		goto err_attr_not_same;
 	}
 
-	dflt_dpio->dpio_id = attr.id;
 #ifdef DEBUG
 	printf("Init: DPIO id=0x%d\n", dflt_dpio->dpio_id);
 #endif
@@ -945,8 +972,14 @@
 	dpio_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
 err_get_enable:
 err_get_attr:
+err_attr_not_same:
 	dpio_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
-	dpio_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
+err_open:
+err_get_api_ver:
+	dpio_destroy(dflt_mc_io,
+		     dflt_dprc_handle,
+		     MC_CMD_NO_FLAGS,
+		     dflt_dpio->dpio_id);
 err_create:
 	free(dflt_dpio);
 err_calloc:
@@ -963,7 +996,16 @@
 		goto err;
 	}
 
-	err = dpio_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
+	dpio_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
+	if (err < 0) {
+		printf("dpio_close() failed: %d\n", err);
+		goto err;
+	}
+
+	err = dpio_destroy(dflt_mc_io,
+			   dflt_dprc_handle,
+			   MC_CMD_NO_FLAGS,
+			   dflt_dpio->dpio_id);
 	if (err < 0) {
 		printf("dpio_destroy() failed: %d\n", err);
 		goto err;
@@ -1040,6 +1082,7 @@
 
 	child_portal_id = MC_PORTAL_OFFSET_TO_PORTAL_ID(mc_portal_offset);
 	dflt_mc_io->mmio_regs = SOC_MC_PORTAL_ADDR(child_portal_id);
+
 #ifdef DEBUG
 	printf("MC portal of child DPRC container: %d, physical addr %p)\n",
 	       child_dprc_id, dflt_mc_io->mmio_regs);
@@ -1110,6 +1153,7 @@
 	int err;
 	struct dpbp_attr dpbp_attr;
 	struct dpbp_cfg dpbp_cfg;
+	uint16_t major_ver, minor_ver;
 
 	dflt_dpbp = (struct fsl_dpbp_obj *)calloc(
 					sizeof(struct fsl_dpbp_obj), 1);
@@ -1121,8 +1165,11 @@
 
 	dpbp_cfg.options = 512;
 
-	err = dpbp_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpbp_cfg,
-			  &dflt_dpbp->dpbp_handle);
+	err = dpbp_create(dflt_mc_io,
+			  dflt_dprc_handle,
+			  MC_CMD_NO_FLAGS,
+			  &dpbp_cfg,
+			  &dflt_dpbp->dpbp_id);
 
 	if (err < 0) {
 		err = -ENODEV;
@@ -1130,6 +1177,31 @@
 		goto err_create;
 	}
 
+	err = dpbp_get_api_version(dflt_mc_io, 0,
+				   &major_ver,
+				   &minor_ver);
+	if (err < 0) {
+		printf("dpbp_get_api_version() failed: %d\n", err);
+		goto err_get_api_ver;
+	}
+
+	if (major_ver < DPBP_VER_MAJOR || (major_ver == DPBP_VER_MAJOR &&
+					   minor_ver < DPBP_VER_MINOR)) {
+		printf("DPBP version mismatch found %u.%u,",
+		       major_ver, minor_ver);
+		printf("supported version is %u.%u\n",
+		       DPBP_VER_MAJOR, DPBP_VER_MINOR);
+	}
+
+	err = dpbp_open(dflt_mc_io,
+			MC_CMD_NO_FLAGS,
+			dflt_dpbp->dpbp_id,
+			&dflt_dpbp->dpbp_handle);
+	if (err) {
+		printf("dpbp_open() failed\n");
+		goto err_open;
+	}
+
 	memset(&dpbp_attr, 0, sizeof(struct dpbp_attr));
 	err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
 				  dflt_dpbp->dpbp_handle,
@@ -1139,17 +1211,13 @@
 		goto err_get_attr;
 	}
 
-	if ((dpbp_attr.version.major != DPBP_VER_MAJOR) ||
-	    (dpbp_attr.version.minor != DPBP_VER_MINOR)) {
-		printf("DPBP version mismatch found %u.%u,",
-		       dpbp_attr.version.major, dpbp_attr.version.minor);
-		printf("supported version is %u.%u\n",
-		       DPBP_VER_MAJOR, DPBP_VER_MINOR);
+	if (dflt_dpbp->dpbp_id != dpbp_attr.id) {
+		printf("dpbp object id and attribute id are not same\n");
+		goto err_attr_not_same;
 	}
 
-	dflt_dpbp->dpbp_attr.id = dpbp_attr.id;
 #ifdef DEBUG
-	printf("Init: DPBP id=0x%d\n", dflt_dpbp->dpbp_attr.id);
+	printf("Init: DPBP id=0x%x\n", dflt_dpbp->dpbp_attr.id);
 #endif
 
 	err = dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
@@ -1160,12 +1228,18 @@
 
 	return 0;
 
-err_close:
-	free(dflt_dpbp);
 err_get_attr:
+err_attr_not_same:
 	dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
-	dpbp_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
+	dpbp_destroy(dflt_mc_io,
+		     dflt_dprc_handle,
+		     MC_CMD_NO_FLAGS,
+		     dflt_dpbp->dpbp_id);
+err_get_api_ver:
+err_close:
+err_open:
 err_create:
+	free(dflt_dpbp);
 err_calloc:
 	return err;
 }
@@ -1174,15 +1248,8 @@
 {
 	int err;
 
-	err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
-			&dflt_dpbp->dpbp_handle);
-	if (err < 0) {
-		printf("dpbp_open() failed: %d\n", err);
-		goto err;
-	}
-
-	err = dpbp_destroy(dflt_mc_io, MC_CMD_NO_FLAGS,
-			   dflt_dpbp->dpbp_handle);
+	err = dpbp_destroy(dflt_mc_io, dflt_dprc_handle, MC_CMD_NO_FLAGS,
+			   dflt_dpbp->dpbp_id);
 	if (err < 0) {
 		printf("dpbp_destroy() failed: %d\n", err);
 		goto err;
@@ -1203,10 +1270,9 @@
 static int dpni_init(void)
 {
 	int err;
-	struct dpni_attr dpni_attr;
-	uint8_t	ext_cfg_buf[256] = {0};
-	struct dpni_extended_cfg dpni_extended_cfg;
+	uint8_t	cfg_buf[256] = {0};
 	struct dpni_cfg dpni_cfg;
+	uint16_t major_ver, minor_ver;
 
 	dflt_dpni = (struct fsl_dpni_obj *)calloc(
 					sizeof(struct fsl_dpni_obj), 1);
@@ -1216,50 +1282,53 @@
 		goto err_calloc;
 	}
 
-	memset(&dpni_extended_cfg, 0, sizeof(dpni_extended_cfg));
-	err = dpni_prepare_extended_cfg(&dpni_extended_cfg, &ext_cfg_buf[0]);
+	memset(&dpni_cfg, 0, sizeof(dpni_cfg));
+	err = dpni_prepare_cfg(&dpni_cfg, &cfg_buf[0]);
 	if (err < 0) {
 		err = -ENODEV;
-		printf("dpni_prepare_extended_cfg() failed: %d\n", err);
-		goto err_prepare_extended_cfg;
+		printf("dpni_prepare_cfg() failed: %d\n", err);
+		goto err_prepare_cfg;
 	}
 
-	memset(&dpni_cfg, 0, sizeof(dpni_cfg));
-	dpni_cfg.adv.options = DPNI_OPT_UNICAST_FILTER |
-			       DPNI_OPT_MULTICAST_FILTER;
-
-	dpni_cfg.adv.ext_cfg_iova = (uint64_t)&ext_cfg_buf[0];
-	err = dpni_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpni_cfg,
-			  &dflt_dpni->dpni_handle);
-
+	err = dpni_create(dflt_mc_io,
+			  dflt_dprc_handle,
+			  MC_CMD_NO_FLAGS,
+			  &dpni_cfg,
+			  &dflt_dpni->dpni_id);
 	if (err < 0) {
 		err = -ENODEV;
-		printf("dpni_create() failed: %d\n", err);
+		printf("dpni create() failed: %d\n", err);
 		goto err_create;
 	}
 
-	memset(&dpni_attr, 0, sizeof(struct dpni_attr));
-	err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
-				  dflt_dpni->dpni_handle,
-				  &dpni_attr);
+	err = dpni_get_api_version(dflt_mc_io, 0,
+				   &major_ver,
+				   &minor_ver);
 	if (err < 0) {
-		printf("dpni_get_attributes() failed: %d\n", err);
-		goto err_get_attr;
+		printf("dpni_get_api_version() failed: %d\n", err);
+		goto err_get_version;
 	}
 
-	if ((dpni_attr.version.major != DPNI_VER_MAJOR) ||
-	    (dpni_attr.version.minor != DPNI_VER_MINOR)) {
+	if (major_ver < DPNI_VER_MAJOR || (major_ver == DPNI_VER_MAJOR &&
+					   minor_ver < DPNI_VER_MINOR)) {
 		printf("DPNI version mismatch found %u.%u,",
-		       dpni_attr.version.major, dpni_attr.version.minor);
+		       major_ver, minor_ver);
 		printf("supported version is %u.%u\n",
 		       DPNI_VER_MAJOR, DPNI_VER_MINOR);
 	}
 
-	dflt_dpni->dpni_id = dpni_attr.id;
+	err = dpni_open(dflt_mc_io,
+			MC_CMD_NO_FLAGS,
+			dflt_dpni->dpni_id,
+			&dflt_dpni->dpni_handle);
+	if (err) {
+		printf("dpni_open() failed\n");
+		goto err_open;
+	}
+
 #ifdef DEBUG
 	printf("Init: DPNI id=0x%d\n", dflt_dpni->dpni_id);
 #endif
-
 	err = dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 	if (err < 0) {
 		printf("dpni_close() failed: %d\n", err);
@@ -1269,11 +1338,15 @@
 	return 0;
 
 err_close:
-err_get_attr:
 	dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
-	dpni_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
+err_open:
+err_get_version:
+	dpni_destroy(dflt_mc_io,
+		     dflt_dprc_handle,
+		     MC_CMD_NO_FLAGS,
+		     dflt_dpni->dpni_id);
 err_create:
-err_prepare_extended_cfg:
+err_prepare_cfg:
 	free(dflt_dpni);
 err_calloc:
 	return err;
@@ -1283,15 +1356,8 @@
 {
 	int err;
 
-	err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
-			&dflt_dpni->dpni_handle);
-	if (err < 0) {
-		printf("dpni_open() failed: %d\n", err);
-		goto err;
-	}
-
-	err = dpni_destroy(dflt_mc_io, MC_CMD_NO_FLAGS,
-			   dflt_dpni->dpni_handle);
+	err = dpni_destroy(dflt_mc_io, dflt_dprc_handle, MC_CMD_NO_FLAGS,
+			   dflt_dpni->dpni_id);
 	if (err < 0) {
 		printf("dpni_destroy() failed: %d\n", err);
 		goto err;
@@ -1420,6 +1486,7 @@
 #endif
 
 			sub_cmd = argv[2][0];
+
 			switch (sub_cmd) {
 			case 'm':
 				if (argc < 5)
diff --git a/drivers/net/ldpaa_eth/ldpaa_eth.c b/drivers/net/ldpaa_eth/ldpaa_eth.c
index 21be79a..109aba2 100644
--- a/drivers/net/ldpaa_eth/ldpaa_eth.c
+++ b/drivers/net/ldpaa_eth/ldpaa_eth.c
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2014 Freescale Semiconductor
+ * Copyright (C) 2014-2016 Freescale Semiconductor
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -42,80 +43,67 @@
 #endif
 
 #ifdef DEBUG
-static void ldpaa_eth_get_dpni_counter(void)
-{
-	int err = 0;
-	u64 value;
 
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_ING_FRAME,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_ING_FRAME failed\n");
-		return;
-	}
-	printf("DPNI_CNT_ING_FRAME=%lld\n", value);
+#define DPNI_STATS_PER_PAGE 6
 
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_ING_BYTE,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_ING_BYTE failed\n");
-		return;
-	}
-	printf("DPNI_CNT_ING_BYTE=%lld\n", value);
-
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_ING_FRAME_DROP ,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DROP failed\n");
-		return;
-	}
-	printf("DPNI_CNT_ING_FRAME_DROP =%lld\n", value);
+static const char *dpni_statistics[][DPNI_STATS_PER_PAGE] = {
+	{
+	"DPNI_CNT_ING_ALL_FRAMES",
+	"DPNI_CNT_ING_ALL_BYTES",
+	"DPNI_CNT_ING_MCAST_FRAMES",
+	"DPNI_CNT_ING_MCAST_BYTES",
+	"DPNI_CNT_ING_BCAST_FRAMES",
+	"DPNI_CNT_ING_BCAST_BYTES",
+	}, {
+	"DPNI_CNT_EGR_ALL_FRAMES",
+	"DPNI_CNT_EGR_ALL_BYTES",
+	"DPNI_CNT_EGR_MCAST_FRAMES",
+	"DPNI_CNT_EGR_MCAST_BYTES",
+	"DPNI_CNT_EGR_BCAST_FRAMES",
+	"DPNI_CNT_EGR_BCAST_BYTES",
+	}, {
+	"DPNI_CNT_ING_FILTERED_FRAMES",
+	"DPNI_CNT_ING_DISCARDED_FRAMES",
+	"DPNI_CNT_ING_NOBUFFER_DISCARDS",
+	"DPNI_CNT_EGR_DISCARDED_FRAMES",
+	"DPNI_CNT_EGR_CNF_FRAMES",
+	""
+	},
+};
 
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_ING_FRAME_DISCARD,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DISCARD failed\n");
-		return;
-	}
-	printf("DPNI_CNT_ING_FRAME_DISCARD=%lld\n", value);
+static void print_dpni_stats(const char *strings[],
+			     struct dpni_statistics dpni_stats)
+{
+	uint64_t *stat;
+	int i;
 
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_EGR_FRAME,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_EGR_FRAME failed\n");
-		return;
+	stat = (uint64_t *)&dpni_stats;
+	for (i = 0; i < DPNI_STATS_PER_PAGE; i++) {
+		if (strcmp(strings[i], "\0") == 0)
+			break;
+		printf("%s= %llu\n", strings[i], *stat);
+		stat++;
 	}
-	printf("DPNI_CNT_EGR_FRAME=%lld\n", value);
+}
 
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_EGR_BYTE ,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_EGR_BYTE failed\n");
-		return;
-	}
-	printf("DPNI_CNT_EGR_BYTE =%lld\n", value);
+static void ldpaa_eth_get_dpni_counter(void)
+{
+	int err = 0;
+	unsigned int page = 0;
+	struct dpni_statistics dpni_stats;
 
-	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
-		     dflt_dpni->dpni_handle,
-		     DPNI_CNT_EGR_FRAME_DISCARD ,
-		     &value);
-	if (err < 0) {
-		printf("dpni_get_counter: DPNI_CNT_EGR_FRAME_DISCARD failed\n");
-		return;
+	printf("DPNI counters ..\n");
+	for (page = 0; page < 3; page++) {
+		err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS,
+					  dflt_dpni->dpni_handle, page,
+					  &dpni_stats);
+		if (err < 0) {
+			printf("dpni_get_statistics: failed:");
+			printf("%d for page[%d]\n", err, page);
+			return;
+		}
+		print_dpni_stats(dpni_statistics[page], dpni_stats);
 	}
-	printf("DPNI_CNT_EGR_FRAME_DISCARD =%lld\n", value);
 }
 
 static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
@@ -132,6 +120,7 @@
 		printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
 		return;
 	}
+	printf("\nDPMAC counters ..\n");
 	printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
 
 	err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
@@ -392,7 +381,6 @@
 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
 {
 	struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
-	struct dpni_queue_attr rx_queue_attr;
 	struct dpmac_link_state	dpmac_link_state = { 0 };
 #ifdef DEBUG
 	struct dpni_link_state link_state;
@@ -400,6 +388,7 @@
 	int err = 0;
 	struct mii_dev *bus;
 	phy_interface_t enet_if;
+	struct dpni_queue d_queue;
 
 	if (net_dev->state == ETH_STATE_ACTIVE)
 		return 0;
@@ -508,6 +497,10 @@
 	}
 
 #ifdef DEBUG
+	printf("DPMAC link status: %d - ", dpmac_link_state.up);
+	dpmac_link_state.up == 0 ? printf("down\n") :
+	dpmac_link_state.up == 1 ? printf("up\n") : printf("error state\n");
+
 	err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
 				  dflt_dpni->dpni_handle, &link_state);
 	if (err < 0) {
@@ -515,20 +508,21 @@
 		return err;
 	}
 
-	printf("link status: %d - ", link_state.up);
+	printf("DPNI link status: %d - ", link_state.up);
 	link_state.up == 0 ? printf("down\n") :
 	link_state.up == 1 ? printf("up\n") : printf("error state\n");
 #endif
 
-	/* TODO: support multiple Rx flows */
-	err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
-			       dflt_dpni->dpni_handle, 0, 0, &rx_queue_attr);
+	memset(&d_queue, 0, sizeof(struct dpni_queue));
+	err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
+			     dflt_dpni->dpni_handle, DPNI_QUEUE_RX,
+			     0, 0, &d_queue);
 	if (err) {
-		printf("dpni_get_rx_flow() failed\n");
-		goto err_rx_flow;
+		printf("dpni_get_queue failed\n");
+		goto err_get_queue;
 	}
 
-	priv->rx_dflt_fqid = rx_queue_attr.fqid;
+	priv->rx_dflt_fqid = d_queue.fqid;
 
 	err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
 			    &priv->tx_qdid);
@@ -540,7 +534,7 @@
 	return priv->phydev->link;
 
 err_qdid:
-err_rx_flow:
+err_get_queue:
 	dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 err_dpni_bind:
 	ldpaa_dpbp_free();
@@ -548,7 +542,10 @@
 	dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 err_dpni_setup:
 err_dpamc_bind:
-	dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
+	dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
+	dpmac_destroy(dflt_mc_io,
+		      dflt_dprc_handle,
+		      MC_CMD_NO_FLAGS, priv->dpmac_id);
 err_dpmac_setup:
 	return err;
 }
@@ -575,7 +572,14 @@
 	if (err < 0)
 		printf("dprc_disconnect() failed dpmac_endpoint\n");
 
-	err = dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
+	err = dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
+	if (err < 0)
+		printf("dpmac_close() failed\n");
+
+	err = dpmac_destroy(dflt_mc_io,
+			    dflt_dprc_handle,
+			    MC_CMD_NO_FLAGS,
+			    priv->dpmac_id);
 	if (err < 0)
 		printf("dpmac_destroy() failed\n");
 
@@ -593,9 +597,16 @@
 	}
 #endif
 
+	/* Free DPBP handle and reset. */
 	ldpaa_dpbp_free();
+
 	dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
+	if (err < 0)
+		printf("dpni_reset() failed\n");
+
 	dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
+	if (err < 0)
+		printf("dpni_close() failed\n");
 }
 
 static void ldpaa_dpbp_drain_cnt(int count)
@@ -711,6 +722,7 @@
 	}
 
 	err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
+
 	if (err) {
 		printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
 		       dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
@@ -739,21 +751,19 @@
 static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io,
 				     struct ldpaa_eth_priv *priv)
 {
-	struct dpmac_attr attr;
 	int error;
+	uint16_t major_ver, minor_ver;
 
-	memset(&attr, 0, sizeof(struct dpmac_attr));
-	error = dpmac_get_attributes(mc_io, MC_CMD_NO_FLAGS,
-				     priv->dpmac_handle,
-				     &attr);
-	if (error == 0) {
-		if ((attr.version.major != DPMAC_VER_MAJOR) ||
-		    (attr.version.minor != DPMAC_VER_MINOR)) {
-			printf("DPMAC version mismatch found %u.%u,",
-			       attr.version.major, attr.version.minor);
-			printf("supported version is %u.%u\n",
-			       DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
-		}
+	error = dpmac_get_api_version(dflt_mc_io, 0,
+					&major_ver,
+					&minor_ver);
+	if ((major_ver < DPMAC_VER_MAJOR) ||
+	    (major_ver == DPMAC_VER_MAJOR && minor_ver < DPMAC_VER_MINOR)) {
+		printf("DPMAC version mismatch found %u.%u,",
+		       major_ver, minor_ver);
+		printf("supported version is %u.%u\n",
+		       DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
+		return error;
 	}
 
 	return error;
@@ -765,16 +775,38 @@
 	struct dpmac_cfg dpmac_cfg;
 
 	dpmac_cfg.mac_id = priv->dpmac_id;
-	err = dpmac_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpmac_cfg,
-			  &priv->dpmac_handle);
+
+	err = dpmac_create(dflt_mc_io,
+			   dflt_dprc_handle,
+			   MC_CMD_NO_FLAGS, &dpmac_cfg,
+			   &priv->dpmac_id);
 	if (err)
 		printf("dpmac_create() failed\n");
 
 	err = ldpaa_dpmac_version_check(dflt_mc_io, priv);
-	if (err < 0)
+	if (err < 0) {
 		printf("ldpaa_dpmac_version_check() failed: %d\n", err);
+		goto err_version_check;
+	}
+
+	err = dpmac_open(dflt_mc_io,
+			 MC_CMD_NO_FLAGS,
+			 priv->dpmac_id,
+			 &priv->dpmac_handle);
+	if (err < 0) {
+		printf("dpmac_open() failed: %d\n", err);
+		goto err_open;
+	}
 
 	return err;
+
+err_open:
+err_version_check:
+	dpmac_destroy(dflt_mc_io,
+		      dflt_dprc_handle,
+		      MC_CMD_NO_FLAGS, priv->dpmac_id);
+
+	return err;
 }
 
 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
@@ -838,7 +870,6 @@
 		printf("dpni_open() failed\n");
 		goto err_open;
 	}
-
 	err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
 				  dflt_dpni->dpni_handle,
 				  &dflt_dpni->dpni_attrs);
@@ -857,12 +888,13 @@
 	dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
 	/* HW erratum mandates data alignment in multiples of 256 */
 	dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
+
 	/* ...rx, ... */
-	err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
-					dflt_dpni->dpni_handle,
-					&dflt_dpni->buf_layout);
+	err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
+				     dflt_dpni->dpni_handle,
+				     &dflt_dpni->buf_layout, DPNI_QUEUE_RX);
 	if (err) {
-		printf("dpni_set_rx_buffer_layout() failed");
+		printf("dpni_set_buffer_layout() failed");
 		goto err_buf_layout;
 	}
 
@@ -870,21 +902,22 @@
 	/* remove Rx-only options */
 	dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
 				      DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
-	err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
-					dflt_dpni->dpni_handle,
-					&dflt_dpni->buf_layout);
+	err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
+				     dflt_dpni->dpni_handle,
+				     &dflt_dpni->buf_layout, DPNI_QUEUE_TX);
 	if (err) {
-		printf("dpni_set_tx_buffer_layout() failed");
+		printf("dpni_set_buffer_layout() failed");
 		goto err_buf_layout;
 	}
 
 	/* ... tx-confirm. */
 	dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
-	err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
-					     dflt_dpni->dpni_handle,
-					     &dflt_dpni->buf_layout);
+	err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
+				     dflt_dpni->dpni_handle,
+				     &dflt_dpni->buf_layout,
+				     DPNI_QUEUE_TX_CONFIRM);
 	if (err) {
-		printf("dpni_set_tx_conf_buffer_layout() failed");
+		printf("dpni_set_buffer_layout() failed");
 		goto err_buf_layout;
 	}
 
@@ -919,8 +952,7 @@
 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
 {
 	struct dpni_pools_cfg pools_params;
-	struct dpni_tx_flow_cfg dflt_tx_flow;
-	struct dpni_tx_conf_cfg tx_conf_cfg;
+	struct dpni_queue tx_queue;
 	int err = 0;
 
 	memset(&pools_params, 0, sizeof(pools_params));
@@ -934,26 +966,22 @@
 		return err;
 	}
 
-	priv->tx_flow_id = DPNI_NEW_FLOW_ID;
-	memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
+	memset(&tx_queue, 0, sizeof(struct dpni_queue));
 
-	dflt_tx_flow.use_common_tx_conf_queue = 0;
-	err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
-			       dflt_dpni->dpni_handle, &priv->tx_flow_id,
-			       &dflt_tx_flow);
+	err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
+			     dflt_dpni->dpni_handle,
+			     DPNI_QUEUE_TX, 0, 0, &tx_queue);
+
 	if (err) {
-		printf("dpni_set_tx_flow() failed\n");
+		printf("dpni_set_queue() failed\n");
 		return err;
 	}
 
-	memset(&tx_conf_cfg, 0, sizeof(struct dpni_tx_conf_cfg));
-	tx_conf_cfg.errors_only = true;
-	/*Set tx-conf and error configuration*/
-	err = dpni_set_tx_conf(dflt_mc_io, MC_CMD_NO_FLAGS,
-			       dflt_dpni->dpni_handle,
-			       priv->tx_flow_id, &tx_conf_cfg);
+	err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS,
+					    dflt_dpni->dpni_handle,
+					    DPNI_CONF_DISABLE);
 	if (err) {
-		printf("dpni_set_tx_conf() failed\n");
+		printf("dpni_set_tx_confirmation_mode() failed\n");
 		return err;
 	}
 
@@ -996,7 +1024,6 @@
 	struct ldpaa_eth_priv		*priv = NULL;
 	int				err = 0;
 
-
 	/* Net device */
 	net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
 	if (!net_dev) {
diff --git a/drivers/net/ldpaa_eth/ldpaa_eth.h b/drivers/net/ldpaa_eth/ldpaa_eth.h
index 3b16150..1e26630 100644
--- a/drivers/net/ldpaa_eth/ldpaa_eth.h
+++ b/drivers/net/ldpaa_eth/ldpaa_eth.h
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2014 Freescale Semiconductor
+ * Copyright (C) 2014-2016 Freescale Semiconductor
+ * Copyright 2017 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
@@ -117,7 +118,7 @@
 
 struct ldpaa_eth_priv {
 	struct eth_device *net_dev;
-	int dpmac_id;
+	uint32_t dpmac_id;
 	uint16_t dpmac_handle;
 
 	uint16_t tx_data_offset;