From 4f258868283bf563138c854d65df1e5f34eea2af Mon Sep 17 00:00:00 2001

From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>

Date: Sat, 2 Mar 2013 23:51:19 +0100

Subject: [PATCH 187/482] 	Move to more hookless approach in IEEE1275

 devices handling.

---

 ChangeLog                              |   4 +

 grub-core/disk/ieee1275/nand.c         |  31 ++--

 grub-core/disk/ieee1275/ofdisk.c       | 172 +++++++++---------

 grub-core/kern/ieee1275/openfw.c       | 308 ++++++++++++++++++---------------

 grub-core/net/drivers/ieee1275/ofnet.c |  23 +--

 grub-core/term/ieee1275/escc.c         |  41 ++---

 grub-core/term/ieee1275/serial.c       |  73 ++++----

 grub-core/video/ieee1275.c             |  26 +--

 include/grub/ieee1275/ieee1275.h       |  37 ++--

 9 files changed, 376 insertions(+), 339 deletions(-)

diff --git a/ChangeLog b/ChangeLog

index 3231b4b..f107544 100644

--- a/ChangeLog

+++ b/ChangeLog

@@ -1,5 +1,9 @@

 2013-03-02  Vladimir Serbinenko  <phcoder@gmail.com>

+	Move to more hookless approach in IEEE1275 devices handling.

+

+2013-03-02  Vladimir Serbinenko  <phcoder@gmail.com>

+

 	* grub-core/kern/term.c (grub_term_normal_color),

 	(grub_term_highlight_color): Add back lost defaults.

diff --git a/grub-core/disk/ieee1275/nand.c b/grub-core/disk/ieee1275/nand.c

index b2844b1..30ea0f2 100644

--- a/grub-core/disk/ieee1275/nand.c

+++ b/grub-core/disk/ieee1275/nand.c

@@ -36,22 +36,29 @@ static int

 grub_nand_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,

 		   grub_disk_pull_t pull)

 {

-  auto int dev_iterate (struct grub_ieee1275_devalias *alias);

-  int dev_iterate (struct grub_ieee1275_devalias *alias)

-  {

-    if (grub_strcmp (alias->name, "nand") == 0)

-      {

-	hook (alias->name, hook_data);

-	return 1;

-      }

-    

-    return 0;

-  }

+  static int have_nand = -1;

   if (pull != GRUB_DISK_PULL_NONE)

     return 0;

-  return grub_devalias_iterate (dev_iterate);

+  if (have_nand == -1)

+    {

+      struct grub_ieee1275_devalias alias;

+

+      have_nand = 0;

+      FOR_IEEE1275_DEVALIASES(alias)

+	if (grub_strcmp (alias->name, "nand") == 0)

+	  {

+	    have_nand = 1;

+	    break;

+	  }

+      grub_ieee1275_devalias_free (&alias);

+    }

+

+  if (have_nand)

+    return hook ("nand", hook_data);

+

+  return 0;

 }

 static grub_err_t

diff --git a/grub-core/disk/ieee1275/ofdisk.c b/grub-core/disk/ieee1275/ofdisk.c

index 2130cb1..1d4de90 100644

--- a/grub-core/disk/ieee1275/ofdisk.c

+++ b/grub-core/disk/ieee1275/ofdisk.c

@@ -114,107 +114,113 @@ ofdisk_hash_add (char *devpath, char *curcan)

 }

 static void

-scan (void)

+dev_iterate_real (const char *name, const char *path)

 {

-  auto int dev_iterate_real (const char *name, const char *path);

-

-  int dev_iterate_real (const char *name, const char *path)

-    {

-      struct ofdisk_hash_ent *op;

+  struct ofdisk_hash_ent *op;

-      grub_dprintf ("disk", "disk name = %s, path = %s\n", name,

-		    path);

+  grub_dprintf ("disk", "disk name = %s, path = %s\n", name,

+		path);

-      op = ofdisk_hash_find (path);

-      if (!op)

+  op = ofdisk_hash_find (path);

+  if (!op)

+    {

+      char *name_dup = grub_strdup (name);

+      char *can = grub_strdup (path);

+      if (!name_dup || !can)

 	{

-	  char *name_dup = grub_strdup (name);

-	  char *can = grub_strdup (path);

-	  if (!name_dup || !can)

-	    {

-	      grub_errno = GRUB_ERR_NONE;

-	      grub_free (name_dup);

-	      grub_free (can);

-	      return 0;

-	    }

-	  op = ofdisk_hash_add (name_dup, can);

+	  grub_errno = GRUB_ERR_NONE;

+	  grub_free (name_dup);

+	  grub_free (can);

+	  return;

 	}

-      return 0;

+      op = ofdisk_hash_add (name_dup, can);

     }

+  return;

+}

-  auto int dev_iterate_alias (struct grub_ieee1275_devalias *alias);

-  int dev_iterate_alias (struct grub_ieee1275_devalias *alias)

-  {

-    if (grub_strcmp (alias->type, "block") != 0)

-      return 0;

-    return dev_iterate_real (alias->name, alias->path);

-  }

-

-  auto int dev_iterate (struct grub_ieee1275_devalias *alias);

-  int dev_iterate (struct grub_ieee1275_devalias *alias)

-  {

-    if (grub_strcmp (alias->type, "vscsi") == 0)

+static void

+dev_iterate (const struct grub_ieee1275_devalias *alias)

+{

+  if (grub_strcmp (alias->type, "vscsi") == 0)

+    {

+      static grub_ieee1275_ihandle_t ihandle;

+      struct set_color_args

       {

-	static grub_ieee1275_ihandle_t ihandle;

-	struct set_color_args

-	{

-	  struct grub_ieee1275_common_hdr common;

-	  grub_ieee1275_cell_t method;

-	  grub_ieee1275_cell_t ihandle;

-	  grub_ieee1275_cell_t catch_result;

-	  grub_ieee1275_cell_t nentries;

-	  grub_ieee1275_cell_t table;

-	}

-	args;

-	char *buf, *bufptr;

-	unsigned i;

+	struct grub_ieee1275_common_hdr common;

+	grub_ieee1275_cell_t method;

+	grub_ieee1275_cell_t ihandle;

+	grub_ieee1275_cell_t catch_result;

+	grub_ieee1275_cell_t nentries;

+	grub_ieee1275_cell_t table;

+      }

+      args;

+      char *buf, *bufptr;

+      unsigned i;

-	if (grub_ieee1275_open (alias->path, &ihandle))

-	  return 0;

+      if (grub_ieee1275_open (alias->path, &ihandle))

+	return;

-	INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 3);

-	args.method = (grub_ieee1275_cell_t) "vscsi-report-luns";

-	args.ihandle = ihandle;

-	args.table = 0;

-	args.nentries = 0;

+      INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 3);

+      args.method = (grub_ieee1275_cell_t) "vscsi-report-luns";

+      args.ihandle = ihandle;

+      args.table = 0;

+      args.nentries = 0;

-	if (IEEE1275_CALL_ENTRY_FN (&args) == -1 || args.catch_result)

-	  {

-	    grub_ieee1275_close (ihandle);

-	    return 0;

-	  }

+      if (IEEE1275_CALL_ENTRY_FN (&args) == -1 || args.catch_result)

+	{

+	  grub_ieee1275_close (ihandle);

+	  return;

+	}

-	buf = grub_malloc (grub_strlen (alias->path) + 32);

-	if (!buf)

-	  return 0;

-	bufptr = grub_stpcpy (buf, alias->path);

+      buf = grub_malloc (grub_strlen (alias->path) + 32);

+      if (!buf)

+	return;

+      bufptr = grub_stpcpy (buf, alias->path);

-	for (i = 0; i < args.nentries; i++)

-	  {

-	    grub_uint64_t *ptr;

+      for (i = 0; i < args.nentries; i++)

+	{

+	  grub_uint64_t *ptr;

-	    ptr = *(grub_uint64_t **) (args.table + 4 + 8 * i);

-	    while (*ptr)

-	      {

-		grub_snprintf (bufptr, 32, "/disk@%" PRIxGRUB_UINT64_T, *ptr++);

-		if (dev_iterate_real (buf, buf))

-		  return 1;

-	      }

-	  }

-	grub_ieee1275_close (ihandle);

-	grub_free (buf);

-	return 0;

-      }

+	  ptr = *(grub_uint64_t **) (args.table + 4 + 8 * i);

+	  while (*ptr)

+	    {

+	      grub_snprintf (bufptr, 32, "/disk@%" PRIxGRUB_UINT64_T, *ptr++);

+	      dev_iterate_real (buf, buf);

+	    }

+	}

+      grub_ieee1275_close (ihandle);

+      grub_free (buf);

+      return;

+    }

-    if (!grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS)

-	&& grub_strcmp (alias->type, "block") == 0)

-      return dev_iterate_real (alias->path, alias->path);

+  if (!grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS)

+      && grub_strcmp (alias->type, "block") == 0)

+    {

+      dev_iterate_real (alias->path, alias->path);

+      return;

+    }

+

+  {

+    struct grub_ieee1275_devalias child;

-    return grub_children_iterate (alias->path, dev_iterate);

+    FOR_IEEE1275_DEVCHILDREN(alias->path, child)

+      dev_iterate (&child);

   }

+}

+

+static void

+scan (void)

+{

+  struct grub_ieee1275_devalias alias;

+  FOR_IEEE1275_DEVALIASES(alias)

+    {

+      if (grub_strcmp (alias.type, "block") != 0)

+	continue;

+      dev_iterate_real (alias.name, alias.path);

+    }

-  grub_devalias_iterate (dev_iterate_alias);

-  grub_children_iterate ("/", dev_iterate);

+  FOR_IEEE1275_DEVCHILDREN("/", alias)

+    dev_iterate (&alias);

 }

 static int

diff --git a/grub-core/kern/ieee1275/openfw.c b/grub-core/kern/ieee1275/openfw.c

index 40abaa3..90c092c 100644

--- a/grub-core/kern/ieee1275/openfw.c

+++ b/grub-core/kern/ieee1275/openfw.c

@@ -32,184 +32,227 @@ enum grub_ieee1275_parse_type

   GRUB_PARSE_DEVICE_TYPE

 };

-/* Walk children of 'devpath', calling hook for each.  */

-int

-grub_children_iterate (const char *devpath,

-		       int (*hook) (struct grub_ieee1275_devalias *alias))

+static int

+fill_alias (struct grub_ieee1275_devalias *alias)

 {

-  grub_ieee1275_phandle_t dev;

-  grub_ieee1275_phandle_t child;

-  char *childtype, *childpath;

-  char *childname;

-  int ret = 0;

+  grub_ssize_t actual;

-  if (grub_ieee1275_finddevice (devpath, &dev))

+  if (grub_ieee1275_get_property (alias->phandle, "device_type", alias->type,

+				  IEEE1275_MAX_PROP_LEN, &actual))

+    alias->type[0] = 0;

+

+  if (alias->parent_dev == alias->phandle)

     return 0;

-  if (grub_ieee1275_child (dev, &child))

+  if (grub_ieee1275_package_to_path (alias->phandle, alias->path,

+				     IEEE1275_MAX_PATH_LEN, &actual))

     return 0;

-  childtype = grub_malloc (IEEE1275_MAX_PROP_LEN);

-  if (!childtype)

+  if (grub_strcmp (alias->parent_path, alias->path) == 0)

     return 0;

-  childpath = grub_malloc (IEEE1275_MAX_PATH_LEN);

-  if (!childpath)

+

+  if (grub_ieee1275_get_property (alias->phandle, "name", alias->name,

+				  IEEE1275_MAX_PROP_LEN, &actual))

+    return 0;

+  grub_dprintf ("devalias", "device path=%s\n", alias->path);

+  return 1;

+}

+

+void

+grub_ieee1275_devalias_free (struct grub_ieee1275_devalias *alias)

+{

+  grub_free (alias->name);

+  grub_free (alias->type);

+  grub_free (alias->path);

+  grub_free (alias->parent_path);

+  alias->name = 0;

+  alias->type = 0;

+  alias->path = 0;

+  alias->parent_path = 0;

+  alias->phandle = GRUB_IEEE1275_PHANDLE_INVALID;

+}

+

+void

+grub_ieee1275_children_peer (struct grub_ieee1275_devalias *alias)

+{

+  while (grub_ieee1275_peer (alias->phandle, &alias->phandle) != -1)

+    if (fill_alias (alias))

+      return;

+  grub_ieee1275_devalias_free (alias);

+}

+

+void

+grub_ieee1275_children_first (const char *devpath,

+			      struct grub_ieee1275_devalias *alias)

+{

+  grub_ieee1275_phandle_t dev;

+

+  grub_dprintf ("devalias", "iterating children of %s\n",

+		devpath);

+

+  alias->name = 0;

+  alias->path = 0;

+  alias->parent_path = 0;

+  alias->type = 0;

+

+  if (grub_ieee1275_finddevice (devpath, &dev))

+    return;

+

+  if (grub_ieee1275_child (dev, &alias->phandle))

+    return;

+

+  alias->type = grub_malloc (IEEE1275_MAX_PROP_LEN);

+  if (!alias->type)

+    return;

+  alias->path = grub_malloc (IEEE1275_MAX_PATH_LEN);

+  if (!alias->path)

     {

-      grub_free (childtype);

-      return 0;

+      grub_free (alias->type);

+      return;

     }

-  childname = grub_malloc (IEEE1275_MAX_PROP_LEN);

-  if (!childname)

+  alias->parent_path = grub_strdup (devpath);

+  if (!alias->parent_path)

     {

-      grub_free (childpath);

-      grub_free (childtype);

-      return 0;

+      grub_free (alias->path);

+      grub_free (alias->type);

+      return;

     }

-  do

+  alias->name = grub_malloc (IEEE1275_MAX_PROP_LEN);

+  if (!alias->name)

     {

-      struct grub_ieee1275_devalias alias;

-      grub_ssize_t actual;

-

-      if (grub_ieee1275_get_property (child, "device_type", childtype,

-				      IEEE1275_MAX_PROP_LEN, &actual))

-	childtype[0] = 0;

-

-      if (dev == child)

-	continue;

-

-      if (grub_ieee1275_package_to_path (child, childpath,

-					 IEEE1275_MAX_PATH_LEN, &actual))

-	continue;

-

-      if (grub_strcmp (devpath, childpath) == 0)

-	continue;

+      grub_free (alias->path);

+      grub_free (alias->type);

+      grub_free (alias->parent_path);

+      return;

+    }

+  if (!fill_alias (alias))

+    grub_ieee1275_children_peer (alias);

+}

-      if (grub_ieee1275_get_property (child, "name", childname,

-				      IEEE1275_MAX_PROP_LEN, &actual))

-	continue;

+static int

+iterate_recursively (const char *path,

+		     int (*hook) (struct grub_ieee1275_devalias *alias))

+{

+  struct grub_ieee1275_devalias alias;

+  int ret = 0;

-      alias.type = childtype;

-      alias.path = childpath;

-      alias.name = childname;

+  FOR_IEEE1275_DEVCHILDREN(path, alias)

+    {

       ret = hook (&alias);

       if (ret)

 	break;

+      ret = iterate_recursively (alias.path, hook);

+      if (ret)

+	break;

     }

-  while (grub_ieee1275_peer (child, &child) != -1);

-

-  grub_free (childname);

-  grub_free (childpath);

-  grub_free (childtype);

-

+  grub_ieee1275_devalias_free (&alias);

   return ret;

 }

 int

 grub_ieee1275_devices_iterate (int (*hook) (struct grub_ieee1275_devalias *alias))

 {

-  auto int it_through (struct grub_ieee1275_devalias *alias);

-  int it_through (struct grub_ieee1275_devalias *alias)

-  {

-    if (hook (alias))

-      return 1;

-    return grub_children_iterate (alias->path, it_through);

-  }

-

-  return grub_children_iterate ("/", it_through);

+  return iterate_recursively ("/", hook);

 }

-/* Iterate through all device aliases.  This function can be used to

-   find a device of a specific type.  */

-int

-grub_devalias_iterate (int (*hook) (struct grub_ieee1275_devalias *alias))

+void

+grub_ieee1275_devalias_init_iterator (struct grub_ieee1275_devalias *alias)

 {

-  grub_ieee1275_phandle_t aliases;

-  char *aliasname, *devtype;

-  grub_ssize_t actual;

-  struct grub_ieee1275_devalias alias;

-  int ret = 0;

+  alias->name = 0;

+  alias->path = 0;

+  alias->parent_path = 0;

+  alias->type = 0;

-  if (grub_ieee1275_finddevice ("/aliases", &aliases))

-    return 0;

+  grub_dprintf ("devalias", "iterating aliases\n");

-  aliasname = grub_malloc (IEEE1275_MAX_PROP_LEN);

-  if (!aliasname)

-    return 0;

-  devtype = grub_malloc (IEEE1275_MAX_PROP_LEN);

-  if (!devtype)

+  if (grub_ieee1275_finddevice ("/aliases", &alias->parent_dev))

+    return;

+

+  alias->name = grub_malloc (IEEE1275_MAX_PROP_LEN);

+  if (!alias->name)

+    return;

+

+  alias->type = grub_malloc (IEEE1275_MAX_PROP_LEN);

+  if (!alias->type)

     {

-      grub_free (aliasname);

-      return 0;

+      grub_free (alias->name);

+      alias->name = 0;

+      return;

     }

-  /* Find the first property.  */

-  aliasname[0] = '\0';

+  alias->name[0] = '\0';

+}

-  while (grub_ieee1275_next_property (aliases, aliasname, aliasname) > 0)

+int

+grub_ieee1275_devalias_next (struct grub_ieee1275_devalias *alias)

+{

+  if (!alias->name)

+    return 0;

+  while (1)

     {

-      grub_ieee1275_phandle_t dev;

       grub_ssize_t pathlen;

-      char *devpath;

+      grub_ssize_t actual;

+

+      if (alias->path)

+	{

+	  grub_free (alias->path);

+	  alias->path = 0;

+	}

+      if (grub_ieee1275_next_property (alias->parent_dev, alias->name,

+				       alias->name) <= 0)

+	{

+	  grub_ieee1275_devalias_free (alias);

+	  return 0;

+	}

-      grub_dprintf ("devalias", "devalias name = %s\n", aliasname);

+      grub_dprintf ("devalias", "devalias name = %s\n", alias->name);

-      grub_ieee1275_get_property_length (aliases, aliasname, &pathlen);

+      grub_ieee1275_get_property_length (alias->parent_dev, alias->name, &pathlen);

       /* The property `name' is a special case we should skip.  */

-      if (!grub_strcmp (aliasname, "name"))

+      if (grub_strcmp (alias->name, "name") == 0)

 	continue;

       /* Sun's OpenBoot often doesn't zero terminate the device alias

 	 strings, so we will add a NULL byte at the end explicitly.  */

       pathlen += 1;

-      devpath = grub_malloc (pathlen + 1);

-      if (! devpath)

+      alias->path = grub_malloc (pathlen + 1);

+      if (! alias->path)

 	{

-	  grub_free (devtype);

-	  grub_free (aliasname);

+	  grub_ieee1275_devalias_free (alias);

 	  return 0;

 	}

-      if (grub_ieee1275_get_property (aliases, aliasname, devpath, pathlen,

-				      &actual) || actual < 0)

+      if (grub_ieee1275_get_property (alias->parent_dev, alias->name, alias->path,

+				      pathlen, &actual) || actual < 0)

 	{

-	  grub_dprintf ("devalias", "get_property (%s) failed\n", aliasname);

-	  goto nextprop;

+	  grub_dprintf ("devalias", "get_property (%s) failed\n", alias->name);

+	  grub_free (alias->path);

+	  continue;

 	}

       if (actual > pathlen)

 	actual = pathlen;

-      devpath[actual] = '\0';

-      devpath[pathlen] = '\0';

+      alias->path[actual] = '\0';

+      alias->path[pathlen] = '\0';

-      if (grub_ieee1275_finddevice (devpath, &dev))

+      if (grub_ieee1275_finddevice (alias->path, &alias->phandle))

 	{

-	  grub_dprintf ("devalias", "finddevice (%s) failed\n", devpath);

-	  goto nextprop;

+	  grub_dprintf ("devalias", "finddevice (%s) failed\n", alias->path);

+	  grub_free (alias->path);

+	  alias->path = 0;

+	  continue;

 	}

-      if (grub_ieee1275_get_property (dev, "device_type", devtype,

+      if (grub_ieee1275_get_property (alias->phandle, "device_type", alias->type,

 				      IEEE1275_MAX_PROP_LEN, &actual))

 	{

 	  /* NAND device don't have device_type property.  */

-          devtype[0] = 0;

+          alias->type[0] = 0;

 	}

-

-      alias.name = aliasname;

-      alias.path = devpath;

-      alias.type = devtype;

-      ret = hook (&alias);

-

-nextprop:

-      grub_free (devpath);

-      if (ret)

-	break;

+      return 1;

     }

-

-  grub_free (devtype);

-  grub_free (aliasname);

-  return ret;

 }

 /* Call the "map" method of /chosen/mmu.  */

@@ -286,37 +329,28 @@ grub_ieee1275_get_devargs (const char *path)

 }

 /* Get the device path of the Open Firmware node name `path'.  */

-static char *

+char *

 grub_ieee1275_get_devname (const char *path)

 {

   char *colon = grub_strchr (path, ':');

-  char *newpath = 0;

   int pathlen = grub_strlen (path);

-  auto int match_alias (struct grub_ieee1275_devalias *alias);

-

-  int match_alias (struct grub_ieee1275_devalias *curalias)

-    {

-      /* briQ firmware can change capitalization in /chosen/bootpath.  */

-      if (grub_strncasecmp (curalias->path, path, pathlen) == 0

-	  && curalias->path[pathlen] == 0)

-        {

-	  newpath = grub_strdup (curalias->name);

-	  return 1;

-	}

-

-      return 0;

-    }

-

+  struct grub_ieee1275_devalias curalias;

   if (colon)

     pathlen = (int)(colon - path);

   /* Try to find an alias for this device.  */

-  grub_devalias_iterate (match_alias);

-

-  if (! newpath)

-    newpath = grub_strndup (path, pathlen);

+  FOR_IEEE1275_DEVALIASES (curalias)

+    /* briQ firmware can change capitalization in /chosen/bootpath.  */

+    if (grub_strncasecmp (curalias.path, path, pathlen) == 0

+	&& curalias.path[pathlen] == 0)

+      {

+	char *newpath;

+	newpath = grub_strdup (curalias.name);

+	grub_ieee1275_devalias_free (&curalias);

+	return newpath;

+      }

-  return newpath;

+  return grub_strndup (path, pathlen);

 }

 static char *

diff --git a/grub-core/net/drivers/ieee1275/ofnet.c b/grub-core/net/drivers/ieee1275/ofnet.c

index 7e8e2a7..1acfb73 100644

--- a/grub-core/net/drivers/ieee1275/ofnet.c

+++ b/grub-core/net/drivers/ieee1275/ofnet.c

@@ -198,27 +198,6 @@ grub_ieee1275_net_config_real (const char *devpath, char **device, char **path)

   }

 }

-static char *

-find_alias (const char *fullname)

-{

-  char *ret = NULL;

-  auto int find_alias_hook (struct grub_ieee1275_devalias *alias);

-

-  int find_alias_hook (struct grub_ieee1275_devalias *alias)

-  {

-    if (grub_strcmp (alias->path, fullname) == 0)

-      {

-	ret = grub_strdup (alias->name);

-	return 1;

-      }

-    return 0;

-  }

-

-  grub_devalias_iterate (find_alias_hook);

-  grub_errno = GRUB_ERR_NONE;

-  return ret;

-}

-

 static int

 search_net_devices (struct grub_ieee1275_devalias *alias)

 {

@@ -308,7 +287,7 @@ search_net_devices (struct grub_ieee1275_devalias *alias)

   card->driver = NULL;

   card->data = ofdata;

   card->flags = 0;

-  shortname = find_alias (alias->path);

+  shortname = grub_ieee1275_get_devname (alias->path);

   card->name = grub_xasprintf ("ofnet_%s", shortname ? : alias->path);

   card->idle_poll_delay_ms = 10;

   grub_free (shortname);

diff --git a/grub-core/term/ieee1275/escc.c b/grub-core/term/ieee1275/escc.c