ARM AMBA 总线设备驱动总结

最近公司裁员，本人所在的部门全部被lay off了。 呵呵，闲来无事，一边找工作，一边学习linux driver 相关的知识。最近在学习ARM AMBA 总线设备驱动的相关知识，在网上搜索了一下相关的文章，并不是很多，而且有的文章描述的并不是很清楚，无奈之下，只好硬着头皮，自己HACK一下源码了。以下是本人的一些总结，如有不妥之处，还望各位大虾们多多指教。

1：总线

    总线是处理器与一个或多个设备之间的通道，在设备模型中，所有的设备都是通过总线相连。在Linux设备模型中，用bus_type结构表示总线，它定义在<linux/device.h>中：

        struct bus_type {
    const char        * name;

    struct subsystem    subsys;
    struct kset        drivers;
    struct kset        devices;
    struct klist        klist_devices;
    struct klist        klist_drivers;

    struct blocking_notifier_head bus_notifier;

    struct bus_attribute    * bus_attrs;
    struct device_attribute    * dev_attrs;
    struct driver_attribute    * drv_attrs;

    int        (*match)(struct device * dev, struct device_driver * drv);
    int        (*uevent)(struct device *dev, char **envp,
                int num_envp, char *buffer, int buffer_size);
    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 (*suspend_late)(struct device * dev, pm_message_t state);
    int (*resume_early)(struct device * dev);
    int (*resume)(struct device * dev);
};
    我们注意到，一个总线下面包含了两个kset，分别代表了总线的驱动程序和插入总线的所有设备。

2:  AMBA总线的声明与注册

    在<driver/amba/bus.c>中有对AMBA总线的声明,如下：

    /*
 * Primecells are part of the Advanced Microcontroller Bus Architecture,
 * so we call the bus "amba".
 */
static struct bus_type amba_bustype = {
 .name  = "amba",
 .match  = amba_match,
 .uevent  = amba_uevent,
 .suspend = amba_suspend,
 .resume  = amba_resume,
};

    注意，只有非常少的bus_type成员需要初始化，他们中大部分是由设备模型中心来控制。

    对于新的总线，我们必须调用bus_register进行注册：

    static int __init amba_init(void)
{
 return bus_register(&amba_bustype);
}

    如果注册成功，新的总线子系统就会被添加到系统中，可以在sysfs的sys/bus目录下看到它，然后我们就可以向这个总线添加设备了。

3：AMBA总线设备和驱动程序的加载

    以上AMBA总线层的驱动程序（这些方法在后面将会有所介绍）在内核中已经写好了，我们要做的工作是如何将自己的AMBA设备以及驱动程序加载到AMBA总线中去。下面，将以AMBA-PL011这个串口设备为例，解释驱动和设备是如何被添加的。

    首先我们来看看如何声明一个AMBA总线设备

    AMBA设备结构定义在文件<linux/amba/bus.h>中，如下;

struct amba_device {
 struct device  dev;
 struct resource  res;
 u64   dma_mask;
 unsigned int  periphid;
 unsigned int  irq[AMBA_NR_IRQS];
};

    例如，我们定义一个串口设备UART0：

static struct amba_device uart0_device = {   /
 .dev  = {     /
  .coherent_dma_mask = ~0,   /
  .bus_id = dev:f1,    /
  .platform_data = NULL,    /
 },       /
 .res  = {     /         //端口资源
  .start = UART0_BASE,  /    //设备起始的物理地址
  .end = (UART0_BASE) + SZ_4K - 1,/
  .flags = IORESOURCE_MEM,   /
 },       /
 .dma_mask = ~0,     /
 .irq  = UART0_IRQ,    /     //设备的中断号
 }

    在Linux系统中每一个设备都用一个device结构的一个实例来表示：

    struct device {
 struct klist  klist_children;
 struct klist_node knode_parent;  /* node in sibling list */
 struct klist_node knode_driver;
 struct klist_node knode_bus;
 struct device  * parent;

 struct kobject kobj;
 char bus_id[BUS_ID_SIZE]; /* position on parent bus */
 unsigned  is_registered:1;
 struct device_attribute uevent_attr;
 struct device_attribute *devt_attr;

 struct semaphore sem; /* semaphore 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  *driver_data; /* data private to the driver */
 void  *platform_data; /* Platform specific data, device
        core doesn't touch it */
 void  *firmware_data; /* Firmware specific data (e.g. ACPI,
        BIOS data),reserved for device core*/
 struct dev_pm_info power;

 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 list_head dma_pools; /* dma pools (if dma'ble) */

 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
          override */

 /* class_device migration path */
 struct list_head node;
 struct class  *class;  /* optional*/
 dev_t   devt;  /* dev_t, creates the sysfs "dev" */
 struct attribute_group **groups; /* optional groups */

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

    上面的数据结构的成员很多，其中几个成员需要了解一下：

struct device *parent: 该设备所属的设备，如果为NULL，则表示是顶层设备；

char bus_id[BUS_ID_SIZE]: 在总线上唯一表示该设备的字符串；

struct bus_type *bus: 表示该设备连接到了何种类型的总线上；

struct device_driver: 管理该设备的驱动程序。

 

    在定义了一AMBA设备之后，我们需要将此设备注册到总线上，调用如下函数：

int amba_device_register(struct amba_device *dev, struct resource *parent)

此函数定义在<driver/amba/bus.c>中，下面对这个函数做一些详细分析，看看设备是如何挂载到总线上面去的，以上面的设备为例，我们调用接口函数如下：

    amba_device_register(&uart0_device, &iomem_resource);

    其中，iomem_resource是一IO内存资源，定义如下：

struct resource iomem_resource = {
 .name = "PCI mem",
 .start = 0,
 .end = -1,
 .flags = IORESOURCE_MEM,
};

amba_device_register具体分析如下：

/**
 * amba_device_register - register an AMBA device
 * @dev: AMBA device to register
 * @parent: parent memory resource
 *
 * Setup the AMBA device, reading the cell ID if present.
 * Claim the resource, and register the AMBA device with
 * the Linux device manager.
 */
int amba_device_register(struct amba_device *dev, struct resource *parent)
{
 u32 pid, cid;
 void __iomem *tmp;
 int i, ret;

 dev->dev.release = amba_device_release;
 dev->dev.bus = &amba_bustype;//设备挂载的总线为AMBA
 dev->dev.dma_mask = &dev->dma_mask;
 dev->res.name = dev->dev.bus_id;

 if (!dev->dev.coherent_dma_mask && dev->dma_mask)
  dev_warn(&dev->dev, "coherent dma mask is unset/n");

 ret = request_resource(parent, &dev->res); //检查设备的IO资源是否已经被占用
 if (ret == 0) {  //下面的ioremap主要是将物理地址空间转换成虚拟地址
  tmp = ioremap(dev->res.start, SZ_4K);
  if (!tmp) {
   ret = -ENOMEM;
   goto out;
  }

  for (pid = 0, i = 0; i < 4; i++)  //读取设备的PeriphID
   pid |= (readl(tmp + 0xfe0 + 4 * i) & 255) << (i * 8);
  for (cid = 0, i = 0; i < 4; i++)//读取设备的PCellID
   cid |= (readl(tmp + 0xff0 + 4 * i) & 255) << (i * 8);

//注意，上面的偏址在ARM Periph IP内都是固定的，不相信的话可以查看ARM公司提供的相关外设的IP sepc。

  iounmap(tmp);

  if (cid == 0xb105f00d)
      dev->periphid = pid;
  if (dev->periphid)//如果设备的ID不为NULL，就注册设备，否则退出。

                                   //注意，如果不是标准的 ARM Periph IP,而你又想将此设备挂载到AMBA总线上的话，你必须为自己的设备提供一个PeriphID, 并在定义设备的时候初始化这个成员变量。
     ret = device_register(&dev->dev);  //将设备注册到系统中
  else
      ret = -ENODEV;
  if (ret == 0) {
     device_create_file(&dev->dev, &dev_attr_id);
   if (dev->irq[0] != NO_IRQ)
    device_create_file(&dev->dev, &dev_attr_irq0);
   if (dev->irq[1] != NO_IRQ)
    device_create_file(&dev->dev, &dev_attr_irq1);
   device_create_file(&dev->dev, &dev_attr_resource);
  } else {
 out:
   release_resource(&dev->res);
   printfs("error at amba-register/n");
  }
 }
  return ret;
}
    设备成功注册后，酒后添加到上面提到的总线设备集合中。在设备注册的过程中，系统要搜索总线上注册的驱动，看看有没有匹配的，如果设备还没有绑定驱动程序，则为其绑定一个。

具体的调用过程如下：

        device_register-->>>device_add-->>>bus_attach_device-->>>device_attach-->>>__device_attach

/**
 * device_attach - try to attach device to a driver.
 * @dev: device.
 *
 * Walk the list of drivers that the bus has and call
 * driver_probe_device() for each pair. If a compatible
 * pair is found, break out and return.
 *
 * Returns 1 if the device was bound to a driver;
 * 0 if no matching device was found; error code otherwise.
 *
 * When called for a USB interface, @dev->parent->sem must be held.
 */
int device_attach(struct device * dev)
{
 int ret = 0;

 down(&dev->sem);
 if (dev->driver) { //如果设备已经有驱动，绑定它
  ret = device_bind_driver(dev);
  if (ret == 0)
   ret = 1;
 } else //如果没有，遍历总线上的驱动链表，查找是否有匹配的驱动
  ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
 up(&dev->sem);
 return ret;
};

 

/**
 * driver_probe_device - attempt to bind device & driver together
 * @drv: driver to bind a device to
 * @dev: device to try to bind to the driver
 *
 * First, we call the bus's match function, if one present, which should
 * compare the device IDs the driver supports with the device IDs of the
 * device. Note we don't do this ourselves because we don't know the
 * format of the ID structures, nor what is to be considered a match and
 * what is not.
 *
 * This function returns 1 if a match is found, an error if one occurs
 * (that is not -ENODEV or -ENXIO), and 0 otherwise.
 *
 * This function must be called with @dev->sem held.  When called for a
 * USB interface, @dev->parent->sem must be held as well.
 */
int driver_probe_device(struct device_driver * drv, struct device * dev)
{
 struct stupid_thread_structure *data;
 struct task_struct *probe_task;
 int ret = 0;
 
 if (!device_is_registered(dev))
  return -ENODEV;
 if (drv->bus->match && !drv->bus->match(dev, drv))//比较设备的ID与驱动的ID是否相等
  goto done;
  
 pr_debug("%s: Matched Device %s with Driver %s/n",
   drv->bus->name, dev->bus_id, drv->name);

 data = kmalloc(sizeof(*data), GFP_KERNEL);
 if (!data)
  return -ENOMEM;
 data->drv = drv;
 data->dev = dev;
 printfs("track driver probe/n");
 if (drv->multithread_probe) {
  probe_task = kthread_run(really_probe, data,
      "probe-%s", dev->bus_id);
  if (IS_ERR(probe_task))
   ret = really_probe(data);
 } else
  ret = really_probe(data); //如果找到了匹配的驱动，调用驱动的probe方法初始化设备

done:
 //printfs("track driver probe: go to done/n");
 return ret;
}

转载 ： http://blog.csdn.net/wind_beneath_wings/article/details/3349966