}
 EXPORT_SYMBOL_GPL(platform_profile_cycle);
 
-int platform_profile_register(struct platform_profile_handler *pprof)
+int platform_profile_register(struct platform_profile_handler *pprof, void *drvdata)
 {
        int err;
 
 
        pprof->class_dev.class = &platform_profile_class;
        pprof->class_dev.parent = pprof->dev;
+       dev_set_drvdata(&pprof->class_dev, drvdata);
        dev_set_name(&pprof->class_dev, "platform-profile-%d", pprof->minor);
        err = device_register(&pprof->class_dev);
        if (err) {
        platform_profile_remove(*pprof);
 }
 
-int devm_platform_profile_register(struct platform_profile_handler *pprof)
+int devm_platform_profile_register(struct platform_profile_handler *pprof, void *drvdata)
 {
        struct platform_profile_handler **dr;
        int ret;
        if (!dr)
                return -ENOMEM;
 
-       ret = platform_profile_register(pprof);
+       ret = platform_profile_register(pprof, drvdata);
        if (ret) {
                devres_free(dr);
                return ret;
 
        enum ssam_tmp_profile tp;
        int status;
 
-       tpd = container_of(pprof, struct ssam_platform_profile_device, handler);
+       tpd = dev_get_drvdata(&pprof->class_dev);
 
        status = ssam_tmp_profile_get(tpd->sdev, &tp);
        if (status)
        struct ssam_platform_profile_device *tpd;
        int tp;
 
-       tpd = container_of(pprof, struct ssam_platform_profile_device, handler);
+       tpd = dev_get_drvdata(&pprof->class_dev);
 
        tp = convert_profile_to_ssam_tmp(tpd->sdev, profile);
        if (tp < 0)
        set_bit(PLATFORM_PROFILE_BALANCED_PERFORMANCE, tpd->handler.choices);
        set_bit(PLATFORM_PROFILE_PERFORMANCE, tpd->handler.choices);
 
-       return platform_profile_register(&tpd->handler);
+       return platform_profile_register(&tpd->handler, tpd);
 }
 
 static void surface_platform_profile_remove(struct ssam_device *sdev)
 
                                ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO;
                }
 
-               err = platform_profile_register(&platform_profile_handler);
+               err = platform_profile_register(&platform_profile_handler, NULL);
                if (err)
                        return err;
 
 
 static int amd_pmf_profile_get(struct platform_profile_handler *pprof,
                               enum platform_profile_option *profile)
 {
-       struct amd_pmf_dev *pmf = container_of(pprof, struct amd_pmf_dev, pprof);
+       struct amd_pmf_dev *pmf = dev_get_drvdata(&pprof->class_dev);
 
        *profile = pmf->current_profile;
        return 0;
 static int amd_pmf_profile_set(struct platform_profile_handler *pprof,
                               enum platform_profile_option profile)
 {
-       struct amd_pmf_dev *pmf = container_of(pprof, struct amd_pmf_dev, pprof);
+       struct amd_pmf_dev *pmf = dev_get_drvdata(&pprof->class_dev);
        int ret = 0;
 
        pmf->current_profile = profile;
        set_bit(PLATFORM_PROFILE_PERFORMANCE, dev->pprof.choices);
 
        /* Create platform_profile structure and register */
-       err = platform_profile_register(&dev->pprof);
+       err = platform_profile_register(&dev->pprof, dev);
        if (err)
                dev_err(dev->dev, "Failed to register SPS support, this is most likely an SBIOS bug: %d\n",
                        err);
 
        struct asus_wmi *asus;
        int tp;
 
-       asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
+       asus = dev_get_drvdata(&pprof->class_dev);
        tp = asus->throttle_thermal_policy_mode;
 
        switch (tp) {
        struct asus_wmi *asus;
        int tp;
 
-       asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
+       asus = dev_get_drvdata(&pprof->class_dev);
 
        switch (profile) {
        case PLATFORM_PROFILE_PERFORMANCE:
        set_bit(PLATFORM_PROFILE_PERFORMANCE,
                asus->platform_profile_handler.choices);
 
-       err = platform_profile_register(&asus->platform_profile_handler);
+       err = platform_profile_register(&asus->platform_profile_handler, asus);
        if (err == -EEXIST) {
                pr_warn("%s, a platform_profile handler is already registered\n", __func__);
                return 0;
 
        pp_handler.name = "alienware-wmi";
        pp_handler.dev = &platform_device->dev;
 
-       return devm_platform_profile_register(&pp_handler);
+       return devm_platform_profile_register(&pp_handler, NULL);
 }
 
 /*
 
                set_bit(PLATFORM_PROFILE_PERFORMANCE, thermal_handler->choices);
 
        /* Clean up if failed */
-       ret = platform_profile_register(thermal_handler);
+       ret = platform_profile_register(thermal_handler, NULL);
        if (ret)
                goto cleanup_thermal_handler;
 
 
        set_bit(PLATFORM_PROFILE_BALANCED, platform_profile_handler.choices);
        set_bit(PLATFORM_PROFILE_PERFORMANCE, platform_profile_handler.choices);
 
-       err = platform_profile_register(&platform_profile_handler);
+       err = platform_profile_register(&platform_profile_handler, NULL);
        if (err)
                return err;
 
 
 static int dytc_profile_get(struct platform_profile_handler *pprof,
                            enum platform_profile_option *profile)
 {
-       struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof);
+       struct ideapad_dytc_priv *dytc = dev_get_drvdata(&pprof->class_dev);
 
        *profile = dytc->current_profile;
        return 0;
 static int dytc_profile_set(struct platform_profile_handler *pprof,
                            enum platform_profile_option profile)
 {
-       struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof);
+       struct ideapad_dytc_priv *dytc = dev_get_drvdata(&pprof->class_dev);
        struct ideapad_private *priv = dytc->priv;
        unsigned long output;
        int err;
        set_bit(PLATFORM_PROFILE_PERFORMANCE, priv->dytc->pprof.choices);
 
        /* Create platform_profile structure and register */
-       err = platform_profile_register(&priv->dytc->pprof);
+       err = platform_profile_register(&priv->dytc->pprof, &priv->dytc);
        if (err)
                goto pp_reg_failed;
 
 
 static int inspur_platform_profile_set(struct platform_profile_handler *pprof,
                                       enum platform_profile_option profile)
 {
-       struct inspur_wmi_priv *priv = container_of(pprof, struct inspur_wmi_priv,
-                                                   handler);
+       struct inspur_wmi_priv *priv = dev_get_drvdata(&pprof->class_dev);
        u8 ret_code[4] = {0, 0, 0, 0};
        int ret;
 
 static int inspur_platform_profile_get(struct platform_profile_handler *pprof,
                                       enum platform_profile_option *profile)
 {
-       struct inspur_wmi_priv *priv = container_of(pprof, struct inspur_wmi_priv,
-                                                   handler);
+       struct inspur_wmi_priv *priv = dev_get_drvdata(&pprof->class_dev);
        u8 ret_code[4] = {0, 0, 0, 0};
        int ret;
 
        set_bit(PLATFORM_PROFILE_BALANCED, priv->handler.choices);
        set_bit(PLATFORM_PROFILE_PERFORMANCE, priv->handler.choices);
 
-       return platform_profile_register(&priv->handler);
+       return platform_profile_register(&priv->handler, priv);
 }
 
 static void inspur_wmi_remove(struct wmi_device *wdev)
 
 
        dytc_profile.dev = &tpacpi_pdev->dev;
        /* Create platform_profile structure and register */
-       err = platform_profile_register(&dytc_profile);
+       err = platform_profile_register(&dytc_profile, NULL);
        /*
         * If for some reason platform_profiles aren't enabled
         * don't quit terminally.
 
                                enum platform_profile_option profile);
 };
 
-int platform_profile_register(struct platform_profile_handler *pprof);
+int platform_profile_register(struct platform_profile_handler *pprof, void *drvdata);
 int platform_profile_remove(struct platform_profile_handler *pprof);
-int devm_platform_profile_register(struct platform_profile_handler *pprof);
+int devm_platform_profile_register(struct platform_profile_handler *pprof, void *drvdata);
 int platform_profile_cycle(void);
 void platform_profile_notify(struct platform_profile_handler *pprof);