Linux驱动的platform机制

intplatform_device_register(structplatform_device*pdev)

{

device_initialize(&pdev->dev);

arch_setup_pdev_archdata(pdev);

returnplatform_device_add(pdev);

}

voiddevice_initialize(structdevice*dev)

{

dev->kobj.kset=devices_kset;

kobject_init(&dev->kobj,&device_ktype);

INIT_LIST_HEAD(&dev->dma_pools);

mutex_init(&dev->mutex);

lockdep_set_novalidate_class(&dev->mutex);

spin_lock_init(&dev->devres_lock);

INIT_LIST_HEAD(&dev->devres_head);

device_pm_init(dev);

set_dev_node(dev,-1);

}

intplatform_device_add(structplatform_device*pdev)

{

inti,ret;

if(!pdev)

return-EINVAL;

if(!pdev->dev.parent)

pdev->dev.parent=&platform_bus;

pdev->dev.bus=&platform_bus_type;//初始化structdevice中的bus_type

ret=device_add(&pdev->dev);

}

}

structdeviceplatform_bus={

.init_name="platform",//初始化device的name

};

intdevice_add(structdevice*dev)

{

dev=get_device(dev);//调用container_ofcontainer_of(kobj,structdevice,kobj)得到dev

/*first,registerwithgenericlayer.*/

/*werequirethenametobesetbefore,andpassNULL*/

error=kobject_add(&dev->kobj,dev->kobj.parent,NULL);

if(error)

gotoError;

/*notifyplatformofdeviceentry*/

if(platform_notify)

platform_notify(dev);

error=device_create_file(dev,&dev_attr_uevent);//创建设备属性文件

error=device_add_attrs(dev);

error=bus_add_device(dev);//添加设备到bus

kobject_uevent(&dev->kobj,KOBJ_ADD);

bus_probe_device(dev);

structplatform_device{

constchar*name;

intid;

boolid_auto;

structdevicedev;

u32num_resources;

structresource*resource;

conststructplatform_device_id*id_entry;

/*MFDcellpointer*/

structmfd_cell*mfd_cell;

/*archspecificadditions*/

structpdev_archdataarchdata;

};

int__platform_driver_register(structplatform_driver*drv,

structmodule*owner)

{

drv->driver.owner=owner;

drv->driver.bus=&platform_bus_type;

if(drv->probe)

drv->driver.probe=platform_drv_probe;

if(drv->remove)

drv->driver.remove=platform_drv_remove;

if(drv->shutdown)

drv->driver.shutdown=platform_drv_shutdown;

returndriver_register(&drv->driver);

}

intdriver_register(structdevice_driver*drv)

{

...

ret=bus_add_driver(drv);

kobject_uevent(&drv->p->kobj,KOBJ_ADD);

returnret;

}

intbus_add_driver(structdevice_driver*drv)

{

structbus_type*bus;

structdriver_private*priv;

interror=0;

bus=bus_get(drv->bus);

priv=kzalloc(sizeof(*priv),GFP_KERNEL);

klist_init(&priv->klist_devices,NULL,NULL);

priv->driver=drv;

drv->p=priv;

priv->kobj.kset=bus->p->drivers_kset;

error=kobject_init_and_add(&priv->kobj,&driver_ktype,NULL,

"%s",drv->name);

klist_add_tail(&priv->knode_bus,&bus->p->klist_drivers);

if(drv->bus->p->drivers_autoprobe){

error=driver_attach(drv);

}

return0;

}

intdriver_attach(structdevice_driver*drv)

{

returnbus_for_each_dev(drv->bus,NULL,drv,__driver_attach);

}

staticint__driver_attach(structdevice*dev,void*data)

{

structdevice_driver*drv=data;

if(!driver_match_device(drv,dev))

return0;

if(dev->parent)/*NeededforUSB*/

device_lock(dev->parent);

device_lock(dev);

if(!dev->driver)

driver_probe_device(drv,dev);

device_unlock(dev);

if(dev->parent)

device_unlock(dev->parent);

return0;

}

intdriver_probe_device(structdevice_driver*drv,structdevice*dev)

{

intret=0;

if(!device_is_registered(dev))

return-ENODEV;

pr_debug("bus:'%s':%s:matcheddevice%swithdriver%s\n",

drv->bus->name,__func__,dev_name(dev),drv->name);

pm_runtime_barrier(dev);

ret=really_probe(dev,drv);

pm_request_idle(dev);

returnret;

}

staticintreally_probe(structdevice*dev,structdevice_driver*drv)

{

if(dev->bus->probe){

ret=dev->bus->probe(dev);

if(ret)

gotoprobe_failed;

}elseif(drv->probe){

ret=drv->probe(dev);

if(ret)

gotoprobe_failed;

}

driver_bound(dev);

}