43             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in new()
58             // SAFETY: The `ptr` is guaranteed by the C code to be valid.  in table()
74             // SAFETY: The pointer was created via `dev_pm_opp_init_cpufreq_table`, and is only  in drop()
183         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in new()
195         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in drop()
321         // SAFETY: This is the same token value returned by the C code via `dev_pm_opp_set_config`.  in drop()
493             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in set()
514     /// SAFETY: Called from C. Inputs must be valid pointers.
523             // SAFETY: 'dev' is guaranteed by the C code to be valid.  in config_clks()
527                 // SAFETY: 'opp_table' is guaranteed by the C code to be valid.  in config_clks()
529                 // SAFETY: 'opp' is guaranteed by the C code to be valid.  in config_clks()
539     /// SAFETY: Called from C. Inputs must be valid pointers.
548             // SAFETY: 'dev' is guaranteed by the C code to be valid.  in config_regulators()
552                 // SAFETY: 'old_opp' is guaranteed by the C code to be valid.  in config_regulators()
554                 // SAFETY: 'new_opp' is guaranteed by the C code to be valid.  in config_regulators()
612 /// SAFETY: It is okay to send ownership of [`Table`] across thread boundaries.
615 /// SAFETY: It is okay to access [`Table`] through shared references from other threads because
622     /// # Safety
626         // SAFETY: By the safety requirements, ptr is valid and its refcount will be incremented.  in from_raw_table()
642         // SAFETY: The requirements are satisfied by the existence of the [`Device`] and its safety  in from_dev()
662         // SAFETY: The requirements are satisfied by the existence of the [`Device`] and its safety  in from_of()
680         // SAFETY: The requirements are satisfied by the existence of the [`Device`] and its safety  in remove_of()
690         // SAFETY: The cpumask is valid and the returned pointer will be owned by the [`Table`]  in from_of_cpumask()
708         // SAFETY: The cpumask is valid and we took the reference from [`from_of_cpumask`] earlier,  in remove_of_cpumask()
715         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_count()
725         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in max_clock_latency_ns()
733         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in max_volt_latency_ns()
741         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in max_transition_latency_ns()
749         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in suspend_freq()
757         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in sync_regulators()
765         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in sharing_cpus()
772         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in set_sharing_cpus()
790         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in of_sharing_cpus()
806         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in adjust_voltage()
829         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in set_rate()
837         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in set_opp()
857                     // SAFETY: The requirements are satisfied by the existence of [`Device`] and  in opp_from_freq()
858                     // its safety requirements. The returned pointer will be owned by the new  in opp_from_freq()
870             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_freq()
876             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_freq()
883         // SAFETY: The `ptr` is guaranteed by the C code to be valid.  in opp_from_freq()
892             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_level()
896             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_level()
902             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_level()
909         // SAFETY: The `ptr` is guaranteed by the C code to be valid.  in opp_from_level()
921             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_bw()
927             // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in opp_from_bw()
934         // SAFETY: The `ptr` is guaranteed by the C code to be valid.  in opp_from_bw()
941         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in enable_opp()
949         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in disable_opp()
957         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in of_register_em()
971         // SAFETY: The requirements are satisfied by the existence of [`Device`] and its safety  in of_unregister_em()
979         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe  in drop()
1036 /// SAFETY: It is okay to send the ownership of [`OPP`] across thread boundaries.
1039 /// SAFETY: It is okay to access [`OPP`] through shared references from other threads because we're
1043 /// SAFETY: The type invariants guarantee that [`OPP`] is always refcounted.
1046         // SAFETY: The existence of a shared reference means that the refcount is nonzero.  in inc_ref()
1051         // SAFETY: The safety requirements guarantee that the refcount is nonzero.  in dec_ref()
1062     /// # Safety
1071         // SAFETY: The safety requirements guarantee the validity of the pointer.  in from_raw_opp_owned()
1082     /// # Safety
1087         // SAFETY: The caller guarantees that the pointer is not dangling and stays valid for the  in from_raw_opp()
1101         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe to  in freq()
1109         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe to  in voltage()
1117         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe to  in level()
1125         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe to  in power()
1133         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe to  in required_pstate()
1141         // SAFETY: By the type invariants, we know that `self` owns a reference, so it is safe to  in is_turbo()