case TC_SETUP_QDISC_TAPRIO: {
                struct tc_taprio_qopt_offload *taprio = type_data;
 
-               if (!hellcreek_validate_schedule(hellcreek, taprio))
-                       return -EOPNOTSUPP;
+               switch (taprio->cmd) {
+               case TAPRIO_CMD_REPLACE:
+                       if (!hellcreek_validate_schedule(hellcreek, taprio))
+                               return -EOPNOTSUPP;
 
-               if (taprio->enable)
                        return hellcreek_port_set_schedule(ds, port, taprio);
-
-               return hellcreek_port_del_schedule(ds, port);
+               case TAPRIO_CMD_DESTROY:
+                       return hellcreek_port_del_schedule(ds, port);
+               default:
+                       return -EOPNOTSUPP;
+               }
        }
        default:
                return -EOPNOTSUPP;
 
 
        mutex_lock(&ocelot->tas_lock);
 
-       if (!taprio->enable) {
+       if (taprio->cmd == TAPRIO_CMD_DESTROY) {
                ocelot_port_mqprio(ocelot, port, &taprio->mqprio);
                ocelot_rmw_rix(ocelot, 0, QSYS_TAG_CONFIG_ENABLE,
                               QSYS_TAG_CONFIG, port);
 
                mutex_unlock(&ocelot->tas_lock);
                return 0;
+       } else if (taprio->cmd != TAPRIO_CMD_REPLACE) {
+               return -EOPNOTSUPP;
        }
 
        ret = ocelot_port_mqprio(ocelot, port, &taprio->mqprio);
 
        /* Can't change an already configured port (must delete qdisc first).
         * Can't delete the qdisc from an unconfigured port.
         */
-       if (!!tas_data->offload[port] == admin->enable)
+       if ((!!tas_data->offload[port] && admin->cmd == TAPRIO_CMD_REPLACE) ||
+           (!tas_data->offload[port] && admin->cmd == TAPRIO_CMD_DESTROY))
                return -EINVAL;
 
-       if (!admin->enable) {
+       if (admin->cmd == TAPRIO_CMD_DESTROY) {
                taprio_offload_free(tas_data->offload[port]);
                tas_data->offload[port] = NULL;
 
                        return rc;
 
                return sja1105_static_config_reload(priv, SJA1105_SCHEDULING);
+       } else if (admin->cmd != TAPRIO_CMD_REPLACE) {
+               return -EOPNOTSUPP;
        }
 
        /* The cycle time extension is the amount of time the last cycle from
 
        int retval;
 
        memset(&qopt, 0, sizeof(qopt));
-       qopt.enable = 0;
+       qopt.cmd = TAPRIO_CMD_DESTROY;
        retval = tsnep_tc_setup(adapter->netdev, TC_SETUP_QDISC_TAPRIO, &qopt);
        if (retval)
                return false;
        for (i = 0; i < 255; i++)
                qopt->entries[i].command = TC_TAPRIO_CMD_SET_GATES;
 
-       qopt->enable = 1;
+       qopt->cmd = TAPRIO_CMD_REPLACE;
        qopt->base_time = ktime_set(0, 0);
        qopt->cycle_time = 1500000;
        qopt->cycle_time_extension = 0;
        if (!run_taprio(adapter, qopt, 100))
                goto failed;
 
-       qopt->enable = 1;
+       qopt->cmd = TAPRIO_CMD_REPLACE;
        qopt->base_time = ktime_set(0, 0);
        qopt->cycle_time = 411854;
        qopt->cycle_time_extension = 0;
        if (!run_taprio(adapter, qopt, 100))
                goto failed;
 
-       qopt->enable = 1;
+       qopt->cmd = TAPRIO_CMD_REPLACE;
        qopt->base_time = ktime_set(0, 0);
        delay_base_time(adapter, qopt, 12);
        qopt->cycle_time = 125000;
        for (i = 0; i < 255; i++)
                qopt->entries[i].command = TC_TAPRIO_CMD_SET_GATES;
 
-       qopt->enable = 1;
+       qopt->cmd = TAPRIO_CMD_REPLACE;
        qopt->base_time = ktime_set(0, 0);
        qopt->cycle_time = 100000;
        qopt->cycle_time_extension = 0;
        for (i = 0; i < 255; i++)
                qopt->entries[i].command = TC_TAPRIO_CMD_SET_GATES;
 
-       qopt->enable = 1;
+       qopt->cmd = TAPRIO_CMD_REPLACE;
        qopt->base_time = ktime_set(0, 0);
        qopt->cycle_time = 100000;
        qopt->cycle_time_extension = 50000;
 
        if (!adapter->gate_control)
                return -EOPNOTSUPP;
 
-       if (!qopt->enable) {
+       if (qopt->cmd == TAPRIO_CMD_DESTROY) {
                /* disable gate control if active */
                mutex_lock(&adapter->gate_control_lock);
 
                mutex_unlock(&adapter->gate_control_lock);
 
                return 0;
+       } else if (qopt->cmd != TAPRIO_CMD_REPLACE) {
+               return -EOPNOTSUPP;
        }
 
        retval = tsnep_validate_gcl(qopt);
 
        gcl_len = admin_conf->num_entries;
 
        tge = enetc_rd(hw, ENETC_PTGCR);
-       if (!admin_conf->enable) {
+       if (admin_conf->cmd == TAPRIO_CMD_DESTROY) {
                enetc_wr(hw, ENETC_PTGCR, tge & ~ENETC_PTGCR_TGE);
                enetc_reset_ptcmsdur(hw);
 
        struct enetc_ndev_priv *priv = netdev_priv(ndev);
        int err, i;
 
+       if (taprio->cmd != TAPRIO_CMD_REPLACE &&
+           taprio->cmd != TAPRIO_CMD_DESTROY)
+               return -EOPNOTSUPP;
+
        /* TSD and Qbv are mutually exclusive in hardware */
        for (i = 0; i < priv->num_tx_rings; i++)
                if (priv->tx_ring[i]->tsd_enable)
 
        size_t n;
        int i;
 
-       adapter->qbv_enable = qopt->enable;
+       switch (qopt->cmd) {
+       case TAPRIO_CMD_REPLACE:
+               adapter->qbv_enable = true;
+               break;
+       case TAPRIO_CMD_DESTROY:
+               adapter->qbv_enable = false;
+               break;
+       default:
+               return -EOPNOTSUPP;
+       }
 
-       if (!qopt->enable)
+       if (!adapter->qbv_enable)
                return igc_tsn_clear_schedule(adapter);
 
        if (qopt->base_time < 0)
 
 static int lan966x_tc_setup_qdisc_taprio(struct lan966x_port *port,
                                         struct tc_taprio_qopt_offload *taprio)
 {
-       return taprio->enable ? lan966x_taprio_add(port, taprio) :
-                               lan966x_taprio_del(port);
+       switch (taprio->cmd) {
+       case TAPRIO_CMD_REPLACE:
+               return lan966x_taprio_add(port, taprio);
+       case TAPRIO_CMD_DESTROY:
+               return lan966x_taprio_del(port);
+       default:
+               return -EOPNOTSUPP;
+       }
 }
 
 static int lan966x_tc_setup_qdisc_tbf(struct lan966x_port *port,
 
                return -EOPNOTSUPP;
        }
 
-       if (!qopt->enable)
+       if (qopt->cmd == TAPRIO_CMD_DESTROY)
                goto disable;
+       else if (qopt->cmd != TAPRIO_CMD_REPLACE)
+               return -EOPNOTSUPP;
+
        if (qopt->num_entries >= dep)
                return -EINVAL;
        if (!qopt->cycle_time)
 
        mutex_lock(&priv->plat->est->lock);
        priv->plat->est->gcl_size = size;
-       priv->plat->est->enable = qopt->enable;
+       priv->plat->est->enable = qopt->cmd == TAPRIO_CMD_REPLACE;
        mutex_unlock(&priv->plat->est->lock);
 
        for (i = 0; i < size; i++) {
 
 
        am65_cpsw_est_update_state(ndev);
 
-       if (!est_new->taprio.enable) {
+       if (est_new->taprio.cmd == TAPRIO_CMD_DESTROY) {
                am65_cpsw_stop_est(ndev);
                return ret;
        }
        am65_cpsw_est_set_sched_list(ndev, est_new);
        am65_cpsw_port_est_assign_buf_num(ndev, est_new->buf);
 
-       am65_cpsw_est_set(ndev, est_new->taprio.enable);
+       am65_cpsw_est_set(ndev, est_new->taprio.cmd == TAPRIO_CMD_REPLACE);
 
        if (tact == TACT_PROG) {
                ret = am65_cpsw_timer_set(ndev, est_new);
        am65_cpsw_cp_taprio(taprio, &est_new->taprio);
        ret = am65_cpsw_configure_taprio(ndev, est_new);
        if (!ret) {
-               if (taprio->enable) {
+               if (taprio->cmd == TAPRIO_CMD_REPLACE) {
                        devm_kfree(&ndev->dev, port->qos.est_admin);
 
                        port->qos.est_admin = est_new;
 static int am65_cpsw_setup_taprio(struct net_device *ndev, void *type_data)
 {
        struct am65_cpsw_port *port = am65_ndev_to_port(ndev);
+       struct tc_taprio_qopt_offload *taprio = type_data;
        struct am65_cpsw_common *common = port->common;
 
+       if (taprio->cmd != TAPRIO_CMD_REPLACE &&
+           taprio->cmd != TAPRIO_CMD_DESTROY)
+               return -EOPNOTSUPP;
+
        if (!IS_ENABLED(CONFIG_TI_AM65_CPSW_TAS))
                return -ENODEV;
 
 
        bool broken_mqprio:1;
 };
 
+enum tc_taprio_qopt_cmd {
+       TAPRIO_CMD_REPLACE,
+       TAPRIO_CMD_DESTROY,
+};
+
 struct tc_taprio_sched_entry {
        u8 command; /* TC_TAPRIO_CMD_* */
 
 struct tc_taprio_qopt_offload {
        struct tc_mqprio_qopt_offload mqprio;
        struct netlink_ext_ack *extack;
-       u8 enable;
+       enum tc_taprio_qopt_cmd cmd;
        ktime_t base_time;
        u64 cycle_time;
        u64 cycle_time_extension;
 
                               "Not enough memory for enabling offload mode");
                return -ENOMEM;
        }
-       offload->enable = 1;
+       offload->cmd = TAPRIO_CMD_REPLACE;
        offload->extack = extack;
        mqprio_qopt_reconstruct(dev, &offload->mqprio.qopt);
        offload->mqprio.extack = extack;
                               "Not enough memory to disable offload mode");
                return -ENOMEM;
        }
-       offload->enable = 0;
+       offload->cmd = TAPRIO_CMD_DESTROY;
 
        err = ops->ndo_setup_tc(dev, TC_SETUP_QDISC_TAPRIO, offload);
        if (err < 0) {