Linux 裝置驅動模型

Linux系統將裝置和驅動歸一到裝置驅動模型中了來管理

 裝置驅動程式功能：

　　　　1，對硬體裝置初始化和釋放

　　　　2，對裝置進行管理，包括實參設定，以及提供對裝置的統一操作介面

　　　　3，讀取應用程式傳遞給裝置檔案的資料或回送應用程式請求的資料

　　　　4，檢測或處理裝置出現的錯誤

 

裝置驅動模型提供了硬體的抽象包括：

1，電源管理

　　其實，電源管理就是一些裝置不工作的時候，讓它歇一會，休眠一會（最低消耗），達到省電的目的

　　它的一個重要的功能是：

　　　省電模式下，使系統中的裝置以一定的先後順序掛起

　　　在全速工作模式下，使系統的裝置以一定的先後順序恢複運行

　　　　　　就是這個意思，一條匯流排上有n個裝置，只用當n個裝置都掛起的時候，那個匯流排才能掛起。但是，只要有一個裝置恢複，匯流排就得恢複

2，隨插即用裝置支援

　　這個大家都深有體會，你把PS/2的滑鼠，鍵盤拔出來，然後再插上去，看看是不是沒反應了。但是把USB的滑鼠鍵盤拔下來再插上去，可以繼續用

　　這就是傳說中的隨插即用的支援

3，與使用者空間的通訊

　　　和使用者間通訊的方式很多，以前大名鼎鼎的proc檔案系統，就是一個鮮明的代表。它給了使用者一雙千裡眼。但是proc還是被後來者sysfs檔案系統給拿下了，從此改朝換代。

　　雖然proc依然在世，但是它的影響力已經下降。同時不得不說，proc得到過天下，肯定是有它的過人之處，那裡sysfs可能會受挫。但是強者依然不是那麼好動搖的

 

Linux裝置驅動模型有幾個基本資料結構模型：kobject，kset，subsystem

 

kobject：這是裝置驅動模型的基礎，就想是一座樓的地板磚和磚頭。sysfs是它的子子孫孫，父父爺爺撐起來的

 

struct kobject

{

　　　　const char *name;     //顯示在sysfs中的名稱

　　　　struct list_head entry; 　　//下一個kobject結構

　　　　struct kobject *parent;　　　//指向父kobject結構體，如果存在

　　　　struct kset 　　*kset;　　　　//指向kset集合

　　　　struct kobj_type　　*ktype;  //指向kobject類型描述元

　　　　struct sysfs_dirent *sd;        //對應sysfs的檔案目錄

　　　　struct kref kref;　　　　　　　　//kobject引用計數

　　　　unsigned int state_initialized:1;  //是否初始化

　　　　unsigned int state_in_sysfs:1;   //是否加入sysfs

　　　　unsigned int state_add_uevent_sent:1;  //是否支援熱插

　　　　unsigned int state_remove_uevent_sent:1; //是否支援熱拔

}

void  kobject_init(struct kobject *kobj,struct kobj_type *ktype)

{

　　char * err_str;

　　if(!kobj)

　　{

　　　　err_str = "invalid kobject pointer!"

　　　　goto error;

　　}

　　if(!ktype)

　　{

　　　　err_str = "must have a ktype to be initialized properly!\n";

　　　　goto error;

　　}

　　if(kobj->state_initialized)

　　{

　　　　printk(KERN_ERR"kobject (%p): tried to init an initialized"

　　　　　　　　　　　　　　　　　　　　"object ,something is seriously wrong.\n",kobj);

　　　　dump_stack();

　　}

 

　　kobject_init_internal(kobj);         //初始化kobject的內部成員

　　kobj->ktype = ktype ;　　　　//為kobject綁定一個ktype屬性   

　　return ;

error:

　　　printk(KERN_ERR"kobject (%p) : %s\n",kobj,err_str);

　　　dump_stack();

}

 

static void kobject_init_internal(struct koject *kobj)

{

　　if(!kobj)

　　　　return ;

　　kref_init(&kobj->kerf);

　　INIT_LIST_HEAD(&kobj->entry);

　　kobj->state_in_sysfs = 0;

　　kobj->state_add_uevent_sent = 0;

　　kobj->state_remove_uevent_sent = 0;

　　kobj->state_initialized = 1;

}

 

核心介面:

　　　　kobject_init();　　始化kobject

　　　　kobject_get();     增加kobject引用計數

　　　　kobject_put();　　減少kobject引用計數，計數為零時，調用kobject_release（）釋放，它在kobj_type裡面

　　　　kobject_set_name();   設定名字

　　　　kobject_rename();　　　　重新命名

　　　　kobject_add()　　　　　　添加

　　　　

每個kobject都會有一個屬性kobj_type

struct kobj_type

{

　　void (*release)(struct kobject *kobj);    //釋放kobject和其他佔用資源的函數

　　struct sysfs_ops *sysfs_ops;　　　　　　//操作屬性的方法

　　struct attribute **default_attrs;  　　　　//屬性數組

};

 

struct attribute

{

　　const char *name;　　　　　　　//屬性的名稱

　　struct module *owner;　　　　//只用擁有該屬性的模組，已經不常使用

　　mode_t mode;　　　　　　　　//屬性讀寫權限

};

 

struct sysfs_ops

{

　　ssize_t (*show)(struct kobject *,struct attribute *,char *);　　//讀屬性操作函數

　　ssize_t (*store)(struct kobject *,struct attribute *,const char *,size_t);  //寫屬性操作函數

};

 

struct kobject *kobject_get(struct kobject *kobj)

{

　　if(kobj)

　　　　kref_get(&kobj->kerf);

　　return kobj;

}

 

void kobject_put(struct kobject *kobj)

{

　　if(kobj)

　　{

　　　　　if(!kobj->state_initialized)

　　　　　　WARN(1,KERN_WARNING"kobject: ‘%s' (%p):is not initialized,yet kobject_put() is being called.\n",kobject_name(kobj),kobj);

　　　　　　kref_put(&kobj->kref,kobject_release);

　　}

}

 

 

 

 

 

通常kobject類型的default_attr成員定義了kobjet擁有的所有預設屬性。但是特殊情況下，可以添加一些預設的屬性：

添加屬性檔案：

int sysfs_create_file(struct kobject *kobj,const struct attribute  *attr);

刪除屬性檔案：

void sysfs_remove_file(struct kobject  *kobj , const   struct attribute  *attr);

 

struct kset

{

　　struct list_head list;   //串連所包含的kobject對象的鏈表首地址

　　spinlock_t  list_lock;   //維護list鏈表的自旋鎖

　　struct kobject kobj;  //內嵌kobject，說明kset本身也是一個目錄

　　struct kset_uevent_ops *uevent_ops;     //熱插拔事件

}; 

 

struct kset_uevent_ops

{

　　int (*filter)(struct kset *kset,struct kobject *kobj);

　　const char *(*name)(struct kset *kset,struct kobject *kobj);

　　int (*uevent)(struct kset *kset,struct kobject *kobj,struct kobj_uevent_ent *env);

};

 

kset和kobject關係：

1,kset集合包含了屬於其的kobject結構體，kset.list鏈表用來 串連第一個和最後一個kobject對象。第一個kobject使用entry串連kset集合和第二個kobject對象。第二個kobject對象使用entry串連第一個kobject對象和第三個kobject對象，依次類推，最終形成了一個kobject對象的鏈表

2，所有的kobject結構的parent指標指向kset包含的kobject對象，構成一個父子層次關係

3，kobject的所有kset指標指向包含它的kset集合，所以通過kobject對象很容易就能找到kset集合

4，kobject的kobj_type指標指向自身的kobj_type，每一個kobject都有一個單獨的kobj_type結構。另外在kset集合中也有一個kobject結構體，該結構體的XXX也指向一個kobj_type結構體。可知，kobj_type中定義了一組屬性和操作屬性的方法。這裡注意：kset中kobj_type的優先順序要高於kobject對象中的kobj_type的優先順序。如果兩個kobj_type都存在，那麼優先調用kset中的函數。如果kset中的kobj_type為空白，才調用各個kobject結構體本身對應的kobj_type中的函數

5，kset中的kobj也負責對kset的引用計數

 

kset操作

void kset_init(struct kset *k)  //初始化

{

　　kobject_init_internal(&k->kobj);

　　INIT_LIST_HEAD(&k->list);

　　spin_lock_init(&k->list_lock);

}

 

int kset_register(struct kset *k); //註冊函數

void kset_unregister(struct kset *k);  //登出函數

static inline struct kset *kset_get(struct kset *k);

static inline void kset_put(struct kset *k);

 

裝置驅動模型的三大組件

匯流排：

　struct bus_type

{

　　const char *name;

　　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,struct kobj_uevent_env *env);

　　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);

　　

　　struct dev_pm_ops *pm;

　　struct bus_type_private *p;

};

 

struct bus_type_private

{

　　struct kset subsys;  //代表該bus子系統，裡面的kobj是該bus的主kobj，也就是最頂層

　　struct kset *drivers_kset;  //掛載到該匯流排上的所有驅動集合

　　struct kset * devices_kset;  //掛載到該匯流排上的所有裝置集合

　　struct klist klist_devices;  //所有的裝置列表

　　struct klist klist_drivers;  //所有的驅動程式列表

　　struct block_notifier_head bus_notifier;

　　unsigned int drivers_autoprobe:1; //設定是否在驅動註冊是，自動彈出裝置

　　struct bus_type *bus;  //回指向包含自己的匯流排

};

 

int bus_register(struct bus_type *bus);

void bus_unregister(struct bus_type *bus);

 

struct bus_attribute

{

　　struct attribute attr;

　　ssize_t (*show)(struct bus_type *bus,char *buf);

　　ssize_t (*store)（struct bus_type *bus,const char *buf,size_t count);

};

int bus_create_file(struct bus_type *bus,struct bus_attribute *attr);

void bus_remove_file(struct bus_type *bus,struct bus_attribute *attr);

 

裝置：

　struct device

{

　　struct klist klist_children;   //串連子裝置的鏈表

　　struct device *parent;     //指向父裝置的指標

　　struct kobject kobj;      //內嵌的kobject

　　char bus_id[BUS_ID_SIZE];   //串連到匯流排上的位置

　　unsigned uevent_supress:1;  //是否支援熱插拔事件

　　const char *init_name;       //裝置的初始化名字

　　struct device_type *type;   //裝置相關的特殊處理函數

　　struct bus_type *bus;    //指向串連的匯流排指標

　　struct device_driver *driver;  //指向該裝置的驅動程式

　　void *driver_data;   //指向驅動程式私人資料的指標

　　struct dev_pm_info power;  //電源管理資訊

　　dev_t devt;    //裝置號

　　struct class *class; //指向裝置所屬類

　　struct attribute_group **groups; //裝置的組屬性

　　void (*release)(struct device *dev);  //釋放裝置描述符的回呼函數

　　...

};

 

int device_register(struct device *dev);

void device_unregister(struct device *dev);

 

struct device_attribute

{

　　struct attribute attr;

　　ssize_t  (*show)(struct device *dev,struct device_attribute *attr,char *buf);

　　ssize_t (*store)(struct device *dev,struct device_attribute *attr,const char *buf,size_t count);

};

 

int device_create_file(struct device *device,struct device_attribute);

void device_remove_file(struct device *dev,struct device_attribute *attr);

 

 

驅動：

struct device_driver

{

　　const char *name;　　//裝置驅動名字

　　struct bus_type *bus;  //指向驅動屬於的匯流排，匯流排上有很多裝置

　　struct module *owner;   //裝置驅動自身模組

　　const char *mod_name;  //裝置驅動名字

　　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);

　　struct attribute_group **group;

　　struct dev_pm_ops *pm;

　　struct driver_private *p;

};

 

struct driver_private

{

　　struct kobject kobj;   //內嵌kobject結構，用來構建裝置驅動程式模型

　　struct klist klist_devices;  //該驅動支援的所有裝置鏈表

　　struct klist_node knode_bus;  //該驅動所屬匯流排

　　struct module_kobject *mkobj;  //驅動的模組

　　struct device_driver *driver;  //指向驅動本身

};

 

int driver_register(struct device_driver *drv);

void driver_unregister(struct device_driver *drv);

 

struct driver_attribute

{

　　struct attribute attr;

　　ssize_t (*show)(struct device_driver *driver ,char *buf);

　　ssize_t (*store)(struct device_driver*driver,const char *buf,size_t count);

};

 

int driver_create_file(struct device_driver *drv,struct driver_attribute *attr);

void driver_remove_file(struct device_driver *drv,struct driver_attribute *attr);