patch-1.3.44 linux/include/asm-sparc/openprom.h

• Lines: 431
• Date: Sat Nov 25 04:32:14 1995
• Orig file: v1.3.43/linux/include/asm-sparc/openprom.h
• Orig date: Tue Jun 27 14:11:45 1995

diff -u --recursive --new-file v1.3.43/linux/include/asm-sparc/openprom.h linux/include/asm-sparc/openprom.h
@@ -1,3 +1,4 @@
+/* $Id: openprom.h,v 1.15 1995/11/25 02:32:13 davem Exp $ */
 #ifndef __SPARC_OPENPROM_H
 #define __SPARC_OPENPROM_H
 
@@ -7,297 +8,176 @@
  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  */
 
-/* In the v0 interface of the openboot prom we could traverse a nice
- * little list structure to figure out where in vm-space the prom had
- * mapped itself and how much space it was taking up. In the v2 prom
- * interface we have to rely on 'magic' values. :-( Most of the machines
- * I have checked on have the prom mapped here all the time though.
- */
-
+/* Imperical constants... */
 #define KADB_DEBUGGER_BEGVM     0xffc00000    /* Where kern debugger is in virt-mem */
-
 #define	LINUX_OPPROM_BEGVM	0xffd00000
 #define	LINUX_OPPROM_ENDVM	0xfff00000
-
 #define	LINUX_OPPROM_MAGIC      0x10010407
 
 #ifndef __ASSEMBLY__
-/* The device functions structure for the v0 prom. Nice and neat, open,
- * close, read & write divvied up between net + block + char devices. We
- * also have a seek routine only usable for block devices. The divide
- * and conquer strategy of this struct becomes unnecessary for v2.
- *
- * V0 device names are limited to two characters, 'sd' for scsi-disk,
- * 'le' for local-ethernet, etc. Note that it is technically possible
- * to boot a kernel off of a tape drive and use the tape as the root
- * partition! In order to do this you have to have 'magic' formatted
- * tapes from Sun supposedly :-)
- */
-
+/* V0 prom device operations. */
 struct linux_dev_v0_funcs {
-	int	(*v0_devopen)(char *device_str);
-	int	(*v0_devclose)(int dev_desc);
-	int	(*v0_rdblkdev)(int dev_desc, int num_blks, int blk_st, char*  buf);
-	int	(*v0_wrblkdev)(int dev_desc, int num_blks, int blk_st, char*  buf);
-	int	(*v0_wrnetdev)(int dev_desc, int num_bytes, char*  buf);
-	int	(*v0_rdnetdev)(int dev_desc, int num_bytes, char*  buf);
-	int	(*v0_rdchardev)(int dev_desc, int num_bytes, int dummy, char*  buf);
-	int	(*v0_wrchardev)(int dev_desc, int num_bytes, int dummy, char*  buf);
-	int	(*v0_seekdev)(int dev_desc, long logical_offst, int from);
+	int (*v0_devopen)(char *device_str);
+	int (*v0_devclose)(int dev_desc);
+	int (*v0_rdblkdev)(int dev_desc, int num_blks, int blk_st, char *buf);
+	int (*v0_wrblkdev)(int dev_desc, int num_blks, int blk_st, char *buf);
+	int (*v0_wrnetdev)(int dev_desc, int num_bytes, char *buf);
+	int (*v0_rdnetdev)(int dev_desc, int num_bytes, char *buf);
+	int (*v0_rdchardev)(int dev_desc, int num_bytes, int dummy, char *buf);
+	int (*v0_wrchardev)(int dev_desc, int num_bytes, int dummy, char *buf);
+	int (*v0_seekdev)(int dev_desc, long logical_offst, int from);
 };
 
-/* The OpenBoot Prom device operations for version-2 interfaces are both
- * good and bad. They now allow you to address ANY device whatsoever
- * that is in the machine via these funny "device paths". They look like
- * this:
- *
- *   "/sbus/esp@0,0xf004002c/sd@3,1"
- *
- * You can basically reference any device on the machine this way, and
- * you pass this string to the v2 dev_ops. Producing these strings all
- * the time can be a pain in the rear after a while. Why v2 has memory
- * allocations in here are beyond me. Perhaps they figure that if you
- * are going to use only the prom's device drivers then your memory
- * management is either non-existent or pretty sad. :-)
- */
-
+/* V2 and later prom device operations. */
 struct linux_dev_v2_funcs {
-	int	(*v2_inst2pkg)(int d);	/* Convert ihandle to phandle */
-
-	/* "dumb" prom memory management routines, probably
-	 *  only safe to use for mapping device address spaces...
-         */
-
-	char* 	(*v2_dumb_mem_alloc)(char*  va, unsigned sz);
-	void	(*v2_dumb_mem_free)(char*  va, unsigned sz);
-
-	/* "dumb" mmap() munmap(), copy on write? what's that? */
-	char* 	(*v2_dumb_mmap)(char*  virta, int which_io, unsigned paddr, unsigned sz);
-	void	(*v2_dumb_munmap)(char*  virta, unsigned size);
-
-	/* Basic Operations, self-explanatory */
-	int	(*v2_dev_open)(char *devpath);
-	void	(*v2_dev_close)(int d);
-	int	(*v2_dev_read)(int d, char*  buf, int nbytes);
-	int	(*v2_dev_write)(int d, char*  buf, int nbytes);
-	void	(*v2_dev_seek)(int d, int hi, int lo);
+	int (*v2_inst2pkg)(int d);	/* Convert ihandle to phandle */
+	char * (*v2_dumb_mem_alloc)(char *va, unsigned sz);
+	void (*v2_dumb_mem_free)(char *va, unsigned sz);
+
+	/* To map devices into virtual I/O space. */
+	char * (*v2_dumb_mmap)(char *virta, int which_io, unsigned paddr, unsigned sz);
+	void (*v2_dumb_munmap)(char *virta, unsigned size);
+
+	int (*v2_dev_open)(char *devpath);
+	void (*v2_dev_close)(int d);
+	int (*v2_dev_read)(int d, char *buf, int nbytes);
+	int (*v2_dev_write)(int d, char *buf, int nbytes);
+	void (*v2_dev_seek)(int d, int hi, int lo);
 
 	/* Never issued (multistage load support) */
-	void	(*v2_wheee2)(void);
-	void	(*v2_wheee3)(void);
+	void (*v2_wheee2)(void);
+	void (*v2_wheee3)(void);
 };
 
-/* Just like the device ops, they slightly screwed up the mem-list
- * from v0 to v2. Probably easier on the prom-writer dude, sucks for
- * us though. See above comment about prom-vm mapped address space
- * magic numbers. :-(
- */
-
 struct linux_mlist_v0 {
-	struct	linux_mlist_v0 *theres_more;
-	char* 	start_adr;
+	struct linux_mlist_v0 *theres_more;
+	char *start_adr;
 	unsigned num_bytes;
 };
 
-/* The linux_mlist_v0's are pointed to by this structure. One list
- * per description. This means one list for total physical memory,
- * one for prom's address mapping, and one for physical mem left after
- * the kernel is loaded.
- */
-
 struct linux_mem_v0 {
-	struct	linux_mlist_v0 **v0_totphys;	/* all of physical */
-	struct	linux_mlist_v0 **v0_prommap;	/* addresses map'd by prom */
-	struct  linux_mlist_v0 **v0_available;	/* what phys. is left over */
+	struct linux_mlist_v0 **v0_totphys;
+	struct linux_mlist_v0 **v0_prommap;
+	struct linux_mlist_v0 **v0_available; /* What we can use */
 };
 
 /* Arguments sent to the kernel from the boot prompt. */
-
 struct linux_arguments_v0 {
-	char	*argv[8];		/* argv format for boot string */
-	char	args[100];		/* string space */
-	char	boot_dev[2];		/* e.g., "sd" for `b sd(...' */
-	int	boot_dev_ctrl;		/* controller # */
-	int	boot_dev_unit;		/* unit # */
-	int	dev_partition;		/* partition # */
-	char	*kernel_file_name;	/* kernel to boot, e.g., "vmunix" */
-	void	*aieee1;		/* give me some time  :> */
+	char *argv[8];
+	char args[100];
+	char boot_dev[2];
+	int boot_dev_ctrl;
+	int boot_dev_unit;
+	int dev_partition;
+	char *kernel_file_name;
+	void *aieee1;           /* XXX */
 };
 
-/* Prom version-2 gives us the raw strings for boot arguments and
- * boot device path. We also get the stdin and stdout file pseudo
- * descriptors for use with the mungy v2 device functions.
- */
+/* V2 and up boot things. */
 struct linux_bootargs_v2 {
-	char	**bootpath;		/* V2: Path to boot device */
-	char	**bootargs;		/* V2: Boot args */
-	int	*fd_stdin;		/* V2: Stdin descriptor */
-	int	*fd_stdout;		/* V2: Stdout descriptor */
+	char **bootpath;
+	char **bootargs;
+	int *fd_stdin;
+	int *fd_stdout;
 };
 
-/* This is the actual Prom Vector from which everything else is accessed
- * via struct and function pointers, etc. The prom when it loads us into
- * memory plops a pointer to this master structure in register %o0 before
- * it jumps to the kernel start address. I will update this soon to cover
- * the v3 semantics (cpu_start, cpu_stop and other SMP fun things). :-)
- */
-
+/* The top level PROM vector. */
 struct linux_romvec {
 	/* Version numbers. */
-	unsigned int	pv_magic_cookie;      /* Magic Mushroom... */
-	unsigned int	pv_romvers;	      /* iface vers (0, 2, or 3) */
-	unsigned int	pv_plugin_revision;   /* revision relative to above vers */
-	unsigned int	pv_printrev;	      /* print revision */
-
-	/* Version 0 memory descriptors (see below). */
-	struct linux_mem_v0 pv_v0mem;	      /* V0: Memory description lists. */
+	unsigned int pv_magic_cookie;
+	unsigned int pv_romvers;
+	unsigned int pv_plugin_revision;
+	unsigned int pv_printrev;
+
+	/* Version 0 memory descriptors. */
+	struct linux_mem_v0 pv_v0mem;
 
-	/* Node operations (see below). */
-	struct	linux_nodeops *pv_nodeops;   /* node functions, gets device data */
+	/* Node operations. */
+	struct linux_nodeops *pv_nodeops;
 
-	char	**pv_bootstr;		    /* Boot command, eg sd(0,0,0)vmunix */
+	char **pv_bootstr;
+	struct linux_dev_v0_funcs pv_v0devops;
 
-	struct	linux_dev_v0_funcs pv_v0devops; 	/* V0: device ops */
-
-	/*
-	 * PROMDEV_* cookies.  I fear these may vanish in lieu of fd0/fd1
-	 * (see below) in future PROMs, but for now they work fine.
-	 */
-	char	*pv_stdin;		/* stdin cookie */
-	char	*pv_stdout;		/* stdout cookie */
+	char *pv_stdin;
+	char *pv_stdout;
 #define	PROMDEV_KBD	0		/* input from keyboard */
 #define	PROMDEV_SCREEN	0		/* output to screen */
 #define	PROMDEV_TTYA	1		/* in/out to ttya */
 #define	PROMDEV_TTYB	2		/* in/out to ttyb */
 
 	/* Blocking getchar/putchar.  NOT REENTRANT! (grr) */
-	int	(*pv_getchar)(void);
-	void	(*pv_putchar)(int ch);
+	int (*pv_getchar)(void);
+	void (*pv_putchar)(int ch);
 
-	/* Non-blocking variants that return -1 on error. */
-	int	(*pv_nbgetchar)(void);
-	int	(*pv_nbputchar)(int ch);
+	/* Non-blocking variants. */
+	int (*pv_nbgetchar)(void);
+	int (*pv_nbputchar)(int ch);
 
-	/* Put counted string (can be very slow). */
-	void	(*pv_putstr)(char *str, int len);
+	void (*pv_putstr)(char *str, int len);
 
 	/* Miscellany. */
-	void	(*pv_reboot)(char *bootstr);
-	void	(*pv_printf)(const char *fmt, ...);
-	void	(*pv_abort)(void);	/* BREAK key abort */
-	int	*pv_ticks;		/* milliseconds since last reset */
-	void    (*pv_halt)(void);	/* End the show */
-	void	(**pv_synchook)(void);	/* "sync" ptr to function */
-
-	/*
-	 * This eval's a FORTH string.  Unfortunately, its interface
-	 * changed between V0 and V2, which gave us much pain.
-	 */
+	void (*pv_reboot)(char *bootstr);
+	void (*pv_printf)(const char *fmt, ...);
+	void (*pv_abort)(void);
+	int *pv_ticks;
+	void (*pv_halt)(void);
+	void (**pv_synchook)(void);
+
+	/* Evaluate a forth string, not different proto for V0 and V2->up. */
 	union {
-		void	(*v0_eval)(int len, char *str);
-		void	(*v2_eval)(char *str);
+		void (*v0_eval)(int len, char *str);
+		void (*v2_eval)(char *str);
 	} pv_fortheval;
 
-	struct	linux_arguments_v0 **pv_v0bootargs; /* V0: Boot args */
+	struct linux_arguments_v0 **pv_v0bootargs;
 
-	/* Extract Ethernet address from network device. */
-	unsigned int	(*pv_enaddr)(int d, char *enaddr);
+	/* Get ether address. */
+	unsigned int (*pv_enaddr)(int d, char *enaddr);
 
-	struct	linux_bootargs_v2 pv_v2bootargs;    /* V2: Boot args+std-in/out */
-	struct	linux_dev_v2_funcs pv_v2devops;	    /* V2: device operations */
+	struct linux_bootargs_v2 pv_v2bootargs;
+	struct linux_dev_v2_funcs pv_v2devops;
 
-	int	filler[15];
-
-	/*
-	 * The following is machine-dependent.
-	 *
-	 * The sun4c needs a PROM function to set a PMEG for another
-	 * context, so that the kernel can map itself in all contexts.
-	 * It is not possible simply to set the context register, because
-	 * contexts 1 through N may have invalid translations for the
-	 * current program counter.  The hardware has a mode in which
-	 * all memory references go to the PROM, so the PROM can do it
-	 * easily.
-	 */
-	void	(*pv_setctxt)(int ctxt, char*  va, int pmeg);
+	int filler[15];
+
+	/* This one is sun4c/sun4 only. */
+	void (*pv_setctxt)(int ctxt, char *va, int pmeg);
 
 	/* Prom version 3 Multiprocessor routines. This stuff is crazy.
 	 * No joke. Calling these when there is only one cpu probably
 	 * crashes the machine, have to test this. :-)
-         */
+	 */
 
 	/* v3_cpustart() will start the cpu 'whichcpu' in mmu-context
 	 * 'thiscontext' executing at address 'prog_counter'
-         */
-
+	 */
 	int (*v3_cpustart)(unsigned int whichcpu, int ctxtbl_ptr,
-			   int thiscontext, char* prog_counter);
+			   int thiscontext, char *prog_counter);
 
 	/* v3_cpustop() will cause cpu 'whichcpu' to stop executing
 	 * until a resume cpu call is made.
 	 */
-
 	int (*v3_cpustop)(unsigned int whichcpu);
 
 	/* v3_cpuidle() will idle cpu 'whichcpu' until a stop or
 	 * resume cpu call is made.
 	 */
-
 	int (*v3_cpuidle)(unsigned int whichcpu);
 
 	/* v3_cpuresume() will resume processor 'whichcpu' executing
 	 * starting with whatever 'pc' and 'npc' were left at the
 	 * last 'idle' or 'stop' call.
 	 */
-
 	int (*v3_cpuresume)(unsigned int whichcpu);
-
 };
 
-/*
- * In addition to the global stuff defined in the PROM vectors above,
- * the PROM has quite a collection of `nodes'.  A node is described by
- * an integer---these seem to be internal pointers, actually---and the
- * nodes are arranged into an N-ary tree.  Each node implements a fixed
- * set of functions, as described below.  The first two deal with the tree
- * structure, allowing traversals in either breadth- or depth-first fashion.
- * The rest deal with `properties'.
- *
- * A node property is simply a name/value pair.  The names are C strings
- * (NUL-terminated); the values are arbitrary byte strings (counted strings).
- * Many values are really just C strings.  Sometimes these are NUL-terminated,
- * sometimes not, depending on the the interface version; v0 seems to
- * terminate and v2 not.  Many others are simply integers stored as four
- * bytes in machine order: you just get them and go.  The third popular
- * format is an `address', which is made up of one or more sets of three
- * integers as defined below.
- *
- * One uses these functions to traverse the device tree to see what devices
- * this machine has attached to it.
- *
- * N.B.: for the `next' functions, next(0) = first, and next(last) = 0.
- * Whoever designed this part had good taste.  On the other hand, these
- * operation vectors are global, rather than per-node, yet the pointers
- * are not in the openprom vectors but rather found by indirection from
- * there.  So the taste balances out.
- */
-
+/* Routines for traversing the prom device tree. */
 struct linux_nodeops {
-	/*
-	 * Tree traversal.
-	 */
-	int	(*no_nextnode)(int node);	/* next(node) */
-	int	(*no_child)(int node);	/* first child */
-
-	/*
-	 * Property functions.  Proper use of getprop requires calling
-	 * proplen first to make sure it fits.  Kind of a pain, but no
-	 * doubt more convenient for the PROM coder.
-	 */
-	int	(*no_proplen)(int node, char*  name);
-	int	(*no_getprop)(int node, char*  name, char*  val);
-	int	(*no_setprop)(int node, char*  name, char*  val, int len);
-	char* 	(*no_nextprop)(int node, char*  name);
+	int (*no_nextnode)(int node);
+	int (*no_child)(int node);
+	int (*no_proplen)(int node, char *name);
+	int (*no_getprop)(int node, char *name, char *val);
+	int (*no_setprop)(int node, char *name, char *val, int len);
+	char * (*no_nextprop)(int node, char *name);
 };
 
 /* More fun PROM structures for device probing. */
@@ -306,23 +186,23 @@
 #define PROMINTR_MAX    15
 
 struct linux_prom_registers {
-  int which_io;         /* is this in OBIO space? */
-  char *phys_addr;      /* The physical address of this register */
-  int reg_size;         /* How many bytes does this register take up? */
+	int which_io;         /* is this in OBIO space? */
+	char *phys_addr;      /* The physical address of this register */
+	int reg_size;         /* How many bytes does this register take up? */
 };
 
 struct linux_prom_irqs {
-  int pri;    /* IRQ priority */
-  int vector; /* This is foobar, what does it do? */
+	int pri;    /* IRQ priority */
+	int vector; /* This is foobar, what does it do? */
 };
 
 /* Element of the "ranges" vector */
 struct linux_prom_ranges {
-	unsigned int	ot_child_space;
-	unsigned int	ot_child_base;		/* Bus feels this */
-	unsigned int	ot_parent_space;
-	unsigned int	ot_parent_base;		/* CPU looks from here */
-	unsigned int	or_size;
+	unsigned int ot_child_space;
+	unsigned int ot_child_base;		/* Bus feels this */
+	unsigned int ot_parent_space;
+	unsigned int ot_parent_base;		/* CPU looks from here */
+	unsigned int or_size;
 };
 
 #endif /* !(__ASSEMBLY__) */