Merge pull request #4 from rust-embedded/implement-unexport

unexport and poll functionality

Author: posborne

README.md

@@ -55,29 +55,27 @@ how you can configure your GPIOs.
 # the following keys:
 #
 # - `num`: Required.  The GPIO number.
+# - `names`: Required.  One or more names for the GPIO
 # - `direction`: Default: `"in"`.  Must be either "in" or "out"
-# - `active_low`: Default: `false`.  If set to true, the polatiry of the pin will
+# - `active_low`: Default: `false`.  If set to true, the polarity of the pin will
 #    be reversed.
 # - `export`: Default: `true`.  If true, this GPIO will be automatically
 #    exported when `gpio export-all` is run (e.g. by an init script).
-# - `aliases`: Additional names for the same GPIO
 #
 
-# Basic Form
-[pins.reset_button]
-num = 73           # required
-direction = "in"   # default: in
-active_low = true  # default: false
-export = true      # default: true
+[[pins]]
+num = 73                 # required
+names = ["reset_button"] # required (may have multiple)
+direction = "in"         # default: in
+active_low = false       # default: false (really means invert logic)
+export = true            # default: true
 
-[pins.status_led]
+[[pins]]
 num = 37
-aliases = ["A27", "green_led"]
+names = ["status_led", "A27", "green_led"]
 direction = "out"
 
-# Compact Form
-[pins]
-error_led = { num = 11, direction = "in", export = false}
+# ...
 ```
 
 ## Implementation Notes

src/commands/gpio_exportall.rs

@@ -11,7 +11,8 @@ pub fn main(config: &GpioConfig, opts: &GpioExportAllOptions) {
         None => config.get_symlink_root(),
     };
 
-    for pin in config.get_pins() {
+    // export all pins except those for which export is set to false
+    for pin in config.get_pins().iter().filter(|p| p.export) {
         if let Err(e) = export::export(pin, Some(symlink_root)) {
             println!("Error occurred while exporting pin: {:?}", pin);
             println!("{}", e);

src/commands/gpio_poll.rs

@@ -0,0 +1,52 @@
+// Copyright (C) 2016, The gpio-utils Authors
+
+use options::GpioPollOptions;
+use config::GpioConfig;
+use sysfs_gpio::Edge;
+use std::process::exit;
+
+pub fn main(config: &GpioConfig, opts: &GpioPollOptions) {
+    let timeout = opts.timeout.unwrap_or(-1);
+    let pin_config = match config.get_pin(&opts.pin[..]) {
+        Some(pin) => pin,
+        None => {
+            println!("Unable to find config entry for pin '{}'", opts.pin);
+            exit(1)
+        }
+    };
+    let pin = pin_config.get_pin();
+    let edge = match &opts.edge[..] {
+        "rising" => Edge::RisingEdge,
+        "falling" => Edge::FallingEdge,
+        "both" => Edge::BothEdges,
+        other => {
+            println!("Unexpected edge value: {}", other);
+            exit(1);
+        }
+    };
+
+    // set the pin direction
+    pin.set_edge(edge).unwrap_or_else(|e| {
+        println!("Error setting edge on pin: {:?}", e);
+        exit(1);
+    });
+
+    let mut poller = pin.get_poller().unwrap_or_else(|e| {
+        println!("Error creating pin poller: {:?}", e);
+        exit(1);
+    });
+    match poller.poll(timeout) {
+        Ok(Some(value)) => {
+            println!("{}", value);
+            exit(0);
+        }
+        Ok(None) => {
+            println!("TIMEOUT");
+            exit(2)
+        }
+        Err(e) => {
+            println!("Error on Poll: {:?}", e);
+            exit(1);
+        }
+    }
+}

src/commands/gpio_read.rs

@@ -1,6 +1,6 @@
 // Copyright (C) 2016, Paul Osborne <[email protected]>
 
-use options::{GpioReadOptions};
+use options::GpioReadOptions;
 use config::GpioConfig;
 use std::process::exit;
 

src/commands/gpio_unexport.rs

@@ -0,0 +1,24 @@
+// Copyright (C) 2016, The gpio-utils Authors
+
+use options::GpioUnexportOptions;
+use config::GpioConfig;
+use std::process::exit;
+use export;
+
+pub fn main(config: &GpioConfig, opts: &GpioUnexportOptions) {
+    let pin_config = config.get_pin(&opts.pin[..]).unwrap_or_else(|| {
+        println!("Unable to find config entry for pin '{}'", opts.pin);
+        exit(1)
+    });
+
+    let symlink_root = match opts.symlink_root {
+        Some(ref slr) => &slr[..],
+        None => config.get_symlink_root(),
+    };
+
+    if let Err(e) = export::unexport(pin_config, Some(symlink_root)) {
+        println!("Error occurred while unexport pin {:?}", pin_config);
+        println!("{}", e);
+        exit(1);
+    }
+}

src/commands/gpio_unexportall.rs

@@ -0,0 +1,21 @@
+// Copyright (C) 2016, The gpio-utils Authors
+
+use options::GpioUnexportAllOptions;
+use config::GpioConfig;
+use std::process::exit;
+use export;
+
+pub fn main(config: &GpioConfig, opts: &GpioUnexportAllOptions) {
+    let symlink_root = match opts.symlink_root {
+        Some(ref slr) => &slr[..],
+        None => config.get_symlink_root(),
+    };
+
+    for pin in config.get_pins().iter().filter(|p| p.export) {
+        if let Err(e) = export::unexport(pin, Some(symlink_root)) {
+            println!("Error occurred while exporting pin: {:?}", pin);
+            println!("{}", e);
+            exit(1);
+        }
+    }
+}

src/commands/mod.rs

@@ -4,3 +4,6 @@ pub mod gpio_read;
 pub mod gpio_export;
 pub mod gpio_exportall;
 pub mod gpio_write;
+pub mod gpio_unexport;
+pub mod gpio_unexportall;
+pub mod gpio_poll;

src/export.rs

@@ -7,6 +7,45 @@ use std::io::ErrorKind;
 use config::PinConfig;
 use sysfs_gpio;
 
+/// Unexport the pin specified in the provided config
+///
+/// Unexporting a config (in this context) involves a few different
+/// actions:
+///
+/// 1. For each GPIO name/alias, the corresponding symlink is remvoed from
+///    `/var/run/gpio/<name>` (or an alternate configured symlink_root).
+/// 2. The GPIO pin istself is unexported (vai /sys/class/gpio/unexport)
+///
+/// If the GPIO was already unexported, this function will continue
+/// without an error as the desired end state is achieved.
+pub fn unexport(pin_config: &PinConfig,
+                symlink_root: Option<&str>)
+                -> Result<(), sysfs_gpio::Error> {
+    if let Some(symroot) = symlink_root {
+        // create symlink for each name
+        for name in &pin_config.names {
+            let mut dst = path::PathBuf::from(symroot);
+            dst.push(name);
+            try!(match fs::remove_file(dst) {
+                Ok(_) => Ok(()),
+                Err(ref e) if e.kind() == ErrorKind::NotFound => Ok(()),
+                Err(e) => Err(e),
+            });
+        }
+    }
+
+    // unexport the pin itself.  On many boards, it turns out, some pins are
+    // exported by the kernel itself but we might still be assigning names.  In
+    // those cases we will get an error here.  We handle that rather than
+    // exposing the error up the chain. (EINVAL)
+    let pin = pin_config.get_pin();
+    match pin.unexport() {
+        Ok(_) => Ok(()),
+        Err(sysfs_gpio::Error::Io(ref e)) if e.kind() == ErrorKind::InvalidInput => Ok(()),
+        Err(e) => Err(e)
+    }
+}
+
 /// Export the pin specified in the provided config
 ///
 /// Exporting a pin (in this context) involves, a few different

src/main.rs

@@ -44,7 +44,19 @@ fn main() {
                     .arg(Arg::with_name("pin")
                          .help("The pin name (or number)")
                          .index(1)
-                         .required(true)))
+                         .required(true))
+                    .arg(Arg::with_name("timeout")
+                         .help("Timeout (in ms) for the poll operation (-1 to wait forever, default)")
+                         .takes_value(true)
+                         .short("t")
+                         .long("timeout")
+                         .required(false))
+                    .arg(Arg::with_name("edge")
+                         .help("The edge to poll on")
+                         .takes_value(true)
+                         .short("e")
+                         .long("edge")
+                         .required(false)))
 
         // gpio write
         .subcommand(SubCommand::with_name("write")
@@ -88,15 +100,23 @@ fn main() {
                     .arg(Arg::with_name("pin")
                          .help("The pin name (or number)")
                          .index(1)
-                         .required(true)))
+                         .required(true))
+                    .arg(Arg::with_name("symlink-root")
+                         .help("root directory for export symlinks")
+                         .takes_value(true)
+                         .short("r")
+                         .long("symlink-root")
+                         .required(false)))
 
         // gpio unexport-all
         .subcommand(SubCommand::with_name("unexport-all")
                     .about("Unexport all configured, exported GPIOs")
-                    .arg(Arg::with_name("pin")
-                         .help("The pin name (or number)")
-                         .index(1)
-                         .required(true)))
+                    .arg(Arg::with_name("symlink-root")
+                         .help("root directory for export symlinks")
+                         .takes_value(true)
+                         .short("r")
+                         .long("symlink-root")
+                         .required(false)))
 
         // gpio status
         .subcommand(SubCommand::with_name("status")
@@ -132,7 +152,21 @@ fn main() {
             };
             gpio_read::main(&cfg, &read_options);
         }
-        ("poll", Some(_)) => {}
+        ("poll", Some(m)) => {
+            let timeout = m.value_of("timeout").map(|timeout| {
+                timeout.parse::<isize>().unwrap_or_else(|_| {
+                    println!("Unable to parse timeout value {:?} as integer", timeout);
+                    exit(1);
+                })
+            });
+            let poll_options = GpioPollOptions {
+                gpio_opts: gpio_options,
+                edge: String::from(m.value_of("edge").unwrap_or("both")),
+                timeout: timeout,
+                pin: String::from(m.value_of("pin").unwrap()),
+            };
+            gpio_poll::main(&cfg, &poll_options);
+        }
         ("write", Some(m)) => {
             let write_options = GpioWriteOptions {
                 gpio_opts: gpio_options,
@@ -169,8 +203,21 @@ fn main() {
             };
             gpio_exportall::main(&cfg, &exportall_options);
         }
-        ("unexport", Some(_)) => {}
-        ("unexport-all", Some(_)) => {}
+        ("unexport", Some(m)) => {
+            let unexport_options = GpioUnexportOptions {
+                gpio_opts: gpio_options,
+                pin: String::from(m.value_of("pin").unwrap()),
+                symlink_root: m.value_of("symlink-root").map(|slr| String::from(slr)),
+            };
+            gpio_unexport::main(&cfg, &unexport_options);
+        }
+        ("unexport-all", Some(m)) => {
+            let unexportall_options = GpioUnexportAllOptions {
+                gpio_opts: gpio_options,
+                symlink_root: m.value_of("symlink-root").map(|slr| String::from(slr)),
+            };
+            gpio_unexportall::main(&cfg, &unexportall_options);
+        }
         ("status", Some(_)) => {}
         _ => {}
     }

src/options.rs

@@ -21,6 +21,8 @@ pub struct GpioWriteOptions {
 #[derive(Debug)]
 pub struct GpioPollOptions {
     pub gpio_opts: GpioOptions,
+    pub timeout: Option<isize>,
+    pub edge: String,
     pub pin: String,
 }
 
@@ -40,12 +42,14 @@ pub struct GpioExportAllOptions {
 #[derive(Debug)]
 pub struct GpioUnexportOptions {
     pub gpio_opts: GpioOptions,
+    pub symlink_root: Option<String>,
     pub pin: String,
 }
 
 #[derive(Debug)]
 pub struct GpioUnexportAllOptions {
     pub gpio_opts: GpioOptions,
+    pub symlink_root: Option<String>,
 }
 
 #[derive(Debug)]