Claude review: rust: add basic serial device bus abstractions

[Claude Code Review Bot <claude-review@example.com>]

Patch Review

This is the main patch — 548 lines of Rust in `rust/kernel/serdev.rs`, plus C helpers and build system integration.

**Typo in Parity enum doc:**
```rust
+    /// Even partiy.
+    Even = bindings::serdev_parity_SERDEV_PARITY_EVEN,
```
"partiy" → "parity"

**Broken rustdoc link in `write()` doc:**
```rust
+    /// Note that any accepted data has only been buffered by the controller. Use
+    /// [ Device::wait_until_sent`] to make sure the controller write buffer has actually been
```
Should be `` [`Device::wait_until_sent`] `` (missing opening backtick).

**`Timeout::into_jiffies` silent overflow behavior:**
```rust
+    fn into_jiffies(self) -> isize {
+        match self {
+            Self::Jiffies(value) => value.get().try_into().unwrap_or_default(),
```
If the jiffies value overflows `isize`, `unwrap_or_default()` silently returns 0, which maps to `MAX_SCHEDULE_TIMEOUT` (wait forever). This is a safe fallback, but it's a silent semantic change. Consider documenting this behavior, or at minimum adding a code comment.

**SAFETY comments on `UnsafeCell<bool>` could be more precise:**

On the write side in `probe_callback`:
```rust
+            // SAFETY: We have exclusive access to `private_data.error`.
+            unsafe { *private_data.error.get() = result.is_err() };
```
This is correct because the write occurs before `complete_all()`, so no reader has passed the completion wait yet. The comment should mention this ordering guarantee.

On the read side in `receive_buf_callback`:
```rust
+        // SAFETY: No one has exclusive access to `private_data.error`.
+        if unsafe { *private_data.error.get() } {
```
This is safe because `wait_for_completion()` establishes a happens-before relationship with `complete_all()`, ensuring the write to `error` is visible. The comment should state this ordering guarantee rather than just asserting no exclusive access.

**Probe error paths and completion signaling:**

If `devm_serdev_device_open` fails, the `?` exits early without calling `complete_all()`. This is safe because the device isn't open so no data can arrive at the receive callback. However, if `T::probe` succeeds but `set_drvdata` fails, the completion *is* signaled and the error flag *is* set, so the receive callback will correctly discard data during the window before devres cleanup closes the device. This is well-handled.

**The `probe_callback` / `receive_buf_callback` synchronization** is well-designed for the probe/receive race: `set_client_ops` and `devm_serdev_device_open` are called before `T::probe`, so the device can receive data before driver data is ready. The `Completion` correctly serializes this.

**`write_all` return type semantics:**
```rust
+    pub fn write_all(&self, data: &[u8], timeout: Timeout) -> Result<usize> {
+        let ret = unsafe {
+            bindings::serdev_device_write(...)
+        };
+        to_result(ret as i32).map(|()| ret.unsigned_abs())
```
The `ret as i32` cast is documented as safe because error codes fit in `i32`. For success, `ret` is the number of bytes written (positive `ssize_t`). If somehow `ret > i32::MAX` (>2GB serial write), the cast would wrap to negative and be incorrectly treated as an error. In practice this can't happen over serial, but it's worth noting the assumption.

**`AlwaysRefCounted` for `Device`:**
```rust
+unsafe impl AlwaysRefCounted for Device {
+    fn inc_ref(&self) {
+        self.as_ref().inc_ref();
+    }
+
+    unsafe fn dec_ref(obj: NonNull<Self>) {
+        unsafe { bindings::serdev_device_put(obj.cast().as_ptr()) }
```
`inc_ref` delegates to the embedded `device::Device`, while `dec_ref` calls `serdev_device_put` directly. These are equivalent (both operate on the same underlying `struct device`), so this is correct.

---

---
Generated by Claude Code Patch Reviewer