gb_connection_hd_find() looks up a connection on a host device by its host-side CPort id. Callers that only know the remote end of a connection (the interface id and the CPort id) have no way to find it.

Add gb_connection_hd_find_by_intf(), which walks the host device's connection list and returns a reference-counted pointer to the matching connection, or NULL if there is none. The caller is responsible for dropping the reference with gb_connection_put(). The first user is gb-softsvc driver, added later in this series.

Signed-off-by: Ayush Singh ayush@beagleboard.org --- drivers/greybus/connection.c | 23 +++++++++++++++++++++++ include/linux/greybus/connection.h | 3 +++ 2 files changed, 26 insertions(+)

diff --git a/drivers/greybus/connection.c b/drivers/greybus/connection.c index f8fda22bc466..dc9eb49a69bc 100644 --- a/drivers/greybus/connection.c +++ b/drivers/greybus/connection.c @@ -71,6 +71,29 @@ gb_connection_hd_find(struct gb_host_device *hd, u16 cport_id) return connection; }

+struct gb_connection *gb_connection_hd_find_by_intf(struct gb_host_device *hd, + u8 intf_id, u16 intf_cport) +{ + struct gb_connection *connection; + unsigned long flags; + + spin_lock_irqsave(&gb_connections_lock, flags); + list_for_each_entry(connection, &hd->connections, hd_links) { + if (connection->intf && + connection->intf->interface_id == intf_id && + connection->intf_cport_id == intf_cport) { + gb_connection_get(connection); + goto found; + } + } + connection = NULL; +found: + spin_unlock_irqrestore(&gb_connections_lock, flags); + + return connection; +} +EXPORT_SYMBOL_GPL(gb_connection_hd_find_by_intf); + /* * Callback from the host driver to let us know that data has been * received on the bundle. diff --git a/include/linux/greybus/connection.h b/include/linux/greybus/connection.h index b53aad2270d6..589721d46015 100644 --- a/include/linux/greybus/connection.h +++ b/include/linux/greybus/connection.h @@ -131,4 +131,7 @@ static inline void gb_connection_set_data(struct gb_connection *connection, void gb_connection_get(struct gb_connection *connection); void gb_connection_put(struct gb_connection *connection);

+struct gb_connection *gb_connection_hd_find_by_intf(struct gb_host_device *hd, + u8 intf_id, u16 intf_cport); + #endif /* __CONNECTION_H */

Add Rust abstractions for the Greybus core, enough to implement a Greybus host driver in Rust.

The abstractions are split into 3 modules:

- Top level mod.rs: Basic abstractions greybus structures. - hd.rs: Greybus Host Device specific abstractions. - protocols.rs: Abstractions for greybus_protocols.h, i.e. greybus protocol types and constants.

Only the APIs used by gb-softsvc and gb-uart-node driver are covered. As such, protocols.rs also only contains abstractions for greybus structures that are used by SVC and some types such as Greybus Interface do not implement AlwaysRefCounted at the moment.

HdDriver Note **************

In C message_send callback, it is possible for the caller to defer calling gb_message_sent. This is used in es2 driver. However, looking at the internals, it does not seem like the message owenership is actually transferred to the caller in real terms. Instead, it is more like the caller is shared ownership. This is evident ny the fact that message_cancel can be called at any point, and depending on wheather the message is request or response, the message can become invalid after the message_cancel callback. Thus the driver is expected to ensure that no dangling references to that message exist.

Since gb_message is not an internally ref counted structure in true terms (it does seem to use the ref counting in the internal operation), and since double calls to gb_message_sent are not really allowed, I have made the decision to call gb_message_sent on a message in the abstractions rather than making the driver call it. This means the driver only gets a reference to the message, and never owns it. This does prevent a driver to use it in the way es2 currently does, but seems much less of a footgun.

Another possibility would be to implement AlwaysRefCounted on Message and pass the calls to gb_operation_get/put, but I have not gone through the internals enough to figure out if this is correct in all cases.

Signed-off-by: Ayush Singh ayush@beagleboard.org --- MAINTAINERS | 1 + drivers/greybus/Kconfig | 7 + rust/bindings/bindings_helper.h | 1 + rust/kernel/alloc.rs | 5 + rust/kernel/greybus/hd.rs | 333 +++++++++++++++++++++++++++++++++ rust/kernel/greybus/mod.rs | 232 +++++++++++++++++++++++ rust/kernel/greybus/protocols.rs | 392 +++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 2 + 8 files changed, 973 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS index 1e3b42eff741..80247a031353 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -11338,6 +11338,7 @@ F: drivers/greybus/ F: drivers/staging/greybus/ F: include/linux/greybus.h F: include/linux/greybus/ +F: rust/kernel/greybus/

GREYBUS UART PROTOCOLS DRIVERS M: David Lin dtwlin@gmail.com diff --git a/drivers/greybus/Kconfig b/drivers/greybus/Kconfig index c3f056d28b01..3bf3b8691442 100644 --- a/drivers/greybus/Kconfig +++ b/drivers/greybus/Kconfig @@ -15,6 +15,13 @@ menuconfig GREYBUS To compile this code as a module, choose M here: the module will be called greybus.ko

+config RUST_GREYBUS_ABSTRACTIONS + bool "Rust greybus abstractions" + depends on RUST + select GREYBUS + help + This enables the Rust abstraction for the Greybus API. + if GREYBUS

config GREYBUS_BEAGLEPLAY diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h index 6eb3caaee497..ded5300e75da 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -62,6 +62,7 @@ #include <linux/file.h> #include <linux/firmware.h> #include <linux/fs.h> +#include <linux/greybus.h> #include <linux/i2c.h> #include <linux/interrupt.h> #include <linux/io-pgtable.h> diff --git a/rust/kernel/alloc.rs b/rust/kernel/alloc.rs index 21067bde6860..d0ba4d91b3d3 100644 --- a/rust/kernel/alloc.rs +++ b/rust/kernel/alloc.rs @@ -38,6 +38,11 @@ pub struct Flags(u32);

impl Flags { + /// Create from gfp_t + pub(crate) fn new(v: bindings::gfp_t) -> Self { + Self(v) + } + /// Get the raw representation of this flag. pub(crate) fn as_raw(self) -> u32 { self.0 diff --git a/rust/kernel/greybus/hd.rs b/rust/kernel/greybus/hd.rs new file mode 100644 index 000000000000..ee2a4930ff2e --- /dev/null +++ b/rust/kernel/greybus/hd.rs @@ -0,0 +1,333 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Greybus host device abstractions. +//! +//! A driver implements the transmit path through [`HdDriver`] and feeds received data back into +//! the core with [`Device::data_rcvd`]. +//! +//! A host device is created, populated with driver private data and added to the Greybus bus by +//! constructing a [`Registration`], which owns the underlying `struct gb_host_device`. Dropping +//! the registration drops the private data and removes the device from the bus, so it is normally +//! stored in the driver data of the parent device and torn down implicitly when that device goes +//! away. +//! +//! Individual references to a live host device are represented by [`ARef<Device>`], which keeps +//! the embedded `struct device` reference count balanced. +//! +//! C header: [`include/linux/greybus/hd.h`](srctree/include/linux/greybus/hd.h) +//! +//! # Examples +//! +//! ```ignore +//! use kernel::{device, prelude::*}; +//! +//! struct MyHd { +//! // transport state +//! } +//! +//! #[vtable] +//! impl HdDriver for MyHd { +//! fn message_send(data: &Self, dest_cport_id: u16, msg: Message) -> Result { +//! // Copy what is needed out of `msg`, queue it, and return without sleeping. +//! // Call `HostDevice::message_sent()` once the core may release the message. +//! Ok(()) +//! } +//! +//! fn message_cancel(_msg: Message) {} +//! } +//! +//! fn probe(parent: &device::Device) -> Result<Registration<MyHd>> { +//! Registration::new(parent, BUFFER_SIZE_MAX, NUM_CPORTS, try_pin_init!(MyHd {})) +//! } +//! ``` + +use core::{ + marker::PhantomData, + ptr::{ + addr_of_mut, + NonNull, // + }, +}; + +use crate::{ + alloc::Flags, + device, + error::{ + code, + from_err_ptr, + to_result, // + }, + greybus::{ + Connection, + Message, // + }, + prelude::*, + sync::aref::{ + ARef, + AlwaysRefCounted, // + }, + types::Opaque, +}; + +/// The set of callbacks a Greybus host driver can provide. +#[vtable] +pub trait HdDriver: Send + Sync + Sized + 'static { + /// Transmits `msg` to `dest_cport_id`. + /// + /// This may be called in atomic context and therefore must not sleep; queue the message and + /// return. Once the core is allowed to release the message, call + /// [`HostDevice::message_sent`]. + /// + /// The message is only borrowed for the duration of this call: copy what is needed out of it, + /// do not stash the reference. + fn message_send(data: &Self, dest_cport_id: u16, msg: &Message, gfp_mask: Flags) -> Result; + + /// Aborts the transmission of a message previously handed to [`HdDriver::message_send`]. + /// + /// Always called in process context. + fn message_cancel(msg: &Message); +} + +/// Builds the C callback table for a [`HdDriver`] implementation. +struct HdDriverVTable<T: HdDriver>(PhantomData<T>); + +impl<T: HdDriver> HdDriverVTable<T> { + const DRIVER: bindings::gb_hd_driver = bindings::gb_hd_driver { + // Both are mandatory, hence no `HAS_*` check. See [`HdDriver`]. + message_send: Some(Self::message_send), + message_cancel: Some(Self::message_cancel), + // Every other callback is left `NULL`, which the Greybus core takes as "use the default + // behaviour". + ..pin_init::zeroed() + }; + + const fn build() -> &'static bindings::gb_hd_driver { + &Self::DRIVER + } + + /// # Safety + /// + /// `hd` must point at a registered host device whose private area holds a pointer to a live + /// `T`, and `msg` must point at a valid message. + unsafe extern "C" fn message_send( + hd: *mut bindings::gb_host_device, + dest_cport_id: u16, + msg: *mut bindings::gb_message, + gfp_mask: bindings::gfp_t, + ) -> c_int { + // SAFETY: `gb_host_device` and `HostDevice` have the same layout. + let hd = unsafe { Device::<device::CoreInternal<'_>>::from_raw(hd) }; + // SAFETY: `message_send` is only ever called after a successful call to + // `gb_hd_add`, hence it's guaranteed that `Device::set_drvdata()` has been called + // and stored a `Pin<KBox<T>>`. + let data = unsafe { hd.as_ref().drvdata_borrow() }; + // SAFETY: The caller guarantees `msg` is valid for the duration of this call. + let msg = unsafe { Message::from_raw(msg) }; + + match T::message_send(&data, dest_cport_id, msg, Flags::new(gfp_mask)) { + Ok(()) => { + // SAFETY: `msg` is still valid since `sent` is not called anywhere else. + unsafe { msg.sent(0) }; + 0 + } + Err(e) => e.to_errno(), + } + } + + /// # Safety + /// + /// `msg` must point at a valid message of a registered host device of this driver. + unsafe extern "C" fn message_cancel(msg: *mut bindings::gb_message) { + // SAFETY: The caller guarantees `msg` is valid for the duration of this call. + let msg = unsafe { Message::from_raw(msg) }; + T::message_cancel(msg); + } +} + +/// A Greybus host device. +/// +/// # Invariants +/// +/// The wrapped value is a valid `struct gb_host_device` created by `gb_hd_create()`, and every +/// [`ARef<HostDevice>`] owns an increment on its reference count. +#[repr(transparent)] +pub struct Device<Ctx = device::Normal> { + ptr: Opaquebindings::gb_host_device, + _ctx: PhantomData<Ctx>, +} + +// SAFETY: `gb_host_device` is reference counted through its embedded `struct device`, which may be +// used from any thread. +unsafe impl<Ctx> Send for Device<Ctx> {} + +// SAFETY: `gb_host_device` has its own internal locking, so it is safe to share references to it +// across threads. +unsafe impl<Ctx> Sync for Device<Ctx> {} + +// SAFETY: The embedded `struct device` carries the reference count, and `gb_hd_put()` is just +// `put_device()` on it, so the object stays alive for as long as increments are outstanding. +unsafe impl<Ctx> AlwaysRefCounted for Device<Ctx> { + #[inline] + fn inc_ref(&self) { + // SAFETY: By the type invariant there is a live reference to the host device, and `dev` is + // its embedded `struct device`. + unsafe { bindings::get_device(&raw mut (*self.ptr.get()).dev) }; + } + + #[inline] + unsafe fn dec_ref(obj: NonNull<Self>) { + // SAFETY: The caller guarantees it owns an increment on the reference count. + unsafe { bindings::gb_hd_put(obj.as_ptr().cast()) } + } +} + +impl<Ctx> Device<Ctx> { + /// # Safety + /// + /// `ptr` must be a valid pointer to a `struct gb_host_device`. + #[inline] + pub(crate) const unsafe fn from_raw<'a>(ptr: *mut bindings::gb_host_device) -> &'a Self { + // SAFETY: `Device` is a transparent wrapper of `Opaquebindings::gb_host_device`. + unsafe { &*ptr.cast() } + } + + #[inline] + pub(crate) fn as_raw(&self) -> *mut bindings::gb_host_device { + self.ptr.get() + } + + /// Hands a message received on `hd_cport_id` to the Greybus core. + #[inline] + pub fn data_rcvd(&self, cport_id: u16, msg: &[u8]) { + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid + // `struct gb_host_device`. `msg` is valid for reads of ``msg.len()` bytes for the duration + // of the call, and the core only reads through the pointer — it copies the payload into + // the operation before returning — so handing it a `*mut` derived from a shared reference + // is sound. + // + // TODO: The C signature of this function should be changed to take const pointer for msg. + unsafe { + bindings::greybus_data_rcvd(self.as_raw(), cport_id, msg.as_ptr().cast_mut(), msg.len()) + } + } + + /// Looks up the connection bound to `cport` on interface `id`. + pub fn find_connection_by_intf(&self, id: u8, cport: u16) -> Option<ARef<Connection>> { + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid + // `struct gb_host_device`. + let ptr = NonNull::new(unsafe { + bindings::gb_connection_hd_find_by_intf(self.as_raw(), id, cport) + })?; + + // SAFETY: ptr is a valid gb_connection + Some(unsafe { ARef::from_raw(ptr.cast()) }) + } +} + +impl<Ctx: device::DeviceContext> AsRef<device::Device<Ctx>> for Device<Ctx> { + #[inline] + fn as_ref(&self) -> &device::Device<Ctx> { + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid + // `struct gb_host_device`. `dev` points to a valid `struct device`. + unsafe { device::Device::from_raw(addr_of_mut!((*self.as_raw()).dev)) } + } +} + +/// A host device owned by its driver, together with the driver's private data `T`. +/// +/// Created and added to the Greybus bus on construction, removed on drop. +/// +/// # Invariants +/// +/// `ptr` points at a valid `struct gb_host_device` obtained from `gb_hd_create()`, whose driver +/// data holds a live `T` +#[repr(transparent)] +pub struct Registration<T> { + ptr: NonNullbindings::gb_host_device, + _data: PhantomData<T>, +} + +impl<T: HdDriver> Registration<T> { + /// Creates a host device under `parent` and adds it to the Greybus bus. + /// + /// `buffer_size_max` is the largest message the transport can carry in one go, header + /// included. `num_cports` is the number of cports that the greybus host device can connect to. + /// + /// `data` is initialised in place before the device is added, so callbacks may run against it + /// from the moment `gb_hd_add()` succeeds. + pub fn new( + parent: &device::Device, + buffer_size_max: usize, + num_cports: usize, + data: impl PinInit<T, Error>, + ) -> Result<Self> { + // SAFETY: `parent` is a valid device, and the driver table is `'static`. The core only + // ever reads through the driver pointer, so casting away `const` is fine. + let hd = from_err_ptr(unsafe { + bindings::gb_hd_create( + core::ptr::from_ref(HdDriverVTable::<T>::build()).cast_mut(), + parent.as_raw(), + buffer_size_max, + num_cports, + ) + })?; + + // SAFETY: `hd` is a valid pointer to `gb_host_device`. + let hd_dev: &Device<device::CoreInternal<'_>> = unsafe { Device::from_raw(hd) }; + hd_dev.as_ref().set_drvdata(data)?; + + // SAFETY: By the type invariant the host device is valid, and it has not been added yet. + to_result(unsafe { bindings::gb_hd_add(hd) })?; + + // INVARIANT: `gb_hd_create()` returns a valid `gb_host_device` on success, + // and we own the reference it returns until `Drop`. + Ok(Self { + ptr: NonNull::new(hd).ok_or(code::ENOMEM)?, + _data: PhantomData, + }) + } +} + +impl<T> Registration<T> { + fn as_raw(&self) -> *mut bindings::gb_host_device { + self.ptr.as_ptr() + } +} + +impl<T> AsRef<Device> for Registration<T> { + #[inline] + fn as_ref(&self) -> &Device { + // SAFETY: By the type invariant the host device is valid. + unsafe { Device::from_raw(self.as_raw()) } + } +} + +impl<T> Drop for Registration<T> { + fn drop<'a>(&'a mut self) { + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid + // `struct gb_host_device`. + unsafe { bindings::gb_hd_del(self.as_raw()) } + + { + // SAFETY: `hd` is a valid pointer to `gb_host_device`. + let hd_dev = unsafe { Device::<device::CoreInternal<'_>>::from_raw(self.as_raw()) }; + // SAFETY: The driver data was set to a `T` in `Registration::new()` and has not been + // taken since, and this is the only place that takes it. + drop(unsafe { hd_dev.as_ref().drvdata_obtain::<T>() }); + } + + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid + // `struct gb_host_device`. + unsafe { bindings::gb_hd_put(self.as_raw()) }; + } +} + +// SAFETY: The greybus host device API is thread-safe as guaranteed by the device core, as long as +// gb_hd_del() is guaranteed to only be called once - which is guaranteed by our type not +// having Copy/Clone. +unsafe impl<T: Send> Send for Registration<T> {} + +// SAFETY: The greybus device API is thread-safe as guaranteed by the device core, as long as +// gb_hd_del() is guaranteed to only be called once - which is guaranteed by our type not +// having Copy/Clone. +unsafe impl<T: Sync> Sync for Registration<T> {} diff --git a/rust/kernel/greybus/mod.rs b/rust/kernel/greybus/mod.rs new file mode 100644 index 000000000000..791aac38ec29 --- /dev/null +++ b/rust/kernel/greybus/mod.rs @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Abstractions for the Greybus core. +//! +//! C header: [`include/linux/greybus.h`](srctree/include/linux/greybus.h) +//! +//! Greybus host drivers ("host devices") bridge the Greybus core to whatever transport actually +//! carries the traffic. A host driver creates a [`HostDevice`], registers it, and implements +//! [`HdDriver`] to transmit the messages the core hands it. + +use core::ptr::NonNull; + +use crate::{ + sync::aref::AlwaysRefCounted, + transmute::FromBytes, + types::Opaque, // +}; + +pub mod hd; +pub mod protocols; + +/// The largest Greybus message, header included. +/// +/// Bounded by the 16-bit `size` field in the operation header. +pub const GB_OPERATION_SIZE_MAX: usize = u16::MAX as usize; + +/// The largest valid CPort id. +/// +/// Ids above this are reserved by the protocol; a host device's `num_cports` cannot exceed +/// `CPORT_ID_MAX + 1`. +pub const CPORT_ID_MAX: usize = bindings::CPORT_ID_MAX as usize; + +/// A Greybus message handed to a host driver for transmission. +/// +/// # Invariants +/// +/// The shared reference is only ever handed out for the duration of a [`HdDriver`] callback, during +/// which the Greybus core guarantees the message and its buffer stay alive. +#[repr(transparent)] +pub struct Message(Opaquebindings::gb_message); + +impl Message { + /// # Safety + /// + /// `ptr` must be non-null and point at a valid `struct gb_message` which outlives the + /// returned `Self`. + #[inline] + pub(crate) const unsafe fn from_raw<'a>(ptr: *mut bindings::gb_message) -> &'a Self { + // SAFETY: `Message` is a transparent wrapper of `Opaquebindings::gb_message`. + unsafe { &*ptr.cast() } + } + + /// Returns the operation header at the start of the message. + #[inline] + pub const fn header(&self) -> &protocols::GbOperationMsgHdr { + // SAFETY: `header` points at a valid `gb_operation_msg_hdr` for as long as the message is + // alive, and `GbOperationMsgHdr` is a transparent wrapper of it. + unsafe { &*(*self.0.get()).header.cast() } + } + + /// # Safety + /// + /// `Message` is not valid after this call. + #[inline] + pub(crate) unsafe fn sent(&self, status: i32) { + // SAFETY: By the type invariant the message is valid and still owned by the transport, + // and its connection and host device are alive for as long as it is. + unsafe { + bindings::greybus_message_sent( + self.operation().connection().host_device().as_raw(), + self.0.get(), + status, + ); + } + } + + /// Returns the payload, i.e. the message without its operation header. + pub const fn payload_bytes(&self) -> &[u8] { + // SAFETY: By the type invariant the message is valid. + let payload = unsafe { (*self.0.get()).payload }; + // SAFETY: By the type invariant the message is valid. + let payload_size = unsafe { (*self.0.get()).payload_size }; + + if payload.is_null() || payload_size == 0 { + return &[]; + } + + // SAFETY: A non-null `payload` points at `payload_size` initialized bytes. + unsafe { core::slice::from_raw_parts(payload.cast::<u8>(), payload_size) } + } + + /// Interprets the message payload as a `T`. + /// + /// Returns `None` if the payload is too short or misaligned for `T`. + #[inline] + pub fn payload<T: FromBytes>(&self) -> Option<&T> { + T::from_bytes(self.payload_bytes()) + } + + /// Returns the operation this message belongs to. + #[inline] + pub const fn operation(&self) -> &Operation { + // SAFETY: By the type invariant the message is valid, and its `operation` is set for as + // long as the message is alive. + unsafe { Operation::from_raw((*self.0.get()).operation) } + } +} + +/// A Greybus operation. +/// +/// # Invariants +/// +/// The wrapped value is a valid `struct gb_operation`. +#[repr(transparent)] +pub struct Operation(Opaquebindings::gb_operation); + +impl Operation { + /// # Safety + /// + /// `ptr` must be a valid pointer to a `struct gb_operation`. + #[inline] + pub(crate) const unsafe fn from_raw<'a>(ptr: *mut bindings::gb_operation) -> &'a Self { + // SAFETY: `Operation` is a transparent wrapper of `Opaquebindings::gb_operation`. + unsafe { &*ptr.cast() } + } + + /// Returns the connection this operation travels on. + #[inline] + pub const fn connection(&self) -> &Connection { + // SAFETY: By the type invariant the operation is valid, and its `connection` is alive for + // as long as the operation is. + unsafe { Connection::from_raw((*self.0.get()).connection) } + } +} + +/// A Greybus connection. +/// +/// # Invariants +/// +/// The wrapped value is a valid `struct gb_connection`. +#[repr(transparent)] +pub struct Connection(Opaquebindings::gb_connection); + +// SAFETY: `gb_connection_put()` drops the reference acquired by `gb_connection_get()`, so the +// connection stays alive for as long as increments are outstanding. +unsafe impl AlwaysRefCounted for Connection { + #[inline] + fn inc_ref(&self) { + // SAFETY: By the type invariant there is a live reference to the connection. + unsafe { bindings::gb_connection_get(self.0.get()) } + } + + #[inline] + unsafe fn dec_ref(obj: NonNull<Self>) { + // SAFETY: The caller guarantees it owns an increment on the reference count. + unsafe { bindings::gb_connection_put(obj.as_ptr().cast()) } + } +} + +impl Connection { + /// # Safety + /// + /// `ptr` must be a valid pointer to a `struct gb_connection`. + #[inline] + pub(crate) const unsafe fn from_raw<'a>(ptr: *mut bindings::gb_connection) -> &'a Self { + // SAFETY: `Connection` is a transparent wrapper of `Opaquebindings::gb_connection`. + unsafe { &*ptr.cast() } + } + + /// Returns the interface at the far end of the connection. In cases like SVC connection, + /// interface can be NULL. + #[inline] + pub const fn interface(&self) -> Option<&Interface> { + // SAFETY: By the type invariant the connection is valid. + let intf_ptr = unsafe { (*self.0.get()).intf }; + + if intf_ptr.is_null() { + None + } else { + // SAFETY: By the previous check, intf_ptr is valid. + Some(unsafe { Interface::from_raw(intf_ptr) }) + } + } + + /// Returns the CPort id this connection uses on the interface. + #[inline] + pub const fn intf_cport_id(&self) -> u16 { + // SAFETY: By the type invariant the connection is valid. + unsafe { (*self.0.get()).intf_cport_id } + } + + /// Returns the CPort id this connection uses on the host device. + #[inline] + pub const fn hd_cport_id(&self) -> u16 { + // SAFETY: By the type invariant the connection is valid. + unsafe { (*self.0.get()).hd_cport_id } + } + + /// Returns the host device this connection belongs to. + #[inline] + pub const fn host_device(&self) -> &hd::Device { + // SAFETY: By the type invariant the connection is valid, and its `hd` is alive for as + // long as the connection is. + unsafe { hd::Device::from_raw((*self.0.get()).hd) } + } +} + +/// A Greybus interface. +/// +/// # Invariants +/// +/// The wrapped value is a valid `struct gb_interface`. +#[repr(transparent)] +pub struct Interface(Opaquebindings::gb_interface); + +impl Interface { + /// # Safety + /// + /// `ptr` must be a valid pointer to a `struct gb_interface`. + #[inline] + pub(crate) const unsafe fn from_raw<'a>(ptr: *mut bindings::gb_interface) -> &'a Self { + // SAFETY: `Interface` is a transparent wrapper of `Opaquebindings::gb_interface`. + unsafe { &*ptr.cast() } + } + + /// Returns the interface id, unique within its host device. + #[inline] + pub const fn id(&self) -> u8 { + // SAFETY: By the type invariant the interface is valid. + unsafe { (*self.0.get()).interface_id } + } +} diff --git a/rust/kernel/greybus/protocols.rs b/rust/kernel/greybus/protocols.rs new file mode 100644 index 000000000000..4658ace5e323 --- /dev/null +++ b/rust/kernel/greybus/protocols.rs @@ -0,0 +1,392 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Greybus wire format definitions. +//! +//! Thin `repr(transparent)` wrappers over the generated bindings for the operation header and the +//! SVC protocol messages, plus the constants that go in their type and result fields. The +//! wrappers exist to keep the byte-order conversions in one place: constructors take native-endian +//! values and store little-endian, accessors convert back. + +/// Set in the header type field to mark a message as a response to the operation of the same id. +pub const MESSAGE_TYPE_RESPONSE: u8 = 0x80; + +/// The CPort id reserved for the SVC connection on every host device. +pub const GB_SVC_CPORT_ID: u16 = bindings::GB_SVC_CPORT_ID as u16; + +/// Defines `u8` constants from same-named `bindings` values. +macro_rules! gb_u8_consts { + ($($name:ident),* $(,)?) => { + $( + #[allow(missing_docs)] + pub const $name: u8 = bindings::$name as u8; + )* + }; +} + +// SVC Operation Types +gb_u8_consts! { + GB_SVC_TYPE_PROTOCOL_VERSION, + GB_SVC_TYPE_SVC_HELLO, + GB_SVC_TYPE_INTF_DEVICE_ID, + GB_SVC_TYPE_INTF_RESET, + GB_SVC_TYPE_CONN_CREATE, + GB_SVC_TYPE_CONN_DESTROY, + GB_SVC_TYPE_DME_PEER_GET, + GB_SVC_TYPE_DME_PEER_SET, + GB_SVC_TYPE_ROUTE_CREATE, + GB_SVC_TYPE_ROUTE_DESTROY, + GB_SVC_TYPE_TIMESYNC_ENABLE, + GB_SVC_TYPE_TIMESYNC_DISABLE, + GB_SVC_TYPE_TIMESYNC_AUTHORITATIVE, + GB_SVC_TYPE_INTF_SET_PWRM, + GB_SVC_TYPE_INTF_EJECT, + GB_SVC_TYPE_PING, + GB_SVC_TYPE_PWRMON_RAIL_COUNT_GET, + GB_SVC_TYPE_PWRMON_RAIL_NAMES_GET, + GB_SVC_TYPE_PWRMON_SAMPLE_GET, + GB_SVC_TYPE_PWRMON_INTF_SAMPLE_GET, + GB_SVC_TYPE_TIMESYNC_WAKE_PINS_ACQUIRE, + GB_SVC_TYPE_TIMESYNC_WAKE_PINS_RELEASE, + GB_SVC_TYPE_TIMESYNC_PING, + GB_SVC_TYPE_MODULE_INSERTED, + GB_SVC_TYPE_MODULE_REMOVED, + GB_SVC_TYPE_INTF_VSYS_ENABLE, + GB_SVC_TYPE_INTF_VSYS_DISABLE, + GB_SVC_TYPE_INTF_REFCLK_ENABLE, + GB_SVC_TYPE_INTF_REFCLK_DISABLE, + GB_SVC_TYPE_INTF_UNIPRO_ENABLE, + GB_SVC_TYPE_INTF_UNIPRO_DISABLE, + GB_SVC_TYPE_INTF_ACTIVATE, + GB_SVC_TYPE_INTF_RESUME, + GB_SVC_TYPE_INTF_MAILBOX_EVENT, + GB_SVC_TYPE_INTF_OOPS, +} + +// UNIPRO modes +gb_u8_consts! { + GB_SVC_UNIPRO_FAST_MODE, + GB_SVC_UNIPRO_SLOW_MODE, + GB_SVC_UNIPRO_FAST_AUTO_MODE, + GB_SVC_UNIPRO_SLOW_AUTO_MODE, + GB_SVC_UNIPRO_MODE_UNCHANGED, + GB_SVC_UNIPRO_HIBERNATE_MODE, + GB_SVC_UNIPRO_OFF_MODE, +} + +// PWR States +gb_u8_consts! { + GB_SVC_SETPWRM_PWR_OK, + GB_SVC_SETPWRM_PWR_LOCAL, + GB_SVC_SETPWRM_PWR_REMOTE, + GB_SVC_SETPWRM_PWR_BUSY, + GB_SVC_SETPWRM_PWR_ERROR_CAP, + GB_SVC_SETPWRM_PWR_FATAL_ERROR, +} + +// Vsys Result +gb_u8_consts! { + GB_SVC_INTF_VSYS_OK, + GB_SVC_INTF_VSYS_FAIL, +} + +// Refclk Result +gb_u8_consts! { + GB_SVC_INTF_REFCLK_OK, + GB_SVC_INTF_REFCLK_FAIL, +} + +// Unipro Result +gb_u8_consts! { + GB_SVC_INTF_UNIPRO_OK, + GB_SVC_INTF_UNIPRO_FAIL, + GB_SVC_INTF_UNIPRO_NOT_OFF, +} + +// Op Codes +gb_u8_consts! { + GB_SVC_OP_SUCCESS, + GB_SVC_OP_UNKNOWN_ERROR, + GB_SVC_INTF_NOT_DETECTED, + GB_SVC_INTF_NO_UPRO_LINK, + GB_SVC_INTF_UPRO_NOT_DOWN, + GB_SVC_INTF_UPRO_NOT_HIBERNATED, + GB_SVC_INTF_NO_V_SYS, + GB_SVC_INTF_V_CHG, + GB_SVC_INTF_WAKE_BUSY, + GB_SVC_INTF_NO_REFCLK, + GB_SVC_INTF_RELEASING, + GB_SVC_INTF_NO_ORDER, + GB_SVC_INTF_MBOX_SET, + GB_SVC_INTF_BAD_MBOX, + GB_SVC_INTF_OP_TIMEOUT, + GB_SVC_PWRMON_OP_NOT_PRESENT, +} + +// Greybus Interface Types +gb_u8_consts! { + GB_SVC_INTF_TYPE_UNKNOWN, + GB_SVC_INTF_TYPE_DUMMY, + GB_SVC_INTF_TYPE_UNIPRO, + GB_SVC_INTF_TYPE_GREYBUS, +} + +/// The header every Greybus message starts with. +/// +/// # Invariants +/// +/// The `size` field covers the header and the payload that follows it. +#[repr(transparent)] +pub struct GbOperationMsgHdr(bindings::gb_operation_msg_hdr); + +// SAFETY: `gb_operation_msg_hdr` is a POD type with no padding and no interior mutability. +unsafe impl kernel::transmute::AsBytes for GbOperationMsgHdr {} + +impl GbOperationMsgHdr { + /// Builds a header. `size` is the whole message, this header included. + #[inline] + pub const fn new(size: u16, operation_id: u16, type_: u8, result: u8) -> Self { + Self(bindings::gb_operation_msg_hdr { + size: size.to_le(), + operation_id: operation_id.to_le(), + type_, + result, + pad: [0u8; 2], + }) + } + + /// Returns the type field, response bit included. + #[inline] + pub const fn msg_type(&self) -> u8 { + self.0.type_ + } + + /// Returns whether this is a response rather than a request. + #[inline] + pub const fn is_response(&self) -> bool { + self.0.type_ & MESSAGE_TYPE_RESPONSE != 0 + } + + /// Returns the operation id pairing a response with its request. Zero for unidirectional + /// messages. + #[inline] + pub const fn operation_id(&self) -> u16 { + u16::from_le(self.0.operation_id) + } + + /// Returns the type field with the response bit cleared. + #[inline] + pub const fn request_type(&self) -> u8 { + self.msg_type() & !MESSAGE_TYPE_RESPONSE + } + + /// Returns the whole message size, this header included. + #[inline] + pub const fn size(&self) -> u16 { + u16::from_le(self.0.size) + } +} + +/// Request for [`GB_SVC_TYPE_PROTOCOL_VERSION`]. +#[repr(transparent)] +pub struct GbSvcVersionRequest(bindings::gb_svc_version_request); + +impl GbSvcVersionRequest { + /// Creates a request advertising SVC protocol version `major`.`minor`. + #[inline] + pub const fn new(major: u8, minor: u8) -> Self { + Self(bindings::gb_svc_version_request { major, minor }) + } +} + +/// Request for [`GB_SVC_TYPE_SVC_HELLO`]. +#[repr(transparent)] +pub struct GbSvcHelloRequest(bindings::gb_svc_hello_request); + +impl GbSvcHelloRequest { + /// Creates a hello request identifying the endo as `endo_id` and the AP's own interface as + /// `interface_id`. + #[inline] + pub const fn new(endo_id: u16, interface_id: u8) -> Self { + Self(bindings::gb_svc_hello_request { + endo_id: endo_id.to_le(), + interface_id, + }) + } +} + +/// Request for [`GB_SVC_TYPE_INTF_SET_PWRM`]. +#[repr(transparent)] +pub struct GbSvcIntfSetPwrmRequest(bindings::gb_svc_intf_set_pwrm_request); + +// SAFETY: `gb_svc_intf_set_pwrm_request` is a struct of `u8` fields, so every bit pattern of its +// size is a valid instance. +unsafe impl kernel::transmute::FromBytes for GbSvcIntfSetPwrmRequest {} + +impl GbSvcIntfSetPwrmRequest { + /// Returns the requested TX gear, one of the `GB_SVC_UNIPRO_*` modes. + #[inline] + pub const fn tx_mode(&self) -> u8 { + self.0.tx_mode + } + + /// Returns the requested RX gear, one of the `GB_SVC_UNIPRO_*` modes. + #[inline] + pub const fn rx_mode(&self) -> u8 { + self.0.rx_mode + } +} + +/// Response to [`GB_SVC_TYPE_INTF_SET_PWRM`]. +#[repr(transparent)] +pub struct GbSvcIntfSetPwrmResponse(bindings::gb_svc_intf_set_pwrm_response); + +impl GbSvcIntfSetPwrmResponse { + /// `result_code` is one of the `GB_SVC_SETPWRM_PWR_*` codes. + #[inline] + pub const fn new(result_code: u8) -> Self { + Self(bindings::gb_svc_intf_set_pwrm_response { result_code }) + } +} + +/// Response to [`GB_SVC_TYPE_DME_PEER_GET`]. +#[repr(transparent)] +pub struct GbSvcDmePeerGetResponse(bindings::gb_svc_dme_peer_get_response); + +impl GbSvcDmePeerGetResponse { + /// `result_code` is the UniPro `ConfigResultCode`; `attr_value` is the UniPro attribute + /// value. + #[inline] + pub const fn new(result_code: u16, attr_value: u32) -> Self { + Self(bindings::gb_svc_dme_peer_get_response { + result_code: result_code.to_le(), + attr_value: attr_value.to_le(), + }) + } +} + +/// Response to [`GB_SVC_TYPE_DME_PEER_SET`]. +#[repr(transparent)] +pub struct GbSvcDmePeerSetResponse(bindings::gb_svc_dme_peer_set_response); + +impl GbSvcDmePeerSetResponse { + /// `result_code` is the UniPro `ConfigResultCode`. + #[inline] + pub const fn new(result_code: u16) -> Self { + Self(bindings::gb_svc_dme_peer_set_response { + result_code: result_code.to_le(), + }) + } +} + +/// Response to [`GB_SVC_TYPE_PWRMON_RAIL_COUNT_GET`]. +#[repr(transparent)] +pub struct GbSvcPwrmonRailCountGetResponse(bindings::gb_svc_pwrmon_rail_count_get_response); + +impl GbSvcPwrmonRailCountGetResponse { + /// Creates a response reporting `rail_count` available rails. + #[inline] + pub const fn new(rail_count: u8) -> Self { + Self(bindings::gb_svc_pwrmon_rail_count_get_response { rail_count }) + } +} + +/// Response to [`GB_SVC_TYPE_INTF_VSYS_ENABLE`] and [`GB_SVC_TYPE_INTF_VSYS_DISABLE`]. +#[repr(transparent)] +pub struct GbSvcIntfVsysResponse(bindings::gb_svc_intf_vsys_response); + +impl GbSvcIntfVsysResponse { + /// `result_code` is [`GB_SVC_INTF_VSYS_OK`] or [`GB_SVC_INTF_VSYS_FAIL`]. + #[inline] + pub const fn new(result_code: u8) -> Self { + Self(bindings::gb_svc_intf_vsys_response { result_code }) + } +} + +/// Response to [`GB_SVC_TYPE_INTF_REFCLK_ENABLE`] and [`GB_SVC_TYPE_INTF_REFCLK_DISABLE`]. +#[repr(transparent)] +pub struct GbSvcIntfRefclkResponse(bindings::gb_svc_intf_refclk_response); + +impl GbSvcIntfRefclkResponse { + /// `result_code` is [`GB_SVC_INTF_REFCLK_OK`] or [`GB_SVC_INTF_REFCLK_FAIL`]. + #[inline] + pub const fn new(result_code: u8) -> Self { + Self(bindings::gb_svc_intf_refclk_response { result_code }) + } +} + +/// Response to [`GB_SVC_TYPE_INTF_UNIPRO_ENABLE`] and [`GB_SVC_TYPE_INTF_UNIPRO_DISABLE`]. +#[repr(transparent)] +pub struct GbSvcIntfUniproResponse(bindings::gb_svc_intf_unipro_response); + +impl GbSvcIntfUniproResponse { + /// `result_code` is one of the `GB_SVC_INTF_UNIPRO_*` codes. + #[inline] + pub const fn new(result_code: u8) -> Self { + Self(bindings::gb_svc_intf_unipro_response { result_code }) + } +} + +/// Response to [`GB_SVC_TYPE_INTF_ACTIVATE`]. +#[repr(transparent)] +pub struct GbSvcIntfActivateResponse(bindings::gb_svc_intf_activate_response); + +impl GbSvcIntfActivateResponse { + /// `status` is one of the `GB_SVC_OP_*` codes; `intf_type` is one of the + /// `GB_SVC_INTF_TYPE_*` values and is only meaningful when `status` is + /// [`GB_SVC_OP_SUCCESS`]. + #[inline] + pub const fn new(status: u8, intf_type: u8) -> Self { + Self(bindings::gb_svc_intf_activate_response { status, intf_type }) + } +} + +/// Response to [`GB_SVC_TYPE_INTF_RESUME`]. +#[repr(transparent)] +pub struct GbSvcIntfResumeResponse(bindings::gb_svc_intf_resume_response); + +impl GbSvcIntfResumeResponse { + /// `status` is one of the `GB_SVC_OP_*` codes. + #[inline] + pub const fn new(status: u8) -> Self { + Self(bindings::gb_svc_intf_resume_response { status }) + } +} + +/// Request for [`GB_SVC_TYPE_MODULE_INSERTED`]. +#[repr(transparent)] +pub struct GbSvcModuleInsertedRequest(bindings::gb_svc_module_inserted_request); + +impl GbSvcModuleInsertedRequest { + /// The module spans `intf_count` consecutive interfaces starting at `primary_intf_id`. + /// `flags` is a mask of `GB_SVC_MODULE_INSERTED_FLAG_*` values. + #[inline] + pub const fn new(primary_intf_id: u8, intf_count: u8, flags: u16) -> Self { + Self(bindings::gb_svc_module_inserted_request { + primary_intf_id, + intf_count, + flags: flags.to_le(), + }) + } +} + +/// Request for [`GB_SVC_TYPE_MODULE_REMOVED`]. +#[repr(transparent)] +pub struct GbSvcModuleRemovedRequest(bindings::gb_svc_module_removed_request); + +// SAFETY: `gb_svc_module_removed_request` is a struct of `u8` field, so every bit pattern of its +// size is a valid instance. +unsafe impl kernel::transmute::FromBytes for GbSvcModuleRemovedRequest {} + +impl GbSvcModuleRemovedRequest { + /// `primary_intf_id` identifies the module, and matches the one given when it was inserted. + #[inline] + pub const fn new(primary_intf_id: u8) -> Self { + Self(bindings::gb_svc_module_removed_request { primary_intf_id }) + } + + /// Returns the primary_intf_id field. + #[inline] + pub const fn primary_intf_id(&self) -> u8 { + self.0.primary_intf_id + } +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 45c4f4db51d2..fca4f1795fea 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -80,6 +80,8 @@ pub mod fs; #[cfg(CONFIG_GPU_BUDDY = "y")] pub mod gpu; +#[cfg(CONFIG_RUST_GREYBUS_ABSTRACTIONS)] +pub mod greybus; #[cfg(CONFIG_I2C = "y")] pub mod i2c; pub mod id_pool;

Add devicetree bindings for the BeagleBoard.org BeagleConnect Freedom, a wireless-enabled board based on the TI CC1352P7. The board exposes an MCU that can be attached to a host over USB, UART, SPI or I2C, and is described as a child node of the corresponding bus.

Signed-off-by: Ayush Singh ayush@beagleboard.org --- .../beagle/beagle,beagleconnect-freedom.yaml | 39 ++++++++++++++++++++++ MAINTAINERS | 6 ++++ 2 files changed, 45 insertions(+)

diff --git a/Documentation/devicetree/bindings/beagle/beagle,beagleconnect-freedom.yaml b/Documentation/devicetree/bindings/beagle/beagle,beagleconnect-freedom.yaml new file mode 100644 index 000000000000..be051a39acdc --- /dev/null +++ b/Documentation/devicetree/bindings/beagle/beagle,beagleconnect-freedom.yaml @@ -0,0 +1,39 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/beagle/beagle,beagleconnect-freedom.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: BeagleBoard.org BeagleConnect Freedom + +description: + The BeagleBoard.org BeagleConnect Freedom board connected over USB, UART, SPI or I2C. + +maintainers: + - Ayush Singh ayush@beagleboard.org + +properties: + compatible: + const: beagle,beagleconnect-freedom + + reg: + maxItems: 1 + + vbat-supply: true + +required: + - compatible + +allOf: + - $ref: /schemas/spi/spi-peripheral-props.yaml# + +unevaluatedProperties: false + +examples: + - | + serial { + mcu { + compatible = "beagle,beagleconnect-freedom"; + vbat-supply = <&vbat>; + }; + }; diff --git a/MAINTAINERS b/MAINTAINERS index 3ba56cdbf056..d047090be5f4 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -11334,6 +11334,12 @@ L: greybus-dev@lists.linaro.org (moderated for non-subscribers) S: Maintained F: drivers/greybus/gb_softsvc.rs

+GREYBUS UART NODE DRIVERS +M: Ayush Singh ayush@beagleboard.com +L: greybus-dev@lists.linaro.org (moderated for non-subscribers) +S: Maintained +F: Documentation/devicetree/bindings/beagle/beagle,beagleconnect-freedom.yaml + GREYBUS SUBSYSTEM M: Johan Hovold johan@kernel.org M: Alex Elder elder@kernel.org

Add a driver for Greybus nodes attached over a plain serial port. The node is registered with the software SVC (gb-softsvc), which handles the SVC protocol on behalf of the AP, so no dedicated coprocessor running SVC firmware is needed.

Greybus messages are carried over HDLC framing on the wire. Each frame carries a one-byte address (0x01 for Greybus) and control byte, followed by the 16-bit CPort ID and the Greybus message itself.

Port parameters are taken from the firmware node: "baudrate" if present, otherwise 115200, with flow control and parity disabled.

Since gb-uart-node imports types from gb-softsvc, Rust to Rust calling setup from nova-core [0] is being used.

[0]: https://lore.kernel.org/all/20260622-nova-exports-v5-0-6191773fc977@nvidia.c...

Signed-off-by: Ayush Singh ayush@beagleboard.org --- MAINTAINERS | 1 + drivers/greybus/.gitignore | 1 + drivers/greybus/Kconfig | 15 +++ drivers/greybus/Makefile | 48 ++++++++ drivers/greybus/gb_uart_node.rs | 245 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 310 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS index d047090be5f4..49c6dac72748 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -11339,6 +11339,7 @@ M: Ayush Singh ayush@beagleboard.com L: greybus-dev@lists.linaro.org (moderated for non-subscribers) S: Maintained F: Documentation/devicetree/bindings/beagle/beagle,beagleconnect-freedom.yaml +F: drivers/greybus/gb_uart_node.rs

GREYBUS SUBSYSTEM M: Johan Hovold johan@kernel.org diff --git a/drivers/greybus/.gitignore b/drivers/greybus/.gitignore new file mode 100644 index 000000000000..ff9c4a3539b4 --- /dev/null +++ b/drivers/greybus/.gitignore @@ -0,0 +1 @@ +exports_gb_softsvc_generated.h diff --git a/drivers/greybus/Kconfig b/drivers/greybus/Kconfig index 381d1a6ee135..34de913af287 100644 --- a/drivers/greybus/Kconfig +++ b/drivers/greybus/Kconfig @@ -60,5 +60,20 @@ config GREYBUS_SOFTSVC To compile this code as a module, choose M here: the module will be called gb-softsvc.ko

+config GREYBUS_UART_NODE + tristate "Greybus UART node transport" + depends on RUST + depends on GREYBUS_SOFTSVC + depends on RUST_SERIAL_DEV_BUS_ABSTRACTIONS + select RUST_CRC_CCITT_ABSTRACTIONS + help + Select this option if you have a Greybus node connected over a + serial port. The node is registered with the software SVC, which + handles the SVC protocol on behalf of the AP, so no dedicated + coprocessor running SVC firmware is required. + + To compile this code as a module, choose M here: the module + will be called gb-uart-node.ko + endif # GREYBUS

diff --git a/drivers/greybus/Makefile b/drivers/greybus/Makefile index e6f594128802..81151963c01e 100644 --- a/drivers/greybus/Makefile +++ b/drivers/greybus/Makefile @@ -28,3 +28,51 @@ obj-$(CONFIG_GREYBUS_ES2) += gb-es2.o obj-$(CONFIG_GREYBUS_SOFTSVC) += gb-softsvc.o gb-softsvc-y += gb_softsvc.o gb_softsvc_exports.o

+obj-$(CONFIG_GREYBUS_UART_NODE) += gb-uart-node.o +gb-uart-node-y += gb_uart_node.o + +# Export Rust symbols from gb-softsvc only if gb-uart-node actually references them. +gb-softsvc-export-deps := $(if $(CONFIG_GREYBUS_UART_NODE),$(obj)/gb_uart_node.o) + +rust_needed_exports = \ + { $(if $(strip $(2)),$(NM) -u $(2);,) echo "__DEFINED_RUST_SYMBOLS__"; \ + $(NM) -p --defined-only $(1); } | \ + awk -v fmt='$(3)' ' \ + /^__DEFINED_RUST_SYMBOLS__$$/ { defs = 1; next } \ + !defs { if ($$NF ~ /^_R/) needed[$$NF] = 1; next } \ + defs && $$2 ~ /(T|R|D|B)/ && $$3 ~ /^_R/ && \ + $$3 !~ /_(init|cleanup)_module$$/ && \ + $$3 !~ /__(pfx|cfi|odr_asan)/ && \ + $$3 in needed { printf fmt, $$3 } \ + ' + +quiet_cmd_exports = EXPORTS $@ + cmd_exports = \ + $(call rust_needed_exports,$<,$(gb-softsvc-export-deps),EXPORT_SYMBOL_RUST_GPL(%s);\n) > $@ + +$(obj)/exports_gb_softsvc_generated.h: $(obj)/gb_softsvc.o $(gb-softsvc-export-deps) FORCE + $(call if_changed,exports) + +targets += exports_gb_softsvc_generated.h + +$(obj)/gb_softsvc_exports.o: $(obj)/exports_gb_softsvc_generated.h +CFLAGS_gb_softsvc_exports.o := -I $(objtree)/$(obj) + +ifdef CONFIG_MODVERSIONS +# The C export shim declares Rust symbols as `extern int`, so reuse its export +# list but generate symbol CRCs from the Rust object instead of the shim's DWARF. +$(obj)/gb_softsvc_exports.o: private cmd_gensymtypes_c = \ + $(call getexportsymbols,\1) | \ + $(objtree)/scripts/gendwarfksyms/gendwarfksyms \ + $(if $(KBUILD_GENDWARFKSYMS_STABLE), --stable) \ + $(if $(KBUILD_SYMTYPES), --symtypes $(@:.o=.symtypes),) \ + $(obj)/gb_softsvc.o +endif + +# Output nova-core's crate metadata for use by nova-drm at compile time. +RUSTFLAGS_gb_softsvc.o += \ + --emit=metadata=$(objtree)/$(obj)/libgb_softsvc.rmeta + +# Allow nova-drm to import nova-core's types. +$(obj)/gb_uart_node.o: $(obj)/gb_softsvc.o +RUSTFLAGS_gb_uart_node.o := -L $(objtree)/$(obj) --extern gb_softsvc diff --git a/drivers/greybus/gb_uart_node.rs b/drivers/greybus/gb_uart_node.rs new file mode 100644 index 000000000000..3eb4f8ab3655 --- /dev/null +++ b/drivers/greybus/gb_uart_node.rs @@ -0,0 +1,245 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Greybus UART Node driver + +use kernel::{ + alloc::Flags, + crc_ccitt::crc_ccitt, + device::{ + AsBusDevice, + Bound, + Core, // + }, + error::code, + new_spinlock, of, + prelude::*, + serdev, + sync::{ + aref::ARef, + Arc, + SpinLock, // + }, +}; + +use zerocopy::little_endian; +use zerocopy_derive::{FromBytes, Immutable, KnownLayout}; + +const HDLC_MAX_FRAME_LEN: usize = 256; + +const HDLC_FRAME: u8 = 0x7E; +const HDLC_ESC: u8 = 0x7D; +const HDLC_XOR: u8 = 0x20; +const HDLC_EXPECTED_CRC: u16 = 0xf0b8; + +const ADDRESS_GREYBUS: u8 = 0x01; + +#[repr(C, packed)] +#[derive(FromBytes, Immutable, KnownLayout)] +struct GreybusFrame { + cport: little_endian::U16, + msg: [u8], +} + +struct HdlcRx { + rx_buf: KVec<u8>, + rx_in_esc: bool, + sdev: ARefserdev::Device, + node: gb_softsvc::Module, +} + +impl HdlcRx { + fn new(sdev: ARefserdev::Device, node: gb_softsvc::Module) -> Result<Self> { + Ok(Self { + node, + sdev, + rx_buf: KVec::with_capacity(HDLC_MAX_FRAME_LEN, GFP_KERNEL)?, + rx_in_esc: false, + }) + } + + fn frame_finish(&self) -> Result<()> { + if self.rx_buf.len() < 4 { + return Err(code::EFAULT); + } + + let crc = crc_ccitt(0xffff, &self.rx_buf); + if crc != HDLC_EXPECTED_CRC { + dev_warn!(self.sdev.as_ref(), "CRC failed {}", crc); + return Ok(()); + } + + let addr = self.rx_buf[0]; + let _ctrl = self.rx_buf[1]; + let payload = &self.rx_buf[2..self.rx_buf.len() - size_of::<u16>()]; + + match addr { + ADDRESS_GREYBUS => { + let frame = GreybusFrame::ref_from_bytes(payload).map_err(|_| code::EINVAL)?; + self.node.submit_message(0, frame.cport.into(), &frame.msg) + } + _ => Err(code::EINVAL), + } + } + + fn rx(&mut self, data: &[u8]) -> usize { + for i in data.iter() { + match *i { + HDLC_FRAME => { + if !self.rx_buf.is_empty() { + if let Err(e) = self.frame_finish() { + dev_warn!(self.sdev.as_ref(), "bad frame: {e:?}\n"); + } + } + + self.rx_buf.clear(); + self.rx_in_esc = false; + } + HDLC_ESC => self.rx_in_esc = true, + _ => { + let c = if self.rx_in_esc { *i ^ HDLC_XOR } else { *i }; + self.rx_in_esc = false; + + if self.rx_buf.push_within_capacity(c).is_err() { + dev_warn!(self.sdev.as_ref(), "buffer overflow. Dropping frame"); + + self.rx_buf.clear(); + self.rx_in_esc = false; + } + } + } + } + + data.len() + } +} + +struct GbNode { + sdev: ARefserdev::Device, +} + +impl GbNode { + const fn new(sdev: ARefserdev::Device) -> Self { + Self { sdev } + } + + fn fill_buf(mut crc: u16, data: &[u8], buf: &mut KVec<u8>) -> Result<u16> { + for i in data { + crc = crc_ccitt(crc, &[*i]); + if *i == HDLC_ESC || *i == HDLC_FRAME { + buf.push_within_capacity(HDLC_ESC)?; + buf.push_within_capacity(i ^ HDLC_XOR)?; + } else { + buf.push_within_capacity(*i)?; + } + } + + Ok(crc) + } +} + +impl gb_softsvc::InterfaceOps for GbNode { + fn write(&self, data: &[u8], cport: u16, gfp_mask: Flags) -> Result<()> { + // SAFETY: `GbNode` only exists while its serdev driver is bound, so the device is in the + // `Bound` state for the duration of this call. + let bound: &serdev::Device<Bound> = + unsafe { serdev::Device::from_device(self.sdev.as_ref().as_bound()) }; + + let mut buf = KVec::with_capacity(HDLC_MAX_FRAME_LEN, gfp_mask)?; + + let mut crc = 0xffff; + + buf.push_within_capacity(HDLC_FRAME)?; + + crc = Self::fill_buf(crc, &[ADDRESS_GREYBUS, 0x03], &mut buf)?; + crc = Self::fill_buf(crc, &cport.to_le_bytes(), &mut buf)?; + crc = Self::fill_buf(crc, data, &mut buf)?; + + crc ^= 0xffff; + Self::fill_buf(crc, &crc.to_le_bytes(), &mut buf)?; + + buf.push_within_capacity(HDLC_FRAME)?; + + bound.write_all(&buf, 0)?; + + Ok(()) + } +} + +#[pin_data] +struct GbUartNode { + #[pin] + rx: SpinLock<Option<HdlcRx>>, +} + +impl GbUartNode { + fn init(sdev: &serdev::Device<Core<'_>>) -> Result<HdlcRx> { + if sdev + .set_baudrate( + sdev.as_ref() + .fwnode() + .and_then(|fwnode| fwnode.property_read(c"baudrate").optional()) + .unwrap_or(115200), + ) + .is_err() + { + return Err(EINVAL); + } + sdev.set_flow_control(false); + sdev.set_parity(serdev::Parity::None)?; + + let node = gb_softsvc::Module::new(&[Arc::new(GbNode::new(sdev.into()), GFP_KERNEL)?])?; + + HdlcRx::new(sdev.into(), node) + } +} + +kernel::of_device_table!( + OF_TABLE, + <GbUartNode as serdev::Driver>::IdInfo, + [(of::DeviceId::new(c"beagle,beagleconnect-freedom"), ())] +); + +#[vtable] +impl serdev::Driver for GbUartNode { + type IdInfo = (); + type Data<'bound> = Self; + const OF_ID_TABLE: Option<of::IdTableSelf::IdInfo> = Some(&OF_TABLE); + + fn probe<'bound>( + sdev: &'bound serdev::Device<Core<'_>>, + _info: Option<&'bound Self::IdInfo>, + ) -> impl PinInit<Self, Error> + 'bound { + dev_dbg!(sdev.as_ref(), "Probe gb_uart_node.\n"); + + try_pin_init!(Self { + rx <- new_spinlock!(Some(Self::init(sdev)?), "gb_uart_node::rx"), + }? Error) + } + + fn receive<'bound>( + _sdev: &'bound serdev::Device<Bound>, + this: Pin<&Self>, + data: &[u8], + ) -> usize { + if let Some(mut guard) = this.rx.try_lock() { + if let Some(ref mut hdlc_rx) = *guard { + return hdlc_rx.rx(data); + } + } + + 0 + } + + fn unbind<'bound>(_: &'bound serdev::Device<Core<'_>>, this: Pin<&Self::Data<'bound>>) { + // Getting a bound device is not possible after this point. So drop HdlcRx. + let _ = this.rx.lock().take(); + } +} + +kernel::module_serdev_device_driver! { + type: GbUartNode, + name: "gb_uart_node", + authors: ["Ayush Singh ayush@beagleboard.org"], + description: "Greybus node connected over UART", + license: "GPL v2", +}