Explication détaillée du modèle de périphérique Linux (1)_Concepts de base

1.Introduction

Dans l'article « L'architecture globale du noyau Linux », Wowo a mentionné que le noyau Linux prend en charge presque tous les périphériques matériels avec différentes fonctions dans le monde, ce qui est également un avantage de Linux. Cependant, cela signifie également que la moitié du code du noyau Linux est constitué de pilotes de périphériques. Avec la mise à niveau rapide des périphériques matériels, la quantité de code de pilotes de périphériques augmente également rapidement. À mon avis, ce phénomène détruit le concept de « la simplicité est belle » et rend le noyau Linux très volumineux, désordonné et difficile à maintenir. Cependant, Wowo comprend également que ce n'est pas la faute de Linux, car Linux est un noyau de macro et doit faire face à la diversité des périphériques et implémenter les pilotes correspondants.

Afin de réduire la complexité du développement de pilotes Linux causée par la diversité des périphériques et de mettre en œuvre des fonctions telles que le branchement à chaud des périphériques et la gestion de l'alimentation, le noyau Linux introduit le concept de modèle de périphérique (également appelé modèle de pilote). Le modèle de périphérique classe et résume les périphériques matériels, puis résume un ensemble de structures de données et d'interfaces standard. De cette façon, le développement de pilotes devient simple et nécessite uniquement de remplir et d'implémenter les structures de données spécifiées par le noyau.

Cet article partira du concept de base du modèle de périphérique et expliquera progressivement la mise en œuvre et l'utilisation du modèle de périphérique Linux à travers l'analyse du code du noyau correspondant.

2. Concepts de base du modèle de périphérique Linux

2.1 Concepts de bus, de classe, de périphérique et de pilote de périphérique

La figure suivante est un exemple de topologie matérielle courante pour les systèmes embarqués :

La topologie matérielle décrit trois des quatre concepts importants du modèle de périphérique Linux : bus, classe et périphérique (le quatrième est le pilote de périphérique, qui sera abordé plus tard).

Bus : Linux estime (vous pouvez vous référer aux commentaires de struct bus_type dans include/linux/device.h) que le bus est un canal d'échange d'informations entre le CPU et un ou plusieurs périphériques. Afin de faciliter l'abstraction du modèle de périphérique, tous les périphériques doivent être connectés au bus (qu'il s'agisse du bus interne du CPU, d'un bus virtuel ou d'un "bus de plateforme").

Classe : dans le modèle d'appareil Linux, le concept de classe est très similaire à celui de classe dans la programmation orientée objet. Il collecte principalement des appareils ayant des fonctions ou des attributs similaires, de sorte qu'un ensemble d'appareils pouvant être utilisés dans plusieurs applications puisse être abstrait. . Structures de données et fonctions d'interface partagées entre les appareils. Ainsi, les pilotes appartenant à des appareils appartenant à la même Classe n'ont plus besoin de définir de manière répétée ces ressources publiques et peuvent directement hériter de la Classe.

Device : résume tous les périphériques matériels du système, décrivant son nom, ses attributs, son bus subordonné, sa classe subordonnée et d'autres informations.

Pilote de périphérique : le modèle de périphérique Linux utilise le pilote pour extraire le pilote du périphérique matériel, qui inclut les implémentations d'interface liées à l'initialisation du périphérique et à la gestion de l'alimentation. Le développement de pilotes dans le noyau Linux tourne essentiellement autour de cette abstraction (implémentant les fonctions d'interface spécifiées).

Remarque : Qu'est-ce que Platform Bus ?
Il existe un type de périphériques dans les ordinateurs qui sont directement connectés au processeur via leurs contrôleurs de périphérique respectifs, et le processeur peut y accéder (ou accéder à leurs contrôleurs) via des opérations d'adressage régulières. Cette méthode de connexion n'est pas une connexion par bus au sens traditionnel du terme. Cependant, le modèle de périphérique doit être universel, donc Linux crée un bus de plate-forme fictif auquel ces périphériques peuvent se connecter.

2.2 L'idée de base du modèle d'appareil

L'idée centrale du modèle de périphérique Linux est (pour atteindre l'objectif xxx par xxx moyens) :

1. Utilisez deux structures de données, Device (struct device) et Device Driver (struct device_driver), pour décrire le périphérique matériel sous les deux angles de « à quoi sert-il » et « comment l'utiliser » respectivement. Cela unifie le format d'écriture des pilotes de périphériques et modifie le développement des pilotes des questions à développement aux questions à remplir, simplifiant ainsi le développement des pilotes de périphériques.

2. Utilisez également les deux structures de données de périphérique et de pilote de périphérique pour réaliser le plug-and-play (échange à chaud) de périphériques matériels.
Dans le noyau Linux, tant que n'importe quel périphérique et pilote de périphérique portent le même nom, le noyau exécutera la fonction d'initialisation (sonde) dans la structure du pilote de périphérique, qui initialisera le périphérique et le rendra disponible.
Pour la plupart des périphériques remplaçables à chaud, leurs pilotes de périphérique existent toujours dans le noyau. Lorsque l'appareil n'est pas branché, sa structure Device n'existe pas, son Driver n'effectue donc pas d'opérations d'initialisation. Lorsque le périphérique est inséré, le noyau créera une structure Device (avec le même nom que Driver), qui déclenchera l'exécution de Driver. C'est le concept plug and play.

3. Résolvez les dépendances entre les appareils via l'arborescence de type "Bus–>Device" (voir la légende au chapitre 2.1), et cette dépendance est particulièrement importante dans les processus tels que la mise sous et hors tension, la gestion de l'alimentation, etc.
Imaginez qu'un périphérique soit monté sur un bus. Pour démarrer le périphérique, le bus sur lequel il est monté doit d'abord être démarré. Évidemment, s'il y a de nombreux périphériques dans le système et que les dépendances sont très complexes, ni le noyau ni les développeurs de pilotes ne pourront maintenir cette relation.
La structure arborescente du modèle d'appareil peut gérer automatiquement cette dépendance. Avant de démarrer un périphérique, le noyau vérifiera si le périphérique dépend d'autres périphériques ou bus. Si cela dépend, il vérifiera si les objets dépendants ont été démarrés. Sinon, ils seront démarrés en premier jusqu'à ce que les conditions de démarrage du périphérique soient réunies. rencontré. Ce que les développeurs de pilotes doivent faire, c'est informer le noyau des dépendances du périphérique lors de l'écriture d'un pilote de périphérique.

4. Utilisez la structure de classe et introduisez des concepts orientés objet dans le modèle de périphérique, qui peuvent abstraire au maximum les fonctionnalités communes, réduire la duplication du travail dans le processus de développement des pilotes et réduire la charge de travail.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!