Modèle de pilote de périphérique Linux

En général, tout système d'exploitation a besoin d'un logiciel spécifique à l'appareil. Ce logiciel comprend la fonctionnalité de l'appareil et est une couche intermédiaire entre le système d'exploitation et le matériel. Le pilote de périphérique est le terme utilisé pour ce logiciel. Dans cet article, nous allons discuter de la façon dont Linux gère les appareils et les pilotes d'appareils. En mots simples, nous explorerons le cadre du pilote de périphérique de Linux.

Description

En règle générale, sur n'importe quelle carte ou plate-forme, plusieurs appareils sont présents et ces appareils sont connectés les uns aux autres par certaines lignes ou protocoles physiques. Ces protocoles de connexion sont appelés bus. Il existe plusieurs protocoles de bus disponibles. Peu d'exemples sont I2C, SPI, AHB, APB, PCI, etc. Prenons un exemple de périphérique de mémoire EEPROM. Eeprom est connecté au système par bus I2C. CPU utilisera le protocole I2C pour lire / écrire des données d'EEPROM. Du côté CPU, cette manipulation du protocole sera effectuée par le contrôleur de protocole I2C. Le contrôleur I2C sur le CPU agit comme le dispositif maître. EEPROM agit comme le dispositif esclave. Tous les détails de I2C sont disponibles dans la spécification I2C.

Dans les systèmes de bras basés sur Linux, les appareils EEPROM sont peuplés à l'aide de l'arborescence de l'appareil. Définir l'EEPROM dans l'arborescence de l'appareil est suffisant pour déclarer l'appareil dans le système. Avec cette instance d'arborescence d'arborescence, l'instance de périphérique sera créée par le noyau Linux tout en démarrant. Lorsque le Linux se marie, il analyse l'arborescence de l'appareil et a créé l'instance des appareils définis dans l'arborescence de l'appareil.

Avec cet appareil est créé dans le Linux mais Linux ne pourra pas comprendre l'appareil. Pour la communication / opérations de l'appareil, un logiciel spécial spécifique à l'appareil est nécessaire. Ce sera connu comme le pilote de périphérique pour l'appareil. Revenant à l'exemple EEPROM, un pilote de périphérique EEPROM sera nécessaire pour lire / écrire les données de l'EEPROM.

Pour lier le pilote de périphérique à l'appareil spécifique, une chaîne compatible est nécessaire. La chaîne compatible est utilisée par le noyau Linux pour sonder le pilote spécifique à l'appareil lors du démarrage. Le noyau Linux offre également la flexibilité qu'un pilote de périphérique peut être chargé au moment de l'exécution. La seule condition est que le conducteur ne doit pas être nécessaire pour que la plate-forme démarre. Le pilote de périphérique qui est ajouté plus tard au noyau est compilé sous forme d'objets du noyau. Ce sont les fichiers présents comme .ko. La commande INSMOD est utilisée pour ajouter les objets du noyau sur le noyau en cours d'exécution.

Une fois le pilote de périphérique sondé avec l'appareil, l'appareil peut être utilisé pour les opérations. Le dispositif EEPROM peut être lu / écrit après l'initialisation du pilote EEPROM dans le noyau Linux. Le pilote EEPROM initialise l'appareil et offre la capacité du noyau Linux pour lire / écrire l'EEPROM.

Prenons un exemple de pilote de périphérique EEPROM en tant qu'AT24, le code source du périphérique peut être trouvé sur le lien: https: // github.com / Torvalds / Linux / Blob / Master / Drivers / Misc / Eeprom / AT24.c

Ce pilote prend en charge un très large nombre d'appareils EEPROM comme décrit dans les commentaires du pilote ATMEL AT24C ou * Microchip 24LC, etc.

Voici les informations d'arborescence de périphérique à ajouter pour créer une instance de périphérique:

eeprom @ 50
compatible = "atmel, 24c32";
reg = <0x50>;
pagesize = <32>;

Cela doit être ajouté au nœud de contrôleur I2C spécifique, où ce périphérique EEPROM est connecté.

Comme nous pouvons le voir, il y a une chaîne compatible. Ceci est les informations utilisées par le noyau Linux pour localiser le pilote de périphérique de l'appareil EEPROM.

Pour obtenir les informations sur les appareils et les appareils présents sur le système Linux, les entrées SYSFS sont le meilleur endroit.

Pour chaque appareil et pilote du système, les entrées SYSFS seront créées par le noyau. L'utilisateur peut référer ces fichiers sysfs pour diagnostiquer le système.

Si nous voyons le contenu du répertoire SYS dans le noyau Linux:

/ sys / bus: Tous les bus présents sur le système sont répertoriés à l'intérieur.

Le bus I2C peut également être vu. Pendant que nous discutions de l'exemple de l'appareil I2C. À l'intérieur du répertoire de bus, nous avons le répertoire de bus I2C.

Pour tout bus dans le SYSFS, nous aurons tous les appareils et chauffeurs présents dans ce bus. Voyons le contenu de I2C Bus:

Si nous parcourons davantage le répertoire des appareils et des pilotes, nous obtiendrons la liste complète des appareils et des pilotes connus du noyau Linux.

À l'intérieur des appareils, nous pouvons voir qu'il y a plusieurs bus I2C présents dans le système. I2C-0, I2C-1, I2C-5, etc., sont des bus i2c différents. 0-0018 et 0-001A sont les dispositifs esclaves sur I2C-0. 1-0050 et 1-0068 sont les appareils d'esclaves I2C sur le bus non. 1 I.e. I2C-1.

À l'intérieur du répertoire du pilote, nous avons la liste de tous les pilotes de l'appareil esclave I2C.

Revenant à notre exemple de dispositif EEPROM, 1-0050 est le dispositif d'esclave EEPROM. Si nous plongeons davantage dans le répertoire 1-0050, nous verrons quelque chose comme ci-dessous:

Cela nous a fourni les connaissances sur le conducteur qui contrôlent cet appareil. Dans l'instantané, nous pouvons voir les contrôles du pilote AT24 l'EEPROM présent dans le système. C'est le pilote qui est lié à cet appareil EEPROM.

Pour accéder au périphérique EEPROM depuis l'espace utilisateur, le pilote a créé le fichier «eeprom» qui peut également être vu dans l'instantané.

Pour lire les données EEPROM 8K et vider dans le fichier, la commande DD peut être utilisée comme ci-dessous:

dd if = / sys / bus / i2c / dispositifs / 1-0050 / eeprom de = eeprom_data.bac bs = décompte de 1k = 8

Comme on peut le voir à partir des journaux que 8k octets sont lus à partir de l'Eeprom et écrits à l'Eeprom_data.bac. Ce fichier bac aura les données EEPROM. La commande DD est la commande la plus populaire et couramment utilisée dans Linux World.

Tout comme cet appareil EEPROM, d'autres appareils I2C doivent également suivre les directives fournies par le noyau Linux. D'autres appareils I2C pourraient être RTC, Toch Screen, etc. Dans l'ensemble, ce cadre du pilote de périphérique s'applique même aux appareils à l'extérieur de la portée I2C.

Il peut s'agir d'un appareil SPI ou de tout autre appareil. Il y aura une instance de périphérique à créer et une autre instance de pilote. L'appareil et le conducteur seront liés / connectés via le chauffeur de bus. Ceci est le framework générique du pilote de périphérique dans Linux.

Liaison et non-liaison du conducteur

La liaison du pilote avec un appareil est le processus d'association ou de liaison du pilote à l'appareil qui peut le contrôler ou le comprendre. La non-liaison est le processus inverse, lorsque nous dissolons le pilote avec l'appareil.

Il y a des fichiers sysfs présents dans tous les pilotes. Les noms de fichiers sont liés et insuffisants. Ce sont les fichiers qui peuvent être utilisés pour se lier et dériver. Voici l'instantané du pilote EEPROM AT24:

Débinding du conducteur avec appareil

Comme nous pouvons le voir, l'instance de l'appareil est présente à l'intérieur d'AT24. Cela signifie que l'appareil est déjà lié. Nous pouvons faire écho au nom du périphérique pour délier le pilote de l'appareil.

La non-liaison du conducteur avec l'appareil peut être vue dans l'instantané.

ECHO 1-0050> / SYS / BUS / I2C / DIVIFIERS / AT24 / INFIND; est la commande qui a fait la intrans. Après cette commande, l'appareil n'est pas présent. Par conséquent, l'appareil n'est pas lié au pilote maintenant.

Liaison du pilote avec appareil

ECHO 1-0050> / SYS / BUS / I2C / DRIPERS / AT24 / BONDE; est la commande qui fait la liaison du pilote avec l'appareil.

La première commande LS montre que les détails de l'appareil ne sont pas présents dans le répertoire AT24, ce qui signifie que l'appareil n'est lié à aucun pilote. Deuxièmement, nous avons publié une commande pour lier l'appareil avec le pilote. En conséquence, nous avons vu les informations de l'appareil se remplir dans le répertoire du pilote. Par conséquent, le conducteur est lié à l'appareil avec succès.

L'appareil ne peut être accessible qu'après la liaison réussie du pilote avec l'appareil.

Conclusion

Nous avons discuté du framework du pilote de périphérique dans le noyau Linux avec un exemple de périphérique EEPROM I2C. Nous avons exploré la création de périphériques EEPROM dans l'arborescence de l'appareil et la liaison du pilote avec l'appareil. Une certaine exploration a été effectuée sur les fichiers sysfs, qui fournit les très bonnes informations de diagnostic sur les appareils et les pilotes présents dans le noyau Linux. Nous avons vu un exemple d'accès EEPROM à l'aide de la commande DD. Nous avons également compris le cadre générique impliquant un appareil, des pilotes et des bus. Enfin, nous avons également référé les moyens de lier et de délier les conducteurs et les appareils manuellement à partir de l'espace utilisateur.