[fidl][clk] Make fuchsia.hardware.clock open and flexible

API guidelines say that FIDL protocols should prefer to be open with
flexible methods unless there's a good reason for it not to be that way.

Update `fuchsia.hardware.clock` ahead of API calibration to satisfy that
requirement.

Test: fx set core.vim3 && fx build
Bug: b/342220727
Change-Id: I507dbe90f27c1d6bde1a3438608542a586a1ea59
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/1052894
API-Review: Jocelyn Dang <jocelyndang@google.com>
Reviewed-by: Jocelyn Dang <jocelyndang@google.com>
Commit-Queue: Gurjant Kalsi <gkalsi@google.com>

Author: gkalsi

sdk/fidl/fuchsia.hardware.clock/clock.fidl

@@ -13,79 +13,79 @@ type FrequencyInfo = struct {
 };
 
 /// Used for driver-to-non-driver communication.
-closed protocol Device {
-    strict Measure(struct {
+open protocol Device {
+    flexible Measure(struct {
         clock uint32;
     }) -> (struct {
         info FrequencyInfo;
     });
-    strict GetCount() -> (struct {
+    flexible GetCount() -> (struct {
         count uint32;
     });
 
     // For debugging
-    strict Enable(struct {
+    flexible Enable(struct {
         clock uint32;
     }) -> () error zx.Status;
 
-    strict Disable(struct {
+    flexible Disable(struct {
         clock uint32;
     }) -> () error zx.Status;
 };
 
 /// Used for driver-to-driver communication.
 @discoverable
-closed protocol Clock {
+open protocol Clock {
 
     /// Enables (ungates) this clock.
     /// Drivers *must* call enable on all clocks they depend upon.
-    strict Enable() -> () error zx.Status;
+    flexible Enable() -> () error zx.Status;
 
     /// Disables (gates) this clock.
     /// Drivers should call this method to indicate to the clock subsystem that
     /// a particular clock signal is no longer necessary.
-    strict Disable() -> () error zx.Status;
+    flexible Disable() -> () error zx.Status;
 
     /// Returns `true` if a given clock is running.
     /// May query the hardware or return a cached value.
-    strict IsEnabled() -> (struct {
+    flexible IsEnabled() -> (struct {
         enabled bool;
     }) error zx.Status;
 
     /// Attempt to set the rate of the clock provider.
-    strict SetRate(struct {
+    flexible SetRate(struct {
         hz uint64;
     }) -> () error zx.Status;
 
     /// Query the hardware for the highest supported rate that does not
     /// exceed hz_in.
-    strict QuerySupportedRate(struct {
+    flexible QuerySupportedRate(struct {
         hz_in uint64;
     }) -> (struct {
         hz_out uint64;
     }) error zx.Status;
 
     /// Returns the current rate that a given clock is running at.
-    strict GetRate() -> (struct {
+    flexible GetRate() -> (struct {
         hz uint64;
     }) error zx.Status;
 
     /// Sets the input of this clock by index. I.e. by selecting a mux.
     /// This clock has N inputs defined 0 through N-1, which are valid arguemts
     /// as the index to SetInput.
-    strict SetInput(struct {
+    flexible SetInput(struct {
         idx uint32;
     }) -> () error zx.Status;
 
     /// Returns the number of inputs this clock has.
     /// Any value between 0 and UINT32_MAX is a valid return for this method.
     /// A Root Oscillator may return 0 for instance, if it has no inputs.
-    strict GetNumInputs() -> (struct {
+    flexible GetNumInputs() -> (struct {
         n uint32;
     }) error zx.Status;
 
     /// Returns the index of the current input of this clock.
-    strict GetInput() -> (struct {
+    flexible GetInput() -> (struct {
         index uint32;
     }) error zx.Status;
 };

sdk/fidl/fuchsia.hardware.clockimpl/clock-impl.fidl

@@ -15,46 +15,46 @@ using zx;
 @transport("Driver")
 open protocol ClockImpl {
     /// Clock Gating Control.
-    strict Enable(struct {
+    flexible Enable(struct {
         id uint32;
     }) -> () error zx.Status;
-    strict Disable(struct {
+    flexible Disable(struct {
         id uint32;
     }) -> () error zx.Status;
-    strict IsEnabled(struct {
+    flexible IsEnabled(struct {
         id uint32;
     }) -> (struct {
         enabled bool;
     }) error zx.Status;
 
     /// Clock Frequency Scaling Control.
-    strict SetRate(struct {
+    flexible SetRate(struct {
         id uint32;
         hz uint64;
     }) -> () error zx.Status;
-    strict QuerySupportedRate(struct {
+    flexible QuerySupportedRate(struct {
         id uint32;
         hz uint64;
     }) -> (struct {
         hz uint64;
     }) error zx.Status;
-    strict GetRate(struct {
+    flexible GetRate(struct {
         id uint32;
     }) -> (struct {
         hz uint64;
     }) error zx.Status;
 
     /// Clock input control.
-    strict SetInput(struct {
+    flexible SetInput(struct {
         id uint32;
         idx uint32;
     }) -> () error zx.Status;
-    strict GetNumInputs(struct {
+    flexible GetNumInputs(struct {
         id uint32;
     }) -> (struct {
         n uint32;
     }) error zx.Status;
-    strict GetInput(struct {
+    flexible GetInput(struct {
         id uint32;
     }) -> (struct {
         index uint32;

src/devices/block/drivers/aml-sdmmc/aml-sdmmc-with-banjo-test.cc

@@ -198,6 +198,11 @@ class FakeClock : public fidl::WireServer<fuchsia_hardware_clock::Clock> {
     completer.ReplyError(ZX_ERR_NOT_SUPPORTED);
   }
 
+  void handle_unknown_method(fidl::UnknownMethodMetadata<fuchsia_hardware_clock::Clock> metadata,
+                             fidl::UnknownMethodCompleter::Sync& completer) override {
+    ZX_ASSERT_MSG(0, "Unexpected FIDL Method Ordinal, ord = 0x%lx", metadata.method_ordinal);
+  }
+
   fidl::ServerBindingGroup<fuchsia_hardware_clock::Clock> bindings_;
 
   bool enabled_ = false;

src/devices/clock/drivers/amlogic-clk/aml-clk.h

@@ -66,6 +66,10 @@ class AmlClock : public DeviceType, public ddk::ClockImplProtocol<AmlClock, ddk:
   void GetCount(GetCountCompleter::Sync& completer) override;
   void Enable(EnableRequestView request, EnableCompleter::Sync& completer) override;
   void Disable(DisableRequestView request, DisableCompleter::Sync& completer) override;
+  void handle_unknown_method(fidl::UnknownMethodMetadata<fuchsia_hardware_clock::Device> metadata,
+                             fidl::UnknownMethodCompleter::Sync& completer) override {
+    zxlogf(ERROR, "Unexpected Clock FIDL call: 0x%lx", metadata.method_ordinal);
+  }
 
   // Device protocol implementation.
   void DdkUnbind(ddk::UnbindTxn txn);

src/devices/clock/drivers/clock/clock.cc

@@ -84,6 +84,12 @@ void ClockDevice::GetInput(GetInputCompleter::Sync& completer) {
   }
 }
 
+void ClockDevice::handle_unknown_method(
+    fidl::UnknownMethodMetadata<fuchsia_hardware_clock::Clock> metadata,
+    fidl::UnknownMethodCompleter::Sync& completer) {
+  zxlogf(ERROR, "Unexpected Clock FIDL call: 0x%lx", metadata.method_ordinal);
+}
+
 zx_status_t ClockDevice::ServeOutgoing(fidl::ServerEnd<fuchsia_io::Directory> server_end) {
   fuchsia_hardware_clock::Service::InstanceHandler handler({
       .clock = bindings_.CreateHandler(this, dispatcher_, fidl::kIgnoreBindingClosure),

src/devices/clock/drivers/clock/clock.h

@@ -62,6 +62,9 @@ class ClockDevice : public ClockDeviceType, public fidl::WireServer<fuchsia_hard
   void GetNumInputs(GetNumInputsCompleter::Sync& completer) override;
   void GetInput(GetInputCompleter::Sync& completer) override;
 
+  void handle_unknown_method(fidl::UnknownMethodMetadata<fuchsia_hardware_clock::Clock> metadata,
+                             fidl::UnknownMethodCompleter::Sync& completer) override;
+
   const ClockImplProxy clock_;
   const uint32_t id_;