7.5 Écran AMOLED Tactile
7.5.3 Écriture du pilote
Il faut un bus SPI libre sur la carte pour communiquer avec l’écran. D’après la documentation, la carte possède trois bus SPI. Nous souhaitions préservez les ports USB et nous avons sacrifié l’un des deux bus gérant la connexion à une carte MMC en se basant sur le bus 3. Les informations nécessaires pour configurer les différents éléments se trouvent dans le dossier documentation du noyau. Dans notre cas, c’est le fichier Documentation/spi/spi-summary qui fut d’une grande aide.
La procédure est la suivante :
1. Déclarer les ports SPI présents sur la carte (cette partie était déjà présente dans les sources fournit par ARMADEUS).
2. Déclarer les périphériques utilisés sur les ports.
3. Indiquer le pilote utiliser.
31
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
(a) Format des données verticale
(b) Format des données horizontales
(c) Forme de l’horloge et des donnés sur le bus
FIGURE37 – Chronogrammes des différents signaux de l’écran
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
FIGURE38 – SPI 3 wire
(a) Connexion des bus MOSI et MISO ensemble
(b) Émission de de 0xFF sur le bus pendant l’envoie
FIGURE39 – Connexion d’un bus SPI 3-wire vers un bus half duplex Déclaration du périphérique
On déclare le périphérique avec le bout de code suivant :
1
2 static struct spi_board_info spi_board_info[] __initdata = { 3 /* .... */
4
5 #ifdef CONFIG_LCD_TS_MODULE
6 {
7 .modalias = " l c d _ t s ", 8 .controller_data = &lcd_ts_hw,
9 .max_speed_hz = 8000000, /* 8MHz */
10 .bus_num = 2, /* SPI3 */
11 .chip_select = 0,
33
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
20 #define NCSPIN (GPIO_PORTE | 21) /* Adresse des PINS utilisees. On se sert des headers fournit par Motorola */
21 #define RESETPIN (GPIO_PORTE | 19) 22
23 24
25 static int lcd_ts_pins [] ={ /* Pins en sortie */
26 (NCSPIN | GPIO_GPIO | GPIO_OUT), 27 (RESETPIN | GPIO_GPIO | GPIO_OUT), 28
29 };
30
31 static int lcd_ts_init(struct spi_device *spi){
32
33 gpio_set_value(RESETPIN,1); /* Les fonctions gpio_set_value et mxc_gpio_setup_multiple_pins sont relatif a la pateforme MXC */
34 gpio_set_value(NCSPIN,1);
39 static int lcd_ts_exit(struct spi_device *spi){
40
49 static int lcd_ts_reset (int value){
50 gpio_set_value(RESETPIN,value);
63 static struct spi_imx_chip lcd_ts_hw = { 64 .cs_control = lcd_ts_cs,
65 };
66
67 static struct lcd_ts apf27_lcd_ts_config = { 68
Les arguments sont les suivants :
– modalias : le nom du module correspondant au pilote.
– controller_data : un pointeur vers une structure de contrôl propre à la plateforme (Chip Select).
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION – max_speed_hz : vitesse maximale du bus.
– bus_num : bus de communication du processeur (SPI3).
– chip_select : présence d’une pin CS.
– platform_data : un pointeur sur une structure contenant les adresses des fonctions d’initialisation du périphérique es-clave.
Ces fonctions d’initialisation se trouvent plus bas dans le code. Elles sont écrites suivants les procédures de démarrage de l’écran trouvées dans la datasheet :
FIGURE40 – Séquence d’allumage de l’écran
Écriture du pilote
Cette section de code se situe au niveau de la communication SPI à proprement parlé, il n’y a plus de configuration matériel.
Le pilote prend la forme d’un module que l’on peut appeler et qui est relié au bon périphérique SPI via la structure vue dans la partie précédente. On reprends les informations de la plate-forme via une structure :
1
2 struct lcd_ts {
35
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
3 struct display_device * display_dev;
4 struct spi_device *spi ;/* SPI BUS */
5 int (*init)(struct spi_device *spi);
6 int (*exit)(struct spi_device *spi);
7 int (*reset)(int value);
8 int ncspin;
9 int resetpin;
10 };
Puis on définit un driver SPI via une nouvelle structure :
1 static struct spi_driver lcd_ts_driver = { 2 .probe = lcd_ts_probe,
Chacun des éléments est un pointeur sur une fonction de configuration du périphérique. Toutes les références doivent être définies. Les fonctions shutdown, suspend et resume ne seront pas utilisées et ne renverront que 0.
La fonction probe correspond à l’initialisation du périphérique sur le bus.
1 static int lcd_ts_probe (struct spi_device *spi_device){
2
3 printk("LCD SPI Bus R e g i s t r a t i o n \ n ");
4 struct lcd_ts *lcd_data;
5 int err = -EINVAL;
6 lcd_data = (struct lcd_ts *)(spi_device->dev.platform_data);
7 lcd_data->init(spi_device); /* Initialise GPIO */
8
Cette fonction appelle la fonction lcd_ts_init_screen qui va transmettre la trame de configuration de l’écran conformément à la datasheet (cf Fig.41) :
1 static int lcd_ts_init_screen( struct lcd_ts * lcd_ts_dev){
2
3 /* gpio_set_value(lcd_ts_dev->resetpin,1); */
4
5 /* initial procedure for 24-bit parallel RGB (DE) */
6 lcd_ts_write (lcd_ts_dev, 0x04, 0x23); /*set display mode 24-bit parallel RGB (DE)*/
7 lcd_ts_write (lcd_ts_dev, 0x05, 0x82); /*set display mode*/
8 lcd_ts_write (lcd_ts_dev, 0x07, 0x0F); /*set driver capability*/
9 lcd_ts_write (lcd_ts_dev, 0x34, 0x18); /*set display timing*/
10 lcd_ts_write (lcd_ts_dev, 0x35, 0x28); /*set display timing*/
11 lcd_ts_write (lcd_ts_dev, 0x36, 0x16); /*set display timing*/
12 lcd_ts_write (lcd_ts_dev, 0x37, 0x01); /*set display timing*/
13 lcd_ts_write (lcd_ts_dev, 0x02, 0x02); /*OTP On*/
14 lcd_ts_write (lcd_ts_dev, 0x0A, 0x79); /*VGHVGL=+/-6V*/
15 lcd_ts_write (lcd_ts_dev, 0x09, 0x20); /*VGAM1OUT=4.85V*/
16 lcd_ts_write (lcd_ts_dev, 0x10, 0x6A); /*set R slop*/
17 lcd_ts_write (lcd_ts_dev, 0x11, 0x6A); /*set G slop*/
18 lcd_ts_write (lcd_ts_dev, 0x12, 0x68); /*set B slop*/
19 lcd_ts_write (lcd_ts_dev, 0x13, 0x00); /*set R_0*/
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
FIGURE41 – Initialisation de l’écran dans la documentation
37
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
21 lcd_ts_write (lcd_ts_dev, 0x15, 0x05); /*set R_36*/
22 lcd_ts_write (lcd_ts_dev, 0x16, 0x05); /*set R_80*/
23 lcd_ts_write (lcd_ts_dev, 0x17, 0x04); /*set R_124*/
24 lcd_ts_write (lcd_ts_dev, 0x18, 0x03); /*set R_168*/
25 lcd_ts_write (lcd_ts_dev, 0x19, 0x02); /*set R_212*/
26 lcd_ts_write (lcd_ts_dev, 0x1A, 0x02); /*set R_255*/
27 lcd_ts_write (lcd_ts_dev, 0x1B, 0x00); /*set G_0*/
28 lcd_ts_write (lcd_ts_dev, 0x1C, 0x06); /*set G_10*/
29 lcd_ts_write (lcd_ts_dev, 0x1D, 0x05); /*set G_36*/
30 lcd_ts_write (lcd_ts_dev, 0x1E, 0x06); /*set G_80*/
31 lcd_ts_write (lcd_ts_dev, 0x1F, 0x06); /*set G_124*/
32 lcd_ts_write (lcd_ts_dev, 0x20, 0x05); /*set G_168*/
33 lcd_ts_write (lcd_ts_dev, 0x21, 0x05); /*set G_212*/
34 lcd_ts_write (lcd_ts_dev, 0x22, 0x07); /*set G_255*/
35 lcd_ts_write (lcd_ts_dev, 0x23, 0x00); /*set G_0*/
36 lcd_ts_write (lcd_ts_dev, 0x24, 0x07); /*set B_10*/
37 lcd_ts_write (lcd_ts_dev, 0x25, 0x06); /*set B_36*/
38 lcd_ts_write (lcd_ts_dev, 0x26, 0x07); /*set B_80*/
39 lcd_ts_write (lcd_ts_dev, 0x27, 0x07); /*set B_124*/
40 lcd_ts_write (lcd_ts_dev, 0x28, 0x06); /*set B_168*/
41 lcd_ts_write (lcd_ts_dev, 0x29, 0x04); /*set B_212*/
42 lcd_ts_write (lcd_ts_dev, 0x2A, 0x07); /*set B_255*/
43 lcd_ts_write (lcd_ts_dev, 0x06, 0x03); /*set display on*/
44
45 /* gpio_set_value(lcd_ts_dev->resetpin,1);*/
46 }
Une fois la communication terminée, il faut terminer libérer les ressources. C’est le but de la fonction resume :
1 static int lcd_ts_remove(struct spi_device *spi_device){
2
3 struct lcd_ts * lcd_data ;
4 lcd_data = (struct lcd_ts * )(spi_device->dev.platform_data);
5
6 lcd_data->exit(spi_device); /* Free GPIO */
7 /* Init Sequence */
8 lcd_data->reset(0);
9
10 return 0;
11 }
Nous devons ouvrir notre module à l’extérieur et proposer des fonctions d’initialisation et de désallocation du pilote dans le système.
23 MODULE_DESCRIPTION(" HX5116 AMOLED D r i v e r ");
24 MODULE_LICENSE("GPL");
Toutes les fonctions sont déclarées statiques de manière à cloisonner la compilation et l’édition de liens aux références de ce fichier.
Le pilote devra être lancé manuellement dès l’identification sur le shell. On pourra par la suite rendre automatiquement le lancement du module. La commande pour lancer le module sera : modprobe lcd_ts.
7.5. ÉCRAN AMOLED TACTILE 7. RÉALISATION
Programme Mandel sous SDL
La SDL est une librarie libre très utilisée pour créer des jeux vidéos 2D. Son aptitude à dialoguer directement avec le framebuffer linux la rende très rapide.
Le programme Mandel affiche une réprésentation de l’ensemble de Mandelbrot dans le plan d’Argand-Gauss. Son pro-gramme est détaillé dans les annexes.
FIGURE42 – La fractale de Mandelbrot sur PC avec la librarie SDL