Émuler le RTC D1759 et supprimer le réglage automatique de l'heure

Valider les boutons, le tactile et les outils du simulateur
Relecture et validations locales terminées : iPhone OS 2.2.1 et 2.1.1, gestes, HTTP, saisie, installation et persistance.
2026-10-01 07:41:33 +00:00 · 2026-10-01 09:15:58 +02:00 · 2026-09-30 16:27:48 +00:00 · 2026-09-30 16:25:06 +00:00 · 2026-09-30 17:13:13 +02:00
25 changed files with 1372 additions and 114 deletions
@@ -20,3 +20,5 @@ __pycache__/
 /qemu-ios-generate-nor/
 !/patches/
 !/patches/*.patch
+
+/apps/TouchProbe/TouchProbe.app/
@@ -1,6 +1,44 @@
 # Passation — simulateur iPod Touch 2G / iPhone OS 2.2.1

-État au 2026-09-30. Environnement : conteneur Arch Linux, utilisateur `dev` avec sudo, sans `CAP_NET_ADMIN`, sans `/dev/ppp` ni TUN.
+État au 2026-10-01. Environnement : conteneur Arch Linux, utilisateur `dev` avec sudo, sans `CAP_NET_ADMIN`, sans `/dev/ppp` ni TUN.
+
+## Dernière mise à jour — RTC D1759
+
+Le modèle `d1759` remplace `pcf50633` sur la machine 2G. Il corrige le
+pointeur I²C et fournit le compteur LE32 en `0x5c` avec décalage Unix LE32 en
+`0x64`. Les notes anciennes attribuant un accès indirect RTC à `0x61/0x62`
+étaient incorrectes : ces registres concernent le démarrage.
+`start -W` et `wait` ne règlent plus l'heure via l'agent.
+Voir [RTC.md](RTC.md) pour le protocole, les preuves et les limites.
+Le raccordement GPIO est aussi borné aux cinq IRQ définies, pour éviter
+l'accès hors limites révélé à la recompilation.
+
+## Historique — fiabilisation GPIO/SPI et agent v12
+
+Les sections de diagnostic plus anciennes ci-dessous décrivent les étapes précédentes.
+Le workflow `push-app` puis déverrouillage/lancement a été validé avec l'agent v11.
+Cette suite corrige les débordements GPIO/SYSIC, les commandes tactiles invalides,
+les trames instables et les transactions SPI abandonnées à la reprise de l'écran.
+Huit cycles veille/réveil alternant Home et Power ont passé sur 5H11a sans perte
+du tactile. La calibration TouchProbe retrouve les coordonnées écran sur sept
+points ; la vitesse verticale et le calcul signé des vitesses sont corrigés.
+
+L'agent v12 conserve le protocole et transfère par blocs de 64 Kio avec fichiers
+temporaires distincts. `ipod-test-app` prépare une NAND indépendante, vérifie le
+premier plan, récupère journal et capture, puis arrête sa propre session.
+Voir le README pour les commandes et les tests reproductibles ASan/UBSan.
+Validation finale : huit régressions matérielles avec ASan/UBSan et sept tests
+sur les transferts ; HelloEmu réussit le workflow automatique, l'application
+absente échoue avec capture et arrêt de la VM. Un fichier de 8 460 608 octets
+fait l'aller-retour via l'agent v12 avec SHA-256 identique. Trois cycles de
+veille/réveil supplémentaires avec la calibration finale et l'agent v12 passent,
+puis HelloEmu se lance au premier plan avec son journal. Diagnostics locaux :
+`work/fiabilisation-20260930/` (dont `test-hello`, `test-echec`, `hello-final.png`).
+Les sessions de validation sont arrêtées.
+Les fichiers générés, images et diagnostics restent hors du dépôt. Les images
+5H11a et les NAND d'origine sont conservées ; le RTC, le Wi-Fi matériel, l'audio
+et la veille profonde restent à implémenter. Les nouveaux correctifs ne sont
+pas encore validés sur 5F138.

 ## Objectif

@@ -53,7 +91,7 @@ On veut le comportement le plus fidèle possible à un vrai appareil. La consign
   - Ancienne base sauvegardée : `images/5H11a/nand-readonly-backup`, `rootfs-v8-backup.img`,
     `machine-opts-readonly-backup`. Session d'origine : `run/nand-before-persistence` et `fw-before-persistence`.
     Session de test avec app et fichier de 8 Mio : `run/nand-persistence-verified` (firmware `persistence-test-v10`).
-2. **Horloge RTC du PMU** non émulée : le D1759 passe par un accès indirect, index en `0x61` et donnée en `0x62`. Le modèle PCF50633 existant est faux pour le 2G. Contournement en place : `settime`.
+2. **Horloge RTC du PMU** : compteur et décalage D1759 implémentés ; IRQ d'alarme et persistance du décalage entre instances QEMU restent absentes. Voir la dernière mise à jour et `RTC.md`.
 3. **Réglages > Wi-Fi** affiche « Pas de Wi-Fi », parce que la puce BCM4325 n'est pas émulée. Le réseau passe par une interface ppp0, que l'app peut voir comme un VPN ou une connexion transitoire. Émuler le WiFi pour de vrai (SDIO + firmware FullMAC) serait un gros chantier ; le pont slirp est réutilisable.
 4. **Pas encore écrits** :
   - un script `ipod-test-app` (construit l'image, boote, lance l'app avec `--log`, fait une capture, affiche les logs) ;
@@ -64,7 +102,7 @@ On veut le comportement le plus fidèle possible à un vrai appareil. La consign
 ## Démarrer

 ```bash
-ipod-emu start -f -W            # 2.2.1 (défaut), NAND vierge, attend SpringBoard puis règle l'heure
+ipod-emu start -f -W            # 2.2.1 (défaut), NAND vierge, attend SpringBoard
 ipod-agent ping                 # l'agent répond quand PPP est monté (quelques secondes)
 ipod-agent launch com.apple.mobilesafari --url http://example.com/
 ipod-qmp screenshot /tmp/s.png  # tap X Y | swipe | home | hmp "info registers"
@@ -27,7 +27,7 @@ redirection. `stop` nettoie le relais suivi par PID même si QEMU est déjà arr
 ## Utilisation

 ```bash
-ipod-emu start -W               # agent v11 : conserve la NAND, attend SpringBoard et déverrouille (~35–50 s)
+ipod-emu start -w 5H11a-agent-v12 -W  # attend SpringBoard et déverrouille (~25–50 s)
 # Ajouter -f uniquement pour remettre la NAND à zéro.
 ipod-qmp screenshot ecran.png   # capture 320x480
 ipod-qmp tap 160 326            # touche (coordonnées écran), ipod-qmp tap X Y 1.5 = appui long
@@ -37,14 +37,13 @@ ipod-emu log                    # console du kernel + syslog iOS
 ipod-emu stop
 ```

- Pas de touch avant que `ipod-emu wait` / `start -W` ait rendu la main : le contrôleur tactile plante QEMU s'il est
-  touché pendant son démarrage.
+- Attendre `ipod-emu wait` / `start -W` avant les gestes : le pilote tactile invité doit avoir terminé son démarrage.
 - VNC sur `127.0.0.1:5900` pour interagir à la main (tunnel SSH : `ssh -L 5900:127.0.0.1:5900 …`).
 - Le lancement d'une app prend 10-20 s.

 ## Déverrouillage après redémarrage

-Avec l'agent **v11**, `start -W` et `wait` vérifient le verrouillage, réveillent
+Avec l'agent **v11 ou ultérieur**, `start -W` et `wait` vérifient le verrouillage, réveillent
 l'écran et effectuent le glissement normal avant de rendre la main.
 `ipod-agent screen` retourne `locked=0 passcode=0` une fois déverrouillé ;
 `ipod-agent unlock` permet de refaire ce parcours après démarrage.
@@ -89,6 +88,66 @@ Les `.app`/`.ipa` vont dans `/Applications` (re-signés avec `ldid -S` ; le kern
 la toolchain de l'environnement (`arm-apple-darwin9-gcc -isysroot /opt/theos/sdks/iPhoneOS2.2.1.sdk`), voir
 `apps/HelloEmu`. Environ 230 Mo libres dans l'image 2.2.1.

+## Test automatique et diagnostics
+
+```bash
+# Construire d'abord l'agent v12 et une image dédiée depuis la base inchangée :
+PATH=/opt/cctools/bin:$PATH make -C agent
+ipod-mkimage -b 5H11a -o 5H11a-agent-v12 agent/overlay
+
+# Après avoir arrêté sa session, tester dans une NAND indépendante :
+ipod-test-app MonApp.app
+ipod-test-app MonApp.ipa --output /chemin/nouveau-dossier
+ipod-test-app paquet.deb --bundle-id com.exemple.monapp
+```
+
+Les chemins `agent/` ci-dessus sont relatifs au dossier des outils ; dans le dépôt,
+utiliser `contrib/ipod-emu/agent`. Choisir un nom d'image absent lors de sa création.
+`--base` permet de choisir une autre image contenant l'agent v11 ou ultérieur.
+Le bundle-id est lu dans le plist des `.app` et `.ipa` ; il doit être fourni pour
+les `.deb` et overlays. Le runner refuse de démarrer si les ports VNC ou agent
+sont déjà occupés. Chaque test crée une image et une session dans son propre
+répertoire ; la NAND de `run/` et l'image de base restent conservées.
+
+Le code de sortie vaut zéro uniquement si l'app apparaît puis reste au premier
+plan pendant `--settle` secondes (3 par défaut), si les diagnostics sont collectés
+et si la VM est arrêtée. Ce contrôle ne remplace pas les tests fonctionnels de l'app.
+Les résultats vont dans `work/tests/<date>-<identifiant>/`, ou dans un nouveau dossier
+`--output` : `result.json`, `workflow.log`, `app.log`, `screen.png` et les logs QEMU,
+série et réseau dans `session/run/`. En cas d'échec, les diagnostics disponibles
+sont conservés et la session de test est arrêtée.
+
+## Tactile et transferts
+
+Home/Power ne doivent plus écrire hors du tableau GPIO : le port C est inclus.
+Les trous des registres SYSIC ne débordent plus dans le groupe voisin.
+Le tactile traite séparément les requêtes de longueur et de données, accepte
+EA/EB, conserve une trame stable, et abandonne proprement une commande lors de
+la réinitialisation SPI. Les commandes et rapports inconnus ne font plus arrêter
+QEMU. Le découpage des requêtes est documenté également dans
+[OpeniBoot Z2](https://github.com/iDroid-Project/openiBoot/blob/master/plat-s5l8900/multitouch-z2.c).
+
+La vitesse verticale utilise `y`, les vitesses conservent leur signe et sont
+bornées à 16 bits. `apps/TouchProbe` permet de mesurer la calibration : compiler
+avec son Makefile, lancer avec `--log`, puis comparer les gestes QMP au marqueur
+bleu et aux coordonnées du journal (ajouter 20 pixels à l'ordonnée locale de la vue).
+La calibration a été vérifiée sur 5H11a, sur sept points de `(20,40)` à `(300,460)`.
+Les modifications n'ont pas encore été validées sur 5F138.
+
+Agent **v12** : `put` et `get` utilisent des blocs de 64 Kio au lieu d'allouer
+le fichier entier dans l'iPod. Un upload incomplet supprime son temporaire et
+conserve le fichier précédent ; le client fait de même pour les téléchargements.
+Le protocole reste compatible avec l'agent v11. Les téléchargements vers stdout
+peuvent naturellement afficher un préfixe avant une erreur de transport.
+
+Depuis le dépôt, les tests sans firmware sont :
+
+```bash
+contrib/ipod-emu/tests/run-rtc           # protocole I²C et horloge D1759, ASan/UBSan
+contrib/ipod-emu/tests/run-multitouch    # build QEMU arm existant, Ninja, compilateur avec ASan/UBSan
+python3 contrib/ipod-emu/tests/test-transfers.py  # Python et compilateur C, sockets locales
+```
+
 ## Limites

 - **Persistance NAND** : les pages et métadonnées écrites par iOS, ainsi que les effacements de blocs, sont conservés
@@ -98,14 +157,17 @@ la toolchain de l'environnement (`arm-apple-darwin9-gcc -isysroot /opt/theos/sdk
 - **Internet** : PPP sur UART1, pont `ipod-netd` vers libslirp ; DNS et HTTP fonctionnent. `ipod-agent fetch
  http://example.com/` teste le réseau depuis l'iPod. L'écran Réglages affiche toujours « Pas de Wi-Fi », car la puce
  BCM4325 n'est pas émulée.
- **Heure** : le RTC n'est pas émulé ; `start -W` / `wait` règle l'heure depuis l'hôte dès que l'agent répond,
-  avant la fin du démarrage de SpringBoard.
+- **Heure** : le RTC D1759 fournit l'heure dès le démarrage, avec la configuration QEMU `-rtc`
+  (UTC et horloge hôte par défaut). `start -W` / `wait` ne modifie plus la date.
+  `ipod-agent settime SECONDES_UNIX` reste disponible pour les tests explicites.
+  Le décalage écrit par iOS reste en mémoire pendant la session ; une nouvelle instance QEMU repart
+  de sa base RTC. Les IRQ d'alarme matérielle ne sont pas émulées. Voir [RTC.md](RTC.md).
  L'image de base est en français, région France, fuseau Europe/Paris.
 - **Relance de SpringBoard** : `respring` peut bloquer la reconstruction du catalogue d'apps. `push-app` redémarre
  donc l'émulateur sans reconstruire l'image ni réinitialiser la NAND. Avec l'agent v11, le déverrouillage puis
-  le lancement de HelloEmu au premier plan sont validés après cette installation. Les gestes Home/Power restent
-  susceptibles de déclencher un défaut du pilote lors de la reprise de l'écran ; le workflow automatique utilise
-  le réveil par l'API d'affichage et vérifie le verrouillage.
+  le lancement de HelloEmu au premier plan sont validés après cette installation. Les corrections GPIO/SPI
+  ont permis huit cycles veille/réveil alternant Home et Power sur 5H11a. Le déverrouillage automatique
+  continue à vérifier l'état de l'écran.
 - **Veille** : l'agent v10 pose `SleepDisabled` sur `IOPMrootDomain`, le SoC ne sachant pas reprendre une veille profonde.
 - Pas de son, pas d'accélération graphique (SpringBoard tourne avec `LK_ENABLE_MBX2D=0`).

@@ -0,0 +1,82 @@
+# RTC du D1759 — iPod Touch 2G
+
+Le modèle `d1759` fournit l'heure avant le lancement des services iOS. La
+machine 2G l'utilise à l'adresse I²C `0x73` ; le modèle historique `pcf50633`
+reste disponible séparément. Les images et l'agent v12 existants conviennent.
+Il faut reconstruire QEMU et utiliser le lanceur mis à jour.
+
+## Protocole observé
+
+Le désassemblage local du pilote `AppleD1759PMURTC` de 5H11a montre :
+
+| Registres | Comportement |
+| --- | --- |
+| `0x5c` à `0x5f` | Compteur de secondes sur 32 bits, petit-boutiste |
+| `0x64` à `0x67` | Décalage ajouté au compteur pour obtenir les secondes Unix |
+| `0x50` à `0x5a` | Réglages d'alarme conservés en mémoire, sans IRQ |
+| `0x60` à `0x63` | Suivi du démarrage, indépendant du RTC |
+
+Sur le kernelcache déchiffré, le segment `__PRELINK` a le décalage adresse
+virtuelle/fichier `0xc0029000`. La routine à `0xc03c8f08` lit quatre octets en
+`0x5c` et ajoute le décalage chargé au démarrage par `0xc03c8c10` depuis `0x64`.
+La routine à `0xc03c8f48` règle l'heure en écrivant la différence en `0x64`.
+Les routines PMU à `0xc03c11e8` et `0xc03c1228` transmettent directement le
+registre au nub I²C. Ce sont des observations du binaire local, pas des
+symboles exportés ni une spécification complète du composant.
+
+Le protocole I²C standard, registre puis données, est aussi visible dans
+[OpeniBoot pour le S5L8720](https://github.com/iDroid-Project/openiBoot/blob/master/plat-s5l8720/pmu.c).
+Sa fonction RTC est laissée à implémenter et ne constitue pas une preuve du
+format du compteur. Les anciennes notes décrivant `0x61/0x62` comme un accès
+indirect RTC étaient incorrectes.
+
+Une lecture capture le compteur au début de la réception pour éviter de
+mélanger deux secondes entre les octets. Les sélections de registre avec STOP
+et avec START répété sont acceptées. Le compteur est en lecture seule ; les
+écritures de décalage sont conservées pendant la session.
+
+## Configuration et limites
+
+QEMU initialise le compteur via `qemu_get_timedate`, puis le fait avancer avec
+`rtc_clock`. Les options habituelles `-rtc base=...,clock=...` sont respectées.
+Par défaut, la base est UTC et le temps suit l'horloge de l'hôte. Le fuseau
+horaire d'affichage reste un réglage d'iOS. Une base reproductible peut être
+passée au lanceur, par exemple :
+
+```bash
+IPOD_QEMU_EXTRA='-rtc base=2024-02-29T23:59:59,clock=vm' ipod-emu start -W
+```
+
+`start -W` et `wait` ne lancent plus `settime`. La commande
+`ipod-agent settime SECONDES_UNIX` reste un réglage volontaire pour les tests.
+Le décalage RTC ne persiste pas entre deux processus QEMU ; une nouvelle
+instance repart de sa configuration `-rtc`. Les IRQ d'alarme, la veille
+profonde et la migration de l'état RTC ne sont pas implémentées.
+
+Un reset QEMU à chaud peut laisser PPP inaccessible. Pour redémarrer une
+session conservée, utiliser `ipod-agent sync`, `ipod-emu stop`, puis
+`ipod-emu start -W`, qui conserve la NAND.
+
+## Validation
+
+```bash
+contrib/ipod-emu/tests/run-rtc
+```
+
+Le test compile le modèle réel avec ASan/UBSan et utilise le bus I²C QEMU :
+base UTC avec fuseau hôte différent, date fixe bissextile, cohérence des
+lectures au changement de seconde, décalages positifs/négatifs et séparation
+des registres de démarrage.
+
+Validation du 1er octobre 2026 sur des copies de NAND :
+
+- 5H11a / iPhone OS 2.2.1 et 5F138 / iPhone OS 2.1.1 démarrent sans `settime` ;
+  `gettimeofday` dans un programme armv6 retrouve l'heure Unix de l'hôte.
+- Un changement volontaire de date continue à avancer. Après un reset à
+  chaud de 5F138, les journaux précoces d'iOS retrouvent le décalage écrit ;
+  PPP ne reprend pas correctement après ce reset.
+- Les démarrages normaux, le déverrouillage et le lancement d'applications
+  sont vérifiés avec le lanceur sans synchronisation par l'agent.
+
+Les diagnostics restent hors du dépôt dans
+`/srv/homes/iphoneos2/ipod-emu/work/rtc-20261001/`.
@@ -67,7 +67,7 @@ struct rt_msghdr {
 #include <notify.h>
 #include <unistd.h>

-#define VERSION "11"
+#define VERSION "12"
 #define PORT 7788
 #define PPP_TTY "/dev/tty.bluetooth"
 #define GUEST_IP "10.0.2.15"
@@ -236,7 +236,7 @@ static int send_all(int fd, const void *b, size_t n)
    const char *p = b;
    while (n) {
        ssize_t w = write(fd, p, n);
-        if (w < 0) { if (errno == EINTR) continue; return -1; }
+        if (w <= 0) { if (w < 0 && errno == EINTR) continue; if (!w) errno = EIO; return -1; }
        p += w; n -= w;
    }
    return 0;
@@ -569,49 +569,75 @@ static int read_full(int fd, void *b, size_t n)
    char *p = b;
    while (n) {
        ssize_t r = read(fd, p, n);
-        if (r <= 0) { if (r < 0 && errno == EINTR) continue; return -1; }
+        if (r <= 0) { if (r < 0 && errno == EINTR) continue; if (!r) errno = EIO; return -1; }
        p += r; n -= r;
    }
    return 0;
 }

+/* Transferts par blocs : ne pas allouer la taille du fichier sur l'iPod. */
 static void cmd_put(int fd, char **args, int nargs)
 {
    if (nargs < 3) { reply_str(fd, 0, "usage: put<TAB>chemin<TAB>mode octal<TAB>taille + données"); return; }
-    size_t size = strtoul(args[2], NULL, 10);
-    char *data = malloc(size ? size : 1);
-    if (read_full(fd, data, size)) { free(data); return; }
+    char *end;
+    errno = 0;
+    unsigned long size = strtoul(args[2], &end, 10);
+    if (errno || !args[2][0] || args[2][0] == '-' || *end) {
+        reply_str(fd, 0, "taille invalide"); return;
+    }
    char dir[1024];
-    strncpy(dir, args[0], sizeof dir - 1);
-    dir[sizeof dir - 1] = 0;
+    if (strlen(args[0]) >= sizeof dir) { reply_str(fd, 0, "chemin trop long"); return; }
+    strcpy(dir, args[0]);
    char *slash = strrchr(dir, '/');
    if (slash && slash != dir) { *slash = 0; mkdirs(dir); }
    char tmp[1100];
-    snprintf(tmp, sizeof tmp, "%s.emuagent-tmp", args[0]);
-    int f = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, strtoul(args[1], NULL, 8));
-    if (f < 0 || send_all(f, data, size) || fsync(f)) {
-        reply_str(fd, 0, "écriture de %s : %s", args[0], strerror(errno));
-        if (f >= 0) close(f);
-        free(data);
+    snprintf(tmp, sizeof tmp, "%s.emuagent-XXXXXX", args[0]);
+    int f = mkstemp(tmp);
+    if (f < 0) { reply_str(fd, 0, "création : %s", strerror(errno)); return; }
+    char data[65536];
+    size_t remaining = size;
+    int failed = 0;
+    while (remaining) {
+        size_t chunk = remaining < sizeof data ? remaining : sizeof data;
+        if (read_full(fd, data, chunk) || send_all(f, data, chunk)) { failed = 1; break; }
+        remaining -= chunk;
+    }
+    if (!failed && (fchmod(f, strtoul(args[1], NULL, 8)) || fsync(f))) failed = 1;
+    int saved = errno;
+    if (close(f) && !failed) { failed = 1; saved = errno; }
+    if (!failed && rename(tmp, args[0])) { failed = 1; saved = errno; }
+    if (failed) {
+        unlink(tmp);
+        reply_str(fd, 0, "écriture de %s : %s", args[0], strerror(saved));
        return;
    }
-    close(f);
-    chmod(tmp, strtoul(args[1], NULL, 8));
-    rename(tmp, args[0]);
-    free(data);
-    reply_str(fd, 1, "%zu octets écrits", size);
+    reply_str(fd, 1, "%lu octets écrits", size);
 }

 static void cmd_get(int fd, char **args, int nargs)
 {
+    if (nargs < 1) { reply_str(fd, 0, "usage: get<TAB>chemin"); return; }
+    int f = open(args[0], O_RDONLY | O_NONBLOCK);
    struct stat st;
-    if (nargs < 1 || stat(args[0], &st) || !S_ISREG(st.st_mode)) { reply_str(fd, 0, "%s : %s", nargs ? args[0] : "?", strerror(errno)); return; }
-    int f = open(args[0], O_RDONLY);
-    char *data = malloc(st.st_size ? st.st_size : 1);
-    if (f < 0 || read_full(f, data, st.st_size)) { reply_str(fd, 0, "lecture de %s : %s", args[0], strerror(errno)); free(data); if (f >= 0) close(f); return; }
+    if (f < 0 || fstat(f, &st) || !S_ISREG(st.st_mode)) {
+        reply_str(fd, 0, "lecture de %s impossible", args[0]);
+        if (f >= 0) close(f);
+        return;
+    }
+    char hdr[128], data[65536];
+    snprintf(hdr, sizeof hdr, "OK %llu\n", (unsigned long long)st.st_size);
+    if (send_all(fd, hdr, strlen(hdr))) { close(f); return; }
+    off_t remaining = st.st_size;
+    while (remaining) {
+        size_t chunk = remaining < (off_t)sizeof data ? (size_t)remaining : sizeof data;
+        /* Après l'en-tête, une erreur impose de fermer la connexion :
+           le client détecte la réponse incomplète et conserve son ancien fichier. */
+        if (read_full(f, data, chunk) || send_all(fd, data, chunk)) {
+            close(f); shutdown(fd, SHUT_RDWR); return;
+        }
+        remaining -= chunk;
+    }
    close(f);
-    reply(fd, 1, NULL, data, st.st_size);
-    free(data);
 }

 static void cmd_ls(int fd, char **args, int nargs)
@@ -742,7 +768,7 @@ static void handle(int fd, char *line)
    else if (!strcmp(cmd, "sc")) cmd_sc(fd, a, na);
    else if (!strcmp(cmd, "routes")) cmd_routes(fd);
    else if (!strcmp(cmd, "settime")) {
-        /* le RTC du PMU (D1759) n'est pas émulé : l'hôte donne l'heure (secondes Unix) */
+        /* Réglage explicite de l'heure pour les tests (secondes Unix). */
        struct timeval tv = { na ? strtol(a[0], NULL, 10) : 0, 0 };
        if (na && !settimeofday(&tv, NULL)) {
            notify_post("com.apple.system.clock_set");   /* SpringBoard et les apps mettent leur horloge à jour */
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleExecutable</key>
+	<string>TouchProbe</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.ioslegacy.touchprobe</string>
+	<key>CFBundleName</key>
+	<string>TouchProbe</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>MinimumOSVersion</key>
+	<string>2.0</string>
+</dict>
+</plist>
@@ -0,0 +1,10 @@
+# Sonde de calibration tactile pour iPhone OS 2.
+SDK := /opt/theos/sdks/iPhoneOS2.2.1.sdk
+CC := /opt/cctools/bin/arm-apple-darwin9-gcc
+all: TouchProbe.app/TouchProbe
+TouchProbe.app/TouchProbe: main.m Info.plist
+	mkdir -p TouchProbe.app
+	$(CC) -isysroot $(SDK) -arch armv6 -miphoneos-version-min=2.0 -O2 -o $@ main.m -framework UIKit -framework Foundation
+	cp Info.plist TouchProbe.app/
+	ldid -S $@
+.PHONY: all
@@ -0,0 +1,30 @@
+#import <UIKit/UIKit.h>
+@interface ProbeView : UIView
+@end
+@implementation ProbeView
+- (void)record:(NSSet *)touches phase:(NSString *)phase {
+ CGPoint p=[[touches anyObject] locationInView:self];
+ UIView *marker=[self viewWithTag:99];
+ if (!marker) {
+  marker=[[[UIView alloc] initWithFrame:CGRectMake(0,0,0,0)] autorelease];
+  marker.tag=99; marker.backgroundColor=[UIColor blueColor]; marker.userInteractionEnabled=NO;
+  [self addSubview:marker];
+ }
+ marker.frame=CGRectMake(p.x-2,p.y-2,5,5);
+ NSLog(@"TOUCH %@ %.1f %.1f",phase,p.x,p.y);
+}
+- (void)touchesBegan:(NSSet *)t withEvent:(UIEvent *)e { [self record:t phase:@"begin"]; }
+- (void)touchesMoved:(NSSet *)t withEvent:(UIEvent *)e { [self record:t phase:@"move"]; }
+- (void)touchesEnded:(NSSet *)t withEvent:(UIEvent *)e { [self record:t phase:@"end"]; }
+@end
+@interface ProbeApp : NSObject <UIApplicationDelegate> { UIWindow *window; }
+@end
+@implementation ProbeApp
+- (void)applicationDidFinishLaunching:(UIApplication *)app {
+ window=[[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
+ ProbeView *v=[[ProbeView alloc] initWithFrame:CGRectMake(0,20,320,460)];
+ v.backgroundColor=[UIColor whiteColor];[window addSubview:v];[v release];[window makeKeyAndVisible];
+ NSLog(@"TouchProbe ready window=%@ view=%@",NSStringFromCGRect(window.frame),NSStringFromCGRect(v.frame));
+}
+@end
+int main(int argc,char **argv) { NSAutoreleasePool *p=[[NSAutoreleasePool alloc] init];int rc=UIApplicationMain(argc,argv,nil,@"ProbeApp");[p release];return rc; }
@@ -20,7 +20,7 @@

 Code de sortie : 0 si OK, 1 si erreur, code de sortie du programme pour exec.
 """
-import os, socket, subprocess, sys, time
+import os, socket, subprocess, sys, tempfile, time

 HOST = os.environ.get("IPOD_AGENT_HOST", "127.0.0.1")
 PORT = int(os.environ.get("IPOD_AGENT_PORT", "7788"))
@@ -31,19 +31,41 @@ class Agent:
        self.s = socket.create_connection((HOST, PORT), timeout=timeout)
        self.f = self.s.makefile("rb")

-    def call(self, *fields, data=None):
+    def call(self, *fields, data=None, sink=None):
        line = "\t".join(str(x) for x in fields) + "\n"
        self.s.sendall(line.encode())
        if data is not None:
-            self.s.sendall(data)
-        hdr = self.f.readline().decode().rstrip("\n")
+            if hasattr(data, "read"):
+                remaining = int(fields[-1])
+                while remaining:
+                    chunk = data.read(min(65536, remaining))
+                    if not chunk:
+                        raise ConnectionError("fichier local tronqué pendant l'upload")
+                    self.s.sendall(chunk)
+                    remaining -= len(chunk)
+            else:
+                self.s.sendall(data)
+        hdr = self.f.readline(4096).decode().rstrip("\n")
        if not hdr:
            raise ConnectionError("connexion fermée par l'agent")
        parts = hdr.split(" ", 2)
+        if len(parts) < 2:
+            raise ConnectionError("en-tête invalide")
        n = int(parts[1])
-        body = self.f.read(n)
-        if len(body) != n:
-            raise ConnectionError(f"réponse tronquée : {len(body)} octets reçus sur {n}")
+        if n < 0 or parts[0] not in ("OK", "ERR"):
+            raise ConnectionError("en-tête invalide")
+        body = bytearray()
+        received = 0
+        while received < n:
+            chunk = self.f.read(min(65536, n - received))
+            if not chunk:
+                raise ConnectionError(f"réponse tronquée : {received} octets reçus sur {n}")
+            received += len(chunk)
+            if sink is not None and parts[0] == "OK":
+                sink.write(chunk)
+            else:
+                body.extend(chunk)
+        body = bytes(body)
        return parts[0] == "OK", body, parts[2] if len(parts) > 2 else None


@@ -88,8 +110,7 @@ def unlock(a):
        if not ok:
            sys.exit(body.decode())
        time.sleep(2)  # laisser le pilote réactiver l'écran et le tactile
-        # La surface tactile émulée est légèrement plus petite que l'écran :
-        # le geste doit atteindre le bord droit pour terminer le déverrouillage.
+        # Terminer le geste au bord droit du curseur de déverrouillage.
        subprocess.run([qmp, "-s", sock, "swipe", "60", "450", "319", "450"], check=True)
        time.sleep(2)
        state = screen()
@@ -175,20 +196,30 @@ def main():
        unlock(a)
        return
    if cmd == "get":
-        ok, body, _ = a.call("get", rest[0])
-        if not ok:
-            sys.exit(body.decode())
-        if len(rest) > 1:
-            with open(rest[1], "wb") as fh:
-                fh.write(body)
-        else:
-            sys.stdout.buffer.write(body)
+        tmp = None
+        try:
+            if len(rest) > 1:
+                destination = os.path.abspath(rest[1])
+                fd, tmp = tempfile.mkstemp(prefix=".ipod-get-", dir=os.path.dirname(destination))
+                with os.fdopen(fd, "wb") as fh:
+                    ok, body, _ = a.call("get", rest[0], sink=fh)
+                    fh.flush()
+                    os.fsync(fh.fileno())
+                if ok:
+                    os.replace(tmp, destination)
+                    tmp = None
+            else:
+                ok, body, _ = a.call("get", rest[0], sink=sys.stdout.buffer)
+            if not ok:
+                sys.exit(body.decode())
+        finally:
+            if tmp is not None:
+                os.unlink(tmp)
        return
    if cmd == "put":
-        with open(rest[0], "rb") as fh:
-            data = fh.read()
        mode = rest[2] if len(rest) > 2 else ("755" if os.access(rest[0], os.X_OK) else "644")
-        ok, body, _ = a.call("put", rest[1], mode, len(data), data=data)
+        with open(rest[0], "rb") as fh:
+            ok, body, _ = a.call("put", rest[1], mode, os.fstat(fh.fileno()).st_size, data=fh)
    elif cmd == "push-app":
        push_app(a, rest[0])
        return
@@ -207,4 +238,7 @@ def main():


 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    except (OSError, ValueError, ConnectionError) as e:
+        sys.exit(f"Erreur de transfert ou de protocole : {e}")
@@ -20,7 +20,7 @@ Usage : ipod-emu start [-f] [-W] [-w FW]   démarre (headless, VNC $VNC, QMP $RU
          -W     attend que SpringBoard soit prêt à recevoir des touches
          -w FW  firmware à utiliser (défaut : $FW ; dispo : $(ls "$EMU_HOME/images" 2>/dev/null | tr '\n' ' '))
        ipod-emu wait [SECONDES]    attend SpringBoard (défaut 300 s) — n'envoyez PAS de touch avant :
-                                    le contrôleur tactile plante s'il est touché pendant son boot
+                                    le pilote tactile doit avoir terminé son démarrage
        ipod-emu stop | status | log | console
 Pilotage (écran, touch, boutons) : ipod-qmp --help
 USAGE
@@ -34,10 +34,7 @@ ready() {

 wait_ready() {
    local t=${1:-300} s=$SECONDS
-    # Régler l'heure dès que PPP répond, avant que SpringBoard initialise
-    # ses timers à partir de préférences persistées datées dans le futur.
-    "$(dirname "$0")/ipod-agent" wait 60 >/dev/null 2>&1 &&
-        timeout 15 "$(dirname "$0")/ipod-agent" settime "$(date +%s)" >/dev/null 2>&1 || true
+    # Le RTC D1759 fournit l'heure avant le démarrage des services iOS.
    until ready; do
        [ -n "$(pid)" ] || { echo "L'émulateur s'est arrêté (voir $RUN/qemu.log)" >&2; return 1; }
        grep -aq 'Fatal Exception\|MACH Reboot' "$RUN/serial.log" && { echo "Kernel panic / reboot (voir $RUN/serial.log)" >&2; return 1; }
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Teste une application dans une NAND indépendante et conserve les diagnostics."""
+import argparse
+import json
+import os
+from pathlib import Path
+import plistlib
+import shutil
+import socket
+import subprocess
+import tempfile
+import time
+import zipfile
+
+
+def bundle_id(package):
+    if package.is_dir() and package.suffix == '.app':
+        with (package / 'Info.plist').open('rb') as f:
+            return plistlib.load(f)['CFBundleIdentifier']
+    if package.suffix == '.ipa':
+        with zipfile.ZipFile(package) as z:
+            plists = [n for n in z.namelist() if n.startswith('Payload/') and
+                      n.endswith('.app/Info.plist') and n.count('/') == 2]
+            if len(plists) != 1:
+                raise ValueError('IPA ambiguë : préciser --bundle-id')
+            return plistlib.loads(z.read(plists[0]))['CFBundleIdentifier']
+    raise ValueError('Préciser --bundle-id pour un paquet .deb ou un overlay')
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('package', type=Path, help='.app, .ipa, .deb ou overlay')
+    p.add_argument('--bundle-id')
+    p.add_argument('--base', default=os.environ.get('IPOD_TEST_BASE', '5H11a-agent-v12'))
+    p.add_argument('--output', type=Path, help='nouveau dossier de résultats (doit être absent)')
+    p.add_argument('--settle', type=float, default=3, help='attente après apparition au premier plan')
+    args = p.parse_args()
+    package = args.package.resolve()
+    tools = Path(__file__).resolve().parent
+    default_home = tools.parent if (tools.parent / 'images').is_dir() else Path.home() / 'ipod-emu'
+    home = Path(os.environ.get('IPOD_EMU_HOME', default_home)).resolve()
+    try:
+        if not package.exists():
+            raise ValueError('Application introuvable')
+        identifier = args.bundle_id or bundle_id(package)
+        if not isinstance(identifier, str) or not identifier or any(c in identifier for c in '\t\r\n'):
+            raise ValueError('Bundle-id invalide')
+        if Path(args.base).name != args.base or args.base in ('.', '..'):
+            raise ValueError('Nom de firmware invalide')
+        if args.settle < 0:
+            raise ValueError('--settle doit être positif')
+        base = home / 'images' / args.base
+        if not (base / 'rootfs.img').is_file():
+            raise ValueError(f'Image de base introuvable : {base}')
+        # Les ports sont partagés par les sessions : ne jamais arrêter une VM tierce.
+        vnc = os.environ.get('IPOD_VNC', '127.0.0.1:0')
+        host, display = vnc.rsplit(':', 1)
+        for address, port in [(os.environ.get('IPOD_AGENT_HOST', '127.0.0.1'),
+                               int(os.environ.get('IPOD_AGENT_PORT', '7788'))),
+                              (host or '127.0.0.1', 5900 + int(display))]:
+            try:
+                connection = socket.create_connection((address, port), timeout=1)
+            except ConnectionRefusedError:
+                continue
+            else:
+                connection.close()
+                raise ValueError(f'Port {port} occupé : arrêter votre session avant ce test')
+        if args.output:
+            result = args.output.resolve()
+            result.mkdir(parents=True, exist_ok=False)
+        else:
+            parent = home / 'work' / 'tests'
+            parent.mkdir(parents=True, exist_ok=True)
+            result = Path(tempfile.mkdtemp(prefix=time.strftime('%Y%m%d-%H%M%S-'), dir=parent))
+    except (OSError, ValueError, KeyError, plistlib.InvalidFileException, zipfile.BadZipFile) as e:
+        p.exit(1, f'{e}\n')
+
+    print(f'Diagnostics : {result}', flush=True)
+    session = result / 'session'
+    (session / 'images').mkdir(parents=True)
+    (session / 'images' / args.base).symlink_to(base, target_is_directory=True)
+    for dependency in ('xpwn', 'gen-v1', 'netd'):
+        (session / dependency).symlink_to(home / dependency, target_is_directory=True)
+    env = dict(os.environ, IPOD_EMU_HOME=str(session),
+               IPOD_QEMU=os.environ.get('IPOD_QEMU', str(home.parent / 'qemu-ios/build/qemu-system-arm')))
+    # Un socket de session explicite ne doit pas viser la VM de l'utilisateur.
+    env.pop('IPOD_QMP', None)
+    image_name = 'test-app' if args.base != 'test-app' else 'test-app-result'
+    started = False
+    report = {'package': str(package), 'bundle_id': identifier, 'base': args.base, 'ok': False}
+
+    with (result / 'workflow.log').open('w') as workflow:
+        def run(tool, *argv, capture=False, timeout=360):
+            r = subprocess.run([str(tools / tool), *map(str, argv)], env=env,
+                               stdout=subprocess.PIPE if capture else workflow,
+                               stderr=workflow, text=True, timeout=timeout)
+            if capture:
+                workflow.write(r.stdout)
+                workflow.flush()
+            if r.returncode:
+                raise RuntimeError(f'{tool} {argv[0] if argv else ""} : code {r.returncode}')
+            return r.stdout if capture else None
+
+        try:
+            run('ipod-mkimage', '-b', args.base, '-o', image_name, package, timeout=900)
+            started = True  # nettoie également un démarrage partiel
+            run('ipod-emu', 'start', '-w', image_name, '-W')
+            run('ipod-agent', 'launch', identifier, '--log', '/private/var/mobile/ipod-test-app.log')
+            deadline = time.monotonic() + 30
+            while run('ipod-agent', 'front', capture=True, timeout=20).strip() != identifier:
+                if time.monotonic() >= deadline:
+                    raise RuntimeError('Application absente du premier plan après 30 s')
+                time.sleep(1)
+            time.sleep(args.settle)
+            front = run('ipod-agent', 'front', capture=True, timeout=20).strip()
+            report['front'] = front
+            if front != identifier:
+                raise RuntimeError('Application quittée pendant la période de stabilisation')
+            report['ok'] = True
+        except (OSError, RuntimeError, subprocess.TimeoutExpired) as e:
+            report['error'] = str(e)
+        finally:
+            if started:
+                for tool, argv in [('ipod-agent', ['get', '/private/var/mobile/ipod-test-app.log', result / 'app.log']),
+                                   ('ipod-qmp', ['screenshot', result / 'screen.png'])]:
+                    try:
+                        run(tool, *argv, timeout=30)
+                    except (OSError, RuntimeError, subprocess.TimeoutExpired) as e:
+                        report.setdefault('diagnostic_errors', []).append(str(e))
+                try:
+                    run('ipod-agent', 'sync', timeout=15)
+                except (OSError, RuntimeError, subprocess.TimeoutExpired):
+                    pass
+                try:
+                    run('ipod-emu', 'stop', timeout=30)
+                except (OSError, RuntimeError, subprocess.TimeoutExpired) as e:
+                    report['ok'] = False
+                    report['stop_error'] = str(e)
+            if report.get('diagnostic_errors'):
+                report['ok'] = False
+            (result / 'result.json').write_text(json.dumps(report, indent=2, ensure_ascii=False) + '\n')
+    print('Test réussi' if report['ok'] else 'Test échoué : consulter workflow.log et result.json')
+    return 0 if report['ok'] else 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Compile et exécute les régressions tactiles avec ASan/UBSan sur un build QEMU existant."""
+import argparse
+import json
+import os
+from pathlib import Path
+import shlex
+import subprocess
+
+p = argparse.ArgumentParser(description=__doc__)
+p.add_argument('--build', type=Path)
+a = p.parse_args()
+root = Path(__file__).resolve().parents[3]
+build = (a.build or root / 'build').resolve()
+source = Path(__file__).with_name('test-multitouch.c')
+commands = json.loads((build / 'compile_commands.json').read_text())
+c = next(c for c in commands if c['file'].endswith('ipod_touch_multitouch.c'))
+old_root = str(Path(c['directory']).parent)
+args = shlex.split(c['command'].replace(old_root, str(root)))
+obj = str(build / 'test-ipod-multitouch.o')
+args[args.index('-c') + 1] = str(source)
+args[args.index('-o') + 1] = obj
+args[args.index('-MF') + 1] = obj + '.d'
+args += ['-fsanitize=address,undefined', '-fno-omit-frame-pointer']
+subprocess.run(args, cwd=build, check=True)
+links = json.loads(subprocess.check_output(
+    ['ninja', '-C', str(build), '-t', 'compdb', '-x', 'c_LINKER_RSP', 'c_LINKER'], text=True))
+link = next(c for c in links if c.get('output') == 'qemu-system-arm')
+args = shlex.split(link['command'].replace(old_root, str(root)))
+args = [x for x in args if x not in (
+    'qemu-system-arm.p/system_main.c.o',
+    'libqemu-arm-softmmu.fa.p/hw_arm_ipod_touch_multitouch.c.o',
+    'libqemu-arm-softmmu.fa.p/hw_arm_ipod_touch_gpio.c.o',
+    'libqemu-arm-softmmu.fa.p/hw_arm_ipod_touch_sysic.c.o',
+    'libqemu-arm-softmmu.fa.p/hw_arm_ipod_touch_spi.c.o')]
+out = str(build / 'test-ipod-multitouch')
+args[args.index('-o') + 1] = out
+args += [obj, '-fsanitize=address,undefined']
+subprocess.run(args, cwd=build, check=True)
+# QEMU conserve volontairement ses registres de types et sa boucle globale à la sortie.
+env = dict(os.environ, ASAN_OPTIONS='detect_leaks=0', UBSAN_OPTIONS='halt_on_error=1')
+subprocess.run([out], env=env, check=True)
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Compile et exécute les régressions RTC avec ASan/UBSan sur un build QEMU existant."""
+import argparse
+import json
+import os
+from pathlib import Path
+import shlex
+import subprocess
+
+p = argparse.ArgumentParser(description=__doc__)
+p.add_argument('--build', type=Path)
+a = p.parse_args()
+root = Path(__file__).resolve().parents[3]
+build = (a.build or root / 'build').resolve()
+source = Path(__file__).with_name('test-rtc.c')
+commands = json.loads((build / 'compile_commands.json').read_text())
+c = next(c for c in commands if c['file'].endswith('ipod_touch_pcf50633_pmu.c'))
+old_root = str(Path(c['directory']).parent)
+args = shlex.split(c['command'].replace(old_root, str(root)))
+obj = str(build / 'test-ipod-rtc.o')
+args[args.index('-c') + 1] = str(source)
+args[args.index('-o') + 1] = obj
+args[args.index('-MF') + 1] = obj + '.d'
+args += ['-fsanitize=address,undefined', '-fno-omit-frame-pointer']
+subprocess.run(args, cwd=build, check=True)
+links = json.loads(subprocess.check_output(
+    ['ninja', '-C', str(build), '-t', 'compdb', '-x', 'c_LINKER_RSP', 'c_LINKER'], text=True))
+link = next(c for c in links if c.get('output') == 'qemu-system-arm')
+args = shlex.split(link['command'].replace(old_root, str(root)))
+args = [x for x in args if x not in (
+    'qemu-system-arm.p/system_main.c.o',
+    'libqemu-arm-softmmu.fa.p/hw_arm_ipod_touch_pcf50633_pmu.c.o')]
+out = str(build / 'test-ipod-rtc')
+args[args.index('-o') + 1] = out
+args += [obj, '-fsanitize=address,undefined']
+subprocess.run(args, cwd=build, check=True)
+# QEMU conserve volontairement ses registres de types et sa boucle globale à la sortie.
+env = dict(os.environ, ASAN_OPTIONS='detect_leaks=0', UBSAN_OPTIONS='halt_on_error=1')
+subprocess.run([out], env=env, check=True)
@@ -0,0 +1,200 @@
+/* Régressions du protocole tactile : commandes invalides et trames concurrentes. */
+#include "qemu/osdep.h"
+#include "qemu/main-loop.h"
+#include "sysemu/cpus.h"
+#include "hw/arm/ipod_touch_multitouch.c"
+#include "hw/arm/ipod_touch_gpio.c"
+#include "hw/arm/ipod_touch_sysic.c"
+#include "hw/arm/ipod_touch_spi.c"
+
+static IPodTouchMultitouchState *new_sensor(void)
+{
+    IPodTouchMultitouchState *s = IPOD_TOUCH_MULTITOUCH(
+        object_new(TYPE_IPOD_TOUCH_MULTITOUCH));
+    ipod_touch_multitouch_realize(SSI_PERIPHERAL(s), &error_abort);
+    return s;
+}
+
+static void destroy_sensor(IPodTouchMultitouchState *s)
+{
+    finish_transfer(s);
+    timer_free(s->touch_timer);
+    timer_free(s->touch_end_timer);
+    g_free(s->next_frame);
+    g_free(s->read_frame);
+    object_unref(OBJECT(s));
+}
+
+static uint8_t transfer(IPodTouchMultitouchState *s, uint8_t byte)
+{
+    return ipod_touch_multitouch_transfer(SSI_PERIPHERAL(s), byte);
+}
+
+static void test_unknown(void)
+{
+    IPodTouchMultitouchState *s = new_sensor();
+    for (int i = 0; i < 10000; i++) {
+        g_assert_cmpuint(transfer(s, 0xab), ==, 0xff);
+        g_assert_cmpuint(s->cur_cmd, ==, 0);
+        g_assert_null(s->in_buffer);
+    }
+    uint8_t out[16];
+    out[0] = transfer(s, MT_CMD_GET_INTERFACE_VERSION);
+    for (int i = 1; i < 16; i++) out[i] = transfer(s, 0);
+    g_assert_cmpuint(out[2], ==, MT_INTERFACE_VERSION);
+    destroy_sensor(s);
+}
+
+static void test_snapshot(void)
+{
+    IPodTouchMultitouchState *s = new_sensor();
+    MTFrame expected = *s->next_frame;
+    uint8_t out[sizeof(MTFrame)];
+    out[0] = transfer(s, MT_CMD_FRAME_READ);
+    for (int i = 1; i < 16; i++) out[i] = transfer(s, 0);
+    g_free(s->next_frame);
+    s->next_frame = get_frame(s, MT_EVENT_TOUCH_START, .4, .6,
+                             100, 660, 580, 150);
+    g_assert_cmpuint(s->cur_cmd, ==, 0);
+    out[16] = transfer(s, 0xeb);
+    out[17] = transfer(s, 0);
+    out[18] = transfer(s, 1);
+    for (size_t i = 19; i < sizeof out; i++) out[i] = transfer(s, 0);
+    expected.frame_packet.unused1 = expected.frame_length.length1;
+    expected.frame_packet.checksum_pad = -(expected.frame_packet.cmd +
+        expected.frame_packet.unused1 + expected.frame_packet.length1 +
+        expected.frame_packet.length2);
+    g_assert_cmpmem(out, sizeof out, &expected, sizeof expected);
+    g_assert_cmpuint(s->next_frame->finger_data.event, ==, MT_EVENT_TOUCH_START);
+    destroy_sensor(s);
+}
+
+static void test_reports(void)
+{
+    IPodTouchMultitouchState *s = new_sensor();
+    uint8_t out[16];
+    for (int cmd = MT_CMD_GET_REPORT_INFO; cmd <= MT_CMD_SHORT_CONTROL_READ; cmd += 3) {
+        out[0] = transfer(s, cmd);
+        out[1] = transfer(s, 0xff);
+        for (int i = 2; i < 16; i++) out[i] = transfer(s, 0);
+        g_assert_cmpuint(out[2], ==, 1);
+        unsigned sum = 0;
+        for (int i = 0; i < 14; i++) sum += out[i];
+        g_assert_cmpuint(lduw_le_p(out + 14), ==, sum);
+    }
+    transfer(s, MT_CMD_SHORT_CONTROL_READ);
+    transfer(s, MT_REPORT_SENSOR_DIMENSIONS);
+    for (int i = 2; i < 16; i++) out[i] = transfer(s, 0);
+    g_assert_cmpuint(ldl_le_p(out + 3), ==, 5000);
+    g_assert_cmpuint(ldl_le_p(out + 7), ==, 7500);
+    destroy_sensor(s);
+}
+
+static void test_spi_abort(void)
+{
+    IPodTouchSPIState *spi = IPOD_TOUCH_SPI(object_new(TYPE_IPOD_TOUCH_SPI));
+    DEVICE(spi)->id = g_strdup("spi-test");
+    set_spi_base(4);
+    ipod_touch_spi_realize(DEVICE(spi), &error_abort);
+    ipod_touch_spi_write(spi, R_TXCNT, 2, 4);
+    ipod_touch_spi_write(spi, R_RXCNT, 2, 4);
+    ipod_touch_spi_write(spi, R_TXDATA, MT_CMD_FRAME_READ, 4);
+    ipod_touch_spi_write(spi, R_TXDATA, 2, 4);
+    ipod_touch_spi_write(spi, R_CTRL, R_CTRL_RUN, 4);
+    g_assert_cmpuint(spi->mt->in_buffer_ind, ==, 2);
+    ipod_touch_spi_write(spi, R_CTRL, R_CTRL_TX_RESET | R_CTRL_RX_RESET, 4);
+    g_assert_cmpuint(spi->mt->cur_cmd, ==, 0);
+    g_assert_null(spi->mt->in_buffer);
+    uint8_t response[16];
+    response[0] = transfer(spi->mt, MT_CMD_GET_INTERFACE_VERSION);
+    for (int i = 1; i < 16; i++) response[i] = transfer(spi->mt, 0);
+    g_assert_cmpuint(response[2], ==, MT_INTERFACE_VERSION);
+    timer_free(spi->mt->touch_timer);
+    timer_free(spi->mt->touch_end_timer);
+    g_free(spi->mt->next_frame);
+    fifo8_destroy(&spi->tx_fifo);
+    fifo8_destroy(&spi->rx_fifo);
+    object_unref(OBJECT(spi));
+}
+
+static void test_hbpp(void)
+{
+    IPodTouchMultitouchState *s = new_sensor();
+    uint8_t bad[10] = {MT_CMD_HBPP_DATA_PACKET, 0, 0, 4};
+    for (int i = 0; i < 10; i++) transfer(s, bad[i]);
+    g_assert_cmpuint(s->cur_cmd, ==, 0);
+    uint8_t good[10] = {MT_CMD_HBPP_DATA_PACKET, 0, 0, 4, 0, 0, 0, 0, 0, 4};
+    for (int i = 0; i < 10; i++) transfer(s, good[i]);
+    for (int i = 1; i < 21; i++) transfer(s, 0);
+    g_assert_cmpuint(s->cur_cmd, ==, 0);
+    destroy_sensor(s);
+}
+
+static void test_velocity(void)
+{
+    IPodTouchMultitouchState *s = new_sensor();
+    MTFrame *f = get_frame(s, MT_EVENT_TOUCH_MOVED, .4, .6, 1, 1, 1, 1);
+    g_free(f);
+    f = get_frame(s, MT_EVENT_TOUCH_MOVED, .4, .7, 1, 1, 1, 1);
+    g_assert_cmpint(f->finger_data.velX, ==, 0);
+    g_assert_cmpint(f->finger_data.velY, >, 0);
+    g_free(f);
+    f = get_frame(s, MT_EVENT_TOUCH_MOVED, .4, .7, 1, 1, 1, 1);
+    g_assert_cmpint(f->finger_data.velX, ==, 0);
+    g_assert_cmpint(f->finger_data.velY, ==, 0);
+    g_free(f);
+    destroy_sensor(s);
+}
+
+static void test_buttons(void)
+{
+    IPodTouchGPIOState *s = IPOD_TOUCH_GPIO(object_new(TYPE_IPOD_TOUCH_GPIO));
+    g_assert_cmpuint(GPIO2PAD(GPIO_BUTTON_HOME), <, NUM_GPIO_PADS);
+    gpio_set_on(s->gpio_state, GPIO_BUTTON_HOME);
+    gpio_set_on(s->gpio_state, GPIO_BUTTON_POWER);
+    g_assert_true(gpio_is_on(s->gpio_state, GPIO_BUTTON_HOME));
+    g_assert_true(gpio_is_on(s->gpio_state, GPIO_BUTTON_POWER));
+    gpio_set_off(s->gpio_state, GPIO_BUTTON_HOME);
+    g_assert_true(gpio_is_off(s->gpio_state, GPIO_BUTTON_HOME));
+    g_assert_true(gpio_is_on(s->gpio_state, GPIO_BUTTON_POWER));
+    object_unref(OBJECT(s));
+}
+
+static void test_gpio_ranges(void)
+{
+    IPodTouchSYSICState *s = IPOD_TOUCH_SYSIC(object_new(TYPE_IPOD_TOUCH_SYSIC));
+    uint32_t arrays[4][GPIO_NUMINTGROUPS];
+    s->gpio_int_level[0] = 0x1234;
+    memcpy(arrays[0], s->gpio_int_level, sizeof arrays[0]);
+    memcpy(arrays[1], s->gpio_int_status, sizeof arrays[1]);
+    memcpy(arrays[2], s->gpio_int_enabled, sizeof arrays[2]);
+    memcpy(arrays[3], s->gpio_int_type, sizeof arrays[3]);
+    /* Les quatre trous entre groupes ne doivent pas accéder au tableau suivant. */
+    for (int addr = GPIO_INTLEVEL; addr <= GPIO_INTTYPE; addr += 0x20) {
+        ipod_touch_sysic_write(s, addr + GPIO_NUMINTGROUPS * 4, 0xffffffff, 4);
+        g_assert_cmpuint(ipod_touch_sysic_read(s, addr + GPIO_NUMINTGROUPS * 4, 4), ==, 0);
+    }
+    g_assert_cmpmem(arrays[0], sizeof arrays[0], s->gpio_int_level, sizeof arrays[0]);
+    g_assert_cmpmem(arrays[1], sizeof arrays[1], s->gpio_int_status, sizeof arrays[1]);
+    g_assert_cmpmem(arrays[2], sizeof arrays[2], s->gpio_int_enabled, sizeof arrays[2]);
+    g_assert_cmpmem(arrays[3], sizeof arrays[3], s->gpio_int_type, sizeof arrays[3]);
+    object_unref(OBJECT(s));
+}
+
+int main(int argc, char **argv)
+{
+    g_test_init(&argc, &argv, NULL);
+    module_call_init(MODULE_INIT_QOM);
+    qemu_init_main_loop(&error_abort);
+    qemu_init_cpu_loop();
+    qemu_mutex_lock_iothread();
+    g_test_add_func("/ipod-multitouch/unknown", test_unknown);
+    g_test_add_func("/ipod-multitouch/snapshot", test_snapshot);
+    g_test_add_func("/ipod-multitouch/hbpp", test_hbpp);
+    g_test_add_func("/ipod-multitouch/spi-abort", test_spi_abort);
+    g_test_add_func("/ipod-multitouch/reports", test_reports);
+    g_test_add_func("/ipod-multitouch/velocity", test_velocity);
+    g_test_add_func("/ipod-input/buttons", test_buttons);
+    g_test_add_func("/ipod-input/gpio-ranges", test_gpio_ranges);
+    return g_test_run();
+}
@@ -0,0 +1,155 @@
+/* Régressions du D1759 sur le bus I²C réel de QEMU. */
+#include "qemu/osdep.h"
+#include "qemu/main-loop.h"
+#include "qemu/option.h"
+#include "sysemu/cpus.h"
+#include "hw/arm/ipod_touch_pcf50633_pmu.c"
+
+static QemuOptsList rtc_test_opts = {
+    .name = "rtc-test",
+    .head = QTAILQ_HEAD_INITIALIZER(rtc_test_opts.head),
+    .desc = {
+        { .name = "base", .type = QEMU_OPT_STRING },
+        { .name = "clock", .type = QEMU_OPT_STRING },
+        { }
+    }
+};
+
+static I2CBus *bus;
+static Pcf50633State *pmu;
+static DeviceState *parent;
+
+static void setup(const char *base, const char *clock)
+{
+    QemuOpts *opts = qemu_opts_create(&rtc_test_opts, NULL, 0, &error_abort);
+    qemu_opt_set(opts, "base", base, &error_abort);
+    qemu_opt_set(opts, "clock", clock, &error_abort);
+    configure_rtc(opts);
+    qemu_opts_del(opts);
+    parent = qdev_new(TYPE_PCF50633);
+    bus = i2c_init_bus(parent, "rtc-test");
+    pmu = PCF50633(i2c_slave_create_simple(bus, TYPE_D1759, 0x73));
+}
+
+static void teardown(void)
+{
+    qdev_unrealize(DEVICE(pmu));
+    object_unref(OBJECT(parent));
+}
+
+static void select_register(uint8_t reg, bool stop)
+{
+    g_assert_cmpint(i2c_start_transfer(bus, 0x73, false), ==, 0);
+    g_assert_cmpint(i2c_send(bus, reg), ==, 0);
+    if (stop) {
+        i2c_end_transfer(bus);
+    }
+    g_assert_cmpint(i2c_start_transfer(bus, 0x73, true), ==, 0);
+}
+
+static uint32_t read_word(uint8_t reg, bool stop)
+{
+    uint32_t value = 0;
+    select_register(reg, stop);
+    for (int i = 0; i < 4; i++) {
+        value |= (uint32_t)i2c_recv(bus) << (i * 8);
+    }
+    i2c_end_transfer(bus);
+    return value;
+}
+
+static void write_word(uint8_t reg, uint32_t value)
+{
+    g_assert_cmpint(i2c_start_transfer(bus, 0x73, false), ==, 0);
+    g_assert_cmpint(i2c_send(bus, reg), ==, 0);
+    for (int i = 0; i < 4; i++) {
+        g_assert_cmpint(i2c_send(bus, value >> (i * 8)), ==, 0);
+    }
+    i2c_end_transfer(bus);
+}
+
+static void test_host_utc(void)
+{
+    time_t before = time(NULL);
+    /* Le fuseau de l'hôte ne doit pas décaler le compteur Unix. */
+    setenv("TZ", "Pacific/Honolulu", 1);
+    tzset();
+    setup("utc", "host");
+    uint32_t value = read_word(0x5c, false);
+    g_assert_cmpuint(value, >=, before);
+    g_assert_cmpuint(value, <=, time(NULL));
+    g_assert_cmpuint(read_word(0x64, true), ==, 0);
+    teardown();
+    unsetenv("TZ");
+    tzset();
+}
+
+static void test_fixed_base(void)
+{
+    setup("2024-02-29T23:59:59", "vm");
+    g_assert_cmpint(rtc_clock, ==, QEMU_CLOCK_VIRTUAL);
+    g_assert_cmpuint(read_word(0x5c, true), ==, 1709251199);
+    g_assert_cmpuint(read_word(0x5c, false), ==, 1709251199);
+    teardown();
+}
+
+static void test_snapshot_rollover(void)
+{
+    setup("2024-02-29T23:59:59", "vm");
+    uint32_t boundaries[] = { 1709251199, 0x00ffffff, 0xffffffff };
+    for (size_t n = 0; n < G_N_ELEMENTS(boundaries); n++) {
+        pmu->rtc_tick_offset = boundaries[n];
+        select_register(0x5c, false);
+        uint32_t value = i2c_recv(bus);
+        /* Le temps change entre deux octets, après capture du premier. */
+        pmu->rtc_tick_offset++;
+        for (int i = 1; i < 4; i++) {
+            value |= (uint32_t)i2c_recv(bus) << (8 * i);
+        }
+        i2c_end_transfer(bus);
+        g_assert_cmpuint(value, ==, boundaries[n]);
+        g_assert_cmpuint(read_word(0x5c, true), ==, boundaries[n] + 1);
+    }
+    teardown();
+}
+
+static void test_offsets(void)
+{
+    setup("2024-02-29T23:59:59", "vm");
+    uint32_t counter = read_word(0x5c, true);
+    uint32_t offsets[] = { 3600, (uint32_t)-86400, 0x12345678, 0 };
+    for (size_t i = 0; i < G_N_ELEMENTS(offsets); i++) {
+        write_word(0x64, offsets[i]);
+        g_assert_cmpuint(read_word(0x64, false), ==, offsets[i]);
+        g_assert_cmpuint(read_word(0x5c, true), ==, counter);
+    }
+    /* Un changement de date ne doit pas réécrire le compteur matériel. */
+    write_word(0x5c, 1234);
+    g_assert_cmpuint(read_word(0x5c, false), ==, counter);
+    teardown();
+}
+
+static void test_boot_registers(void)
+{
+    setup("2024-02-29T23:59:59", "vm");
+    write_word(0x60, 0xffffffff);
+    g_assert_cmpuint(read_word(0x60, true), ==, 0);
+    g_assert_cmpuint(read_word(0x5c, false), ==, 1709251199);
+    g_assert_cmpuint(read_word(0x64, true), ==, 0);
+    teardown();
+}
+
+int main(int argc, char **argv)
+{
+    g_test_init(&argc, &argv, NULL);
+    module_call_init(MODULE_INIT_QOM);
+    qemu_init_main_loop(&error_abort);
+    qemu_init_cpu_loop();
+    qemu_mutex_lock_iothread();
+    g_test_add_func("/ipod-rtc/host-utc", test_host_utc);
+    g_test_add_func("/ipod-rtc/fixed-base", test_fixed_base);
+    g_test_add_func("/ipod-rtc/snapshot-rollover", test_snapshot_rollover);
+    g_test_add_func("/ipod-rtc/offsets", test_offsets);
+    g_test_add_func("/ipod-rtc/boot-registers", test_boot_registers);
+    return g_test_run();
+}
@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""Teste les transferts réels de l'agent sur socket local, sans firmware Apple."""
+import importlib.util
+from importlib.machinery import SourceFileLoader
+import io
+import os
+from pathlib import Path
+import socket
+import subprocess
+import tempfile
+import threading
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+loader = SourceFileLoader('ipod_agent', str(ROOT / 'bin/ipod-agent'))
+spec = importlib.util.spec_from_loader(loader.name, loader)
+client = importlib.util.module_from_spec(spec)
+loader.exec_module(client)
+
+
+class Transfers(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.work = tempfile.TemporaryDirectory()
+        cls.binary = Path(cls.work.name) / 'transfer-agent'
+        source = (ROOT / 'agent/emuagent.c').read_text()
+        # Compile les fonctions de production, sans dépendances privées d'iOS.
+        functions = source[source.index('static int send_all('):source.index('/* tampon dynamique */')]
+        functions += source[source.index('static int read_full('):source.index('static void cmd_ls(')]
+        harness = '''#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <unistd.h>
+static void mkdirs(const char *path) { (void)path; }
+''' + functions + '''
+int main(int argc, char **argv) {
+    if (argc < 4) return 2;
+    int fd = atoi(argv[1]);
+    if (!strcmp(argv[2], "get")) cmd_get(fd, argv+3, argc-3);
+    else cmd_put(fd, argv+3, argc-3);
+    char ignored[256]; read(fd, ignored, sizeof ignored);
+    close(fd); return 0;
+}
+'''
+        c = Path(cls.work.name) / 'transfer-agent.c'
+        c.write_text(harness)
+        subprocess.run(['cc', '-Wall', '-Wextra', '-Werror', '-fsanitize=undefined',
+                        '-o', str(cls.binary), str(c)], check=True)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.work.cleanup()
+
+    def agent(self, command, *args):
+        a, b = socket.socketpair()
+        process = subprocess.Popen([str(self.binary), str(b.fileno()), command, *map(str, args)],
+                                   pass_fds=(b.fileno(),), env=dict(os.environ, UBSAN_OPTIONS='halt_on_error=1'))
+        b.close()
+        agent = client.Agent.__new__(client.Agent)
+        agent.s, agent.f = a, a.makefile('rb')
+        self.addCleanup(agent.f.close)
+        self.addCleanup(a.close)
+        self.addCleanup(lambda: self.assertEqual(process.wait(timeout=5), 0))
+        return agent
+
+    def test_large_round_trip(self):
+        data = os.urandom(8 * 1024 * 1024 + 37)
+        with tempfile.TemporaryDirectory() as d:
+            path = Path(d) / 'file'
+            a = self.agent('put', path, '640', len(data))
+            # Le harness reçoit les arguments hors bande, puis le contenu du protocole.
+            a.s.sendall(data)
+            ok, _, _ = a.call()  # ligne vide ignorée par ce harness
+            self.assertTrue(ok)
+            self.assertEqual(path.read_bytes(), data)
+            self.assertEqual(path.stat().st_mode & 0o777, 0o640)
+            a = self.agent('get', path)
+            with (Path(d) / 'download').open('wb') as out:
+                ok, _, _ = a.call(sink=out)
+            self.assertTrue(ok)
+            self.assertEqual((Path(d) / 'download').read_bytes(), data)
+
+    def test_interrupted_put_preserves_existing_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = Path(d) / 'file'
+            path.write_bytes(b'ancienne version')
+            a = self.agent('put', path, '644', 100000)
+            a.s.sendall(b'court')
+            a.s.shutdown(socket.SHUT_WR)
+            response = a.f.read()
+            self.assertTrue(response.startswith(b'ERR '))
+            self.assertEqual(path.read_bytes(), b'ancienne version')
+            self.assertEqual(list(Path(d).iterdir()), [path])
+
+    def test_empty_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = Path(d) / 'empty'
+            a = self.agent('put', path, '644', 0)
+            self.assertTrue(a.call()[0])
+            self.assertEqual(path.read_bytes(), b'')
+            self.assertEqual(self.agent('get', path).call()[1], b'')
+
+    def test_download_failure_preserves_destination(self):
+        listener = socket.socket()
+        listener.bind(('127.0.0.1', 0)); listener.listen()
+        def server():
+            connection, _ = listener.accept()
+            connection.recv(1024)
+            connection.sendall(b'OK 100\npartiel')
+            connection.close()
+        thread = threading.Thread(target=server); thread.start()
+        try:
+            with tempfile.TemporaryDirectory() as d:
+                destination = Path(d) / 'download'
+                destination.write_bytes(b'original')
+                r = subprocess.run([str(ROOT / 'bin/ipod-agent'), 'get', '/file', str(destination)],
+                                   env=dict(os.environ, IPOD_AGENT_PORT=str(listener.getsockname()[1]),
+                                            IPOD_AGENT_HOST='127.0.0.1'), capture_output=True)
+                self.assertEqual(r.returncode, 1)
+                self.assertIn('tronquée', r.stderr.decode())
+                self.assertEqual(destination.read_bytes(), b'original')
+                self.assertEqual(list(Path(d).iterdir()), [destination])
+        finally:
+            thread.join(); listener.close()
+
+    def test_upload_respects_announced_size(self):
+        a, b = socket.socketpair()
+        agent = client.Agent.__new__(client.Agent)
+        agent.s, agent.f = a, a.makefile('rb')
+        received = []
+        def server():
+            f = b.makefile('rb')
+            received.append(f.readline())
+            received.append(f.read(3))
+            b.sendall(b'OK 0\n')
+            f.close(); b.close()
+        thread = threading.Thread(target=server); thread.start()
+        try:
+            data = io.BytesIO(b'abcEXTRA')
+            self.assertTrue(agent.call('put', '/file', '644', 3, data=data)[0])
+            self.assertEqual(data.tell(), 3)
+            self.assertEqual(received, [b'put\t/file\t644\t3\n', b'abc'])
+        finally:
+            agent.f.close(); a.close(); thread.join()
+
+    def test_get_rejects_fifo_without_blocking(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = Path(d) / 'fifo'
+            os.mkfifo(path)
+            self.assertFalse(self.agent('get', path).call()[0])
+
+    def test_fragmented_and_truncated_reply(self):
+        for truncated in (False, True):
+            a, b = socket.socketpair()
+            agent = client.Agent.__new__(client.Agent)
+            agent.s, agent.f = a, a.makefile('rb')
+            def server():
+                b.recv(100)
+                for part in (b'OK ', b'10\n', b'123', b'4567', b'890' if not truncated else b''):
+                    b.sendall(part)
+                b.close()
+            thread = threading.Thread(target=server)
+            thread.start()
+            try:
+                if truncated:
+                    with self.assertRaisesRegex(ConnectionError, 'tronquée'):
+                        agent.call('get', '/test')
+                else:
+                    self.assertEqual(agent.call('get', '/test')[1], b'1234567890')
+            finally:
+                agent.f.close(); a.close(); thread.join()
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -328,7 +328,7 @@ static void ipod_touch_machine_init(MachineState *machine)
    nms->sysic = (IPodTouchSYSICState *) g_malloc0(sizeof(struct IPodTouchSYSICState));
    memory_region_add_subregion(sysmem, SYSIC_MEM_BASE, &sysic_state->iomem);
    busdev = SYS_BUS_DEVICE(dev);
-    for(int grp = 0; grp < GPIO_NUMINTGROUPS; grp++) {
+    for (int grp = 0; grp < G_N_ELEMENTS(S5L8900_GPIO_IRQS); grp++) {
        sysbus_connect_irq(busdev, grp, s5l8900_get_irq(nms, S5L8900_GPIO_IRQS[grp]));
    }

@@ -461,7 +461,7 @@ static void ipod_touch_machine_init(MachineState *machine)
    sysbus_connect_irq(busdev, 0, s5l8900_get_irq(nms, S5L8720_I2C0_IRQ));

    // init the PMU
-    I2CSlave * pmu = i2c_slave_create_simple(i2c_state->bus, "pcf50633", 0x73);
+    I2CSlave * pmu = i2c_slave_create_simple(i2c_state->bus, "d1759", 0x73);

    // init the accelerometer
    I2CSlave *accelerometer = i2c_slave_create_simple(i2c_state->bus, "lis302dl", 0x1D);
@@ -159,8 +159,6 @@ static void ipod_touch_lcd_mouse_event(void *opaque, int x, int y, int z, int bu
    float fy = 1 - y / pow(2, 15);

    IPodTouchLCDState *lcd = (IPodTouchLCDState *) opaque;
-    lcd->mt->prev_touch_x = lcd->mt->touch_x;
-    lcd->mt->prev_touch_y = lcd->mt->touch_y;
    lcd->mt->touch_x = fx;
    lcd->mt->touch_y = fy;

@@ -1,4 +1,6 @@
 #include "hw/arm/ipod_touch_multitouch.h"
+#include "qemu/log.h"
+#include "qemu/bswap.h"

 static void prepare_interface_version_response(IPodTouchMultitouchState *s) {
    memset(s->out_buffer + 1, 0, 15);
@@ -62,7 +64,9 @@ static void prepare_report_info_response(IPodTouchMultitouchState *s, uint8_t re
        report_length = MT_REPORT_SENSOR_DIMENSIONS_SIZE;
    }
    else {
-        hw_error("Unknown report ID 0x%02x\n", report_id);
+        qemu_log_mask(LOG_GUEST_ERROR, "%s: rapport inconnu 0x%02x\n",
+                      __func__, report_id);
+        s->out_buffer[2] = 1;
    }

    s->out_buffer[3] = (report_length & 0xFF);
@@ -98,12 +102,13 @@ static void prepare_short_control_response(IPodTouchMultitouchState *s, uint8_t
        s->out_buffer[3] = MT_SENSOR_REGION_PARAM;
    }
    else if(report_id == MT_REPORT_SENSOR_DIMENSIONS) {
-        uint32_t *ob_int32 = (uint32_t *)&s->out_buffer[3];
-        ob_int32[0] = MT_SENSOR_SURFACE_WIDTH;
-        ob_int32[1] = MT_SENSOR_SURFACE_HEIGHT;
+        stl_le_p(&s->out_buffer[3], MT_SENSOR_SURFACE_WIDTH);
+        stl_le_p(&s->out_buffer[7], MT_SENSOR_SURFACE_HEIGHT);
    }
    else {
-        hw_error("Unknown report ID 0x%02x\n", report_id);
+        qemu_log_mask(LOG_GUEST_ERROR, "%s: rapport inconnu 0x%02x\n",
+                      __func__, report_id);
+        s->out_buffer[2] = 1;
    }

    // compute and set the checksum
@@ -116,6 +121,19 @@ static void prepare_short_control_response(IPodTouchMultitouchState *s, uint8_t
    s->out_buffer[15] = (checksum >> 8) & 0xFF;
 }

+static MTFrame *get_frame(IPodTouchMultitouchState *s, uint8_t event,
+                          float x, float y, uint16_t radius1, uint16_t radius2,
+                          uint16_t radius3, uint16_t contactDensity);
+
+static void finish_transfer(IPodTouchMultitouchState *s)
+{
+    g_clear_pointer(&s->in_buffer, g_free);
+    g_clear_pointer(&s->out_buffer, g_free);
+    s->cur_cmd = 0;
+    s->buf_size = s->buf_ind = s->in_buffer_ind = 0;
+    s->in_buffer_capacity = 0;
+}
+
 static uint32_t ipod_touch_multitouch_transfer(SSIPeripheral *dev, uint32_t value)
 {
    IPodTouchMultitouchState *s = IPOD_TOUCH_MULTITOUCH(dev);
@@ -126,10 +144,11 @@ static uint32_t ipod_touch_multitouch_transfer(SSIPeripheral *dev, uint32_t valu
        //printf("Starting command 0x%02x\n", value);
        // we're currently not in a command - start a new command
        s->cur_cmd = value;
-        s->out_buffer = malloc(0x100);
+        s->out_buffer = g_malloc0(0x100);
        s->out_buffer[0] = value; // the response header
        s->buf_ind = 0;
-        s->in_buffer = malloc(0x100);
+        s->in_buffer = g_malloc0(0x100);
+        s->in_buffer_capacity = 0x100;
        s->in_buffer_ind = 0;
        
        if(value == 0x18) { // filler packet??
@@ -193,20 +212,56 @@ static uint32_t ipod_touch_multitouch_transfer(SSIPeripheral *dev, uint32_t valu
        else if(value == MT_CMD_SHORT_CONTROL_READ) {
            s->buf_size = 16;
        }
-        else if(value == MT_CMD_FRAME_READ) {
-            s->buf_size = sizeof(MTFrame);
-            free(s->out_buffer);
-            s->out_buffer = (uint8_t *) s->next_frame;
+        else if(value == MT_CMD_FRAME_READ || value == MT_CMD_FRAME_READ_ALT) {
+            s->buf_size = sizeof(MTFrameLengthPacket);
+            g_free(s->out_buffer);
+            /* La trame doit rester stable entre sa longueur et ses données,
+               même si un événement hôte arrive pendant les lectures SPI. */
+            s->out_buffer = g_memdup2(s->read_frame ? s->read_frame : s->next_frame,
+                                        sizeof(MTFrame));
        }
        else {
-            printf("%s Unknown command 0x%02x!\n", __func__, value);
+            qemu_log_mask(LOG_GUEST_ERROR, "%s: commande inconnue 0x%02x\n",
+                          __func__, value);
+            finish_transfer(s);
+            return 0xff;
        }
    }

+    if (s->buf_ind >= s->buf_size || s->in_buffer_ind >= s->in_buffer_capacity) {
+        finish_transfer(s);
+        return 0xff;
+    }
    s->in_buffer[s->in_buffer_ind] = value;
    s->in_buffer_ind++;

-    if(s->cur_cmd == MT_CMD_HBPP_DATA_PACKET && s->in_buffer_ind == 10) {
+    if ((s->cur_cmd == MT_CMD_FRAME_READ || s->cur_cmd == MT_CMD_FRAME_READ_ALT) &&
+        s->in_buffer_ind == 3) {
+        /* Le troisième octet distingue longueur (0) et données (1).
+           Chaque requête est une transaction complète : une lecture de
+           longueur abandonnée pendant la veille ne décale pas la suivante. */
+        if (value == 1) {
+            MTFrame *frame = (MTFrame *)s->out_buffer;
+            /* Le deuxième octet est déjà émis avant de connaître le sélecteur.
+               Il est ignoré dans les données, mais participe au checksum. */
+            uint8_t second = s->out_buffer[1];
+            frame->frame_packet.unused1 = second;
+            frame->frame_packet.checksum_pad = -(frame->frame_packet.cmd +
+                second + frame->frame_packet.length1 + frame->frame_packet.length2);
+            memmove(s->out_buffer, &frame->frame_packet,
+                    sizeof(MTFrame) - sizeof(MTFrameLengthPacket));
+            s->buf_size = sizeof(MTFrame) - sizeof(MTFrameLengthPacket);
+            g_clear_pointer(&s->read_frame, g_free);
+        } else if (value == 0) {
+            g_free(s->read_frame);
+            s->read_frame = g_memdup2(s->next_frame, sizeof(MTFrame));
+            memcpy(s->out_buffer, s->read_frame, sizeof(MTFrame));
+        } else {
+            finish_transfer(s);
+            return 0xff;
+        }
+    }
+    else if(s->cur_cmd == MT_CMD_HBPP_DATA_PACKET && s->in_buffer_ind == 10) {
        // verify the header checksum
        uint32_t checksum = 0;
        for(int i = 2; i < 8; i++) {
@@ -214,17 +269,22 @@ static uint32_t ipod_touch_multitouch_transfer(SSIPeripheral *dev, uint32_t valu
        }

        if(checksum != (s->in_buffer[8] << 8 | s->in_buffer[9])) {
-            hw_error("HBPP data header checksum doesn't match!");
+            qemu_log_mask(LOG_GUEST_ERROR, "%s: somme de contrôle HBPP invalide\n",
+                          __func__);
+            finish_transfer(s);
+            return 0xff;
        }

-        uint32_t data_len = (s->in_buffer[2] << 10) | (s->in_buffer[3] << 2) + 5;
-        // extend the lengths of the in/out buffers
-        free(s->in_buffer);
-        s->in_buffer = malloc(data_len + 0x10);
-
-        free(s->out_buffer);
-        s->out_buffer = malloc(data_len);
-        memset(s->out_buffer, 0, data_len);
+        uint32_t data_len = ((s->in_buffer[2] << 10) | (s->in_buffer[3] << 2)) + 5;
+        if (data_len < s->in_buffer_ind) {
+            finish_transfer(s);
+            return 0xff;
+        }
+        /* Conserver l'en-tête reçu et dimensionner aussi les petites trames. */
+        s->in_buffer_capacity = MAX(data_len + 10, 0x100);
+        s->in_buffer = g_realloc(s->in_buffer, s->in_buffer_capacity);
+        g_free(s->out_buffer);
+        s->out_buffer = g_malloc0(data_len);
        s->buf_size = data_len;
        s->buf_ind = 0;
    }
@@ -255,17 +315,14 @@ static uint32_t ipod_touch_multitouch_transfer(SSIPeripheral *dev, uint32_t valu
        }

        // we're done with the command
-        s->cur_cmd = 0;
-        s->buf_size = 0;
-        //free(s->out_buffer);
-        //free(s->in_buffer);
+        finish_transfer(s);
    }

    return ret_val;
 }

 static MTFrame *get_frame(IPodTouchMultitouchState *s, uint8_t event, float x, float y, uint16_t radius1, uint16_t radius2, uint16_t radius3, uint16_t contactDensity) {
-    MTFrame *frame = calloc(sizeof(MTFrame), sizeof(uint8_t *));
+    MTFrame *frame = g_new0(MTFrame, 1);

    uint16_t data_len = sizeof(MTFrameHeader) + sizeof(FingerData) + 2;

@@ -310,12 +367,17 @@ static MTFrame *get_frame(IPodTouchMultitouchState *s, uint8_t event, float x, f

    // compute the velocity
    int diff_x = (int)((x - s->prev_touch_x) * MT_INTERNAL_SENSOR_SURFACE_WIDTH);
-    int diff_y = (int)((x - s->prev_touch_y) * MT_INTERNAL_SENSOR_SURFACE_HEIGHT);
-    frame->finger_data.velX = diff_x / (elapsed_ns + 1 - s->last_frame_timestamp) * 1000;
-    frame->finger_data.velY = diff_y / (elapsed_ns + 1 - s->last_frame_timestamp) * 1000;
+    int diff_y = (int)((y - s->prev_touch_y) * MT_INTERNAL_SENSOR_SURFACE_HEIGHT);
+    uint64_t dt = MAX(elapsed_ns - s->last_frame_timestamp, 1);
+    frame->finger_data.velX = CLAMP((int64_t)diff_x * 1000 / (int64_t)dt,
+                                  INT16_MIN, INT16_MAX);
+    frame->finger_data.velY = CLAMP((int64_t)diff_y * 1000 / (int64_t)dt,
+                                  INT16_MIN, INT16_MAX);
+    s->prev_touch_x = x;
+    s->prev_touch_y = y;

-    frame->finger_data.x = (int)(x * MT_INTERNAL_SENSOR_SURFACE_WIDTH);
-    frame->finger_data.y = (int)(y * MT_INTERNAL_SENSOR_SURFACE_HEIGHT);
+    frame->finger_data.x = (int)(x * MT_INTERNAL_SENSOR_SURFACE_WIDTH) + MT_INTERNAL_SENSOR_ORIGIN_X;
+    frame->finger_data.y = (int)(y * MT_INTERNAL_SENSOR_SURFACE_HEIGHT) + MT_INTERNAL_SENSOR_ORIGIN_Y;
    frame->finger_data.radius1 = radius1;
    frame->finger_data.radius2 = radius2;
    frame->finger_data.radius3 = radius3;
@@ -344,6 +406,7 @@ static void ipod_touch_multitouch_inform_frame_ready(IPodTouchMultitouchState *s
 void ipod_touch_multitouch_on_touch(IPodTouchMultitouchState *s) {
    s->touch_down = true;

+    g_free(s->next_frame);
    s->next_frame = get_frame(s, MT_EVENT_TOUCH_START, s->touch_x, s->touch_y, 100, 660, 580, 150);
    ipod_touch_multitouch_inform_frame_ready(s);

@@ -351,6 +414,7 @@ void ipod_touch_multitouch_on_touch(IPodTouchMultitouchState *s) {
 }

 void ipod_touch_multitouch_on_release(IPodTouchMultitouchState *s) {
+    g_free(s->next_frame);
    s->next_frame = get_frame(s, MT_EVENT_TOUCH_ENDED, s->touch_x, s->touch_y, 0, 0, 0, 0);
    s->touch_down = false;
    ipod_touch_multitouch_inform_frame_ready(s);
@@ -363,6 +427,7 @@ static void touch_timer_tick(void *opaque)
 {
    IPodTouchMultitouchState *s = (IPodTouchMultitouchState *)opaque;

+    g_free(s->next_frame);
    s->next_frame = get_frame(s, MT_EVENT_TOUCH_MOVED, s->touch_x, s->touch_y, 100, 660, 580, 150);
    ipod_touch_multitouch_inform_frame_ready(s);

@@ -375,14 +440,22 @@ static void touch_timer_tick(void *opaque)
 static void touch_end_timer_tick(void *opaque)
 {
    IPodTouchMultitouchState *s = (IPodTouchMultitouchState *)opaque;
+    g_free(s->next_frame);
    s->next_frame = get_frame(s, MT_EVENT_TOUCH_FULL_END, s->touch_x, s->touch_y, 0, 0, 0, 0);
    s->touch_down = false;
    ipod_touch_multitouch_inform_frame_ready(s);
 }

+static void multitouch_cs(void *opaque, int pin, int level)
+{
+    IPodTouchMultitouchState *s = opaque;
+    if (level) finish_transfer(s);
+}
+
 static void ipod_touch_multitouch_realize(SSIPeripheral *d, Error **errp)
 {
    IPodTouchMultitouchState *s = IPOD_TOUCH_MULTITOUCH(d);
+    qdev_init_gpio_in_named(DEVICE(d), multitouch_cs, SSI_GPIO_CS, 1);
    memset(s->hbpp_atn_ack_response, 0, 2);
    s->touch_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, touch_timer_tick, s);
    s->touch_end_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, touch_end_timer_tick, s);
@@ -390,6 +463,8 @@ static void ipod_touch_multitouch_realize(SSIPeripheral *d, Error **errp)
    s->prev_touch_x = 0;
    s->prev_touch_y = 0;
    s->last_frame_timestamp = 0;
+    /* Une lecture sans toucher doit renvoyer une trame de fin valide. */
+    s->next_frame = get_frame(s, MT_EVENT_TOUCH_FULL_END, 0, 0, 0, 0, 0, 0);
 }

 static void ipod_touch_multitouch_class_init(ObjectClass *klass, void *data)
@@ -1,5 +1,8 @@
 #include "hw/arm/ipod_touch_pcf50633_pmu.h"
 #include "hw/arm/ipod_touch_lcd.h"
+#include "qemu/cutils.h"
+#include "sysemu/rtc.h"
+#include "sysemu/sysemu.h"

 static int pcf50633_event(I2CSlave *i2c, enum i2c_event event)
 {
@@ -125,9 +128,108 @@ static const TypeInfo pcf50633_info = {
    .class_init    = pcf50633_class_init,
 };

+/* Le pilote AppleD1759PMURTC lit un compteur LE32 en 0x5c et un
+ * décalage LE32 en 0x64. settimeofday ne réécrit que ce décalage.
+ * Les registres 0x61/0x62 concernent les erreurs de démarrage, pas le RTC.
+ */
+static uint32_t d1759_counter(Pcf50633State *s)
+{
+    return s->rtc_tick_offset +
+        qemu_clock_get_ns(rtc_clock) / NANOSECONDS_PER_SECOND;
+}
+
+static int d1759_event(I2CSlave *i2c, enum i2c_event event)
+{
+    Pcf50633State *s = PCF50633(i2c);
+
+    if (event == I2C_START_SEND || event == I2C_FINISH) {
+        s->ready = 1;
+    } else if (event == I2C_START_RECV) {
+        /* Une lecture multioctet reste cohérente au passage d'une seconde. */
+        s->rtc_snapshot = d1759_counter(s);
+    }
+    return 0;
+}
+
+static uint8_t d1759_recv(I2CSlave *i2c)
+{
+    Pcf50633State *s = PCF50633(i2c);
+    uint8_t reg = s->curreg++;
+
+    if (reg >= 0x5c && reg <= 0x5f) {
+        return s->rtc_snapshot >> ((reg - 0x5c) * 8);
+    }
+    if (reg >= 0x64 && reg <= 0x67) {
+        return s->rtc_unix_offset[reg - 0x64];
+    }
+    if (reg >= 0x50 && reg <= 0x5a) {
+        return s->rtc_alarm[reg - 0x50];
+    }
+    switch (reg) {
+    case 0x02: /* Conversion ADC terminée. */
+        return 2;
+    case PMU_MBCS1:
+        return 1;
+    case 0x69:
+    case 0x76:
+    default:
+        return 0;
+    }
+}
+
+static int d1759_send(I2CSlave *i2c, uint8_t data)
+{
+    Pcf50633State *s = PCF50633(i2c);
+    uint8_t reg;
+
+    if (s->ready) {
+        s->curreg = data;
+        s->ready = 0;
+        return 0;
+    }
+    reg = s->curreg++;
+    if (reg >= 0x64 && reg <= 0x67) {
+        s->rtc_unix_offset[reg - 0x64] = data;
+    } else if (reg >= 0x50 && reg <= 0x5a) {
+        /* Conservation des réglages d'alarme ; IRQ RTC non émulée. */
+        s->rtc_alarm[reg - 0x50] = data;
+    } else if (reg == PMU_DSBL1) {
+        lcd_changebrightness(data);
+    }
+    return 0;
+}
+
+static void d1759_init(Object *obj)
+{
+    Pcf50633State *s = PCF50633(obj);
+    struct tm tm;
+
+    qemu_get_timedate(&tm, 0);
+    s->rtc_tick_offset = mktimegm(&tm) -
+        qemu_clock_get_ns(rtc_clock) / NANOSECONDS_PER_SECOND;
+    s->ready = 1;
+}
+
+static void d1759_class_init(ObjectClass *klass, void *data)
+{
+    I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
+
+    k->event = d1759_event;
+    k->recv = d1759_recv;
+    k->send = d1759_send;
+}
+
+static const TypeInfo d1759_info = {
+    .name = TYPE_D1759,
+    .parent = TYPE_PCF50633,
+    .instance_init = d1759_init,
+    .class_init = d1759_class_init,
+};
+
 static void pcf50633_register_types(void)
 {
    type_register_static(&pcf50633_info);
+    type_register_static(&d1759_info);
 }

 type_init(pcf50633_register_types)
@@ -64,8 +64,11 @@ static void apple_spi_update_cs(IPodTouchSPIState *s)
    BusState *b = BUS(s->spi);
    BusChild *kid = QTAILQ_FIRST(&b->children);
    if (kid) {
-        // TODO GPIO not properly setup yet
-        //qemu_set_irq(qdev_get_gpio_in_named(kid->child, SSI_GPIO_CS, 0), (REG(s, R_PIN) & R_PIN_CS) != 0);
+        if (object_dynamic_cast(OBJECT(kid->child), TYPE_IPOD_TOUCH_MULTITOUCH)) {
+            qemu_set_irq(qdev_get_gpio_in_named(kid->child, SSI_GPIO_CS, 0),
+                         (REG(s, R_PIN) & R_PIN_CS) != 0);
+        }
+        /* La sélection de la NOR conserve son comportement historique. */
    }
 }

@@ -197,6 +200,11 @@ static void ipod_touch_spi_write(void *opaque, hwaddr addr, uint64_t data, unsig
    case R_CTRL:
        if (r & R_CTRL_TX_RESET) {
            fifo8_reset(&s->tx_fifo);
+            /* Le pilote interrompt aussi les commandes au retour de veille.
+               Ne pas réutiliser les octets d'une transaction abandonnée. */
+            if (s->mt) {
+                qemu_set_irq(qdev_get_gpio_in_named(DEVICE(s->mt), SSI_GPIO_CS, 0), 1);
+            }
        }
        if (r & R_CTRL_RX_RESET) {
            fifo8_reset(&s->rx_fifo);
@@ -15,22 +15,22 @@ static uint64_t ipod_touch_sysic_read(void *opaque, hwaddr addr, unsigned size)
        case 0x7a:
        case 0x7c:
            return 1;
-        case GPIO_INTLEVEL ... (GPIO_INTLEVEL + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTLEVEL ... (GPIO_INTLEVEL + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTLEVEL) / 4;
            return s->gpio_int_level[group];
        }
-        case GPIO_INTSTAT ... (GPIO_INTSTAT + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTSTAT ... (GPIO_INTSTAT + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTSTAT) / 4;
            return s->gpio_int_status[group];
        }
-        case GPIO_INTEN ... (GPIO_INTEN + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTEN ... (GPIO_INTEN + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTEN) / 4;
            return s->gpio_int_enabled[group];
        }
-        case GPIO_INTTYPE ... (GPIO_INTTYPE + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTTYPE ... (GPIO_INTTYPE + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTTYPE) / 4;
            return s->gpio_int_type[group];
@@ -58,11 +58,11 @@ static void ipod_touch_sysic_write(void *opaque, hwaddr addr, uint64_t val, unsi
        case POWER_OFFCTRL:
            s->power_state = val;
            break;
-        case GPIO_INTLEVEL ... (GPIO_INTLEVEL + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTLEVEL ... (GPIO_INTLEVEL + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            break;
        }
-        case GPIO_INTSTAT ... (GPIO_INTSTAT + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTSTAT ... (GPIO_INTSTAT + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTSTAT) / 4;

@@ -73,13 +73,13 @@ static void ipod_touch_sysic_write(void *opaque, hwaddr addr, uint64_t val, unsi

            break;
        }
-        case GPIO_INTEN ... (GPIO_INTEN + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTEN ... (GPIO_INTEN + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTEN) / 4;
            s->gpio_int_enabled[group] = val;
            break;
        }
-        case GPIO_INTTYPE ... (GPIO_INTTYPE + GPIO_NUMINTGROUPS * 4):
+        case GPIO_INTTYPE ... (GPIO_INTTYPE + (GPIO_NUMINTGROUPS - 1) * 4):
        {
            uint8_t group = (addr - GPIO_INTTYPE) / 4;
            s->gpio_int_type[group] = val;
@@ -21,7 +21,7 @@ OBJECT_DECLARE_SIMPLE_TYPE(IPodTouchGPIOState, IPOD_TOUCH_GPIO)
 #define GPIO_BUTTON_VOLUP_IRQ   0x78
 #define GPIO_BUTTON_VOLDOWN_IRQ 0x62

-#define NUM_GPIO_PADS 0xC
+#define NUM_GPIO_PADS 0xD  /* Ports 0 à C inclus, dont Home et Power. */
 #define NUM_GPIO_PINS 0x20

 #define GPIO2PIN(gpio)       ((gpio) & 7)
@@ -25,9 +25,13 @@ OBJECT_DECLARE_SIMPLE_TYPE(IPodTouchMultitouchState, IPOD_TOUCH_MULTITOUCH)
 #define MT_SENSOR_SURFACE_WIDTH  5000
 #define MT_SENSOR_SURFACE_HEIGHT 7500

-// internal surface width/height
-#define MT_INTERNAL_SENSOR_SURFACE_WIDTH  (9000 - MT_SENSOR_SURFACE_WIDTH) * 84 / 73
-#define MT_INTERNAL_SENSOR_SURFACE_HEIGHT (13850 - MT_SENSOR_SURFACE_HEIGHT) * 84 / 73
+/* Calibration mesurée sur les pixels 320x480 de 5H11a avec TouchProbe.
+ * La transformation du pilote nécessite une étendue et une origine propres
+ * au capteur ; les dimensions annoncées dans les rapports restent 5000x7500. */
+#define MT_INTERNAL_SENSOR_SURFACE_WIDTH  4718
+#define MT_INTERNAL_SENSOR_SURFACE_HEIGHT 7328
+#define MT_INTERNAL_SENSOR_ORIGIN_X       (-68)
+#define MT_INTERNAL_SENSOR_ORIGIN_Y       (-188)

 // report IDs
 #define MT_REPORT_UNKNOWN1            0x70
@@ -52,6 +56,7 @@ OBJECT_DECLARE_SIMPLE_TYPE(IPodTouchMultitouchState, IPOD_TOUCH_MULTITOUCH)
 #define MT_CMD_SHORT_CONTROL_WRITE   0xE4
 #define MT_CMD_SHORT_CONTROL_READ    0xE6
 #define MT_CMD_FRAME_READ            0xEA
+#define MT_CMD_FRAME_READ_ALT        0xEB

 // frame types
 #define MT_FRAME_TYPE_PATH 0x44
@@ -152,6 +157,8 @@ typedef struct IPodTouchMultitouchState {
    float prev_touch_x;
    float prev_touch_y;
    uint64_t last_frame_timestamp;
+    uint32_t in_buffer_capacity;
+    MTFrame *read_frame;
 } IPodTouchMultitouchState;

 void ipod_touch_multitouch_on_touch(IPodTouchMultitouchState *s);
@@ -10,6 +10,7 @@
 #include "time.h"

 #define TYPE_PCF50633                 "pcf50633"
+#define TYPE_D1759                    "d1759"
 OBJECT_DECLARE_SIMPLE_TYPE(Pcf50633State, PCF50633)

 #define PMU_DSBL1 0x30	
@@ -30,6 +31,11 @@ typedef struct Pcf50633State {
 	uint32_t cmd;
 	uint32_t ready;
 	uint32_t curreg;
+	/* D1759 : compteur RTC et décalage Unix, distincts du calendrier PCF. */
+	int64_t rtc_tick_offset;
+	uint32_t rtc_snapshot;
+	uint8_t rtc_unix_offset[4];
+	uint8_t rtc_alarm[11];
 } Pcf50633State;

 #endif
Author	SHA1	Message	Date
Workbench IA	d2c3478fa6	Émuler le RTC D1759 et supprimer le réglage automatique de l'heure	2026-10-01 07:41:33 +00:00
Mahtan	436bdc536c	Valider les boutons, le tactile et les outils du simulateur Relecture et validations locales terminées : iPhone OS 2.2.1 et 2.1.1, gestes, HTTP, saisie, installation et persistance.	2026-10-01 09:15:58 +02:00
Workbench IA	5f65af21fc	Fiabiliser les transferts et automatiser les tests d'applications	2026-09-30 16:27:48 +00:00
Workbench IA	524e9bbb17	Corriger les accès GPIO et fiabiliser le tactile au réveil	2026-09-30 16:25:06 +00:00
Mahtan	e0fd5d5eff	Fiabiliser le simulateur et déverrouiller SpringBoard après installation Relecture et validations locales effectuées : démarrage v11, installation persistante et lancement HelloEmu, session déjà lancée, erreurs QEMU et réseau.	2026-09-30 17:13:13 +02:00