1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 2
3 // Copyright (C) 2023 FUJITA Tomonori <fujita.t 3 // Copyright (C) 2023 FUJITA Tomonori <fujita.tomonori@gmail.com>
4 4
5 //! Network PHY device. 5 //! Network PHY device.
6 //! 6 //!
7 //! C headers: [`include/linux/phy.h`](srctree 7 //! C headers: [`include/linux/phy.h`](srctree/include/linux/phy.h).
8 8
9 use crate::{error::*, prelude::*, types::Opaqu 9 use crate::{error::*, prelude::*, types::Opaque};
10 use core::{marker::PhantomData, ptr::addr_of_m 10 use core::{marker::PhantomData, ptr::addr_of_mut};
11 11
12 pub mod reg; 12 pub mod reg;
13 13
14 /// PHY state machine states. 14 /// PHY state machine states.
15 /// 15 ///
16 /// Corresponds to the kernel's [`enum phy_sta 16 /// Corresponds to the kernel's [`enum phy_state`].
17 /// 17 ///
18 /// Some of PHY drivers access to the state of 18 /// Some of PHY drivers access to the state of PHY's software state machine.
19 /// 19 ///
20 /// [`enum phy_state`]: srctree/include/linux/ 20 /// [`enum phy_state`]: srctree/include/linux/phy.h
21 #[derive(PartialEq, Eq)] 21 #[derive(PartialEq, Eq)]
22 pub enum DeviceState { 22 pub enum DeviceState {
23 /// PHY device and driver are not ready fo 23 /// PHY device and driver are not ready for anything.
24 Down, 24 Down,
25 /// PHY is ready to send and receive packe 25 /// PHY is ready to send and receive packets.
26 Ready, 26 Ready,
27 /// PHY is up, but no polling or interrupt 27 /// PHY is up, but no polling or interrupts are done.
28 Halted, 28 Halted,
29 /// PHY is up, but is in an error state. 29 /// PHY is up, but is in an error state.
30 Error, 30 Error,
31 /// PHY and attached device are ready to d 31 /// PHY and attached device are ready to do work.
32 Up, 32 Up,
33 /// PHY is currently running. 33 /// PHY is currently running.
34 Running, 34 Running,
35 /// PHY is up, but not currently plugged i 35 /// PHY is up, but not currently plugged in.
36 NoLink, 36 NoLink,
37 /// PHY is performing a cable test. 37 /// PHY is performing a cable test.
38 CableTest, 38 CableTest,
39 } 39 }
40 40
41 /// A mode of Ethernet communication. 41 /// A mode of Ethernet communication.
42 /// 42 ///
43 /// PHY drivers get duplex information from ha 43 /// PHY drivers get duplex information from hardware and update the current state.
44 pub enum DuplexMode { 44 pub enum DuplexMode {
45 /// PHY is in full-duplex mode. 45 /// PHY is in full-duplex mode.
46 Full, 46 Full,
47 /// PHY is in half-duplex mode. 47 /// PHY is in half-duplex mode.
48 Half, 48 Half,
49 /// PHY is in unknown duplex mode. 49 /// PHY is in unknown duplex mode.
50 Unknown, 50 Unknown,
51 } 51 }
52 52
53 /// An instance of a PHY device. 53 /// An instance of a PHY device.
54 /// 54 ///
55 /// Wraps the kernel's [`struct phy_device`]. 55 /// Wraps the kernel's [`struct phy_device`].
56 /// 56 ///
57 /// A [`Device`] instance is created when a ca 57 /// A [`Device`] instance is created when a callback in [`Driver`] is executed. A PHY driver
58 /// executes [`Driver`]'s methods during the c 58 /// executes [`Driver`]'s methods during the callback.
59 /// 59 ///
60 /// # Invariants 60 /// # Invariants
61 /// 61 ///
62 /// - Referencing a `phy_device` using this st 62 /// - Referencing a `phy_device` using this struct asserts that you are in
63 /// a context where all methods defined on t 63 /// a context where all methods defined on this struct are safe to call.
64 /// - This struct always has a valid `self.0.m 64 /// - This struct always has a valid `self.0.mdio.dev`.
65 /// 65 ///
66 /// [`struct phy_device`]: srctree/include/lin 66 /// [`struct phy_device`]: srctree/include/linux/phy.h
67 // During the calls to most functions in [`Dri 67 // During the calls to most functions in [`Driver`], the C side (`PHYLIB`) holds a lock that is
68 // unique for every instance of [`Device`]. `P 68 // unique for every instance of [`Device`]. `PHYLIB` uses a different serialization technique for
69 // [`Driver::resume`] and [`Driver::suspend`]: 69 // [`Driver::resume`] and [`Driver::suspend`]: `PHYLIB` updates `phy_device`'s state with
70 // the lock held, thus guaranteeing that [`Dri 70 // the lock held, thus guaranteeing that [`Driver::resume`] has exclusive access to the instance.
71 // [`Driver::resume`] and [`Driver::suspend`] 71 // [`Driver::resume`] and [`Driver::suspend`] also are called where only one thread can access
72 // to the instance. 72 // to the instance.
73 #[repr(transparent)] 73 #[repr(transparent)]
74 pub struct Device(Opaque<bindings::phy_device> 74 pub struct Device(Opaque<bindings::phy_device>);
75 75
76 impl Device { 76 impl Device {
77 /// Creates a new [`Device`] instance from 77 /// Creates a new [`Device`] instance from a raw pointer.
78 /// 78 ///
79 /// # Safety 79 /// # Safety
80 /// 80 ///
81 /// For the duration of `'a`, 81 /// For the duration of `'a`,
82 /// - the pointer must point at a valid `p 82 /// - the pointer must point at a valid `phy_device`, and the caller
83 /// must be in a context where all metho 83 /// must be in a context where all methods defined on this struct
84 /// are safe to call. 84 /// are safe to call.
85 /// - `(*ptr).mdio.dev` must be a valid. 85 /// - `(*ptr).mdio.dev` must be a valid.
86 unsafe fn from_raw<'a>(ptr: *mut bindings: 86 unsafe fn from_raw<'a>(ptr: *mut bindings::phy_device) -> &'a mut Self {
87 // CAST: `Self` is a `repr(transparent 87 // CAST: `Self` is a `repr(transparent)` wrapper around `bindings::phy_device`.
88 let ptr = ptr.cast::<Self>(); 88 let ptr = ptr.cast::<Self>();
89 // SAFETY: by the function requirement 89 // SAFETY: by the function requirements the pointer is valid and we have unique access for
90 // the duration of `'a`. 90 // the duration of `'a`.
91 unsafe { &mut *ptr } 91 unsafe { &mut *ptr }
92 } 92 }
93 93
94 /// Gets the id of the PHY. 94 /// Gets the id of the PHY.
95 pub fn phy_id(&self) -> u32 { 95 pub fn phy_id(&self) -> u32 {
96 let phydev = self.0.get(); 96 let phydev = self.0.get();
97 // SAFETY: The struct invariant ensure 97 // SAFETY: The struct invariant ensures that we may access
98 // this field without additional synch 98 // this field without additional synchronization.
99 unsafe { (*phydev).phy_id } 99 unsafe { (*phydev).phy_id }
100 } 100 }
101 101
102 /// Gets the state of PHY state machine st 102 /// Gets the state of PHY state machine states.
103 pub fn state(&self) -> DeviceState { 103 pub fn state(&self) -> DeviceState {
104 let phydev = self.0.get(); 104 let phydev = self.0.get();
105 // SAFETY: The struct invariant ensure 105 // SAFETY: The struct invariant ensures that we may access
106 // this field without additional synch 106 // this field without additional synchronization.
107 let state = unsafe { (*phydev).state } 107 let state = unsafe { (*phydev).state };
108 // TODO: this conversion code will be 108 // TODO: this conversion code will be replaced with automatically generated code by bindgen
109 // when it becomes possible. 109 // when it becomes possible.
110 match state { 110 match state {
111 bindings::phy_state_PHY_DOWN => De 111 bindings::phy_state_PHY_DOWN => DeviceState::Down,
112 bindings::phy_state_PHY_READY => D 112 bindings::phy_state_PHY_READY => DeviceState::Ready,
113 bindings::phy_state_PHY_HALTED => 113 bindings::phy_state_PHY_HALTED => DeviceState::Halted,
114 bindings::phy_state_PHY_ERROR => D 114 bindings::phy_state_PHY_ERROR => DeviceState::Error,
115 bindings::phy_state_PHY_UP => Devi 115 bindings::phy_state_PHY_UP => DeviceState::Up,
116 bindings::phy_state_PHY_RUNNING => 116 bindings::phy_state_PHY_RUNNING => DeviceState::Running,
117 bindings::phy_state_PHY_NOLINK => 117 bindings::phy_state_PHY_NOLINK => DeviceState::NoLink,
118 bindings::phy_state_PHY_CABLETEST 118 bindings::phy_state_PHY_CABLETEST => DeviceState::CableTest,
119 _ => DeviceState::Error, 119 _ => DeviceState::Error,
120 } 120 }
121 } 121 }
122 122
123 /// Gets the current link state. 123 /// Gets the current link state.
124 /// 124 ///
125 /// It returns true if the link is up. 125 /// It returns true if the link is up.
126 pub fn is_link_up(&self) -> bool { 126 pub fn is_link_up(&self) -> bool {
127 const LINK_IS_UP: u64 = 1; 127 const LINK_IS_UP: u64 = 1;
128 // TODO: the code to access to the bit 128 // TODO: the code to access to the bit field will be replaced with automatically
129 // generated code by bindgen when it b 129 // generated code by bindgen when it becomes possible.
130 // SAFETY: The struct invariant ensure 130 // SAFETY: The struct invariant ensures that we may access
131 // this field without additional synch 131 // this field without additional synchronization.
132 let bit_field = unsafe { &(*self.0.get 132 let bit_field = unsafe { &(*self.0.get())._bitfield_1 };
133 bit_field.get(14, 1) == LINK_IS_UP 133 bit_field.get(14, 1) == LINK_IS_UP
134 } 134 }
135 135
136 /// Gets the current auto-negotiation conf 136 /// Gets the current auto-negotiation configuration.
137 /// 137 ///
138 /// It returns true if auto-negotiation is 138 /// It returns true if auto-negotiation is enabled.
139 pub fn is_autoneg_enabled(&self) -> bool { 139 pub fn is_autoneg_enabled(&self) -> bool {
140 // TODO: the code to access to the bit 140 // TODO: the code to access to the bit field will be replaced with automatically
141 // generated code by bindgen when it b 141 // generated code by bindgen when it becomes possible.
142 // SAFETY: The struct invariant ensure 142 // SAFETY: The struct invariant ensures that we may access
143 // this field without additional synch 143 // this field without additional synchronization.
144 let bit_field = unsafe { &(*self.0.get 144 let bit_field = unsafe { &(*self.0.get())._bitfield_1 };
145 bit_field.get(13, 1) == bindings::AUTO 145 bit_field.get(13, 1) == bindings::AUTONEG_ENABLE as u64
146 } 146 }
147 147
148 /// Gets the current auto-negotiation stat 148 /// Gets the current auto-negotiation state.
149 /// 149 ///
150 /// It returns true if auto-negotiation is 150 /// It returns true if auto-negotiation is completed.
151 pub fn is_autoneg_completed(&self) -> bool 151 pub fn is_autoneg_completed(&self) -> bool {
152 const AUTONEG_COMPLETED: u64 = 1; 152 const AUTONEG_COMPLETED: u64 = 1;
153 // TODO: the code to access to the bit 153 // TODO: the code to access to the bit field will be replaced with automatically
154 // generated code by bindgen when it b 154 // generated code by bindgen when it becomes possible.
155 // SAFETY: The struct invariant ensure 155 // SAFETY: The struct invariant ensures that we may access
156 // this field without additional synch 156 // this field without additional synchronization.
157 let bit_field = unsafe { &(*self.0.get 157 let bit_field = unsafe { &(*self.0.get())._bitfield_1 };
158 bit_field.get(15, 1) == AUTONEG_COMPLE 158 bit_field.get(15, 1) == AUTONEG_COMPLETED
159 } 159 }
160 160
161 /// Sets the speed of the PHY. 161 /// Sets the speed of the PHY.
162 pub fn set_speed(&mut self, speed: u32) { 162 pub fn set_speed(&mut self, speed: u32) {
163 let phydev = self.0.get(); 163 let phydev = self.0.get();
164 // SAFETY: The struct invariant ensure 164 // SAFETY: The struct invariant ensures that we may access
165 // this field without additional synch 165 // this field without additional synchronization.
166 unsafe { (*phydev).speed = speed as i3 166 unsafe { (*phydev).speed = speed as i32 };
167 } 167 }
168 168
169 /// Sets duplex mode. 169 /// Sets duplex mode.
170 pub fn set_duplex(&mut self, mode: DuplexM 170 pub fn set_duplex(&mut self, mode: DuplexMode) {
171 let phydev = self.0.get(); 171 let phydev = self.0.get();
172 let v = match mode { 172 let v = match mode {
173 DuplexMode::Full => bindings::DUPL 173 DuplexMode::Full => bindings::DUPLEX_FULL as i32,
174 DuplexMode::Half => bindings::DUPL 174 DuplexMode::Half => bindings::DUPLEX_HALF as i32,
175 DuplexMode::Unknown => bindings::D 175 DuplexMode::Unknown => bindings::DUPLEX_UNKNOWN as i32,
176 }; 176 };
177 // SAFETY: The struct invariant ensure 177 // SAFETY: The struct invariant ensures that we may access
178 // this field without additional synch 178 // this field without additional synchronization.
179 unsafe { (*phydev).duplex = v }; 179 unsafe { (*phydev).duplex = v };
180 } 180 }
181 181
182 /// Reads a PHY register. 182 /// Reads a PHY register.
183 // This function reads a hardware register 183 // This function reads a hardware register and updates the stats so takes `&mut self`.
184 pub fn read<R: reg::Register>(&mut self, r 184 pub fn read<R: reg::Register>(&mut self, reg: R) -> Result<u16> {
185 reg.read(self) 185 reg.read(self)
186 } 186 }
187 187
188 /// Writes a PHY register. 188 /// Writes a PHY register.
189 pub fn write<R: reg::Register>(&mut self, 189 pub fn write<R: reg::Register>(&mut self, reg: R, val: u16) -> Result {
190 reg.write(self, val) 190 reg.write(self, val)
191 } 191 }
192 192
193 /// Reads a paged register. 193 /// Reads a paged register.
194 pub fn read_paged(&mut self, page: u16, re 194 pub fn read_paged(&mut self, page: u16, regnum: u16) -> Result<u16> {
195 let phydev = self.0.get(); 195 let phydev = self.0.get();
196 // SAFETY: `phydev` is pointing to a v 196 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
197 // So it's just an FFI call. 197 // So it's just an FFI call.
198 let ret = unsafe { bindings::phy_read_ 198 let ret = unsafe { bindings::phy_read_paged(phydev, page.into(), regnum.into()) };
199 if ret < 0 { 199 if ret < 0 {
200 Err(Error::from_errno(ret)) 200 Err(Error::from_errno(ret))
201 } else { 201 } else {
202 Ok(ret as u16) 202 Ok(ret as u16)
203 } 203 }
204 } 204 }
205 205
206 /// Resolves the advertisements into PHY s 206 /// Resolves the advertisements into PHY settings.
207 pub fn resolve_aneg_linkmode(&mut self) { 207 pub fn resolve_aneg_linkmode(&mut self) {
208 let phydev = self.0.get(); 208 let phydev = self.0.get();
209 // SAFETY: `phydev` is pointing to a v 209 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
210 // So it's just an FFI call. 210 // So it's just an FFI call.
211 unsafe { bindings::phy_resolve_aneg_li 211 unsafe { bindings::phy_resolve_aneg_linkmode(phydev) };
212 } 212 }
213 213
214 /// Executes software reset the PHY via `B 214 /// Executes software reset the PHY via `BMCR_RESET` bit.
215 pub fn genphy_soft_reset(&mut self) -> Res 215 pub fn genphy_soft_reset(&mut self) -> Result {
216 let phydev = self.0.get(); 216 let phydev = self.0.get();
217 // SAFETY: `phydev` is pointing to a v 217 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
218 // So it's just an FFI call. 218 // So it's just an FFI call.
219 to_result(unsafe { bindings::genphy_so 219 to_result(unsafe { bindings::genphy_soft_reset(phydev) })
220 } 220 }
221 221
222 /// Initializes the PHY. 222 /// Initializes the PHY.
223 pub fn init_hw(&mut self) -> Result { 223 pub fn init_hw(&mut self) -> Result {
224 let phydev = self.0.get(); 224 let phydev = self.0.get();
225 // SAFETY: `phydev` is pointing to a v 225 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
226 // So it's just an FFI call. 226 // So it's just an FFI call.
227 to_result(unsafe { bindings::phy_init_ 227 to_result(unsafe { bindings::phy_init_hw(phydev) })
228 } 228 }
229 229
230 /// Starts auto-negotiation. 230 /// Starts auto-negotiation.
231 pub fn start_aneg(&mut self) -> Result { 231 pub fn start_aneg(&mut self) -> Result {
232 let phydev = self.0.get(); 232 let phydev = self.0.get();
233 // SAFETY: `phydev` is pointing to a v 233 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
234 // So it's just an FFI call. 234 // So it's just an FFI call.
235 to_result(unsafe { bindings::_phy_star 235 to_result(unsafe { bindings::_phy_start_aneg(phydev) })
236 } 236 }
237 237
238 /// Resumes the PHY via `BMCR_PDOWN` bit. 238 /// Resumes the PHY via `BMCR_PDOWN` bit.
239 pub fn genphy_resume(&mut self) -> Result 239 pub fn genphy_resume(&mut self) -> Result {
240 let phydev = self.0.get(); 240 let phydev = self.0.get();
241 // SAFETY: `phydev` is pointing to a v 241 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
242 // So it's just an FFI call. 242 // So it's just an FFI call.
243 to_result(unsafe { bindings::genphy_re 243 to_result(unsafe { bindings::genphy_resume(phydev) })
244 } 244 }
245 245
246 /// Suspends the PHY via `BMCR_PDOWN` bit. 246 /// Suspends the PHY via `BMCR_PDOWN` bit.
247 pub fn genphy_suspend(&mut self) -> Result 247 pub fn genphy_suspend(&mut self) -> Result {
248 let phydev = self.0.get(); 248 let phydev = self.0.get();
249 // SAFETY: `phydev` is pointing to a v 249 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
250 // So it's just an FFI call. 250 // So it's just an FFI call.
251 to_result(unsafe { bindings::genphy_su 251 to_result(unsafe { bindings::genphy_suspend(phydev) })
252 } 252 }
253 253
254 /// Checks the link status and updates cur 254 /// Checks the link status and updates current link state.
255 pub fn genphy_read_status<R: reg::Register 255 pub fn genphy_read_status<R: reg::Register>(&mut self) -> Result<u16> {
256 R::read_status(self) 256 R::read_status(self)
257 } 257 }
258 258
259 /// Updates the link status. 259 /// Updates the link status.
260 pub fn genphy_update_link(&mut self) -> Re 260 pub fn genphy_update_link(&mut self) -> Result {
261 let phydev = self.0.get(); 261 let phydev = self.0.get();
262 // SAFETY: `phydev` is pointing to a v 262 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
263 // So it's just an FFI call. 263 // So it's just an FFI call.
264 to_result(unsafe { bindings::genphy_up 264 to_result(unsafe { bindings::genphy_update_link(phydev) })
265 } 265 }
266 266
267 /// Reads link partner ability. 267 /// Reads link partner ability.
268 pub fn genphy_read_lpa(&mut self) -> Resul 268 pub fn genphy_read_lpa(&mut self) -> Result {
269 let phydev = self.0.get(); 269 let phydev = self.0.get();
270 // SAFETY: `phydev` is pointing to a v 270 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
271 // So it's just an FFI call. 271 // So it's just an FFI call.
272 to_result(unsafe { bindings::genphy_re 272 to_result(unsafe { bindings::genphy_read_lpa(phydev) })
273 } 273 }
274 274
275 /// Reads PHY abilities. 275 /// Reads PHY abilities.
276 pub fn genphy_read_abilities(&mut self) -> 276 pub fn genphy_read_abilities(&mut self) -> Result {
277 let phydev = self.0.get(); 277 let phydev = self.0.get();
278 // SAFETY: `phydev` is pointing to a v 278 // SAFETY: `phydev` is pointing to a valid object by the type invariant of `Self`.
279 // So it's just an FFI call. 279 // So it's just an FFI call.
280 to_result(unsafe { bindings::genphy_re 280 to_result(unsafe { bindings::genphy_read_abilities(phydev) })
281 } 281 }
282 } 282 }
283 283
284 impl AsRef<kernel::device::Device> for Device 284 impl AsRef<kernel::device::Device> for Device {
285 fn as_ref(&self) -> &kernel::device::Devic 285 fn as_ref(&self) -> &kernel::device::Device {
286 let phydev = self.0.get(); 286 let phydev = self.0.get();
287 // SAFETY: The struct invariant ensure 287 // SAFETY: The struct invariant ensures that `mdio.dev` is valid.
288 unsafe { kernel::device::Device::as_re 288 unsafe { kernel::device::Device::as_ref(addr_of_mut!((*phydev).mdio.dev)) }
289 } 289 }
290 } 290 }
291 291
292 /// Defines certain other features this PHY su 292 /// Defines certain other features this PHY supports (like interrupts).
293 /// 293 ///
294 /// These flag values are used in [`Driver::FL 294 /// These flag values are used in [`Driver::FLAGS`].
295 pub mod flags { 295 pub mod flags {
296 /// PHY is internal. 296 /// PHY is internal.
297 pub const IS_INTERNAL: u32 = bindings::PHY 297 pub const IS_INTERNAL: u32 = bindings::PHY_IS_INTERNAL;
298 /// PHY needs to be reset after the refclk 298 /// PHY needs to be reset after the refclk is enabled.
299 pub const RST_AFTER_CLK_EN: u32 = bindings 299 pub const RST_AFTER_CLK_EN: u32 = bindings::PHY_RST_AFTER_CLK_EN;
300 /// Polling is used to detect PHY status c 300 /// Polling is used to detect PHY status changes.
301 pub const POLL_CABLE_TEST: u32 = bindings: 301 pub const POLL_CABLE_TEST: u32 = bindings::PHY_POLL_CABLE_TEST;
302 /// Don't suspend. 302 /// Don't suspend.
303 pub const ALWAYS_CALL_SUSPEND: u32 = bindi 303 pub const ALWAYS_CALL_SUSPEND: u32 = bindings::PHY_ALWAYS_CALL_SUSPEND;
304 } 304 }
305 305
306 /// An adapter for the registration of a PHY d 306 /// An adapter for the registration of a PHY driver.
307 struct Adapter<T: Driver> { 307 struct Adapter<T: Driver> {
308 _p: PhantomData<T>, 308 _p: PhantomData<T>,
309 } 309 }
310 310
311 impl<T: Driver> Adapter<T> { 311 impl<T: Driver> Adapter<T> {
312 /// # Safety 312 /// # Safety
313 /// 313 ///
314 /// `phydev` must be passed by the corresp 314 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
315 unsafe extern "C" fn soft_reset_callback( 315 unsafe extern "C" fn soft_reset_callback(
316 phydev: *mut bindings::phy_device, 316 phydev: *mut bindings::phy_device,
317 ) -> core::ffi::c_int { 317 ) -> core::ffi::c_int {
318 from_result(|| { 318 from_result(|| {
319 // SAFETY: This callback is called 319 // SAFETY: This callback is called only in contexts
320 // where we hold `phy_device->lock 320 // where we hold `phy_device->lock`, so the accessors on
321 // `Device` are okay to call. 321 // `Device` are okay to call.
322 let dev = unsafe { Device::from_ra 322 let dev = unsafe { Device::from_raw(phydev) };
323 T::soft_reset(dev)?; 323 T::soft_reset(dev)?;
324 Ok(0) 324 Ok(0)
325 }) 325 })
326 } 326 }
327 327
328 /// # Safety 328 /// # Safety
329 /// 329 ///
330 /// `phydev` must be passed by the corresp 330 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
331 unsafe extern "C" fn probe_callback(phydev 331 unsafe extern "C" fn probe_callback(phydev: *mut bindings::phy_device) -> core::ffi::c_int {
332 from_result(|| { 332 from_result(|| {
333 // SAFETY: This callback is called 333 // SAFETY: This callback is called only in contexts
334 // where we can exclusively access 334 // where we can exclusively access `phy_device` because
335 // it's not published yet, so the 335 // it's not published yet, so the accessors on `Device` are okay
336 // to call. 336 // to call.
337 let dev = unsafe { Device::from_ra 337 let dev = unsafe { Device::from_raw(phydev) };
338 T::probe(dev)?; 338 T::probe(dev)?;
339 Ok(0) 339 Ok(0)
340 }) 340 })
341 } 341 }
342 342
343 /// # Safety 343 /// # Safety
344 /// 344 ///
345 /// `phydev` must be passed by the corresp 345 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
346 unsafe extern "C" fn get_features_callback 346 unsafe extern "C" fn get_features_callback(
347 phydev: *mut bindings::phy_device, 347 phydev: *mut bindings::phy_device,
348 ) -> core::ffi::c_int { 348 ) -> core::ffi::c_int {
349 from_result(|| { 349 from_result(|| {
350 // SAFETY: This callback is called 350 // SAFETY: This callback is called only in contexts
351 // where we hold `phy_device->lock 351 // where we hold `phy_device->lock`, so the accessors on
352 // `Device` are okay to call. 352 // `Device` are okay to call.
353 let dev = unsafe { Device::from_ra 353 let dev = unsafe { Device::from_raw(phydev) };
354 T::get_features(dev)?; 354 T::get_features(dev)?;
355 Ok(0) 355 Ok(0)
356 }) 356 })
357 } 357 }
358 358
359 /// # Safety 359 /// # Safety
360 /// 360 ///
361 /// `phydev` must be passed by the corresp 361 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
362 unsafe extern "C" fn suspend_callback(phyd 362 unsafe extern "C" fn suspend_callback(phydev: *mut bindings::phy_device) -> core::ffi::c_int {
363 from_result(|| { 363 from_result(|| {
364 // SAFETY: The C core code ensures 364 // SAFETY: The C core code ensures that the accessors on
365 // `Device` are okay to call even 365 // `Device` are okay to call even though `phy_device->lock`
366 // might not be held. 366 // might not be held.
367 let dev = unsafe { Device::from_ra 367 let dev = unsafe { Device::from_raw(phydev) };
368 T::suspend(dev)?; 368 T::suspend(dev)?;
369 Ok(0) 369 Ok(0)
370 }) 370 })
371 } 371 }
372 372
373 /// # Safety 373 /// # Safety
374 /// 374 ///
375 /// `phydev` must be passed by the corresp 375 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
376 unsafe extern "C" fn resume_callback(phyde 376 unsafe extern "C" fn resume_callback(phydev: *mut bindings::phy_device) -> core::ffi::c_int {
377 from_result(|| { 377 from_result(|| {
378 // SAFETY: The C core code ensures 378 // SAFETY: The C core code ensures that the accessors on
379 // `Device` are okay to call even 379 // `Device` are okay to call even though `phy_device->lock`
380 // might not be held. 380 // might not be held.
381 let dev = unsafe { Device::from_ra 381 let dev = unsafe { Device::from_raw(phydev) };
382 T::resume(dev)?; 382 T::resume(dev)?;
383 Ok(0) 383 Ok(0)
384 }) 384 })
385 } 385 }
386 386
387 /// # Safety 387 /// # Safety
388 /// 388 ///
389 /// `phydev` must be passed by the corresp 389 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
390 unsafe extern "C" fn config_aneg_callback( 390 unsafe extern "C" fn config_aneg_callback(
391 phydev: *mut bindings::phy_device, 391 phydev: *mut bindings::phy_device,
392 ) -> core::ffi::c_int { 392 ) -> core::ffi::c_int {
393 from_result(|| { 393 from_result(|| {
394 // SAFETY: This callback is called 394 // SAFETY: This callback is called only in contexts
395 // where we hold `phy_device->lock 395 // where we hold `phy_device->lock`, so the accessors on
396 // `Device` are okay to call. 396 // `Device` are okay to call.
397 let dev = unsafe { Device::from_ra 397 let dev = unsafe { Device::from_raw(phydev) };
398 T::config_aneg(dev)?; 398 T::config_aneg(dev)?;
399 Ok(0) 399 Ok(0)
400 }) 400 })
401 } 401 }
402 402
403 /// # Safety 403 /// # Safety
404 /// 404 ///
405 /// `phydev` must be passed by the corresp 405 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
406 unsafe extern "C" fn read_status_callback( 406 unsafe extern "C" fn read_status_callback(
407 phydev: *mut bindings::phy_device, 407 phydev: *mut bindings::phy_device,
408 ) -> core::ffi::c_int { 408 ) -> core::ffi::c_int {
409 from_result(|| { 409 from_result(|| {
410 // SAFETY: This callback is called 410 // SAFETY: This callback is called only in contexts
411 // where we hold `phy_device->lock 411 // where we hold `phy_device->lock`, so the accessors on
412 // `Device` are okay to call. 412 // `Device` are okay to call.
413 let dev = unsafe { Device::from_ra 413 let dev = unsafe { Device::from_raw(phydev) };
414 T::read_status(dev)?; 414 T::read_status(dev)?;
415 Ok(0) 415 Ok(0)
416 }) 416 })
417 } 417 }
418 418
419 /// # Safety 419 /// # Safety
420 /// 420 ///
421 /// `phydev` must be passed by the corresp 421 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
422 unsafe extern "C" fn match_phy_device_call 422 unsafe extern "C" fn match_phy_device_callback(
423 phydev: *mut bindings::phy_device, 423 phydev: *mut bindings::phy_device,
424 ) -> core::ffi::c_int { 424 ) -> core::ffi::c_int {
425 // SAFETY: This callback is called onl 425 // SAFETY: This callback is called only in contexts
426 // where we hold `phy_device->lock`, s 426 // where we hold `phy_device->lock`, so the accessors on
427 // `Device` are okay to call. 427 // `Device` are okay to call.
428 let dev = unsafe { Device::from_raw(ph 428 let dev = unsafe { Device::from_raw(phydev) };
429 T::match_phy_device(dev) as i32 429 T::match_phy_device(dev) as i32
430 } 430 }
431 431
432 /// # Safety 432 /// # Safety
433 /// 433 ///
434 /// `phydev` must be passed by the corresp 434 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
435 unsafe extern "C" fn read_mmd_callback( 435 unsafe extern "C" fn read_mmd_callback(
436 phydev: *mut bindings::phy_device, 436 phydev: *mut bindings::phy_device,
437 devnum: i32, 437 devnum: i32,
438 regnum: u16, 438 regnum: u16,
439 ) -> i32 { 439 ) -> i32 {
440 from_result(|| { 440 from_result(|| {
441 // SAFETY: This callback is called 441 // SAFETY: This callback is called only in contexts
442 // where we hold `phy_device->lock 442 // where we hold `phy_device->lock`, so the accessors on
443 // `Device` are okay to call. 443 // `Device` are okay to call.
444 let dev = unsafe { Device::from_ra 444 let dev = unsafe { Device::from_raw(phydev) };
445 // CAST: the C side verifies devnu 445 // CAST: the C side verifies devnum < 32.
446 let ret = T::read_mmd(dev, devnum 446 let ret = T::read_mmd(dev, devnum as u8, regnum)?;
447 Ok(ret.into()) 447 Ok(ret.into())
448 }) 448 })
449 } 449 }
450 450
451 /// # Safety 451 /// # Safety
452 /// 452 ///
453 /// `phydev` must be passed by the corresp 453 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
454 unsafe extern "C" fn write_mmd_callback( 454 unsafe extern "C" fn write_mmd_callback(
455 phydev: *mut bindings::phy_device, 455 phydev: *mut bindings::phy_device,
456 devnum: i32, 456 devnum: i32,
457 regnum: u16, 457 regnum: u16,
458 val: u16, 458 val: u16,
459 ) -> i32 { 459 ) -> i32 {
460 from_result(|| { 460 from_result(|| {
461 // SAFETY: This callback is called 461 // SAFETY: This callback is called only in contexts
462 // where we hold `phy_device->lock 462 // where we hold `phy_device->lock`, so the accessors on
463 // `Device` are okay to call. 463 // `Device` are okay to call.
464 let dev = unsafe { Device::from_ra 464 let dev = unsafe { Device::from_raw(phydev) };
465 T::write_mmd(dev, devnum as u8, re 465 T::write_mmd(dev, devnum as u8, regnum, val)?;
466 Ok(0) 466 Ok(0)
467 }) 467 })
468 } 468 }
469 469
470 /// # Safety 470 /// # Safety
471 /// 471 ///
472 /// `phydev` must be passed by the corresp 472 /// `phydev` must be passed by the corresponding callback in `phy_driver`.
473 unsafe extern "C" fn link_change_notify_ca 473 unsafe extern "C" fn link_change_notify_callback(phydev: *mut bindings::phy_device) {
474 // SAFETY: This callback is called onl 474 // SAFETY: This callback is called only in contexts
475 // where we hold `phy_device->lock`, s 475 // where we hold `phy_device->lock`, so the accessors on
476 // `Device` are okay to call. 476 // `Device` are okay to call.
477 let dev = unsafe { Device::from_raw(ph 477 let dev = unsafe { Device::from_raw(phydev) };
478 T::link_change_notify(dev); 478 T::link_change_notify(dev);
479 } 479 }
480 } 480 }
481 481
482 /// Driver structure for a particular PHY type 482 /// Driver structure for a particular PHY type.
483 /// 483 ///
484 /// Wraps the kernel's [`struct phy_driver`]. 484 /// Wraps the kernel's [`struct phy_driver`].
485 /// This is used to register a driver for a pa 485 /// This is used to register a driver for a particular PHY type with the kernel.
486 /// 486 ///
487 /// # Invariants 487 /// # Invariants
488 /// 488 ///
489 /// `self.0` is always in a valid state. 489 /// `self.0` is always in a valid state.
490 /// 490 ///
491 /// [`struct phy_driver`]: srctree/include/lin 491 /// [`struct phy_driver`]: srctree/include/linux/phy.h
492 #[repr(transparent)] 492 #[repr(transparent)]
493 pub struct DriverVTable(Opaque<bindings::phy_d 493 pub struct DriverVTable(Opaque<bindings::phy_driver>);
494 494
495 // SAFETY: `DriverVTable` doesn't expose any & 495 // SAFETY: `DriverVTable` doesn't expose any &self method to access internal data, so it's safe to
496 // share `&DriverVTable` across execution cont 496 // share `&DriverVTable` across execution context boundaries.
497 unsafe impl Sync for DriverVTable {} 497 unsafe impl Sync for DriverVTable {}
498 498
499 /// Creates a [`DriverVTable`] instance from [ 499 /// Creates a [`DriverVTable`] instance from [`Driver`].
500 /// 500 ///
501 /// This is used by [`module_phy_driver`] macr 501 /// This is used by [`module_phy_driver`] macro to create a static array of `phy_driver`.
502 /// 502 ///
503 /// [`module_phy_driver`]: crate::module_phy_d 503 /// [`module_phy_driver`]: crate::module_phy_driver
504 pub const fn create_phy_driver<T: Driver>() -> 504 pub const fn create_phy_driver<T: Driver>() -> DriverVTable {
505 // INVARIANT: All the fields of `struct ph 505 // INVARIANT: All the fields of `struct phy_driver` are initialized properly.
506 DriverVTable(Opaque::new(bindings::phy_dri 506 DriverVTable(Opaque::new(bindings::phy_driver {
507 name: T::NAME.as_char_ptr().cast_mut() 507 name: T::NAME.as_char_ptr().cast_mut(),
508 flags: T::FLAGS, 508 flags: T::FLAGS,
509 phy_id: T::PHY_DEVICE_ID.id, 509 phy_id: T::PHY_DEVICE_ID.id,
510 phy_id_mask: T::PHY_DEVICE_ID.mask_as_ 510 phy_id_mask: T::PHY_DEVICE_ID.mask_as_int(),
511 soft_reset: if T::HAS_SOFT_RESET { 511 soft_reset: if T::HAS_SOFT_RESET {
512 Some(Adapter::<T>::soft_reset_call 512 Some(Adapter::<T>::soft_reset_callback)
513 } else { 513 } else {
514 None 514 None
515 }, 515 },
516 probe: if T::HAS_PROBE { 516 probe: if T::HAS_PROBE {
517 Some(Adapter::<T>::probe_callback) 517 Some(Adapter::<T>::probe_callback)
518 } else { 518 } else {
519 None 519 None
520 }, 520 },
521 get_features: if T::HAS_GET_FEATURES { 521 get_features: if T::HAS_GET_FEATURES {
522 Some(Adapter::<T>::get_features_ca 522 Some(Adapter::<T>::get_features_callback)
523 } else { 523 } else {
524 None 524 None
525 }, 525 },
526 match_phy_device: if T::HAS_MATCH_PHY_ 526 match_phy_device: if T::HAS_MATCH_PHY_DEVICE {
527 Some(Adapter::<T>::match_phy_devic 527 Some(Adapter::<T>::match_phy_device_callback)
528 } else { 528 } else {
529 None 529 None
530 }, 530 },
531 suspend: if T::HAS_SUSPEND { 531 suspend: if T::HAS_SUSPEND {
532 Some(Adapter::<T>::suspend_callbac 532 Some(Adapter::<T>::suspend_callback)
533 } else { 533 } else {
534 None 534 None
535 }, 535 },
536 resume: if T::HAS_RESUME { 536 resume: if T::HAS_RESUME {
537 Some(Adapter::<T>::resume_callback 537 Some(Adapter::<T>::resume_callback)
538 } else { 538 } else {
539 None 539 None
540 }, 540 },
541 config_aneg: if T::HAS_CONFIG_ANEG { 541 config_aneg: if T::HAS_CONFIG_ANEG {
542 Some(Adapter::<T>::config_aneg_cal 542 Some(Adapter::<T>::config_aneg_callback)
543 } else { 543 } else {
544 None 544 None
545 }, 545 },
546 read_status: if T::HAS_READ_STATUS { 546 read_status: if T::HAS_READ_STATUS {
547 Some(Adapter::<T>::read_status_cal 547 Some(Adapter::<T>::read_status_callback)
548 } else { 548 } else {
549 None 549 None
550 }, 550 },
551 read_mmd: if T::HAS_READ_MMD { 551 read_mmd: if T::HAS_READ_MMD {
552 Some(Adapter::<T>::read_mmd_callba 552 Some(Adapter::<T>::read_mmd_callback)
553 } else { 553 } else {
554 None 554 None
555 }, 555 },
556 write_mmd: if T::HAS_WRITE_MMD { 556 write_mmd: if T::HAS_WRITE_MMD {
557 Some(Adapter::<T>::write_mmd_callb 557 Some(Adapter::<T>::write_mmd_callback)
558 } else { 558 } else {
559 None 559 None
560 }, 560 },
561 link_change_notify: if T::HAS_LINK_CHA 561 link_change_notify: if T::HAS_LINK_CHANGE_NOTIFY {
562 Some(Adapter::<T>::link_change_not 562 Some(Adapter::<T>::link_change_notify_callback)
563 } else { 563 } else {
564 None 564 None
565 }, 565 },
566 // SAFETY: The rest is zeroed out to i 566 // SAFETY: The rest is zeroed out to initialize `struct phy_driver`,
567 // sets `Option<&F>` to be `None`. 567 // sets `Option<&F>` to be `None`.
568 ..unsafe { core::mem::MaybeUninit::<bi 568 ..unsafe { core::mem::MaybeUninit::<bindings::phy_driver>::zeroed().assume_init() }
569 })) 569 }))
570 } 570 }
571 571
572 /// Driver implementation for a particular PHY 572 /// Driver implementation for a particular PHY type.
573 /// 573 ///
574 /// This trait is used to create a [`DriverVTa 574 /// This trait is used to create a [`DriverVTable`].
575 #[vtable] 575 #[vtable]
576 pub trait Driver { 576 pub trait Driver {
577 /// Defines certain other features this PH 577 /// Defines certain other features this PHY supports.
578 /// It is a combination of the flags in th 578 /// It is a combination of the flags in the [`flags`] module.
579 const FLAGS: u32 = 0; 579 const FLAGS: u32 = 0;
580 580
581 /// The friendly name of this PHY type. 581 /// The friendly name of this PHY type.
582 const NAME: &'static CStr; 582 const NAME: &'static CStr;
583 583
584 /// This driver only works for PHYs with I 584 /// This driver only works for PHYs with IDs which match this field.
585 /// The default id and mask are zero. 585 /// The default id and mask are zero.
586 const PHY_DEVICE_ID: DeviceId = DeviceId:: 586 const PHY_DEVICE_ID: DeviceId = DeviceId::new_with_custom_mask(0, 0);
587 587
588 /// Issues a PHY software reset. 588 /// Issues a PHY software reset.
589 fn soft_reset(_dev: &mut Device) -> Result 589 fn soft_reset(_dev: &mut Device) -> Result {
590 kernel::build_error(VTABLE_DEFAULT_ERR 590 kernel::build_error(VTABLE_DEFAULT_ERROR)
591 } 591 }
592 592
593 /// Sets up device-specific structures dur 593 /// Sets up device-specific structures during discovery.
594 fn probe(_dev: &mut Device) -> Result { 594 fn probe(_dev: &mut Device) -> Result {
595 kernel::build_error(VTABLE_DEFAULT_ERR 595 kernel::build_error(VTABLE_DEFAULT_ERROR)
596 } 596 }
597 597
598 /// Probes the hardware to determine what 598 /// Probes the hardware to determine what abilities it has.
599 fn get_features(_dev: &mut Device) -> Resu 599 fn get_features(_dev: &mut Device) -> Result {
600 kernel::build_error(VTABLE_DEFAULT_ERR 600 kernel::build_error(VTABLE_DEFAULT_ERROR)
601 } 601 }
602 602
603 /// Returns true if this is a suitable dri 603 /// Returns true if this is a suitable driver for the given phydev.
604 /// If not implemented, matching is based 604 /// If not implemented, matching is based on [`Driver::PHY_DEVICE_ID`].
605 fn match_phy_device(_dev: &Device) -> bool 605 fn match_phy_device(_dev: &Device) -> bool {
606 false 606 false
607 } 607 }
608 608
609 /// Configures the advertisement and reset 609 /// Configures the advertisement and resets auto-negotiation
610 /// if auto-negotiation is enabled. 610 /// if auto-negotiation is enabled.
611 fn config_aneg(_dev: &mut Device) -> Resul 611 fn config_aneg(_dev: &mut Device) -> Result {
612 kernel::build_error(VTABLE_DEFAULT_ERR 612 kernel::build_error(VTABLE_DEFAULT_ERROR)
613 } 613 }
614 614
615 /// Determines the negotiated speed and du 615 /// Determines the negotiated speed and duplex.
616 fn read_status(_dev: &mut Device) -> Resul 616 fn read_status(_dev: &mut Device) -> Result<u16> {
617 kernel::build_error(VTABLE_DEFAULT_ERR 617 kernel::build_error(VTABLE_DEFAULT_ERROR)
618 } 618 }
619 619
620 /// Suspends the hardware, saving state if 620 /// Suspends the hardware, saving state if needed.
621 fn suspend(_dev: &mut Device) -> Result { 621 fn suspend(_dev: &mut Device) -> Result {
622 kernel::build_error(VTABLE_DEFAULT_ERR 622 kernel::build_error(VTABLE_DEFAULT_ERROR)
623 } 623 }
624 624
625 /// Resumes the hardware, restoring state 625 /// Resumes the hardware, restoring state if needed.
626 fn resume(_dev: &mut Device) -> Result { 626 fn resume(_dev: &mut Device) -> Result {
627 kernel::build_error(VTABLE_DEFAULT_ERR 627 kernel::build_error(VTABLE_DEFAULT_ERROR)
628 } 628 }
629 629
630 /// Overrides the default MMD read functio 630 /// Overrides the default MMD read function for reading a MMD register.
631 fn read_mmd(_dev: &mut Device, _devnum: u8 631 fn read_mmd(_dev: &mut Device, _devnum: u8, _regnum: u16) -> Result<u16> {
632 kernel::build_error(VTABLE_DEFAULT_ERR 632 kernel::build_error(VTABLE_DEFAULT_ERROR)
633 } 633 }
634 634
635 /// Overrides the default MMD write functi 635 /// Overrides the default MMD write function for writing a MMD register.
636 fn write_mmd(_dev: &mut Device, _devnum: u 636 fn write_mmd(_dev: &mut Device, _devnum: u8, _regnum: u16, _val: u16) -> Result {
637 kernel::build_error(VTABLE_DEFAULT_ERR 637 kernel::build_error(VTABLE_DEFAULT_ERROR)
638 } 638 }
639 639
640 /// Callback for notification of link chan 640 /// Callback for notification of link change.
641 fn link_change_notify(_dev: &mut Device) { 641 fn link_change_notify(_dev: &mut Device) {}
642 } 642 }
643 643
644 /// Registration structure for PHY drivers. 644 /// Registration structure for PHY drivers.
645 /// 645 ///
646 /// Registers [`DriverVTable`] instances with 646 /// Registers [`DriverVTable`] instances with the kernel. They will be unregistered when dropped.
647 /// 647 ///
648 /// # Invariants 648 /// # Invariants
649 /// 649 ///
650 /// The `drivers` slice are currently register 650 /// The `drivers` slice are currently registered to the kernel via `phy_drivers_register`.
651 pub struct Registration { 651 pub struct Registration {
652 drivers: Pin<&'static mut [DriverVTable]>, 652 drivers: Pin<&'static mut [DriverVTable]>,
653 } 653 }
654 654
655 // SAFETY: The only action allowed in a `Regis 655 // SAFETY: The only action allowed in a `Registration` instance is dropping it, which is safe to do
656 // from any thread because `phy_drivers_unregi 656 // from any thread because `phy_drivers_unregister` can be called from any thread context.
657 unsafe impl Send for Registration {} 657 unsafe impl Send for Registration {}
658 658
659 impl Registration { 659 impl Registration {
660 /// Registers a PHY driver. 660 /// Registers a PHY driver.
661 pub fn register( 661 pub fn register(
662 module: &'static crate::ThisModule, 662 module: &'static crate::ThisModule,
663 drivers: Pin<&'static mut [DriverVTabl 663 drivers: Pin<&'static mut [DriverVTable]>,
664 ) -> Result<Self> { 664 ) -> Result<Self> {
665 if drivers.is_empty() { 665 if drivers.is_empty() {
666 return Err(code::EINVAL); 666 return Err(code::EINVAL);
667 } 667 }
668 // SAFETY: The type invariants of [`Dr 668 // SAFETY: The type invariants of [`DriverVTable`] ensure that all elements of
669 // the `drivers` slice are initialized 669 // the `drivers` slice are initialized properly. `drivers` will not be moved.
670 // So it's just an FFI call. 670 // So it's just an FFI call.
671 to_result(unsafe { 671 to_result(unsafe {
672 bindings::phy_drivers_register(dri 672 bindings::phy_drivers_register(drivers[0].0.get(), drivers.len().try_into()?, module.0)
673 })?; 673 })?;
674 // INVARIANT: The `drivers` slice is s 674 // INVARIANT: The `drivers` slice is successfully registered to the kernel via `phy_drivers_register`.
675 Ok(Registration { drivers }) 675 Ok(Registration { drivers })
676 } 676 }
677 } 677 }
678 678
679 impl Drop for Registration { 679 impl Drop for Registration {
680 fn drop(&mut self) { 680 fn drop(&mut self) {
681 // SAFETY: The type invariants guarant 681 // SAFETY: The type invariants guarantee that `self.drivers` is valid.
682 // So it's just an FFI call. 682 // So it's just an FFI call.
683 unsafe { 683 unsafe {
684 bindings::phy_drivers_unregister(s 684 bindings::phy_drivers_unregister(self.drivers[0].0.get(), self.drivers.len() as i32)
685 }; 685 };
686 } 686 }
687 } 687 }
688 688
689 /// An identifier for PHY devices on an MDIO/M 689 /// An identifier for PHY devices on an MDIO/MII bus.
690 /// 690 ///
691 /// Represents the kernel's `struct mdio_devic 691 /// Represents the kernel's `struct mdio_device_id`. This is used to find an appropriate
692 /// PHY driver. 692 /// PHY driver.
693 pub struct DeviceId { 693 pub struct DeviceId {
694 id: u32, 694 id: u32,
695 mask: DeviceMask, 695 mask: DeviceMask,
696 } 696 }
697 697
698 impl DeviceId { 698 impl DeviceId {
699 /// Creates a new instance with the exact 699 /// Creates a new instance with the exact match mask.
700 pub const fn new_with_exact_mask(id: u32) 700 pub const fn new_with_exact_mask(id: u32) -> Self {
701 DeviceId { 701 DeviceId {
702 id, 702 id,
703 mask: DeviceMask::Exact, 703 mask: DeviceMask::Exact,
704 } 704 }
705 } 705 }
706 706
707 /// Creates a new instance with the model 707 /// Creates a new instance with the model match mask.
708 pub const fn new_with_model_mask(id: u32) 708 pub const fn new_with_model_mask(id: u32) -> Self {
709 DeviceId { 709 DeviceId {
710 id, 710 id,
711 mask: DeviceMask::Model, 711 mask: DeviceMask::Model,
712 } 712 }
713 } 713 }
714 714
715 /// Creates a new instance with the vendor 715 /// Creates a new instance with the vendor match mask.
716 pub const fn new_with_vendor_mask(id: u32) 716 pub const fn new_with_vendor_mask(id: u32) -> Self {
717 DeviceId { 717 DeviceId {
718 id, 718 id,
719 mask: DeviceMask::Vendor, 719 mask: DeviceMask::Vendor,
720 } 720 }
721 } 721 }
722 722
723 /// Creates a new instance with a custom m 723 /// Creates a new instance with a custom match mask.
724 pub const fn new_with_custom_mask(id: u32, 724 pub const fn new_with_custom_mask(id: u32, mask: u32) -> Self {
725 DeviceId { 725 DeviceId {
726 id, 726 id,
727 mask: DeviceMask::Custom(mask), 727 mask: DeviceMask::Custom(mask),
728 } 728 }
729 } 729 }
730 730
731 /// Creates a new instance from [`Driver`] 731 /// Creates a new instance from [`Driver`].
732 pub const fn new_with_driver<T: Driver>() 732 pub const fn new_with_driver<T: Driver>() -> Self {
733 T::PHY_DEVICE_ID 733 T::PHY_DEVICE_ID
734 } 734 }
735 735
736 /// Get a `mask` as u32. 736 /// Get a `mask` as u32.
737 pub const fn mask_as_int(&self) -> u32 { 737 pub const fn mask_as_int(&self) -> u32 {
738 self.mask.as_int() 738 self.mask.as_int()
739 } 739 }
740 740
741 // macro use only 741 // macro use only
742 #[doc(hidden)] 742 #[doc(hidden)]
743 pub const fn mdio_device_id(&self) -> bind 743 pub const fn mdio_device_id(&self) -> bindings::mdio_device_id {
744 bindings::mdio_device_id { 744 bindings::mdio_device_id {
745 phy_id: self.id, 745 phy_id: self.id,
746 phy_id_mask: self.mask.as_int(), 746 phy_id_mask: self.mask.as_int(),
747 } 747 }
748 } 748 }
749 } 749 }
750 750
751 enum DeviceMask { 751 enum DeviceMask {
752 Exact, 752 Exact,
753 Model, 753 Model,
754 Vendor, 754 Vendor,
755 Custom(u32), 755 Custom(u32),
756 } 756 }
757 757
758 impl DeviceMask { 758 impl DeviceMask {
759 const MASK_EXACT: u32 = !0; 759 const MASK_EXACT: u32 = !0;
760 const MASK_MODEL: u32 = !0 << 4; 760 const MASK_MODEL: u32 = !0 << 4;
761 const MASK_VENDOR: u32 = !0 << 10; 761 const MASK_VENDOR: u32 = !0 << 10;
762 762
763 const fn as_int(&self) -> u32 { 763 const fn as_int(&self) -> u32 {
764 match self { 764 match self {
765 DeviceMask::Exact => Self::MASK_EX 765 DeviceMask::Exact => Self::MASK_EXACT,
766 DeviceMask::Model => Self::MASK_MO 766 DeviceMask::Model => Self::MASK_MODEL,
767 DeviceMask::Vendor => Self::MASK_V 767 DeviceMask::Vendor => Self::MASK_VENDOR,
768 DeviceMask::Custom(mask) => *mask, 768 DeviceMask::Custom(mask) => *mask,
769 } 769 }
770 } 770 }
771 } 771 }
772 772
773 /// Declares a kernel module for PHYs drivers. 773 /// Declares a kernel module for PHYs drivers.
774 /// 774 ///
775 /// This creates a static array of kernel's `s 775 /// This creates a static array of kernel's `struct phy_driver` and registers it.
776 /// This also corresponds to the kernel's `MOD 776 /// This also corresponds to the kernel's `MODULE_DEVICE_TABLE` macro, which embeds the information
777 /// for module loading into the module binary 777 /// for module loading into the module binary file. Every driver needs an entry in `device_table`.
778 /// 778 ///
779 /// # Examples 779 /// # Examples
780 /// 780 ///
781 /// ``` 781 /// ```
782 /// # mod module_phy_driver_sample { 782 /// # mod module_phy_driver_sample {
783 /// use kernel::c_str; 783 /// use kernel::c_str;
784 /// use kernel::net::phy::{self, DeviceId}; 784 /// use kernel::net::phy::{self, DeviceId};
785 /// use kernel::prelude::*; 785 /// use kernel::prelude::*;
786 /// 786 ///
787 /// kernel::module_phy_driver! { 787 /// kernel::module_phy_driver! {
788 /// drivers: [PhySample], 788 /// drivers: [PhySample],
789 /// device_table: [ 789 /// device_table: [
790 /// DeviceId::new_with_driver::<PhySam 790 /// DeviceId::new_with_driver::<PhySample>()
791 /// ], 791 /// ],
792 /// name: "rust_sample_phy", 792 /// name: "rust_sample_phy",
793 /// author: "Rust for Linux Contributors", 793 /// author: "Rust for Linux Contributors",
794 /// description: "Rust sample PHYs driver" 794 /// description: "Rust sample PHYs driver",
795 /// license: "GPL", 795 /// license: "GPL",
796 /// } 796 /// }
797 /// 797 ///
798 /// struct PhySample; 798 /// struct PhySample;
799 /// 799 ///
800 /// #[vtable] 800 /// #[vtable]
801 /// impl phy::Driver for PhySample { 801 /// impl phy::Driver for PhySample {
802 /// const NAME: &'static CStr = c_str!("Ph 802 /// const NAME: &'static CStr = c_str!("PhySample");
803 /// const PHY_DEVICE_ID: phy::DeviceId = p 803 /// const PHY_DEVICE_ID: phy::DeviceId = phy::DeviceId::new_with_exact_mask(0x00000001);
804 /// } 804 /// }
805 /// # } 805 /// # }
806 /// ``` 806 /// ```
807 /// 807 ///
808 /// This expands to the following code: 808 /// This expands to the following code:
809 /// 809 ///
810 /// ```ignore 810 /// ```ignore
811 /// use kernel::c_str; 811 /// use kernel::c_str;
812 /// use kernel::net::phy::{self, DeviceId}; 812 /// use kernel::net::phy::{self, DeviceId};
813 /// use kernel::prelude::*; 813 /// use kernel::prelude::*;
814 /// 814 ///
815 /// struct Module { 815 /// struct Module {
816 /// _reg: ::kernel::net::phy::Registration 816 /// _reg: ::kernel::net::phy::Registration,
817 /// } 817 /// }
818 /// 818 ///
819 /// module! { 819 /// module! {
820 /// type: Module, 820 /// type: Module,
821 /// name: "rust_sample_phy", 821 /// name: "rust_sample_phy",
822 /// author: "Rust for Linux Contributors", 822 /// author: "Rust for Linux Contributors",
823 /// description: "Rust sample PHYs driver" 823 /// description: "Rust sample PHYs driver",
824 /// license: "GPL", 824 /// license: "GPL",
825 /// } 825 /// }
826 /// 826 ///
827 /// struct PhySample; 827 /// struct PhySample;
828 /// 828 ///
829 /// #[vtable] 829 /// #[vtable]
830 /// impl phy::Driver for PhySample { 830 /// impl phy::Driver for PhySample {
831 /// const NAME: &'static CStr = c_str!("Ph 831 /// const NAME: &'static CStr = c_str!("PhySample");
832 /// const PHY_DEVICE_ID: phy::DeviceId = p 832 /// const PHY_DEVICE_ID: phy::DeviceId = phy::DeviceId::new_with_exact_mask(0x00000001);
833 /// } 833 /// }
834 /// 834 ///
835 /// const _: () = { 835 /// const _: () = {
836 /// static mut DRIVERS: [::kernel::net::ph 836 /// static mut DRIVERS: [::kernel::net::phy::DriverVTable; 1] =
837 /// [::kernel::net::phy::create_phy_dr 837 /// [::kernel::net::phy::create_phy_driver::<PhySample>()];
838 /// 838 ///
839 /// impl ::kernel::Module for Module { 839 /// impl ::kernel::Module for Module {
840 /// fn init(module: &'static ThisModul 840 /// fn init(module: &'static ThisModule) -> Result<Self> {
841 /// let drivers = unsafe { &mut DR 841 /// let drivers = unsafe { &mut DRIVERS };
842 /// let mut reg = ::kernel::net::p 842 /// let mut reg = ::kernel::net::phy::Registration::register(
843 /// module, 843 /// module,
844 /// ::core::pin::Pin::static_m 844 /// ::core::pin::Pin::static_mut(drivers),
845 /// )?; 845 /// )?;
846 /// Ok(Module { _reg: reg }) 846 /// Ok(Module { _reg: reg })
847 /// } 847 /// }
848 /// } 848 /// }
849 /// }; 849 /// };
850 /// 850 ///
851 /// #[cfg(MODULE)] 851 /// #[cfg(MODULE)]
852 /// #[no_mangle] 852 /// #[no_mangle]
853 /// static __mod_mdio__phydev_device_table: [: 853 /// static __mod_mdio__phydev_device_table: [::kernel::bindings::mdio_device_id; 2] = [
854 /// ::kernel::bindings::mdio_device_id { 854 /// ::kernel::bindings::mdio_device_id {
855 /// phy_id: 0x00000001, 855 /// phy_id: 0x00000001,
856 /// phy_id_mask: 0xffffffff, 856 /// phy_id_mask: 0xffffffff,
857 /// }, 857 /// },
858 /// ::kernel::bindings::mdio_device_id { 858 /// ::kernel::bindings::mdio_device_id {
859 /// phy_id: 0, 859 /// phy_id: 0,
860 /// phy_id_mask: 0, 860 /// phy_id_mask: 0,
861 /// }, 861 /// },
862 /// ]; 862 /// ];
863 /// ``` 863 /// ```
864 #[macro_export] 864 #[macro_export]
865 macro_rules! module_phy_driver { 865 macro_rules! module_phy_driver {
866 (@replace_expr $_t:tt $sub:expr) => {$sub} 866 (@replace_expr $_t:tt $sub:expr) => {$sub};
867 867
868 (@count_devices $($x:expr),*) => { 868 (@count_devices $($x:expr),*) => {
869 0usize $(+ $crate::module_phy_driver!( 869 0usize $(+ $crate::module_phy_driver!(@replace_expr $x 1usize))*
870 }; 870 };
871 871
872 (@device_table [$($dev:expr),+]) => { 872 (@device_table [$($dev:expr),+]) => {
873 // SAFETY: C will not read off the end 873 // SAFETY: C will not read off the end of this constant since the last element is zero.
874 #[cfg(MODULE)] 874 #[cfg(MODULE)]
875 #[no_mangle] 875 #[no_mangle]
876 static __mod_mdio__phydev_device_table 876 static __mod_mdio__phydev_device_table: [$crate::bindings::mdio_device_id;
877 $crate::module_phy_driver!(@count_ 877 $crate::module_phy_driver!(@count_devices $($dev),+) + 1] = [
878 $($dev.mdio_device_id()),+, 878 $($dev.mdio_device_id()),+,
879 $crate::bindings::mdio_device_id { 879 $crate::bindings::mdio_device_id {
880 phy_id: 0, 880 phy_id: 0,
881 phy_id_mask: 0 881 phy_id_mask: 0
882 } 882 }
883 ]; 883 ];
884 }; 884 };
885 885
886 (drivers: [$($driver:ident),+ $(,)?], devi 886 (drivers: [$($driver:ident),+ $(,)?], device_table: [$($dev:expr),+ $(,)?], $($f:tt)*) => {
887 struct Module { 887 struct Module {
888 _reg: $crate::net::phy::Registrati 888 _reg: $crate::net::phy::Registration,
889 } 889 }
890 890
891 $crate::prelude::module! { 891 $crate::prelude::module! {
892 type: Module, 892 type: Module,
893 $($f)* 893 $($f)*
894 } 894 }
895 895
896 const _: () = { 896 const _: () = {
897 static mut DRIVERS: [$crate::net:: 897 static mut DRIVERS: [$crate::net::phy::DriverVTable;
898 $crate::module_phy_driver!(@co 898 $crate::module_phy_driver!(@count_devices $($driver),+)] =
899 [$($crate::net::phy::create_ph 899 [$($crate::net::phy::create_phy_driver::<$driver>()),+];
900 900
901 impl $crate::Module for Module { 901 impl $crate::Module for Module {
902 fn init(module: &'static ThisM 902 fn init(module: &'static ThisModule) -> Result<Self> {
903 // SAFETY: The anonymous c 903 // SAFETY: The anonymous constant guarantees that nobody else can access
904 // the `DRIVERS` static. T 904 // the `DRIVERS` static. The array is used only in the C side.
905 let drivers = unsafe { &mu 905 let drivers = unsafe { &mut DRIVERS };
906 let mut reg = $crate::net: 906 let mut reg = $crate::net::phy::Registration::register(
907 module, 907 module,
908 ::core::pin::Pin::stat 908 ::core::pin::Pin::static_mut(drivers),
909 )?; 909 )?;
910 Ok(Module { _reg: reg }) 910 Ok(Module { _reg: reg })
911 } 911 }
912 } 912 }
913 }; 913 };
914 914
915 $crate::module_phy_driver!(@device_tab 915 $crate::module_phy_driver!(@device_table [$($dev),+]);
916 } 916 }
917 } 917 }
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.