firmware-utiles: add *.attr for GPIO symbolic links

gpio_setup.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // NOTE: this file is translated from gpio_setup.py
 //
 // A script to create symlinks to platform specific GPIO pins.
 //
 // This script creates a set of symlinks pointing at the sys fs files returning
 // the appropriate GPIO pin values. Each symlink is named to represent the
@@ skipping 51 matching lines @@
 // Can be changed using --pci_address command line option.
 #define DEFAULT_GPIO_DEVICE_PCI_ADDRESS "0000:00:1f.0"
 
 // Can be changed using --acpi_root command line option.
 #define DEFAULT_ACPI_ROOT "/sys/bus/platform/devices/chromeos_acpi"
 
 // can be changed using --symlink_root command line option.
 #define DEFAULT_SYMLINK_ROOT "/home/gpio"
 
 #define GPIO_SIGNAL_TYPE_EXTENSION      "0"
+#define GPIO_ATTRIBUTES_EXTENSION       "1"
 #define GPIO_PIN_NUMBER_EXTENSION       "2"
 
 // Debug header signal type codes are offset by 0x100, the tuple below
 // represents the range of valid codes for the debug header. The range
 // starts at 0x100 and is 0x100 wide.
 const int GPIO_DEBUG_HEADER_RANGE[2] = { 0x100, 0x100 };
 
 // This dictionary maps GPIO signal types codes into their actual names.
 const char *GPIO_SIGNAL_TYPES[] = {
   NULL,                         // note: 0 is NOT a valid index, so we must
@@ skipping 221 matching lines @@
 
  private:
   string pci_address_;
   int    base_;
   int    capacity_;
   string description_;
 
   GpioChip() { }
 };
 
-typedef std::pair<string, int> AcpiMappingEntry;
+typedef struct {
+  string name;
+  int index;
+  int pin_number;
+} AcpiMappingEntry;
+
 typedef std::vector<AcpiMappingEntry> AcpiMapping;
 
 // Scan ACPI information about GPIO and generate a mapping.
 //
 // Returns: a list of tuples, each tuple consisting of a string representing
 //          the GPIO pin name and a number, representing the GPIO pin within
 //          the GPIO device space.
 AcpiMapping ParseAcpiMappings(const string &acpi_root) {
   GlobResult r = glob_glob(format_string("%s/GPIO.[0-9]*", acpi_root.c_str()));
   AcpiMapping acpi_gpio_mapping;
   GlobResult::iterator i;
+
   for (i = r.begin(); i != r.end(); i++) {
+    AcpiMappingEntry entry;
     const char *d = i->c_str();
+    const char *dot_index_string = strrchr(d, '.');
     int signal_type = atoi(open_read_strip(
         format_string("%s/GPIO.%s", d, GPIO_SIGNAL_TYPE_EXTENSION)).c_str());
-    int pin_number = atoi(open_read_strip(
+
+    assert(dot_index_string);
+    entry.index = atoi(dot_index_string + 1);
+    entry.pin_number = atoi(open_read_strip(
         format_string("%s/GPIO.%s", d, GPIO_PIN_NUMBER_EXTENSION)).c_str());
 
     if (signal_type >= GPIO_SIGNAL_TYPE_MIN &&
         signal_type <= static_cast<int>(GPIO_SIGNAL_TYPE_MAX) &&
         GPIO_SIGNAL_TYPES[signal_type] != NULL) {
-      acpi_gpio_mapping.push_back(AcpiMappingEntry(
-          GPIO_SIGNAL_TYPES[signal_type], pin_number));
+      entry.name = GPIO_SIGNAL_TYPES[signal_type];
+      acpi_gpio_mapping.push_back(entry);
       continue;
     }
 
     // This is not a specific signal, could be a debug header pin.
     int debug_header = signal_type - GPIO_DEBUG_HEADER_RANGE[0];
     if (debug_header >= 0 && debug_header < GPIO_DEBUG_HEADER_RANGE[1]) {
-      acpi_gpio_mapping.push_back(AcpiMappingEntry(
-          format_string("debug_header_%d", debug_header), pin_number));
+      entry.name = format_string("debug_header_%d", debug_header);
+      acpi_gpio_mapping.push_back(AcpiMappingEntry(entry));
       continue;
     }
 
     // Unrecognized mapping, could happen if BIOS version is ahead of this
     // script.
     printf("unknown signal type encoding %d in %s\n", signal_type, d);
   }
 
   if (acpi_gpio_mapping.empty())
     GpioSetupError("no gpio mapping found. Is ACPI driver installed?");
 
   return acpi_gpio_mapping;
 }
 
+void CreateSymLink(const string &source_file, const string &symlink) {
+    if (!os_path_exists(symlink)) {
+      os_symlink(source_file.c_str(), symlink.c_str());
+      return;
+    }
+
+    if (!os_path_islink(symlink))
+      GpioSetupError("%s exists but is not a symlink",
+                     os_path_abspath(symlink).c_str());
+    if (os_readlink(symlink) != source_file)
+      GpioSetupError("%s points to a wrong file",
+                     os_path_abspath(symlink).c_str());
+}
+
 void CreateGpioSymlinks(const AcpiMapping& mappings,
                         GpioChip &gpio,
+                        const char *acpi_root,
                         const char *symlink_root) {
   if (!os_path_exists(symlink_root))
     GpioSetupError("%s does not exist", symlink_root);
 
   if (!os_path_isdir(symlink_root))
     GpioSetupError("%s is not a directory", symlink_root);
 
   if (access(symlink_root, W_OK) != 0)
     GpioSetupError("%s is not writable", symlink_root);
 
   if (chdir(symlink_root) != 0)
     GpioSetupError("failed to change directory to %s", symlink_root);
 
   AcpiMapping::const_iterator i;
   for (i = mappings.begin(); i != mappings.end(); ++i) {
-    string symlink = i->first;
-    int pin = i->second;
-    gpio.EnablePin(pin);
+    string symlink, source_file;
+    gpio.EnablePin(i->pin_number);
 
-    string source_file = format_string("%s/gpio%d/value",
-                                       GPIO_ROOT, pin+gpio.base());
-    if (!os_path_exists(symlink)) {
-      os_symlink(source_file.c_str(), symlink.c_str());
-      continue;
-    }
+    symlink = i->name;
+    source_file = format_string("%s/gpio%d/value", GPIO_ROOT,
+                                i->pin_number + gpio.base());
+    CreateSymLink(source_file, symlink);
 
-    if (!os_path_islink(symlink))
-      GpioSetupError("%s exists but is not a symlink",
-                     os_path_abspath(symlink).c_str());
-
-    if (os_readlink(symlink) != source_file)
-      GpioSetupError("%s points to a wrong file",
-                     os_path_abspath(symlink).c_str());
+    symlink = i->name + ".attr";
+    source_file = format_string("%s/GPIO.%d/GPIO.%s",
+                                acpi_root,
+                                i->index,
+                                GPIO_ATTRIBUTES_EXTENSION);
+    CreateSymLink(source_file, symlink);
   }
 }
 
 static const char *__name__ = "";
 static void usage_help_exit(int ret) {
   printf(
       "Usage: %s [options]\n"
       "\n"
       "Options:\n"
       "  -h, --help \t show this help message and exit\n"
@@ skipping 48 matching lines @@
   }
 
   // currently no other non-dashed arguments allowed.
   if (optind != argc)
     usage_help_exit(1);
 
   GpioChip gpioc(cmd_line_options.pci_address);
   gpioc.Attach();
   CreateGpioSymlinks(
       ParseAcpiMappings(cmd_line_options.acpi_root),
-      gpioc, cmd_line_options.symlink_root.c_str());
+      gpioc,
+      cmd_line_options.acpi_root.c_str(),
+      cmd_line_options.symlink_root.c_str());
   return 0;
 }