Programmation système

1  Bus USB

1.1  Présentation du bus USB 1/2

• USB = Universal Serial Bus.
• Standard défini par un consortium autonome.
• Composition de l’"USB Implementers Forum" :
  • Agere Systems ;
  • Apple Computer ;
  • Hewlett-Packard ;
  • Intel ;
  • Microsoft ;
  • NEC.
• Spécifications disponibles sur http://usb.org.
• Premier brouillon en novembre 1994.
• Les différentes versions :
  • USB 1.0, novembre 1995 ;
    • débits de 1,5 Mb/s (low) et de 12 Mb/s (full),
    • correction pour les répéteurs => USB 1.1.
  • USB 2.0, avril 2000 ;
    • débits jusqu’à 480 Mb/s (high),
    • quelques modifications des connecteurs,
    • quelques modifications de l’alimentation.
  • USB 3.0, novembre 2008 ;
    • débits jusqu’à 5 Gb/s (super), débit possible de 3 Gb/s,
    • quelques modifications des connecteurs,
    • quelques modifications de l’alimentation.
  • USB 3.1, septembre 2013 ;
    • débits jusqu’à 10 Gb/s (super 10G), débit possible de 7 Gb/s,
    • puissance fournie jusqu’à 100W (20V).
  • Wireless USB, mai 2005 ;
    • débits de 110 Mb/s (10m) et de 480 Mb/s (3m),
    • fréquence dans la plage de 3.1 Ghz à 10.6 Ghz.

1.2  Présentation du bus USB 2/2

• Caractéristiques remarquables :
  • connexion et déconnexion à chaud ;
  • mode de fonctionnement maître-esclave ;
    • un contrôleur maître,
    • des répéteurs formant une topologie en étoile,
    • répéteurs alimentés uniquement en feuille,
    • des périphériques esclaves,
    • une bande passante partagée (surcoût > 10%),
  • gestion différenciée des esclaves :
    • USB 2.0 => interrogation cycliques,
    • USB 3.0 => interruptions possibles.
• Types de contrôleurs USB :
  • Universal Host Controller Interface (UHCI) :
    • prévu pour de l’USB 1.1,
    • peu de fonctions en matériel,
    • lourdement propriétaire.
  • Open Host Controller Interface (OHCI) :
    • prévu pour de l’USB 1.1,
    • plus de fonctions en matériel.
  • Enhanced Host Controller Interface (EHCI) :
    • prévu pour de l’USB 2.0,
    • cohabitait avec un UHCI ou un OHCI,
    • les ports USB sont communs,
    • les périphériques "high" sont gérés par un EHCI,
    • reroutage des "low" ou "full" vers un UHCI ou un OHCI,
    • introduction de Rate Matching Hub (RMH).
  • Extensible Host Controller Interface (XHCI) :
    • prévu pour de l’USB 3.0,
    • supporte toutes les vitesses.

1.3  Conception des périphériques USB (1/2)

• Des configurations :
  • plusieurs par périphérique esclave ;
  • différents fonctionnements selon l’alimentation ;
  • différents modes de communications ;
  • en général une seule configuration.
• Des sous-périphériques :
  • plusieurs par périphérique esclave ;
  • appelés des fonctions de périphériques ;
  • à une fonction est associée une interface ;
  • exemple : webcam avec micro.
• Des classes de périphériques :

  Classe	Description	Exemple
  00h	Inconnu	Spécifique
  01h	Audio	Carte son
  02h	Communications	Carte réseau
  03h	Human interface device (HID)	Clavier
  05h	Physical Interface Device (PID)	Equipement à retour de force
  06h	Image	Webcam
  07h	Printer	Imprimante
  08h	Mass storage	Clef USB
  09h	USB hub	Répéteur USB
  0Bh	Smart Card	Lecteur de carte
  0Dh	Content security	Lecteur d’empreinte digitale
  0Eh	Video	Webcam
  0Fh	Personal Healthcare	Tensiomètre
  E0h	Wireless Controller	Adaptateur Bluetooth

1.4  Conception des périphériques USB (2/2)

• Des points d’accès :
  • plusieurs par interface (fonction) ;
  • soit une source ou un puit de données ;
  • un maximum de 16 de chaque type.
• En résumé; l’arbre des descripteurs :
  
• Initialisation de périphérique :
  • négociation du débit ;
  • affectation d’une adresse (1 à 127) ;
  • choix d’une configuration.
• Quelques curiosités :
  • contrôleurs situés sur le "pont sud" du circuit ;
  • plusieurs types de contrôleurs USB par carte mère ;
  • plusieurs contrôleurs USB de même type par carte mère ;
  • un répéteur racine par contrôleur USB.

1.5  Les périphériques USB par la pratique (1/2)

• Des périphériques USB sous Linux :

  # lsusb
  Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
  Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
  Bus 001 Device 002: ID 8087:0020 Intel Corp. Integrated Rate Matching Hub
  Bus 002 Device 002: ID 8087:0020 Intel Corp. Integrated Rate Matching Hub
  Bus 001 Device 003: ID 13d3:5130 IMC Networks 
  Bus 001 Device 004: ID 058f:6366 Alcor Micro Corp. Multi Flash Reader
  Bus 002 Device 003: ID 05fe:1958 Chic Technology Corp. 
  Bus 002 Device 004: ID 13fe:1e00 Kingston Technology Company Inc. 
  

• Des contrôleurs USB sous Linux :

   ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
   ...
   ehci_hcd 0000:00:1a.0: new USB bus registered, assigned bus number 1
   ...
   usb usb1: New USB device found, idVendor=1d6b, idProduct=0002
   ...
   hub 1-0:1.0: USB hub found
   hub 1-0:1.0: 2 ports detected
   ...
   ehci_hcd 0000:00:1d.0: new USB bus registered, assigned bus number 2
   ...
   hub 2-0:1.0: USB hub found
   hub 2-0:1.0: 2 ports detected
   ...
   hub 1-1:1.0: USB hub found
   hub 1-1:1.0: 6 ports detected
   ...
   hub 2-1:1.0: USB hub found
   hub 2-1:1.0: 8 ports detected
  

1.6  Les périphériques USB par la pratique (2/2)

• Détection d’un périphérique par le noyau Linux :

   usb 1-1.2: new high speed USB device number 3 using ehci_hcd
   usb 1-1.2: New USB device found, idVendor=13d3, idProduct=5130
   usb 1-1.2: New USB device strings: Mfr=2, Product=1, SerialNumber=0
   usb 1-1.2: Product: USB 2.0 Camera
  

• Caractéristiques de la webcam :

  # lsusb -v -s 1:3
  Bus 001 Device 003: ID 13d3:5130 IMC Networks 
  Device Descriptor:
    bLength                18
    bDescriptorType         1
    bcdUSB               2.00
    bDeviceClass          239 Miscellaneous Device
    bDeviceSubClass         2 ?
    bDeviceProtocol         1 Interface Association
    bMaxPacketSize0        64
    idVendor           0x13d3 IMC Networks
    idProduct          0x5130 
    bcdDevice           12.11
    iManufacturer           2 Sonix Technology Co., Ltd.
    iProduct                1 USB 2.0 Camera
    iSerial                 0 
    bNumConfigurations      1
  ...
  # ls -d /sys/bus/usb/devices/1-1.2*
  /sys/bus/usb/devices/1-1.2 /sys/bus/usb/devices/1-1.2:1.1
  /sys/bus/usb/devices/1-1.2:1.0
  

• Traduction du nom de répertoire 1-1.2:1.1 :
  • fragment 1- pour contrôleur USB 1 ;
  • fragment 1. pour le port 1 du répéteur racine ;
  • fragment 2: pour le port 2 du répéteur secondaire ;
  • fragment 1. pour la première configuration ;
  • fragment 1 pour la seconde interface.

1.7  Communications sur un bus USB (1/3)

• Communications de ou vers les points d’accès :
  • en argot un point d’accès est un endpoint ;
  • son identifiant est sur 8 bits :
    • 4 bits de poids faibles pour le numéro ;
    • 3 bits à zéro ;
    • 1 bit de poid fort pour la direction (1 = in).
• Des canaux de communication vers les points d’accès ;
  • ces canaux s’appellent des tubes (pipes) ;
  • il existe plusieurs modes de communication ;
  • les tubes peuvent être uni-directionnels ou bi-directionnels.
• Différents modes de communication :
  • isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
  • par interruption (interrupt) : latence garantie (e.g. souris) ;
  • de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire) ;
  • de contrôle (control) : commande courte avec réponse (e.g. souris).
• Direction des communication :
  • les tubes de contrôle sont bi-directionnels ;
  • les autres types de tubes sont uni-directionnels ;
  • la direction est IN ou OUT vis à vis de l’hôte.

1.8  Communications sur un bus USB (2/3)

• Les différents types de paquets sur le bus :
  • Initiateur (token) : initie un transfert de données

    Type (8 bits) IN|OUT

    Adresse (7 bits)

    Point d’accès (4 bits)

    Somme de contrôle (5 bits)

  • Données (data) : transport de données

    Type (8 bits) DATAx

    Données (8 à 1024 octets)

    Somme de contrôle (16 bits)

  • Accusés (Handshakes) : confirme ou infirme

    Type (8 bits) ACK|NAK|STALL

• Données DATA0 ou DATA1 pour éviter les doublons.
• Tailles des données selon le débit et le type de tube.
• Pour un tube de transfert de volume :
  • low : 8 octets ;
  • full : 1023 octets ;
  • high : 1024 octets.
• Exemple de paquets :
  
• Implantation des tubes :
  • Point d’accès OUT :
    • envoi par l’hôte d’un initiateur OUT ;
    • envoi par l’hôte de paquets DATAx ;
    • le périphérique accuse réception.
  • Point d’accès IN :
    • envoi par l’hôte d’un initiateur IN ;
    • envoi par le périphérique de paquets DATAx ;
    • l’hôte accuse réception.
• Le tube de contrôle du point d’accès 0 :
  • tube bidirectionnel toujours présent ;
  • tube défini hors interfaces au niveau périphérique ;
  • taille des données; low 8o, full et high 64o, super 512o ;
  • permet d’affecter au périphérique son adresse ;
  • permet de récupérer les descripteurs ;
  • permet de fixer la configuration ;
  • permet d’activer un point d’accès ou de le libérer.

1.9  Communications sur un bus USB (3/3)

• Tubes de contrôle :
  • permettent de configurer le périphérique ;
  • des données avec un protocole de niveau supérieur.
• Tubes pour interruptions :
  • permettent d’envoyer des interruptions ;
  • interruptions IN :
    • l’hôte interroge périodiquement ;
    • le périphérique retourne l’éventuelle interruption.
  • interruptions OUT :
    • l’hôte propage ses interruptions ;
    • le périphérique accuse réception.
• Tubes isodromiques et de volume :
  • fonctionnement de base ;
  • réservation préalable pour les isodromiques.

1.10  Programmation USB mode noyau

• Installez les sources du noyau Linux.
• Allez dans le répertoire des pilotes USB (drivers/usb/).
• Consultez le squelette de pilote usb-skeleton.c.
• Bon courage ...

1.11  Programmation USB mode utilisateur (1/2)

• Utilisation de la bibliothèque libusb-1.0.
• Documentation à http://libusb.sourceforge.net/api-1.0/modules.html.
• Implante les tubes isodromiques.
• Initialisation de la bibliothèque :

  libusb_context *context;
  int status=libusb_init(&context);
  if(status!=0) {perror("libusb_init"); exit(-1);}
  /* ... some code ... */
  libusb_exit(context);
  

• Enumeration des périphériques USB :

  libusb_device **list;
  ssize_t count=libusb_get_device_list(context,&list);
  if(count<0) {perror("libusb_get_device_list"); exit(-1);}
  ssize_t i=0;
  for(i=0;i<count;i++){
    libusb_device *device=list[i];
    struct libusb_device_descriptor desc;
    int status=libusb_get_device_descriptor(device,&desc);
    if(status!=0) continue;
    uint8_t bus=libusb_get_bus_number(device);
    uint8_t address=libusb_get_device_address(device);
    printf("Device Found @ (Bus:Address) %d:%d\n",bus,address);
    printf("Vendor ID 0x0%x\n",desc.idVendor);
    printf("Product ID 0x0%x\n",desc.idProduct);
    }
  libusb_free_device_list(list,1);
  

• Ouverture/fermeture du périphérique à la sauce Unix :

  libusb_device_handle *handle;
  int status=libusb_open(device,&handle);
  if(status!=0){ perror("libusb_open"); exit(-1); }
  /* ... some ... code */
  libusb_close(handle);
  

• Si le méchant noyau est passé avant vous :

  if(libusb_kernel_driver_active(handle,interface)){
    int status=libusb_detach_kernel_driver(handle,interface);
    if(status!=0){ perror("libusb_detach_kernel_driver"); exit(-1); }
    }
  

• Utilisation d’une configuration du périphérique :

  int configuration=valueof("bConfigurationValue");
  int status=libusb_set_configuration(handle,configuration);
  if(status!=0){ perror("libusb_set_configuration"); exit(-1); }
  

• Appropriation d’une interface (fonctionnalité USB) :

  int interface=valueof("bInterfaceNumber");
  int status=libusb_claim_interface(handle,interface);
  if(status!=0){ perror("libusb_claim_interface"); exit(-1); }
  /* ... some code ... */
  status=libusb_release_interface(handle,interface);
  if(status!=0){ perror("libusb_release_interface"); exit(-1); }
  

1.12  Programmation USB mode utilisateur (2/2)

• Fonctions de communication bloquantes :
  • fonctions déconseillées ;
  • tube de contrôle :

    int typ=LIBUSB_REQUEST_TYPE_xxx; /* see libusb.h */
    int req=LIBUSB_REQUEST_yyy    ;  /* see libusb.h */
    int val=...;          /* parameter for req */
    int ind=...;          /* parameter for req */
    char data[MAX_DATA];  /* data to send or to receive */
    int size=...;         /* size to send or maximum size to receive */
    int timeout=...;      /* timeout in ms */
    int nb_bytes=libusb_control_transfer(handle,typ,req,val,ind,data,size,timeout);
    

  • tube pour interruptions :

    int endpoint_out=...;   /* ID of endpoint (bit 8 is 0) */
    int endpoint_in=...;    /* ID of endpoint (bit 8 is 1) */
    char data[MAX_DATA];    /* data to send or to receive */
    int size=...;           /* size to send or maximum size to receive */
    int timeout=...;        /* timeout in ms */
    /* OUT interrupt, from host to device */
    int bytes_out;
    int status=libusb_interrupt_transfer(handle,endpoint_out,data,size,&bytes_out,timeout);
    if(status!=0){ perror("libusb_interrupt_transfer"); exit(-1); }
    /* IN interrupt, host polling device */
    int bytes_in;
    int status=libusb_interrupt_transfer(handle,endpoint_in,data,size,&bytes_in,timeout);
    if(status!=0){ perror("libusb_interrupt_transfer"); exit(-1); }
    

  • tube pour transfert de volume :

    int endpoint_out=...;   /* ID of endpoint (bit 8 is 0) */
    int endpoint_in=...;    /* ID of endpoint (bit 8 is 1) */
    char data[MAX_DATA];    /* data to send or to receive */
    int size=...;           /* size to send or maximum size to receive */
    int timeout=...;        /* timeout in ms */
    /* OUT bulk transfer */
    int bytes_out;
    int status=libusb_bulk_transfer(handle,endpoint_out,data,size,&bytes_out,timeout);
    if(status!=0){ perror("libusb_bulk_transfer"); exit(-1); }
    /* IN bulk transfer */
    int bytes_in;
    int status=libusb_bulk_transfer(handle,endpoint_in,data,size,&bytes_in,timeout);
    if(status!=0){ perror("libusb_bulk_transfer"); exit(-1); }
    

• Fonctions de communication asynchrones :
  • un système de programmation par événements ;
  • tube isodromique implanté.

Ce document a été traduit de L^AT_EX par H^EV^EA