Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
prom_32.c
Go to the documentation of this file.
1 /*
2  * Procedures for creating, accessing and interpreting the device tree.
3  *
4  * Paul Mackerras August 1996.
5  * Copyright (C) 1996-2005 Paul Mackerras.
6  *
7  * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8  * {engebret|bergner}@us.ibm.com
9  *
10  * Adapted for sparc32 by David S. Miller [email protected]
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version
15  * 2 of the License, or (at your option) any later version.
16  */
17 
18 #include <linux/kernel.h>
19 #include <linux/types.h>
20 #include <linux/string.h>
21 #include <linux/mm.h>
22 #include <linux/bootmem.h>
23 
24 #include <asm/prom.h>
25 #include <asm/oplib.h>
26 #include <asm/leon.h>
27 #include <asm/leon_amba.h>
28 
29 #include "prom.h"
30 
31 void * __init prom_early_alloc(unsigned long size)
32 {
33  void *ret;
34 
35  ret = __alloc_bootmem(size, SMP_CACHE_BYTES, 0UL);
36  if (ret != NULL)
37  memset(ret, 0, size);
38 
40 
41  return ret;
42 }
43 
44 /* The following routines deal with the black magic of fully naming a
45  * node.
46  *
47  * Certain well known named nodes are just the simple name string.
48  *
49  * Actual devices have an address specifier appended to the base name
50  * string, like this "foo@addr". The "addr" can be in any number of
51  * formats, and the platform plus the type of the node determine the
52  * format and how it is constructed.
53  *
54  * For children of the ROOT node, the naming convention is fixed and
55  * determined by whether this is a sun4u or sun4v system.
56  *
57  * For children of other nodes, it is bus type specific. So
58  * we walk up the tree until we discover a "device_type" property
59  * we recognize and we go from there.
60  */
61 static void __init sparc32_path_component(struct device_node *dp, char *tmp_buf)
62 {
63  struct linux_prom_registers *regs;
64  struct property *rprop;
65 
66  rprop = of_find_property(dp, "reg", NULL);
67  if (!rprop)
68  return;
69 
70  regs = rprop->value;
71  sprintf(tmp_buf, "%s@%x,%x",
72  dp->name,
73  regs->which_io, regs->phys_addr);
74 }
75 
76 /* "name@slot,offset" */
77 static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
78 {
79  struct linux_prom_registers *regs;
80  struct property *prop;
81 
82  prop = of_find_property(dp, "reg", NULL);
83  if (!prop)
84  return;
85 
86  regs = prop->value;
87  sprintf(tmp_buf, "%s@%x,%x",
88  dp->name,
89  regs->which_io,
90  regs->phys_addr);
91 }
92 
93 /* "name@devnum[,func]" */
94 static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
95 {
97  struct property *prop;
98  unsigned int devfn;
99 
100  prop = of_find_property(dp, "reg", NULL);
101  if (!prop)
102  return;
103 
104  regs = prop->value;
105  devfn = (regs->phys_hi >> 8) & 0xff;
106  if (devfn & 0x07) {
107  sprintf(tmp_buf, "%s@%x,%x",
108  dp->name,
109  devfn >> 3,
110  devfn & 0x07);
111  } else {
112  sprintf(tmp_buf, "%s@%x",
113  dp->name,
114  devfn >> 3);
115  }
116 }
117 
118 /* "name@addrhi,addrlo" */
119 static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
120 {
121  struct linux_prom_registers *regs;
122  struct property *prop;
123 
124  prop = of_find_property(dp, "reg", NULL);
125  if (!prop)
126  return;
127 
128  regs = prop->value;
129 
130  sprintf(tmp_buf, "%s@%x,%x",
131  dp->name,
132  regs->which_io, regs->phys_addr);
133 }
134 
135 /* "name:vendor:device@irq,addrlo" */
136 static void __init ambapp_path_component(struct device_node *dp, char *tmp_buf)
137 {
138  struct amba_prom_registers *regs;
139  unsigned int *intr, *device, *vendor, reg0;
140  struct property *prop;
141  int interrupt = 0;
142 
143  /* In order to get a unique ID in the device tree (multiple AMBA devices
144  * may have the same name) the node number is printed
145  */
146  prop = of_find_property(dp, "reg", NULL);
147  if (!prop) {
148  reg0 = (unsigned int)dp->phandle;
149  } else {
150  regs = prop->value;
151  reg0 = regs->phys_addr;
152  }
153 
154  /* Not all cores have Interrupt */
155  prop = of_find_property(dp, "interrupts", NULL);
156  if (!prop)
157  intr = &interrupt; /* IRQ0 does not exist */
158  else
159  intr = prop->value;
160 
161  prop = of_find_property(dp, "vendor", NULL);
162  if (!prop)
163  return;
164  vendor = prop->value;
165  prop = of_find_property(dp, "device", NULL);
166  if (!prop)
167  return;
168  device = prop->value;
169 
170  sprintf(tmp_buf, "%s:%d:%d@%x,%x",
171  dp->name, *vendor, *device,
172  *intr, reg0);
173 }
174 
175 static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
176 {
177  struct device_node *parent = dp->parent;
178 
179  if (parent != NULL) {
180  if (!strcmp(parent->type, "pci") ||
181  !strcmp(parent->type, "pciex"))
182  return pci_path_component(dp, tmp_buf);
183  if (!strcmp(parent->type, "sbus"))
184  return sbus_path_component(dp, tmp_buf);
185  if (!strcmp(parent->type, "ebus"))
186  return ebus_path_component(dp, tmp_buf);
187  if (!strcmp(parent->type, "ambapp"))
188  return ambapp_path_component(dp, tmp_buf);
189 
190  /* "isa" is handled with platform naming */
191  }
192 
193  /* Use platform naming convention. */
194  return sparc32_path_component(dp, tmp_buf);
195 }
196 
198 {
199  char tmp_buf[64], *n;
200 
201  tmp_buf[0] = '\0';
202  __build_path_component(dp, tmp_buf);
203  if (tmp_buf[0] == '\0')
204  strcpy(tmp_buf, dp->name);
205 
206  n = prom_early_alloc(strlen(tmp_buf) + 1);
207  strcpy(n, tmp_buf);
208 
209  return n;
210 }
211 
212 extern void restore_current(void);
213 
215 {
216  char *msg = "OF stdout device is: %s\n";
217  struct device_node *dp;
218  unsigned long flags;
219  const char *type;
220  phandle node;
221  int skip, tmp, fd;
222 
224 
225  switch (prom_vers) {
226  case PROM_V0:
227  skip = 0;
228  switch (*romvec->pv_stdout) {
229  case PROMDEV_SCREEN:
230  type = "display";
231  break;
232 
233  case PROMDEV_TTYB:
234  skip = 1;
235  /* FALLTHRU */
236 
237  case PROMDEV_TTYA:
238  type = "serial";
239  break;
240 
241  default:
242  prom_printf("Invalid PROM_V0 stdout value %u\n",
243  *romvec->pv_stdout);
244  prom_halt();
245  }
246 
247  tmp = skip;
248  for_each_node_by_type(dp, type) {
249  if (!tmp--)
250  break;
251  }
252  if (!dp) {
253  prom_printf("Cannot find PROM_V0 console node.\n");
254  prom_halt();
255  }
257 
259  if (!strcmp(type, "serial")) {
261  (skip ? ":b" : ":a"));
262  }
263  break;
264 
265  default:
266  case PROM_V2:
267  case PROM_V3:
268  fd = *romvec->pv_v2bootargs.fd_stdout;
269 
270  spin_lock_irqsave(&prom_lock, flags);
271  node = (*romvec->pv_v2devops.v2_inst2pkg)(fd);
272  restore_current();
273  spin_unlock_irqrestore(&prom_lock, flags);
274 
275  if (!node) {
276  prom_printf("Cannot resolve stdout node from "
277  "instance %08x.\n", fd);
278  prom_halt();
279  }
280  dp = of_find_node_by_phandle(node);
281  type = of_get_property(dp, "device_type", NULL);
282 
283  if (!type) {
284  prom_printf("Console stdout lacks "
285  "device_type property.\n");
286  prom_halt();
287  }
288 
289  if (strcmp(type, "display") && strcmp(type, "serial")) {
290  prom_printf("Console device_type is neither display "
291  "nor serial.\n");
292  prom_halt();
293  }
294 
296 
297  if (prom_vers == PROM_V2) {
299  switch (*romvec->pv_stdout) {
300  case PROMDEV_TTYA:
301  strcat(of_console_path, ":a");
302  break;
303  case PROMDEV_TTYB:
304  strcat(of_console_path, ":b");
305  break;
306  }
307  } else {
308  const char *path;
309 
310  dp = of_find_node_by_path("/");
311  path = of_get_property(dp, "stdout-path", NULL);
312  if (!path) {
313  prom_printf("No stdout-path in root node.\n");
314  prom_halt();
315  }
316  strcpy(of_console_path, path);
317  }
318  break;
319  }
320 
322  if (of_console_options) {
324  if (*of_console_options == '\0')
326  }
327 
328  printk(msg, of_console_path);
329 }
330 
332 {
333 }
334 
336 {
337 }