cores: arduino: zephyrCommon Specify port/pin instead of gpio_dt_spec.

In preparation for improvements to allow the use of GPIOs without
device tree definitions,
the interface will be changed to specify port and pin instead of
`gpio_dt_spec`.

Signed-off-by: TOKITA Hiroshi <tokita.hiroshi@gmail.com>

Author: soburi

cores/arduino/zephyrCommon.cpp

@@ -9,7 +9,7 @@
 
 #include <zephyr/spinlock.h>
 
-static const struct gpio_dt_spec arduino_pins[] = {DT_FOREACH_PROP_ELEM_SEP(
+static constexpr struct gpio_dt_spec arduino_pins[] = {DT_FOREACH_PROP_ELEM_SEP(
 	DT_PATH(zephyr_user), digital_pin_gpios, GPIO_DT_SPEC_GET_BY_IDX, (, ))};
 
 namespace {
@@ -58,6 +58,18 @@ constexpr const size_t is_first_appearance(const size_t &idx, const size_t &at,
                tail...);
 }
 
+constexpr inline const struct device *local_gpio_port(pin_size_t gpin) {
+  return (gpin < ARRAY_SIZE(arduino_pins)) ? arduino_pins[gpin].port : nullptr;
+}
+
+constexpr inline pin_size_t local_gpio_pin(pin_size_t gpin) {
+  return (gpin < ARRAY_SIZE(arduino_pins)) ? arduino_pins[gpin].pin : pin_size_t(-1);
+}
+
+inline int global_gpio_pin_configure(pin_size_t pinNumber, int flags) {
+  return gpio_pin_configure_dt(&arduino_pins[pinNumber], flags);
+}
+
 #define GET_DEVICE_VARGS(n, p, i, _) DEVICE_DT_GET(DT_GPIO_CTLR_BY_IDX(n, p, i))
 #define FIRST_APPEARANCE(n, p, i)                                                                  \
   is_first_appearance(0, i, ((size_t)-1), DEVICE_DT_GET(DT_GPIO_CTLR_BY_IDX(n, p, i)),       \
@@ -103,10 +115,10 @@ struct gpio_port_callback *find_gpio_port_callback(const struct device *dev)
 
 void setInterruptHandler(pin_size_t pinNumber, voidFuncPtr func)
 {
-  struct gpio_port_callback *pcb = find_gpio_port_callback(arduino_pins[pinNumber].port);
+  struct gpio_port_callback *pcb = find_gpio_port_callback(local_gpio_port(pinNumber));
 
   if (pcb) {
-    pcb->handlers[arduino_pins[pinNumber].pin].handler = func;
+    pcb->handlers[local_gpio_pin(pinNumber)].handler = func;
   }
 }
 
@@ -192,26 +204,36 @@ void yield(void) {
  */
 void pinMode(pin_size_t pinNumber, PinMode pinMode) {
   if (pinMode == INPUT) { // input mode
-    gpio_pin_configure_dt(&arduino_pins[pinNumber],
+    global_gpio_pin_configure(pinNumber,
                           GPIO_INPUT | GPIO_ACTIVE_HIGH);
   } else if (pinMode == INPUT_PULLUP) { // input with internal pull-up
-    gpio_pin_configure_dt(&arduino_pins[pinNumber],
+    global_gpio_pin_configure(pinNumber,
                           GPIO_INPUT | GPIO_PULL_UP | GPIO_ACTIVE_HIGH);
   } else if (pinMode == INPUT_PULLDOWN) { // input with internal pull-down
-    gpio_pin_configure_dt(&arduino_pins[pinNumber],
+    global_gpio_pin_configure(pinNumber,
                           GPIO_INPUT | GPIO_PULL_DOWN | GPIO_ACTIVE_HIGH);
   } else if (pinMode == OUTPUT) { // output mode
-    gpio_pin_configure_dt(&arduino_pins[pinNumber],
+    global_gpio_pin_configure(pinNumber,
                           GPIO_OUTPUT_LOW | GPIO_ACTIVE_HIGH);
   }
 }
 
 void digitalWrite(pin_size_t pinNumber, PinStatus status) {
-  gpio_pin_set_dt(&arduino_pins[pinNumber], status);
+  const struct device *port = local_gpio_port(pinNumber);
+
+  if (port) {
+    gpio_pin_set(port, local_gpio_pin(pinNumber), status);
+  }
 }
 
 PinStatus digitalRead(pin_size_t pinNumber) {
-  return (gpio_pin_get_dt(&arduino_pins[pinNumber]) == 1) ? HIGH : LOW;
+  const struct device *port = local_gpio_port(pinNumber);
+
+  if (port) {
+    return (gpio_pin_get(port, local_gpio_pin(pinNumber)) == 1) ? HIGH : LOW;
+  } else {
+    return LOW;
+  }
 }
 
 #if CONFIG_ARDUINO_MAX_TONES < 0
@@ -264,18 +286,19 @@ static struct pin_timer* find_pin_timer(pin_size_t pinNumber, bool active_only)
 void tone_expiry_cb(struct k_timer *timer) {
   struct pin_timer *pt = CONTAINER_OF(timer, struct pin_timer, timer);
   k_spinlock_key_t key = k_spin_lock(&pt->lock);
+  const struct device *port = local_gpio_port(pt->pin);
   pin_size_t pin = pt->pin;
 
   if (pt->count == 0 && !pt->infinity) {
-    if (pin != pin_size_t(-1)) {
-      gpio_pin_set_dt(&arduino_pins[pin], 0);
+    if (port) {
+      gpio_pin_set(port, local_gpio_pin(pt->pin), 0);
     }
 
     k_timer_stop(timer);
     pt->pin = pin_size_t(-1);
   } else {
-    if (pin != pin_size_t(-1)) {
-      gpio_pin_toggle_dt(&arduino_pins[pin]);
+    if (port) {
+      gpio_pin_toggle(port, local_gpio_pin(pt->pin));
     }
 
     pt->count--;
@@ -289,13 +312,16 @@ void tone(pin_size_t pinNumber, unsigned int frequency,
   k_spinlock_key_t key;
   struct pin_timer *pt;
   k_timeout_t timeout;
+  const struct device *port;
 
   pt = find_pin_timer(pinNumber, false);
 
   if (pt == nullptr) {
     return;
   }
 
+  port = local_gpio_port(pt->pin);
+
   pinMode(pinNumber, OUTPUT);
   k_timer_stop(&pt->timer);
 
@@ -304,7 +330,9 @@ void tone(pin_size_t pinNumber, unsigned int frequency,
     pt->pin = pin_size_t(-1);
     k_spin_unlock(&pt->lock, key);
 
-    gpio_pin_set_dt(&arduino_pins[pinNumber], 0);
+    if (port) {
+      gpio_pin_set(port, local_gpio_pin(pinNumber), 0);
+    }
     return;
   }
 
@@ -321,26 +349,33 @@ void tone(pin_size_t pinNumber, unsigned int frequency,
 
   k_timer_init(&pt->timer, tone_expiry_cb, NULL);
 
-  gpio_pin_set_dt(&arduino_pins[pinNumber], 0);
+  if (port) {
+    gpio_pin_set(port, local_gpio_pin(pinNumber), 0);
+  }
   k_timer_start(&pt->timer, timeout, timeout);
 }
 
 void noTone(pin_size_t pinNumber) {
   struct pin_timer *pt;
   k_spinlock_key_t key;
+  const struct device *port;
 
   pt = find_pin_timer(pinNumber, true);
 
   if (pt == nullptr) {
     return;
   }
 
+  port = local_gpio_port(pt->pin);
+
   key = k_spin_lock(&pt->lock);
   k_timer_stop(&pt->timer);
   pt->pin = pin_size_t(-1);
   k_spin_unlock(&pt->lock, key);
 
-  gpio_pin_set_dt(&arduino_pins[pinNumber], 0);
+  if (port) {
+    gpio_pin_set(port, local_gpio_pin(pinNumber), 0);
+  }
 }
 
 void delay(unsigned long ms) {
@@ -442,6 +477,7 @@ int analogRead(pin_size_t pinNumber)
 
 void attachInterrupt(pin_size_t pinNumber, voidFuncPtr callback, PinStatus pinStatus)
 {
+  const struct device *port = local_gpio_port(pinNumber);
   struct gpio_port_callback *pcb;
   gpio_flags_t intmode = 0;
 
@@ -463,16 +499,18 @@ void attachInterrupt(pin_size_t pinNumber, voidFuncPtr callback, PinStatus pinSt
     return;
   }
 
-  pcb = find_gpio_port_callback(arduino_pins[pinNumber].port);
+  pcb = find_gpio_port_callback(port);
   __ASSERT(pcb != nullptr, "gpio_port_callback not found");
 
-  pcb->pins |= BIT(arduino_pins[pinNumber].pin);
+  pcb->pins |= BIT(local_gpio_pin(pinNumber));
   setInterruptHandler(pinNumber, callback);
   enableInterrupt(pinNumber);
 
-  gpio_pin_interrupt_configure(arduino_pins[pinNumber].port, arduino_pins[pinNumber].pin, intmode);
-  gpio_init_callback(&pcb->callback, handleGpioCallback, pcb->pins);
-  gpio_add_callback(arduino_pins[pinNumber].port, &pcb->callback);
+  if (port) {
+    gpio_pin_interrupt_configure(port, local_gpio_pin(pinNumber), intmode);
+    gpio_init_callback(&pcb->callback, handleGpioCallback, pcb->pins);
+    gpio_add_callback(port, &pcb->callback);
+  }
 }
 
 void detachInterrupt(pin_size_t pinNumber)
@@ -500,29 +538,30 @@ long random(long max) {
 #endif
 
 unsigned long pulseIn(pin_size_t pinNumber, uint8_t state, unsigned long timeout) {
+  const struct device *port = local_gpio_port(pinNumber);
+  const size_t pin = local_gpio_pin(pinNumber);
   struct k_timer timer;
   int64_t start, end, delta = 0;
-  const struct gpio_dt_spec *spec = &arduino_pins[pinNumber];
 
-  if (!gpio_is_ready_dt(spec)) {
+  if (!device_is_ready(port)) {
     return 0;
   }
 
   k_timer_init(&timer, NULL, NULL);
   k_timer_start(&timer, K_MSEC(timeout), K_NO_WAIT);
 
-  while(gpio_pin_get_dt(spec) == state && k_timer_status_get(&timer) == 0);
+  while(gpio_pin_get(port, pin) == state && k_timer_status_get(&timer) == 0);
   if (k_timer_status_get(&timer) > 0) {
     goto cleanup;
   }
 
-  while(gpio_pin_get_dt(spec) != state && k_timer_status_get(&timer) == 0);
+  while(gpio_pin_get(port, pin) != state && k_timer_status_get(&timer) == 0);
   if (k_timer_status_get(&timer) > 0) {
     goto cleanup;
   }
 
   start = k_uptime_ticks();
-  while(gpio_pin_get_dt(spec) == state && k_timer_status_get(&timer) == 0);
+  while(gpio_pin_get(port, pin) == state && k_timer_status_get(&timer) == 0);
   if (k_timer_status_get(&timer) > 0) {
     goto cleanup;
   }
@@ -536,18 +575,18 @@ unsigned long pulseIn(pin_size_t pinNumber, uint8_t state, unsigned long timeout
 }
 
 void enableInterrupt(pin_size_t pinNumber) {
-  struct gpio_port_callback *pcb = find_gpio_port_callback(arduino_pins[pinNumber].port);
+  struct gpio_port_callback *pcb = find_gpio_port_callback(local_gpio_port(pinNumber));
 
   if (pcb) {
-    pcb->handlers[arduino_pins[pinNumber].pin].enabled = true;
+    pcb->handlers[local_gpio_pin(pinNumber)].enabled = true;
   }
 }
 
 void disableInterrupt(pin_size_t pinNumber) {
-  struct gpio_port_callback *pcb = find_gpio_port_callback(arduino_pins[pinNumber].port);
+  struct gpio_port_callback *pcb = find_gpio_port_callback(local_gpio_port(pinNumber));
 
   if (pcb) {
-    pcb->handlers[arduino_pins[pinNumber].pin].enabled = false;
+    pcb->handlers[local_gpio_pin(pinNumber)].enabled = false;
   }
 }
 
@@ -567,7 +606,7 @@ void noInterrupts(void) {
 
 int digitalPinToInterrupt(pin_size_t pin) {
   struct gpio_port_callback *pcb =
-      find_gpio_port_callback(arduino_pins[pin].port);
+      find_gpio_port_callback(local_gpio_port(pin));
 
   return (pcb) ? pin : -1;
 }