struct dsa_switch *ds;
        struct b53_device *dev;
 
-       ds = dsa_switch_alloc(base, DSA_MAX_PORTS);
+       ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
        if (!ds)
                return NULL;
 
+       ds->dev = base;
+       ds->num_ports = DSA_MAX_PORTS;
+
        dev = devm_kzalloc(base, sizeof(*dev), GFP_KERNEL);
        if (!dev)
                return NULL;
 
        dev_info(&mdiodev->dev, "%s: 0x%0x\n",
                 pdata->name, pdata->enabled_ports);
 
-       ds = dsa_switch_alloc(&mdiodev->dev, DSA_MAX_PORTS);
+       ds = devm_kzalloc(&mdiodev->dev, sizeof(*ds), GFP_KERNEL);
        if (!ds)
                return -ENOMEM;
 
+       ds->dev = &mdiodev->dev;
+       ds->num_ports = DSA_MAX_PORTS;
+
        ps = devm_kzalloc(&mdiodev->dev, sizeof(*ps), GFP_KERNEL);
        if (!ps)
                return -ENOMEM;
 
 {
        int base;
 
-       chip->ds = dsa_switch_alloc(chip->dev, LAN9303_NUM_PORTS);
+       chip->ds = devm_kzalloc(chip->dev, sizeof(*chip->ds), GFP_KERNEL);
        if (!chip->ds)
                return -ENOMEM;
 
+       chip->ds->dev = chip->dev;
+       chip->ds->num_ports = LAN9303_NUM_PORTS;
        chip->ds->priv = chip;
        chip->ds->ops = &lan9303_switch_ops;
        base = chip->phy_addr_base;
 
        if (!priv->hw_info)
                return -EINVAL;
 
-       priv->ds = dsa_switch_alloc(dev, priv->hw_info->max_ports);
+       priv->ds = devm_kzalloc(dev, sizeof(*priv->ds), GFP_KERNEL);
        if (!priv->ds)
                return -ENOMEM;
 
+       priv->ds->dev = dev;
+       priv->ds->num_ports = priv->hw_info->max_ports;
        priv->ds->priv = priv;
        priv->ds->ops = &gswip_switch_ops;
        priv->dev = dev;
 
        struct dsa_switch *ds;
        struct ksz_device *swdev;
 
-       ds = dsa_switch_alloc(base, DSA_MAX_PORTS);
+       ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
        if (!ds)
                return NULL;
 
+       ds->dev = base;
+       ds->num_ports = DSA_MAX_PORTS;
+
        swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
        if (!swdev)
                return NULL;
 
        if (!priv)
                return -ENOMEM;
 
-       priv->ds = dsa_switch_alloc(&mdiodev->dev, DSA_MAX_PORTS);
+       priv->ds = devm_kzalloc(&mdiodev->dev, sizeof(*priv->ds), GFP_KERNEL);
        if (!priv->ds)
                return -ENOMEM;
 
+       priv->ds->dev = &mdiodev->dev;
+       priv->ds->num_ports = DSA_MAX_PORTS;
+
        /* Use medatek,mcm property to distinguish hardware type that would
         * casues a little bit differences on power-on sequence.
         */
 
 
        dev_info(dev, "switch %s detected\n", name);
 
-       ds = dsa_switch_alloc(dev, MV88E6060_PORTS);
+       ds = devm_kzalloc(dev, sizeof(*ds), GFP_KERNEL);
        if (!ds)
                return -ENOMEM;
 
+       ds->dev = dev;
+       ds->num_ports = MV88E6060_PORTS;
        ds->priv = priv;
        ds->dev = dev;
        ds->ops = &mv88e6060_switch_ops;
 
        struct device *dev = chip->dev;
        struct dsa_switch *ds;
 
-       ds = dsa_switch_alloc(dev, mv88e6xxx_num_ports(chip));
+       ds = devm_kzalloc(dev, sizeof(*ds), GFP_KERNEL);
        if (!ds)
                return -ENOMEM;
 
+       ds->dev = dev;
+       ds->num_ports = mv88e6xxx_num_ports(chip);
        ds->priv = chip;
        ds->dev = dev;
        ds->ops = &mv88e6xxx_switch_ops;
 
        if (id != QCA8K_ID_QCA8337)
                return -ENODEV;
 
-       priv->ds = dsa_switch_alloc(&mdiodev->dev, QCA8K_NUM_PORTS);
+       priv->ds = devm_kzalloc(&mdiodev->dev, sizeof(*priv->ds),
+                               QCA8K_NUM_PORTS);
        if (!priv->ds)
                return -ENOMEM;
 
+       priv->ds->dev = &mdiodev->dev;
+       priv->ds->num_ports = DSA_MAX_PORTS;
        priv->ds->priv = priv;
        priv->ops = qca8k_switch_ops;
        priv->ds->ops = &priv->ops;
 
                return ret;
        }
 
-       smi->ds = dsa_switch_alloc(dev, smi->num_ports);
+       smi->ds = devm_kzalloc(dev, sizeof(*smi->ds), GFP_KERNEL);
        if (!smi->ds)
                return -ENOMEM;
+
+       smi->ds->dev = dev;
+       smi->ds->num_ports = smi->num_ports;
        smi->ds->priv = smi;
 
        smi->ds->ops = var->ds_ops;
 
 
        dev_info(dev, "Probed switch chip: %s\n", priv->info->name);
 
-       ds = dsa_switch_alloc(dev, SJA1105_NUM_PORTS);
+       ds = devm_kzalloc(dev, sizeof(*ds), GFP_KERNEL);
        if (!ds)
                return -ENOMEM;
 
+       ds->dev = dev;
+       ds->num_ports = SJA1105_NUM_PORTS;
        ds->ops = &sja1105_switch_ops;
        ds->priv = priv;
        priv->ds = ds;
 
         * We allocate 8 ports and avoid access to the nonexistant
         * ports.
         */
-       vsc->ds = dsa_switch_alloc(dev, 8);
+       vsc->ds = devm_kzalloc(dev, sizeof(*vsc->ds), GFP_KERNEL);
        if (!vsc->ds)
                return -ENOMEM;
+
+       vsc->ds->dev = dev;
+       vsc->ds->num_ports = 8;
        vsc->ds->priv = vsc;
 
        vsc->ds->ops = &vsc73xx_ds_ops;
 
        return false;
 }
 
-struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n);
 void dsa_unregister_switch(struct dsa_switch *ds);
 int dsa_register_switch(struct dsa_switch *ds);
 #ifdef CONFIG_PM_SLEEP
 
        struct device_node *np = ds->dev->of_node;
        int err;
 
+       if (!ds->dev)
+               return -ENODEV;
+
+       if (!ds->num_ports)
+               return -EINVAL;
+
        if (np)
                err = dsa_switch_parse_of(ds, np);
        else if (pdata)
        return dsa_switch_add(ds);
 }
 
-struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
-{
-       struct dsa_switch *ds;
-
-       ds = devm_kzalloc(dev, sizeof(*ds), GFP_KERNEL);
-       if (!ds)
-               return NULL;
-
-       ds->dev = dev;
-       ds->num_ports = n;
-
-       return ds;
-}
-EXPORT_SYMBOL_GPL(dsa_switch_alloc);
-
 int dsa_register_switch(struct dsa_switch *ds)
 {
        int err;