RFC:new superio proposal

[Eric W. Biederman]

ron minnich <rminnich at lanl.gov> writes:

> Abstract:
> 	The superio architecture for linuxbios has worked for the last 2 
> years but is being stretched to the limit by the changes in superio chips. 
> The architecture depended on superio resources being relatively constant 
> between chips, but this assumption no longer holds. In this document we 
> propose several alternatives and solicit comments. 
> 
> Overview:
> The superio architecture in linuxbios was developed over time, and 
> modified as circumstances required. In the beginning it was relatively 
> simple and assumed only one superio per mainboard. The latest version 
> allows an arbitrary number of superios per mainboard, and allows complete
> specification of the superio base I/O address along with the specification
> of reasonable default valures for both the base I/O address and the 
> superio parameters such as serial enable, baud rate, and so on. 
> 
> Specification of superio control parameters is done by a configuration 
> line such as:
> 
> nsuperio sis/950 com1={1} floppy=1  lpt=1
> 
> This fragment sets the superio type to sis/950; sets com1, floppy, and lpt 
> to enabled; and leaves the defaults to com1 (baud rate, etc.) to the 
> default values. 
> 
> While it is not obvious, these configuration parameters are fragments of a
> C initializer. The initializers are used to build a statically initialized
> structure of this type:
> 
> struct superio {
>         struct superio_control *super; // the ops for the device.
>         unsigned int port; // if non-zero, overrides the default port
>         // com ports. This is not done as an array (yet).
>         // We think it's easier to set up from python if it is not an 
> 	// array.
>         struct com_ports com1, com2, com3, com4;
>         // DMA, if it exists.
>         struct lpt_ports lpt1, lpt2;
>         /* flags for each device type. Unsigned int. */
>         // low order bit ALWAYS means enable. Next bit means to enable
>         // LPT is in transition, so we leave this here for the moment.
>         // The winbond chips really stretched the way this works.
>         // so many functions!
>         unsigned int ide, floppy, lpt;
>         unsigned int keyboard, cir, game;
>         unsigned int gpio1, gpio2, gpio3;
>         unsigned int acpi,hwmonitor;
> };
> 
> These structures are, in turn, created and statically initialized by a
> config-tool-generated structure that defines all the superios. This file
> is called nsuperio.c, is created for each mainboard you build, only 
> appears in the build directory, and looks like this:
> 
> ===
> extern struct superio_control superio_winbond_w83627hf_control; 
> 
> struct superio superio_winbond_w83627hf= { 
>   &superio_winbond_w83627hf_control, 
>   .com1={1}, .com2={1}, .floppy=1, .lpt=1, .keyboard=1, .hwmonitor=1};
> 
> struct superio *all_superio[] = {&superio_winbond_w83627hf,
> };
> 
> unsigned long nsuperio = 1;
> ===

This last bit I really like because it falls out cleanly.  Somewhere
you need to specify what you take and what is a better definition
than a structure definition.

And just generating a structure initializer from a few well defined rules
fells very clean.

Structure initializes start getting wordy so we probably do not want
to too much by hand.  But with a convenient syntax for our purposes
I don't see why we can't do something nice and clean.

> This example shows a board with one superio (nsuperio). The superio
> consists of a winbond w83627hf, with com1, com2, floppy, lpt, keyboard, 
> and hwmonitor enabled. Note that this structure also allows for 
> over-riding the default superio base, although that capability is rarely 
> used. 
> 
> The control structure is used to define how to access the superio for 
> purposes of control. It looks like this:
> ===
> struct superio_control {
>   void (*pre_pci_init)(struct superio *s);
>   void (*init)(struct superio *s);
>   void (*finishup)(struct superio *s);
>   unsigned int defaultport;     /* the defaultport. Can be overridden
>                                  * by commands in config
>                                  */
>   // This is the print name for debugging
>   char *name;
> };
> ===
> 
> There are three methods for stages of hardwaremain. First is pre_pci_init 
> (for chips like the acer southbridge that require you to enable some 
> resources BEFORE pci scan); init, called during the 'middle' phase of 
> hardwaremain; and finishup, called before the payload is loaded. 
> 
> This approach was inspired by and borrows heavily on the Plan 9 kernel 
> configuration tools. 
> 
> The problem:
> 
> When the first version of the superio structure came out it was much
> smaller. It has grown and in the limit this structure is the union of all
> possibly superio chips. Obviously, in the long term, this is not
> practical: we can not anticipate all possible superio chips for all time.
> 
> The common PC BIOS solution to this type of problem is to continue with 
> binary structures but add version numbers to them, so that all code that 
> uses a given structure has to check the version number. Personally, I find 
> this grotesque and would rather not work this way. 

Version numbers are the wrong thing. Devices supporting multiple interfaces
and a way to query which interface you have is much cleaner.  In this
case it is just data but still.  
 
> Using textual strings for configuration is something I find far more 
> attractive. Plan 9 has shown that this approach has no real limits and 
> suffices for configuration tasks. The Linux kernel does more limited use 
> of strings for configuration, but still depends on them. Strings are 
> easier to read and work with than binary structures, and more important, a 
> lot easier to deal with when things start going wrong. 
> 
> The proposed solution:
> 
> What follows are three possible ideas for specifying superio resources and 
> their settings. 
> 
> A common part of the new idea is to eliminate the common superio
> structure, due to the many variations in chips, and make it invisible
> outside a given superio source file -- the superio structure is now
> private to a given superio. Thus, sis/950/superio.c would contain its own
> superio structure definitions, and also might contain more than once
> instance of these structures (consider a board with 2 sis 950 chips).
> 
> The control structure would change as follows:
> struct superio_control {
>   int (*create)(struct superio *s);
>   void (*pre_pci_init)(struct superio *s);
>   void (*init)(struct superio *s);
>   void (*finishup)(struct superio *s);
>   unsigned int defaultport;     /* the defaultport. Can be overridden
>                                  * by commands in config
>                                  */
>   // This is the print name for debugging
>   char *name;
> };
> 
> I.e. we add a new function for creating the superio. 
> 
> Communication of superio settings from linuxbios to the superio would be 
> via textual strings. The superio structure becomes this:
> 
> struct superio {
>         struct superio_control *super; // the ops for the device.
>         unsigned int port; // if non-zero, overrides the default port
> 	struct configuration *config;
> };
> 
> 
> So now the question becomes, what is the configuration structure? 
> There are several choices. The simplest, from my point of view, are
> keyword-value pairs:
> struct configuration {
> 	const char *keyword;
> 	const char *value;
> };
> 
> These get filled in by the config tool as before. The linuxbios libary can 
> then provide a generic parsing function for the superios to use. 
> 
> The remaining question is how should the superio command look in 
> freebios2? 
> 
> superio sis/950 "com1=115200,8n1 lpt=1 com2=9600"
> 
> or
> 
> superio sis/950 "com1baud=115200 lpt=1 com1chars=8n1"
> 
> or
> 
> superio sis/950 ((com1 115200 8n1) (lpt 1))
> 
> So,  my questions:
> 
> 1. Does this new scheme look workable. If not, what needs to change?
A) The problem domain is two small it should address all devices
   and configuration for interrupt lines.

We need to address the relative routes on how to get to devices.

In particular we need a way to specify which configuration goes
to which devices.  I.e. how do you configure a board
when someone places 2 identical superio on the board.  2 identical
nics are already common.  In some contexts both the pci bus and the
pci function are variable.

> 2. What should the 'struct configuration' be? does keyword/value work? 

My personal preference is actually much closer to the current scheme.
But instead of 1 structure include things like struct com_ports n times,
and struct lpt_ports n times. Have a linked list of the structures you
need with a common header something like:

struct config_header {
        struct config_header *next;
        int config_type;
};

And then we can have things like:
#define SERIAL_CONFIG 1
struct serial_struct {
        struct config_header header;
        int baud_rate;
};

> 3. what should the superio command look like? 

I'm not certain and how to specify the pieces in the config file.
We need to specify both the device tree, and parameters for each
device.

Possibly something like:
(dev cpu0
        (apic (initial_id 0)))
(dev cpu1
        (apic (initial_id 1)))
(dev E7500
        (bus pci0
                (dev ich3
                        (bus lpc0
                                (dev sio0
                                        (serial baud 115200)
                                )
                        )
                )
                (dev pci-slot-1 (irqa 1) (irqb 2) (irqc 3) (irqd 4))
                (dev pci-slot-2 (irqa 2) (irqb 3) (irqc 4) (irqd 1))
                (dev pci-slot-3 (irqa 3) (irqb 4) (irqc 1) (irqd 2))
                (dev pci-slot-4 (irqa 4) (irqb 1) (irqc 2) (irqd 3))
                (dev pci-slot-5 (irqa 1) (irqb 2) (irqc 3) (irqd 4))
                (dev pci-slot-6 (irqa 2) (irqb 3) (irqc 4) (irqd 1))
        )
)


Where we have a shorthand easy way to specify devices and their configuration
but at the same time have something that will generate structure initializers.

What I have is still way off but it begins to describe the idea. 
There is a lot of information that needs to be specified,
and a lot of it has standardized components so it should use the same
description from piece to piece.

> 
> I'd like to adopt this "RFC" approach for freebios2 as much as we can.  
> There was a lot of give-and-take in the early days of linuxbios about
> structure and it proved useful. There's a lot that will start happening in
> freebios2 now, and we need to try to make sure it will work for everyone.

I mostly agree.  But so far this is still a very formal request for
discussion.  A RFC contains a believed complete specification for
an implementation.  We need something similar for our external
interfaces as well.  

Look at hardwaremain in the freebios2 tree.  I want that to be the
interface that initializes everything and if anything I want to make
it more general and simpler than it is now.

Eric