platform总线相关_2

对于platform来说,最重要的是填充 platform_device 和platform_driver两个结构体
先说platform_device,因为platform_driver在匹配成功之后会拿到platform_device的资源.  

1/platform_device

/*include/linux/platform_device.h*/
struct platform_device {             
    const char  *name;          //platform_device名称，这个名字将会和platform_driver的名字匹配
    int     id;                 //设备id，如果只有一个设备，则为-1
    bool        id_auto;        //系统自动填充
    struct device   dev;        //封装的底层的struct device，
    u32     num_resources;      //设备资源的个数
    struct resource *resource;  //设备资源结构体
    const struct platform_device_id *id_entry;
    /* MFD cell pointer */
    struct mfd_cell *mfd_cell;
    /* arch specific additions */
    struct pdev_archdata    archdata;
};

/*Documentation/driver-model/platform.txt*/
The platform_device.dev.bus_id is the canonical name for the devices.
Its built from two components:

    * platform_device.name ... which is also used to for driver matching.

    * platform_device.id ... the device instance number, or else "-1"
目前,name 和 id  都可以确定了
name === "asyouwish"
id === -1

id_auto这个成员不知道怎么弄,但是好多里面都没写

dev成员的类型是struct device,具体定义在
  
/*include/linux/device.h*/

/**
 * struct device - The basic device structure
 * @parent:	The device's "parent" device, the device to which it is attached.
 * 		In most cases, a parent device is some sort of bus or host
 * 		controller. If parent is NULL, the device, is a top-level device,
 * 		which is not usually what you want.
 * @p:		Holds the private data of the driver core portions of the device.
 * 		See the comment of the struct device_private for detail.
 * @kobj:	A top-level, abstract class from which other classes are derived.
 * @init_name:	Initial name of the device.
 * @type:	The type of device.
 * 		This identifies the device type and carries type-specific
 * 		information.
 * @mutex:	Mutex to synchronize calls to its driver.
 * @bus:	Type of bus device is on.
 * @driver:	Which driver has allocated this
 * @platform_data: Platform data specific to the device.
 * 		Example: For devices on custom boards, as typical of embedded
 * 		and SOC based hardware, Linux often uses platform_data to point
 * 		to board-specific structures describing devices and how they
 * 		are wired.  That can include what ports are available, chip
 * 		variants, which GPIO pins act in what additional roles, and so
 * 		on.  This shrinks the "Board Support Packages" (BSPs) and
 * 		minimizes board-specific #ifdefs in drivers.
 * @power:	For device power management.
 * 		See Documentation/power/devices.txt for details.
 * @pm_domain:	Provide callbacks that are executed during system suspend,
 * 		hibernation, system resume and during runtime PM transitions
 * 		along with subsystem-level and driver-level callbacks.
 * @pins:	For device pin management.
 *		See Documentation/pinctrl.txt for details.
 * @numa_node:	NUMA node this device is close to.
 * @dma_mask:	Dma mask (if dma'ble device).
 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
 * 		hardware supports 64-bit addresses for consistent allocations
 * 		such descriptors.
 * @dma_parms:	A low level driver may set these to teach IOMMU code about
 * 		segment limitations.
 * @dma_pools:	Dma pools (if dma'ble device).
 * @dma_mem:	Internal for coherent mem override.
 * @archdata:	For arch-specific additions.
 * @of_node:	Associated device tree node.
 * @acpi_node:	Associated ACPI device node.
 * @devt:	For creating the sysfs "dev".
 * @id:		device instance
 * @devres_lock: Spinlock to protect the resource of the device.
 * @devres_head: The resources list of the device.
 * @knode_class: The node used to add the device to the class list.
 * @class:	The class of the device.
 * @groups:	Optional attribute groups.
 * @release:	Callback to free the device after all references have
 * 		gone away. This should be set by the allocator of the
 * 		device (i.e. the bus driver that discovered the device).
 *
 * At the lowest level, every device in a Linux system is represented by an
 * instance of struct device. The device structure contains the information
 * that the device model core needs to model the system. Most subsystems,
 * however, track additional information about the devices they host. As a
 * result, it is rare for devices to be represented by bare device structures;
 * instead, that structure, like kobject structures, is usually embedded within
 * a higher-level representation of the device.
 */
struct device {
	struct device		*parent;

	struct device_private	*p;

	struct kobject kobj;
	const char		*init_name; /* initial name of the device */
	const struct device_type *type;

	struct mutex		mutex;	/* mutex to synchronize calls to
					 * its driver.
					 */

	struct bus_type	*bus;		/* type of bus device is on */
	struct device_driver *driver;	/* which driver has allocated this
					   device */
	void		*platform_data;	/* Platform specific data, device
					   core doesn't touch it */
	struct dev_pm_info	power;
	struct dev_pm_domain	*pm_domain;

#ifdef CONFIG_PINCTRL
	struct dev_pin_info	*pins;
#endif

#ifdef CONFIG_NUMA
	int		numa_node;	/* NUMA node this device is close to */
#endif
	u64		*dma_mask;	/* dma mask (if dma'able device) */
	u64		coherent_dma_mask;/* Like dma_mask, but for
					     alloc_coherent mappings as
					     not all hardware supports
					     64 bit addresses for consistent
					     allocations such descriptors. */

	struct device_dma_parameters *dma_parms;

	struct list_head	dma_pools;	/* dma pools (if dma'ble) */

	struct dma_coherent_mem	*dma_mem; /* internal for coherent mem
					     override */
#ifdef CONFIG_CMA
	struct cma *cma_area;		/* contiguous memory area for dma
					   allocations */
#endif
	/* arch specific additions */
	struct dev_archdata	archdata;

	struct device_node	*of_node; /* associated device tree node */
	struct acpi_dev_node	acpi_node; /* associated ACPI device node */

	dev_t			devt;	/* dev_t, creates the sysfs "dev" */
	u32			id;	/* device instance */

	spinlock_t		devres_lock;
	struct list_head	devres_head;

	struct klist_node	knode_class;
	struct class		*class;
	const struct attribute_group **groups;	/* optional groups */

	void	(*release)(struct device *dev);
	struct iommu_group	*iommu_group;
};

device 目前不知道该怎么填.
	但里面有几个被见到过 release platform_data
num_resources 资源的个数.也就是resource结构体的元素个数,可以用ARRAY_SIZE(/*这里是resourse变量指向的数组*/)来表示
resource 类型为struct resource *,具体定义在
/*include/linux/ioport.h*/
  
/*
 * Resources are tree-like, allowing
 * nesting etc..
 */
struct resource {
	resource_size_t start;
	resource_size_t end;
	const char *name;
	unsigned long flags;
	struct resource *parent, *sibling, *child;
};

该变量可以用一个结构体数组来表示,结构体数组类型可以是struct resource [N]

在Document目录下grep "struct resource" * -nr

//这个是网卡芯片的资源
static struct resource bast_dm9k_resource[] = { 
    [0] = { 
        .start = S3C2410_CS5 + BAST_PA_DM9000,
        .end   = S3C2410_CS5 + BAST_PA_DM9000 + 3,
        .flags = IORESOURCE_MEM,
    },  
    [1] = { 
        .start = S3C2410_CS5 + BAST_PA_DM9000 + 0x40,
        .end   = S3C2410_CS5 + BAST_PA_DM9000 + 0x40 + 0x3f,
        .flags = IORESOURCE_MEM,
    },  
    [2] = { 
        .start = IRQ_DM9000,
        .end   = IRQ_DM9000,
        .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
    }   
};
//下面是mflash的资源
static struct resource mg_mflash_rsc[] = { 
    /* Base address of mflash */
    [0] = { 
        .start = 0x08000000,
        .end = 0x08000000 + SZ_64K - 1,
        .flags = IORESOURCE_MEM                             
    },  
    /* mflash interrupt pin */
    [1] = { 
        .start = IRQ_GPIO(84),
        .end = IRQ_GPIO(84),
        .flags = IORESOURCE_IRQ
    },  
    /* mflash reset pin */
    [2] = { 
        .start = 43, 
        .end = 43, 
        .name = MG_RST_PIN,
        .flags = IORESOURCE_IO
    },  
    /* mflash reset-out pin 
     * If you use mflash as storage device (i.e. other than MG_BOOT_DEV),
     * should assign this */
    [3] = { 
        .start = 51, 
        .end = 51, 
        .name = MG_RSTOUT_PIN,
        .flags = IORESOURCE_IO
    }   
};

可见,不同的设备有不同的资源.

---

2/platform_driver

/*include/linux/platform_device.h*/
struct platform_driver {
    int (*probe)(struct platform_device *);     //当platform_driver和platform_device匹配到时，该回调函数自动执行
    int (*remove)(struct platform_device *);    //当platform_driver和platform_device从匹配到分开，该回调函数自动执行
    void (*shutdown)(struct platform_device *); //电源管理函数
    int (*suspend)(struct platform_device *, pm_message_t state);//电源管理函数
    int (*resume)(struct platform_device *);    //电源管理函数
    struct device_driver driver;                //封装的底层的struct driver，
    const struct platform_device_id *id_table;
    bool prevent_deferred_probe;
};

先说结构体
  driver成员,类型是struct device_driver,定义在
/*include/linux/device.h*/

/**
 * struct device_driver - The basic device driver structure
 * @name:	Name of the device driver.
 * @bus:	The bus which the device of this driver belongs to.
 * @owner:	The module owner.
 * @mod_name:	Used for built-in modules.
 * @suppress_bind_attrs: Disables bind/unbind via sysfs.
 * @of_match_table: The open firmware table.
 * @acpi_match_table: The ACPI match table.
 * @probe:	Called to query the existence of a specific device,
 *		whether this driver can work with it, and bind the driver
 *		to a specific device.
 * @remove:	Called when the device is removed from the system to
 *		unbind a device from this driver.
 * @shutdown:	Called at shut-down time to quiesce the device.
 * @suspend:	Called to put the device to sleep mode. Usually to a
 *		low power state.
 * @resume:	Called to bring a device from sleep mode.
 * @groups:	Default attributes that get created by the driver core
 *		automatically.
 * @pm:		Power management operations of the device which matched
 *		this driver.
 * @p:		Driver core's private data, no one other than the driver
 *		core can touch this.
 *
 * The device driver-model tracks all of the drivers known to the system.
 * The main reason for this tracking is to enable the driver core to match
 * up drivers with new devices. Once drivers are known objects within the
 * system, however, a number of other things become possible. Device drivers
 * can export information and configuration variables that are independent
 * of any specific device.
 */
struct device_driver {
	const char		*name;
	struct bus_type		*bus;

	struct module		*owner;
	const char		*mod_name;	/* used for built-in modules */

	bool suppress_bind_attrs;	/* disables bind/unbind via sysfs */

	const struct of_device_id	*of_match_table;
	const struct acpi_device_id	*acpi_match_table;

	int (*probe) (struct device *dev);
	int (*remove) (struct device *dev);
	void (*shutdown) (struct device *dev);
	int (*suspend) (struct device *dev, pm_message_t state);
	int (*resume) (struct device *dev);
	const struct attribute_group **groups;

	const struct dev_pm_ops *pm;

	struct driver_private *p;
};

driver成员中的
	1.name  === 必须和设备中的name相同
  	2.owner === THIS_MODULE
probe 成员
  	这里面针对不同的设备流程也不一样
  	不过一般会创建设备,达到platform_device结构体中定义的资源,初始化设备,然后提供一个ops结构体.
    ops结构体里面一般是函数指针,这些指针指向的内容需要我们自己定义.
    这些指针一般被定义成open close ioctl 之类的
    当然,还可能提供其他一些ops,但是上面说的那个ops一定是要提供的
remove成员
	remove一般做probe的反操作