[BK PATCH] Representing System devices and CPUs

[Patrick Mochel]

  This message is in MIME format.  The first part should be readable text,
  while the remaining parts are likely unreadable without MIME-aware tools.
  Send mail to [e-mail] for more info.

--346834433-165056036-1032381605=:968
Content-Type: TEXT/PLAIN; charset=US-ASCII

Hey there.

The changelogs are below, but this is the executive summary.

This beefs up the support for system devices. It introduces the following 
structures:

struct sys_root {
        u32             id;
        struct device   dev;
        struct device   sysdev;
};

struct sys_device {
        char            * name;
        u32             id;
        struct sys_root * root;
        struct device   dev;
};

The former is intended for multi-board systems (e.g. NUMA-like) so they 
can accurately represent their topology. The latter is for basic 
description of system-level devices, like CPUs, PICs, etc. 

The idea is that the enumerators for multi-board systems will register 
each board (aka 'node') on boot. They should also know what board each 
system device is on, and set that in the sys_device structure. 

Without ->root set, system devices will be added as a child of a pseudo 
bus: 'sys'. They appear in driverfs in the root/sys/ directory. Each 
alternative root gets a directory under root/, and each gets a 'sys' 
subdirectory. System devices appear as children of the root's 'sysdev'. 
struct sys_root::dev can be used to parent other devices and buses 
discovered on that board; e.g. PCI buses on that board.

I've taken the liberty to also implement a CPU device class, and a generic 
cpu structure. The device class is registered on boot, which exports all 
CPUs in a common place in driverfs in class/cpu/.

For ia32, I've created a simple CPU device driver and a static array of 
cpu devices of size NR_CPUS, which are manually registered on boot. The 
cpus get directories under root/sys/ in driverfs, like this:

`-- root
    `-- sys
        |-- cpu0
        |-- cpu1
	...

And get symlinks in the class directory like this:

|-- class
|   |-- cpu
|   |   |-- devices
|   |   |   |-- 0 -> ../../../root/sys/cpu0
|   |   |   |-- 1 -> ../../../root/sys/cpu1
...

When the CPUs are registered, driverfs files may now be created for them. 
I recommend creating device interfaces for various CPU features and 
registering them with the device class. When the device is registered with 
the class, it will also be registered with all of the interfaces of the 
class. More documentation about this is available in the 
Documentation/driver-model/ directory (which is now updated!)

Pending approval/comments of the CPU device code, I will be working on 
converting some of the interfaces over to use it. 

Please apply,

	-pat

p.s. the patch is attached for non-BK users.

Please pull from 

	bk://ldm.bkbits.net/linux-2.5

This will update the following files:

 arch/i386/kernel/cpu/common.c |   34 +++++++++
 arch/i386/kernel/i8259.c      |   16 ++--
 arch/i386/kernel/time.c       |   15 ++--
 drivers/acpi/bus.c            |  120 -----------------------------------
 drivers/base/Makefile         |    5 -
 drivers/base/core.c           |   36 ++++++++--
 drivers/base/cpu.c            |   28 ++++++++
 drivers/base/driver.c         |   11 +++
 drivers/base/sys.c            |  144 +++++++++++++++++++++++++++++++++++++-----
 include/linux/cpu.h           |   28 ++++++++
 include/linux/device.h        |   31 ++++++---
 11 files changed, 303 insertions(+), 165 deletions(-)

through these ChangeSets:

<[e-mail]> (02/09/18 1.553)
   driver model: add CPU device support
   
   Declare a CPU device class, which gives CPUs a directory in driverfs under class/cpu/.
   
   Define a generic 'struct cpu' for basic defintion of CPU devices. Declare a static array
   of size NR_CPUS for ia32 and manually register each one on boot. 
   
   Declare an archtecture specific (ia32 only for now) cpu device driver for handling generic 
   device operations.
   

<[e-mail]> (02/09/18 1.551)
   driver model: strengthen system device support.
   
   Introduce struct sys_root (to describe alternative system roots in multi-
   board (NUMA-like) systems; and struct sys_device to better describe system
   level devices. 
   
   Implement registration functions for alternative system roots (for multi-
   board systems; e.g. NUMA-like systems) 
   
   Beef-up system device registration functions so it registers the device in 
   the root it belongs to and so it sets the bus type. It also sets the device's
   bus_id based on the fields in struct sys_device.
   
   Add a system_bus_type, so we have place to group the devices and drivers..

<[e-mail]> (02/09/18 1.550)
   driver model: Handle devices that have ->driver set on registration. 
   
   If a device is registered, and its driver is set, we call found_match() immediately 
   (and don't walk through the list of drivers of the bus). 
   
   We also handle the case where the driver hasn't been registered yet, so if we a NULL 
   driver from get_driver() in device_attach(), we assume the driver is awaiting a 
   driver_register().

<[e-mail]> (02/09/18 1.549)
   ACPI: get rid of the silly acpi_bus_driver, since it didn't do anything, 
   and won't ever do anything.

--346834433-165056036-1032381605=:968
Content-Type: TEXT/PLAIN; charset=US-ASCII; name="system-device-sep18.diff"
Content-Transfer-Encoding: BASE64
Content-ID: <[e-mail]>
Content-Description: 
Content-Disposition: attachment; filename="system-device-sep18.diff"
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--346834433-165056036-1032381605=:968--