Linux驱动之platform_bus、platform_device、platform_driver

概述：

在Linux驱动里面platform bus，直译过来就是平台总线，实际上，是软件里面虚拟出来的总线，俗称虚拟总线。虚拟总线有什么作用呢？以及怎么用linux虚拟总线子框架？这就是本文要阐述的两个问题。

---

虚拟总线框架：

platform bus也是驱动框架下的一个子系统，是构建在linux驱动框架bus，device，driver这种模型之上的；
platform_bus用来连接platform_device和platform_driver；
platform_device用来存储设备信息；
platform_driver是设备驱动。

---

虚拟总线、设备、驱动的作用

简单来说，有以下三个作用：

• 加载dts信息到platform_device，即将reg（dts描述：控制器，寄存器地址，memery地址）、interrupts（dts描述的中断信息）信息翻译成struct resource(platform_device结构体里面有这个类型的指针)这样的结构体中存放着，供驱动程序访问，reg，interrupts信息放在dts里面，所以也可以说是解析dts。
• 向驱动程序提供系统功能接口，这主要是指struct platform_driver这里面的函数指针。只要platform_driver注册成功，像shutdown函数指针指向的函数，在系统关机的时候就会被调用到，suspend指向的函数，在系统被挂起的时候会被调用到等。
• 加载驱动作用，这个主要是platform_driver里面的probe函数指针。现在新版linux，都是采取在dts节点里面加入compatible属性，以及status属性，在开机时候会调用of_platform_populate()，这个函数会遍历整个dts数，凡是有compatible属性，status属性（status属性可有可无，如果有，属性值必须为ok或okay）都会为这个dts节点，创建一个struct platform_device实例并连接到platorm_bus里面，当驱动加载时，调用到platform_driver_register()，首先在platform_bus里面查询与之匹配的platform_device，如果匹配成功（具体怎么匹配，后面会描述），就能获取到platform_device。老版linux，没有dts出现的时候，是用户在开机时，自己调用platform_device_register()注册platform_device。

解析dts里面reg，interrupts：

首先看下platform_device结构体：

struct platform_device {
	const char	*name;
	int		id;
	bool		id_auto;
	struct device	dev;
	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;
};

解析的过程，就是将reg，interrupts信息翻译成struct resource格式存放。

启动解析：

linux在开机过程中，一般会调用of_platform_populate()这个函数，这个函数一般会在setup.c文件里面调用，如果是arm体系的，在arch/arm/kernel/setup.c里面：

static int __init customize_machine(void)
{
	/*
	 * customizes platform devices, or adds new ones
	 * On DT based machines, we fall back to populating the
	 * machine from the device tree, if no callback is provided,
	 * otherwise we would always need an init_machine callback.
	 */
	if (machine_desc->init_machine)
		machine_desc->init_machine();
#ifdef CONFIG_OF
	else
		of_platform_populate(NULL, of_default_bus_match_table,
					NULL, NULL);
#endif
	return 0;
}

实际，还是要看CPU厂商在哪里调用of_platform_populate()。
总之linux开机时，根据dts节点创建sturct platform_device实例,并且把dts节点reg,interrupts属性翻译成struct resource类型结构体存放。。
要启动dts一个节点reg，interrupts信息解析前，还会判断dts节点的两个属性，其中一个属性是compatible，这个属性一定要存在，否则不会启动解析，调用情况of_platform_populate() --> of_platform_bus_create() --> of_get_property(bus, “compatible”, NULL)

/*
 * Find a property with a given name for a given node
 * and return the value.
 */
const void *of_get_property(const struct device_node *np, const char *name,
			    int *lenp)
{
	struct property *pp = of_find_property(np, name, lenp);

	return pp ? pp->value : NULL;
}
EXPORT_SYMBOL(of_get_property);

另外一个属性，就是status，这个属性不需要一定存在，如果存在，属性值必须为ok或者okay，才能启动解析，或者干脆就没有这个属性，也能启动解析，调用情况，of_platform_populate() --> of_platform_bus_create() --> of_platform_device_create_pdata() --> of_device_is_available()

/**
 *  of_device_is_available - check if a device is available for use
 *
 *  @device: Node to check for availability
 *
 *  Returns 1 if the status property is absent or set to "okay" or "ok",
 *  0 otherwise
 */
int of_device_is_available(const struct device_node *device)
{
	unsigned long flags;
	int res;

	raw_spin_lock_irqsave(&devtree_lock, flags);
	res = __of_device_is_available(device);
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
	return res;

}
EXPORT_SYMBOL(of_device_is_available);

当这两个属性检测通过后，就会启动解析。

解析reg:

在上面的启动解析中，有调用到函数of_platform_device_create_pdata()，调用过程：of_platform_device_create_pdata()–>of_device_alloc()。函数of_device_alloc()：

/**
 * of_device_alloc - Allocate and initialize an of_device
 * @np: device node to assign to device
 * @bus_id: Name to assign to the device.  May be null to use default name.
 * @parent: Parent device.
 */
struct platform_device *of_device_alloc(struct device_node *np,
				  const char *bus_id,
				  struct device *parent)
{
	struct platform_device *dev;
	int rc, i, num_reg = 0, num_irq;
	struct resource *res, temp_res;

	dev = platform_device_alloc("", -1);
	if (!dev)
		return NULL;

	/* count the io and irq resources */
	if (of_can_translate_address(np))
		while (of_address_to_resource(np, num_reg, &temp_res) == 0)
			num_reg++;
	num_irq = of_irq_count(np);

	/* Populate the resource table */
	if (num_irq || num_reg) {
		res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);
		if (!res) {
			platform_device_put(dev);
			return NULL;
		}

		dev->num_resources = num_reg + num_irq;
		dev->resource = res;
		for (i = 0; i < num_reg; i++, res++) {
			rc = of_address_to_resource(np, i, res);
			WARN_ON(rc);
		}
		WARN_ON(of_irq_to_resource_table(np, res, num_irq) != num_irq);
	}

	dev->dev.of_node = of_node_get(np);
#if defined(CONFIG_MICROBLAZE)
	dev->dev.dma_mask = &dev->archdata.dma_mask;
#endif
	dev->dev.parent = parent;

	if (bus_id)
		dev_set_name(&dev->dev, "%s", bus_id);
	else
		of_device_make_bus_id(&dev->dev);

	return dev;
}
EXPORT_SYMBOL(of_device_alloc);

of_address_to_resource()（位于drivers/of/address.c里面）这个函数就会将dts里面的reg属性解析成struct resource结构体存放。在解析过程中会涉及dts关键字有：“reg”,“reg-names”,“ranges”,"#address-cells","#size-cells"。这些关键字，各自有什么作用以及相互关系？先看看如下dts例子：

/{
	...
	...
	...
	{
		compatible = "zimu,testB";
		#address-cells = <1>;
		#size-cells = <1>;
		ranges;
		{
			compatible = "zimu,testA";
			status = "ok";
			reg = <0x100 0x200>,<0x400 0x500>,<0xa00  0x100>;
			reg-names = "addr0","addr1","addr2";
		};
	}
};

对于这中ranges属性值为空的情况：
以上例子，解析完后，platform_device成员的resource指针指向三个struct resource大小连续内存空间，如下定义：
sturct platform_device *pd;
pd = kzalloc(sizeof(sturct platform_device) * 3, GFP_KERNEL);
解析完成后：
pd->num_resource等于3
pd->resource[0].name等于"addr0"
pd->resource[0].start 等于0x100
pd->resource[0].end等于0x300

pd->resource[1].name等于"addr1"
pd->resource[1].start 等于0x400
pd->resource[1].end等于0x900

pd->resource[2].name等于"addr2"
pd->resource[2].start 等于0xa00
pd->resource[2].end等于0xb00
需要访问的时候，可以从pd->num_resource知道有几个sturct resource资源。
注意： #address-cells = <1>表示reg地址占用32位内存空间，即4个byte，如果为2表示占用64位内存空间（8个byte），以此类推，它取值范围是1到4；同样#size-cells = <1>，表示size数值占用32空间，如果是2表示64位内存空间，它的取值范围是大于0，无最大限制。在解析过程中，获取了这两个值后，都会调用宏OF_CHECK_COUNTS判断值是否在要求的范围内，这个宏定义在drivers/of/address.c里面，如下代码片段：

/* Max address size we deal with */
#define OF_MAX_ADDR_CELLS	4
#define OF_CHECK_ADDR_COUNT(na)	((na) > 0 && (na) <= OF_MAX_ADDR_CELLS)
#define OF_CHECK_COUNTS(na, ns)	(OF_CHECK_ADDR_COUNT(na) && (ns) > 0)

关于ranges属性值不为空的情况，如下dts例子：

/{
	...
	...
	...
	compatible = "zimu,testD";
	#address-cells = <1>;
	#size-cells = <1>;
	ranges;
	{
		compatible = "zimu,testC";
		#address-cells = <1>;
		#size-cells = <1>;
		ranges = <0x10 0x10 0x500>,<0x700 0x700 0x2000>,<0x5000 0x5000 0x20000>;
		{
			compatible = "zimu,testB";
			#address-cells = <1>;
			#size-cells = <1>;
			ranges = <0x50 0x50 0x400>,<0x800 0x800 0x1000>,<0x9000 0x9000 0x8000>;
			{
				compatible = "zimu,testA";
				status = "ok";
				reg = <0x100 0x200>,<0x1000 0x100>,<0x10000  0x1000>;
				reg-names = "addr0","addr1","addr2";
			};
		}
	}
};

reg存放格式：
<0x100 0x200>父节点的#address-cells和#size-cells的值都为1，所以第一个32位内存空间存放的是0x100，第二个32位内存地址空间存放的是0x200。
ranges的存放格式：
<0x50 0x50 0x400>所处节点的#address-cells和#size-cells的值都为1，第一个0x50,就是受本节点控制，所以第一个32位内存空间存放的是0x50,父节点#address-cells也是1，它控制第二段内存空间，所以第二个0x50就存放在第二段32位内存空间里面，第三段32位内存空间存放的是size，就是0x400。
<0x100 0x200>，<0x50 0x50 0x400>，<0x10 0x10 0x500>三组是有关系的，其中都受#address-cells和#size-cells控制。在__of_translate_address()–>of_translate_one()这个调用过程解析，需要满足reg的空间范围在父节点ranges的范围内，父节点的ranges范围必须在祖父节点ranges的范围内。如<0x100 0x200>表示起始地址是0x100，大小是0x200，<0x50,0x50,0x400>表示的是起始地址是0x50(第一个0x50)，大小是0x400，其中第二个0x50占多少空间受祖父节点的#address-cells控制。其它以此类推。
解析过程：
reg节点的0x100减去父节点ranges的第一个0x50，得到一个偏移0x50, 然后这偏移加上父节点ranges的第二个0x50,得到0x100，这是__of_translate_address()第一轮循环结束后，得到的这个偏移0x100，进入下一轮循环后，以testC节点作为新起点，拿这个偏移减去0x10，然后得到这个新的偏移0x90，然后0x90加上第二个0x10（testD节点的#address-cells为1），最后得到0x100，这个0x100会作为struct resource里面start成员的值，结构体里面的end，如果解析成功直接就是0x200（当然本例子是故意设置的一个巧合，原因是<0x50 0x50 0x400>，<0x10 0x10 0x500>第二个0x50，第二个0x10不清楚其中的作用，但是分析代码是这样解析的，所以设置这个巧合，有这个巧合，表述解析过程不会错误，其中第二个0x50和0x10也都是故意设置的。）这个循环直到根节点或者ranges没有属性值的节点才会停止。在这个例子中，解析<0x100 0x200>得到的一个struct resource实例情况如下：
sturct resource *p;
pd = kzalloc(sizeof(sturct resource) , GFP_KERNEL);
p->name等于"addr0"
p->start 等于0x100
pd->end等于0x300
其他的两组：
<0x1000 0x100>，<0x800 0x800 0x1000>，<0x700 0x700 0x2000>解析完后：
sturct resource *p;
pd = kzalloc(sizeof(sturct resource) , GFP_KERNEL);
p->name等于"addr1"
p->start 等于0x1000
pd->end等于0x100
另外一组就不说明了，按照这个方法，可以自己分析得出来。分析下列，和ranges没有属性值的情况是一样的，如上述，是故意设置的巧合。
实际ranges没有属性值的情况比较多，有属性值的感觉死板不灵活，至于为什么要设置带属性值情况，搞清楚后，再来讲述。
详细的解析过程，最好是去分析如下调用过程：
of_device_alloc()–>__of_address_to_resource–>of_translate_address()–>
__of_translate_address–>of_translate_one().

解析interrupts:

分三种情况描述解析过程：
首先了解下解析过程中函数的调用：
of_device_alloc()–>of_irq_count()–>of_irq_to_resource()–>
irq_of_parse_and_map()–>of_irq_map_one()–>of_irq_map_raw().
这是解析过程中主要的调用函数，这些函数都定义在drivers/of/irq.c里面。
在of_device_alloc()中有两次调用解析interrupts，第一次是探测inteerupts有几个中断资源被描述，获取到有多少个中断资源后，就分配几个strutc resource内存空间，然后第二次调用解析函数of_irq_to_resource_table()将解析的信息存入到分配内存空间中。

/**
 * of_irq_to_resource_table - Fill in resource table with node's IRQ info
 * @dev: pointer to device tree node
 * @res: array of resources to fill in
 * @nr_irqs: the number of IRQs (and upper bound for num of @res elements)
 *
 * Returns the size of the filled in table (up to @nr_irqs).
 */
int of_irq_to_resource_table(struct device_node *dev, struct resource *res,
		int nr_irqs)
{
	int i;

	for (i = 0; i < nr_irqs; i++, res++)
		if (!of_irq_to_resource(dev, i, res))
			break;

	return i;
}
EXPORT_SYMBOL_GPL(of_irq_to_resource_table);

of_irq_to_resource_table()从这个函数的定义，可以看出前后两次解析都调用到of_irq_to_resource()。
另外在看irq_of_parse_and_map()函数：

/**
 * irq_of_parse_and_map - Parse and map an interrupt into linux virq space
 * @device: Device node of the device whose interrupt is to be mapped
 * @index: Index of the interrupt to map
 *
 * This function is a wrapper that chains of_irq_map_one() and
 * irq_create_of_mapping() to make things easier to callers
 */
unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
{
	struct of_irq oirq;

	if (of_irq_map_one(dev, index, &oirq))
		return 0;

	return irq_create_of_mapping(oirq.controller, oirq.specifier,
				     oirq.size);
}
EXPORT_SYMBOL_GPL(irq_of_parse_and_map);

解析dts里面interrupts主要of_irq_map_one()函数做的事情，也是本章要讲述的。而irq_create_of_mapping()主要是将从dts里面解析的interrupts信息struct of_irq转化成irq的编号，这个过程涉及linux中断子系统，后面会在单独的章节讲述，本章不讲述。

第一种情况：

先看如下dts例子：

/{
	interrupt-parent = <&interrupt_con>;
	zimu-interrupts:zimu-interrupts{
		compatible = "zimu,test-interrupt";
		interrupts = <0 123 4>,<0 125 8>;
		interrupts-names = "int-0","int-1";			
	};

	interrupt_con:interrupt_con{
		compatible = "zimu,test-con";
		interrupt-controller;
		#interrupt-cells = <3>;
	};
}

解析节点zimu-interrupts时：
（1）调用of_get_property()读取interrupts信息，存到内存空间。
（2）调用of_irq_find_parent()找到interrupt-parent属性指向的节点interrupts_con;
（3）在interrupts_con里面如果发现interrupt-controller属性，表示成功。
（4）开始将interrupts的信息解析到struct of_irq结构体里面：

/**
 * of_irq - container for device_node/irq_specifier pair for an irq controller
 * @controller: pointer to interrupt controller device tree node
 * @size: size of interrupt specifier
 * @specifier: array of cells @size long specifing the specific interrupt
 *
 * This structure is returned when an interrupt is mapped. The controller
 * field needs to be put() after use
 */
#define OF_MAX_IRQ_SPEC		4 /* We handle specifiers of at most 4 cells */
struct of_irq {
	struct device_node *controller; /* Interrupt controller node */
	u32 size; /* Specifier size */
	u32 specifier[OF_MAX_IRQ_SPEC]; /* Specifier copy */
};

controller成员存放的，是指向dts节点interrupt_con；size存放的，是#interrupt-cells属性值，本例为３；specifier存放的是interrupts的属性值，在本例中specifier[0]为０，specifier[1]为123，specifier[2]为4;在interrupts有两组属性值，如下循环到第二次：

while (of_irq_to_resource(dev, nr, NULL))
		nr++;

specifier的情况：specifier[0]为０，specifier[1]为12５，specifier[2]为８。
关于interrputs属性值的意义，可参考linux驱动－中断

（５）将解析得到struct of_irq送入到irq_create_of_mapping()转化成irq编号，最后将irq存入到struct resorce，并且会获取interrupt-names属性值和interrupts对应。如下of_irq_to_resource()函数定义：

/**
 * of_irq_to_resource - Decode a node's IRQ and return it as a resource
 * @dev: pointer to device tree node
 * @index: zero-based index of the irq
 * @r: pointer to resource structure to return result into.
 */
int of_irq_to_resource(struct device_node *dev, int index, struct resource *r)
{
	int irq = irq_of_parse_and_map(dev, index);

	/* Only dereference the resource if both the
	 * resource and the irq are valid. */
	if (r && irq) {
		const char *name = NULL;

		memset(r, 0, sizeof(*r));
		/*
		 * Get optional "interrupts-names" property to add a name
		 * to the resource.
		 */
		of_property_read_string_index(dev, "interrupt-names", index,
					      &name);

		r->start = r->end = irq;
		r->flags = IORESOURCE_IRQ | irqd_get_trigger_type(irq_get_irq_data(irq));
		r->name = name ? name : of_node_full_name(dev);
	}

	return irq;
}
EXPORT_SYMBOL_GPL(of_irq_to_resource);

<0 124 4>对应int0;
<0 125 8>对应int1。

第二种情况：

/{
	interrupt-parent = <&interrupt_con>;
	zimu-interrupts:zimu-interrupts{
		compatible = "zimu,test-interrupt";
		interrupts = <0 123 4>,<0 125 8>;
		interrupts-names = "int-0","int-1";
		reg = <0>;			
	};

	interrupt_con:interrupt_con{
		compatible = "zimu,test-con";
		#interrupt-cells = <3>;
		#address-cells = <1>;
		interrupt-map-mask = <0 0 0 0>;
		interrupt-map = <0 0 0 &interrupt_a 0 0 0 0>;	
	};
	interrupt_a:interrupt_a{
		interrupt-controller;
		#interrupt-cells = <3>;
		#address-cells = <1>;
	};
}

在第一种情况的(3)步时，如果没有发现interrupt-controller属性，进入另外一种匹配方式，找到具有interrupt-controller属性的节点。新匹配方式如下：
(1)用zimu-interrupts这个节点的reg的０，与interrupt-map的第一个０异或，然后再与interrupt-map-mask的第一个０与(&)上，这样计算结果为0表示成功，将进入用interrupt-map的第二，三，四个０分别与interrupts的<0 123 4>三个值异或，得到值，再与interrupt-map-mask的第二，三，四个值与，获得结果，如果为０，表示成功。这样，将查询到interrupt_a节点，然后发现interrupt_a节点有interrupt-controller属性，表示查找到中断控制器，最后将interrupts转换成struct resource，就是第一种情况的(4),(5)。

第三种情况：

/{
	interrupt-parent = <&interrupt_con>;
	zimu-interrupts:zimu-interrupts{
		compatible = "zimu,test-interrupt";
		interrupts = <0 123 4>,<0 125 8>;
		interrupts-names = "int-0","int-1";
		reg = <0>;			
	};

	interrupt_con:interrupt_con{
		compatible = "zimu,test-con";
		#interrupt-cells = <3>;
		#address-cells = <1>;
		interrupt-map-mask = <0 0 0 0>;
		interrupt-map = <0 0 0 0 &interrupt_a 0 0 0 0>;	
	};
	interrupt_a:interrupt_a{
		#interrupt-cells = <3>;
		#address-cells = <1>;
		interrupt-map-mask = <0 0 0 0>;
		interrupt-map = <0 0 0 0 &interrupt_b 0 0 0 0>;
	};
	interrupt_b:interrupt_b{
		interrupt-controller;
		#interrupt-cells = <3>;
		#address-cells = <1>;
	};
}

在第二种情况，在interrupt_a节点没有发现interrupt-controller属性，将会用interrupt_con的interrupt-map的第五个0，同interrupt_a的interrupt-map的第一个0异或，得到的结果，同interrupt_a的interrupt-map-mask的第一个0与上，计算结果为０，就表示成功。将进入，用interrupt_con的interrupt-map的第六、七、八个0，分别同interrupt_a的interrupt-map的第二、三、四个0异或上，三次，每次得到的结果，都将分别与interrupt_a的interrupt-map-mask的第二、三、四个０与上，三次与的结果，都为0，表示成功（三次，其中一次不为0都会失败，将会继续查找interrupt-map的另外一组值，看下面的例子，这种情况，将会查找到interrupt_c节点），将查询到interrupt_b，那么发现interrupt-controller，将会开始把interrupts转换成struct resource。

interrupt-map = <0 0 0 0 &interrupt_b 0 0 0 0>,
							<0 0 0 0 &interrupt_c 0 0 0 0>;
interrupt_c:interrupt_c{
		interrupt-controller;
		#interrupt-cells = <3>;
		#address-cells = <1>;
	};

interrupt-map-mask属性可以没有，如果没有这个属性值，将会用默认值0xffffffff。另外关于这里涉及的#address-cells也可以没有，如果没有，会用默认值２。
注意，<0 0 0 0 &interrupt_b 0 0 0 0>头部4个0，尾部４个0，受#address-cell和#interrupt-cells属性值影响，#address-cell控制的值排前面，#interrupt-cells控制的值排后面，头部4个0，第一个0是#address-cell=<1>，后面三个0是#interrupt-cells=<3>。
以上三种情况，主要都是在函数of_irq_map_raw()里面完成解析。

---

虚拟总线、设备、驱动使用方法：

第一：
就是要构建虚拟设备，即platform_device，现在的方法都是在dts里面加入如下类似的信息，也可以自己调用platform_device_register()自己注册（这种方法现在很少用）。

/{
	test:test{
		compatible = "test,aa";
		status = "ok";
		reg = <0x0 0x1000 0x200>;
		interrupts = <0 100 8>;
	};
};

第二：
注册platform_driver，结构体定义如下：

struct platform_driver {
	int (*probe)(struct platform_device *);
	int (*remove)(struct 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;
	const struct platform_device_id *id_table;
};

注册例子：

struct test_struct{
int a;
int b;
}test_struct_t;
test_struct_t t0;
struct platform_device_id test_id_table = {
	 "test.aa", &t0	
};
int test_probe(struct platform_device *pd){};
int test_remove(struct platform_device *pd){};
void test_shutdown(struct platform_device *pd){};
int test_suspend(struct platform_device *pd, pm_message_t state){};
int test_resume(struct platform_device *pd){};
	
struct platform_driver test_drv = {
	.probe = test_probe,
	.remove = test_remove,
	.shutdown = test_shutdown,
	suspend = test_suspend,
	resume = test_resume,
	.driver = {
		.name = "test",
		.owner = THIS_MODULE
	};
	.id_table = test_id_table
};
static int __init test_init(void)
{
	platform_driver_register(&test_drv);
}
static void __exit test_exit(void)
{
	platform_driver_unregister(&test_drv);
}

module_init(test_init);
module_exit(test_exit);

以上只是说明过程的例子，没有实际编译测试过。
注意，id_table的name一定要和dts里面的compatible相同，才能匹配到platform_device。这样的方法，可以采用(test_struct_t)test_drv.id_table->driver_data访问私有数据。
还用如下的办法：

struct of_device_id	test_device_id = {
	.compatible = "test.aa",
	.data = &t0;
};
struct platform_driver test_drv = {
	.probe = test_probe,
	.remove = test_remove,
	.shutdown = test_shutdown,
	suspend = test_suspend,
	resume = test_resume,
	.driver = {
		.name = "test",
		.owner = THIS_MODULE,
		.of_match_table = &test_device_id;
	};	
};

这样，很明显test_device_id的compatible和dts里面的相同，就可以匹配上。明显可以(test_struct_t)test_drv.driver.of_match_table.data访问私有结构体。
t0是驱动的私有数据，除了以上两种访问私有结构体，像如下定义（当然像上面的定义也是可以）：

struct of_device_id	test_device_id = {
	.compatible = "test.aa",
	.data = NULL;
};
struct platform_device_id test_id_table = {
	 "test.aa", NULL	
};

像这样定义后，在prboe函数里面调用platform_set_drvdata()这个函数设置私有结构体t0，在其他地方访问私有结构体调用platform_get_drvdata()就比较方便了。

probe：当匹配成功后，首先，系统会调用这个函数。一般驱动的初始化操作放这个函数里面。
remove：当模块退出时，调用platform_driver_unregister()，这个函数会被调用到。一般卸载驱动时需要操作的放这个函数里面。
shutdown：系统在关机时，会调用到这个函数。关机需要操作的，放这个函数里面。
suspend：系统待机时，会调用到这个函数。设备待机需要操作的放这个函数里面，如设备睡眠。
resume：系统退出待机时，会调用到这个函数。设备，退出待机需要操作的函数放这里面，如退出睡眠。