diff --git a/src/arduino.c b/src/arduino.c
index 57db1696..5bbff776 100644
--- a/src/arduino.c
+++ b/src/arduino.c
@@ -44,13 +44,13 @@ static int arduino_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
     const char *extended_param = ldata(ln);
 
     if(sscanf(extended_param, "attempts=%i", &attempts) == 1) {
-      PDATA(pgm)->retry_attempts = attempts;
+      my.retry_attempts = attempts;
       pmsg_info("setting number of retry attempts to %d\n", attempts);
       continue;
     }
 
     if(str_eq(extended_param, "noautoreset")) {
-      PDATA(pgm)->autoreset = false;
+      my.autoreset = false;
       continue;
     }
 
@@ -121,7 +121,7 @@ static int arduino_open(PROGRAMMER *pgm, const char *port) {
     return -1;
   }
 
-  if(PDATA(pgm)->autoreset) {
+  if(my.autoreset) {
     // This code assumes a negative-logic USB to TTL serial adapter
     // Set RTS/DTR high to discharge the series-capacitor, if present
     serial_set_dtr_rts(&pgm->fd, 0);
diff --git a/src/avr910.c b/src/avr910.c
index 7cb9eb3c..a7a19ed2 100644
--- a/src/avr910.c
+++ b/src/avr910.c
@@ -50,7 +50,7 @@ struct pdata {
   unsigned long caddr;
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // Print error and return when command failed
 #define EI(x) do {                 \
@@ -71,7 +71,7 @@ struct pdata {
 
 static void avr910_setup(PROGRAMMER *pgm) {
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->test_blockmode = 1;
+  my.test_blockmode = 1;
 }
 
 static void avr910_teardown(PROGRAMMER *pgm) {
@@ -165,30 +165,30 @@ static int avr910_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   // See if programmer supports autoincrement of address
 
   EI(avr910_send(pgm, "a", 1));
-  EI(avr910_recv(pgm, &PDATA(pgm)->has_auto_incr_addr, 1));
-  if(PDATA(pgm)->has_auto_incr_addr == 'Y')
+  EI(avr910_recv(pgm, &my.has_auto_incr_addr, 1));
+  if(my.has_auto_incr_addr == 'Y')
     msg_notice("programmer supports auto addr increment\n");
 
   // Check support for buffered memory access, ignore if not available
 
-  if(PDATA(pgm)->test_blockmode == 1) {
+  if(my.test_blockmode == 1) {
     EI(avr910_send(pgm, "b", 1));
     EI(avr910_recv(pgm, &c, 1));
     if(c == 'Y') {
       EI(avr910_recv(pgm, &c, 1));
-      PDATA(pgm)->buffersize = (unsigned int) (unsigned char) c << 8;
+      my.buffersize = (unsigned int) (unsigned char) c << 8;
       EI(avr910_recv(pgm, &c, 1));
-      PDATA(pgm)->buffersize += (unsigned int) (unsigned char) c;
-      msg_notice("programmer supports buffered memory access with " "buffersize = %u bytes\n", PDATA(pgm)->buffersize);
-      PDATA(pgm)->use_blockmode = 1;
+      my.buffersize += (unsigned int) (unsigned char) c;
+      msg_notice("programmer supports buffered memory access with " "buffersize = %u bytes\n", my.buffersize);
+      my.use_blockmode = 1;
     } else {
-      PDATA(pgm)->use_blockmode = 0;
+      my.use_blockmode = 0;
     }
   } else {
-    PDATA(pgm)->use_blockmode = 0;
+    my.use_blockmode = 0;
   }
 
-  if(PDATA(pgm)->devcode == 0) {
+  if(my.devcode == 0) {
     char devtype_1st;
     int dev_supported = 0;
 
@@ -226,7 +226,7 @@ static int avr910_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     buf[1] = ovsigck? devtype_1st: p->avr910_devcode;
   } else {
     // Devcode overridden by -x devcode= option
-    buf[1] = (char) (PDATA(pgm)->devcode);
+    buf[1] = (char) (my.devcode);
   }
 
   // Tell the programmer which part we selected
@@ -291,13 +291,13 @@ static int avr910_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         break;
       }
       pmsg_notice2("%s(): devcode overwritten as 0x%02x\n", __func__, devcode);
-      PDATA(pgm)->devcode = devcode;
+      my.devcode = devcode;
 
       continue;
     }
     if(str_eq(extended_param, "no_blockmode")) {
       pmsg_notice2("avr910_parseextparms(-x): no testing for Blockmode\n");
-      PDATA(pgm)->test_blockmode = 0;
+      my.test_blockmode = 0;
 
       continue;
     }
@@ -370,7 +370,7 @@ static int avr910_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
     }
 
     addr >>= 1;
-    PDATA(pgm)->ctype = 0;      // Invalidate read cache
+    my.ctype = 0;               // Invalidate read cache
   } else if(mem_is_eeprom(m)) {
     cmd[0] = 'D';
   } else {
@@ -389,8 +389,8 @@ static int avr910_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, const
   unsigned long addr, unsigned char *value) {
   char buf[2];
 
-  if(PDATA(pgm)->ctype == 'F' && PDATA(pgm)->caddr == addr) {
-    *value = PDATA(pgm)->cvalue;
+  if(my.ctype == 'F' && my.caddr == addr) {
+    *value = my.cvalue;
     return 0;
   }
 
@@ -400,9 +400,9 @@ static int avr910_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, const
   EI(avr910_recv(pgm, buf, sizeof(buf)));
 
   *value = buf[(addr & 1) ^ 1]; // MSB in buffer first
-  PDATA(pgm)->ctype = 'F';
-  PDATA(pgm)->cvalue = buf[addr & 1];
-  PDATA(pgm)->caddr = addr ^ 1;
+  my.ctype = 'F';
+  my.cvalue = buf[addr & 1];
+  my.caddr = addr ^ 1;
 
   return 0;
 }
@@ -439,7 +439,7 @@ static int avr910_paged_write_flash(const PROGRAMMER *pgm, const AVRPART *p, con
   int page_bytes = page_size;
   int page_wr_cmd_pending = 0;
 
-  PDATA(pgm)->ctype = 0;        // Invalidate read cache
+  my.ctype = 0;                 // Invalidate read cache
 
   page_addr = addr;
   avr910_set_addr(pgm, addr >> 1);
@@ -471,7 +471,7 @@ static int avr910_paged_write_flash(const PROGRAMMER *pgm, const AVRPART *p, con
 
       page_addr = addr;
       page_bytes = page_size;
-    } else if((PDATA(pgm)->has_auto_incr_addr != 'Y') && ((addr & 0x01) == 0)) {
+    } else if((my.has_auto_incr_addr != 'Y') && ((addr & 0x01) == 0)) {
       avr910_set_addr(pgm, addr >> 1);
     }
   }
@@ -506,7 +506,7 @@ static int avr910_paged_write_eeprom(const PROGRAMMER *pgm, const AVRPART *p,
 
     addr++;
 
-    if(PDATA(pgm)->has_auto_incr_addr != 'Y')
+    if(my.has_auto_incr_addr != 'Y')
       avr910_set_addr(pgm, addr);
   }
 
@@ -517,7 +517,7 @@ static int avr910_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
   unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
   int isee = mem_is_eeprom(m);
 
-  if(PDATA(pgm)->use_blockmode == 0) {
+  if(my.use_blockmode == 0) {
     if(mem_is_flash(m))
       return avr910_paged_write_flash(pgm, p, m, page_size, addr, n_bytes);
     if(isee)
@@ -525,10 +525,10 @@ static int avr910_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
     return -2;
   }
 
-  if(PDATA(pgm)->use_blockmode == 1) {
+  if(my.use_blockmode == 1) {
     unsigned int max_addr = addr + n_bytes;
     char *cmd;
-    unsigned int blocksize = PDATA(pgm)->buffersize;
+    unsigned int blocksize = my.buffersize;
 
     if(!mem_is_flash(m) && !isee)
       return -2;
@@ -536,7 +536,7 @@ static int avr910_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
     if(isee)
       blocksize = 1;            // Write single bytes only to EEPROM
     else
-      PDATA(pgm)->ctype = 0;    // Invalidate read cache
+      my.ctype = 0;             // Invalidate read cache
 
     avr910_set_addr(pgm, isee? addr: addr >> 1);
 
@@ -584,9 +584,9 @@ static int avr910_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
 
   avr910_set_addr(pgm, isee? addr: addr >> 1);
 
-  if(PDATA(pgm)->use_blockmode) {
+  if(my.use_blockmode) {
     // Use buffered mode
-    int blocksize = PDATA(pgm)->buffersize;
+    int blocksize = my.buffersize;
 
     cmd[0] = 'g';
     cmd[3] = isee? 'E': 'F';
@@ -616,7 +616,7 @@ static int avr910_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
 
       addr += isee? 1: 2;
 
-      if(PDATA(pgm)->has_auto_incr_addr != 'Y')
+      if(my.has_auto_incr_addr != 'Y')
         avr910_set_addr(pgm, isee? addr: addr >> 1);
     }
   }
diff --git a/src/buspirate.c b/src/buspirate.c
index dd3684e4..225c9b86 100644
--- a/src/buspirate.c
+++ b/src/buspirate.c
@@ -80,19 +80,19 @@ struct pdata {
   char buf_local[100];          // Local buffer for buspirate_readline_noexit()
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // ====== Feature checks ======
 static inline int buspirate_uses_ascii(const PROGRAMMER *pgm) {
-  return (PDATA(pgm)->flag & BP_FLAG_XPARM_FORCE_ASCII);
+  return (my.flag & BP_FLAG_XPARM_FORCE_ASCII);
 }
 
 static inline int buspirate_uses_pullups(const PROGRAMMER *pgm) {
-  return (PDATA(pgm)->flag & BP_FLAG_PULLUPS);
+  return (my.flag & BP_FLAG_PULLUPS);
 }
 
 static inline int buspirate_uses_hiz(const PROGRAMMER *pgm) {
-  return (PDATA(pgm)->flag & BP_FLAG_HIZ);
+  return (my.flag & BP_FLAG_HIZ);
 }
 
 // ====== Serial talker functions - binmode ======
@@ -141,7 +141,7 @@ static int buspirate_expect_bin(const PROGRAMMER *pgm,
   unsigned char *send_data, size_t send_len, unsigned char *expect_data, size_t expect_len) {
   unsigned char *recv_buf = alloca(expect_len);
 
-  if((PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) == 0) {
+  if((my.flag & BP_FLAG_IN_BINMODE) == 0) {
     pmsg_error("called from ascii mode\n");
     return -1;
   }
@@ -163,7 +163,7 @@ static int buspirate_getc(const PROGRAMMER *pgm) {
   int rc;
   unsigned char ch = 0;
 
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     pmsg_error("called from binmode\n");
     return EOF;
   }
@@ -180,8 +180,8 @@ static char *buspirate_readline_noexit(const PROGRAMMER *pgm, char *buf, size_t
   long orig_serial_recv_timeout = serial_recv_timeout;
 
   if(buf == NULL) {
-    buf = PDATA(pgm)->buf_local;
-    len = sizeof(PDATA(pgm)->buf_local);
+    buf = my.buf_local;
+    len = sizeof(my.buf_local);
   }
   buf_p = buf;
   memset(buf, 0, len);
@@ -196,7 +196,7 @@ static char *buspirate_readline_noexit(const PROGRAMMER *pgm, char *buf, size_t
       break;
     }
     buf_p++;
-    serial_recv_timeout = PDATA(pgm)->serial_recv_timeout;
+    serial_recv_timeout = my.serial_recv_timeout;
   }
   serial_recv_timeout = orig_serial_recv_timeout;
   pmsg_debug("%s(): %s%s", __func__, buf, *buf && buf[strlen(buf) - 1] == '\n'? "": "\n");
@@ -223,7 +223,7 @@ static int buspirate_send(const PROGRAMMER *pgm, const char *str) {
 
   pmsg_debug("%s(): %s", __func__, str);
 
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     pmsg_error("called from binmode\n");
     return -1;
   }
@@ -294,17 +294,17 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
     const char *extended_param = ldata(ln);
 
     if(str_eq(extended_param, "ascii")) {
-      PDATA(pgm)->flag |= BP_FLAG_XPARM_FORCE_ASCII;
+      my.flag |= BP_FLAG_XPARM_FORCE_ASCII;
       continue;
     }
 
     if(str_eq(extended_param, "pullups")) {
-      PDATA(pgm)->flag |= BP_FLAG_PULLUPS;
+      my.flag |= BP_FLAG_PULLUPS;
       continue;
     }
 
     if(str_eq(extended_param, "hiz")) {
-      PDATA(pgm)->flag |= BP_FLAG_HIZ;
+      my.flag |= BP_FLAG_HIZ;
       continue;
     }
 
@@ -314,13 +314,13 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         rv = -1;
         break;
       }
-      if(PDATA(pgm)->flag & BP_FLAG_XPARM_RAWFREQ) {
+      if(my.flag & BP_FLAG_XPARM_RAWFREQ) {
         pmsg_error("set either spifreq or rawfreq\n");
         rv = -1;
         break;
       }
-      PDATA(pgm)->flag |= BP_FLAG_XPARM_SPIFREQ;
-      PDATA(pgm)->spifreq = spifreq;
+      my.flag |= BP_FLAG_XPARM_SPIFREQ;
+      my.spifreq = spifreq;
       continue;
     }
 
@@ -330,13 +330,13 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         rv = -1;
         break;
       }
-      if(PDATA(pgm)->flag & BP_FLAG_XPARM_SPIFREQ) {
+      if(my.flag & BP_FLAG_XPARM_SPIFREQ) {
         pmsg_error("set either spifreq or rawfreq\n");
         rv = -1;
         break;
       }
-      PDATA(pgm)->flag |= BP_FLAG_XPARM_RAWFREQ;
-      PDATA(pgm)->spifreq = rawfreq;
+      my.flag |= BP_FLAG_XPARM_RAWFREQ;
+      my.spifreq = rawfreq;
       continue;
     }
 
@@ -347,8 +347,8 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         rv = -1;
         break;
       }
-      PDATA(pgm)->cpufreq = cpufreq;
-      PDATA(pgm)->flag |= BP_FLAG_XPARM_CPUFREQ;
+      my.cpufreq = cpufreq;
+      my.flag |= BP_FLAG_XPARM_CPUFREQ;
       continue;
     }
 
@@ -358,28 +358,28 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
       while((resetpin = strtok(preset, ","))) {
         preset = NULL;          // For subsequent strtok() calls
         if(str_caseeq(resetpin, "cs"))
-          PDATA(pgm)->reset |= BP_RESET_CS;
+          my.reset |= BP_RESET_CS;
         else if(str_caseeq(resetpin, "aux") || str_caseeq(reset, "aux1"))
-          PDATA(pgm)->reset |= BP_RESET_AUX;
+          my.reset |= BP_RESET_AUX;
         else if(str_caseeq(resetpin, "aux2"))
-          PDATA(pgm)->reset |= BP_RESET_AUX2;
+          my.reset |= BP_RESET_AUX2;
         else {
           pmsg_error("-x reset= value must be either CS, AUX or AUX2\n");
           rv = -1;
           break;
         }
       }
-      PDATA(pgm)->flag |= BP_FLAG_XPARM_RESET;
+      my.flag |= BP_FLAG_XPARM_RESET;
       continue;
     }
 
     if(str_eq(extended_param, "nopagedwrite")) {
-      PDATA(pgm)->flag |= BP_FLAG_NOPAGEDWRITE;
+      my.flag |= BP_FLAG_NOPAGEDWRITE;
       continue;
     }
 
     if(str_eq(extended_param, "nopagedread")) {
-      PDATA(pgm)->flag |= BP_FLAG_NOPAGEDREAD;
+      my.flag |= BP_FLAG_NOPAGEDREAD;
       continue;
     }
 
@@ -389,7 +389,7 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         rv = -1;
         break;
       }
-      PDATA(pgm)->serial_recv_timeout = serial_recv_timeout;
+      my.serial_recv_timeout = serial_recv_timeout;
       continue;
     }
 
@@ -422,15 +422,15 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
 
 static int buspirate_verifyconfig(const PROGRAMMER *pgm) {
   // Default reset pin is CS
-  if(PDATA(pgm)->reset == 0x00)
-    PDATA(pgm)->reset |= BP_RESET_CS;
+  if(my.reset == 0x00)
+    my.reset |= BP_RESET_CS;
 
-  if((PDATA(pgm)->reset != BP_RESET_CS) && buspirate_uses_ascii(pgm)) {
+  if((my.reset != BP_RESET_CS) && buspirate_uses_ascii(pgm)) {
     pmsg_error("RESET pin other than CS is not supported in ASCII mode\n");
     return -1;
   }
 
-  if(((PDATA(pgm)->flag & BP_FLAG_XPARM_SPIFREQ) || (PDATA(pgm)->flag & BP_FLAG_XPARM_RAWFREQ))
+  if(((my.flag & BP_FLAG_XPARM_SPIFREQ) || (my.flag & BP_FLAG_XPARM_RAWFREQ))
     && buspirate_uses_ascii(pgm)) {
     pmsg_error("SPI speed selection is not supported in ASCII mode\n");
     return -1;
@@ -472,7 +472,7 @@ static void buspirate_reset_from_binmode(const PROGRAMMER *pgm) {
   buspirate_send_bin(pgm, buf, 1);
   buspirate_recv_bin(pgm, buf, 5);
 
-  if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
+  if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
     // Disable PWM
     if(buspirate_expect_bin_byte(pgm, 0x13, 0x01) != 1) {
       pmsg_error("did not get a response to stop PWM command\n");
@@ -495,7 +495,7 @@ static void buspirate_reset_from_binmode(const PROGRAMMER *pgm) {
     rc = buspirate_recv_bin(pgm, buf, sizeof(buf) - 1);
 
     if(buspirate_is_prompt((const char *) buf)) {
-      PDATA(pgm)->flag &= ~BP_FLAG_IN_BINMODE;
+      my.flag &= ~BP_FLAG_IN_BINMODE;
       break;
     }
     if(rc == EOF)
@@ -503,7 +503,7 @@ static void buspirate_reset_from_binmode(const PROGRAMMER *pgm) {
     memset(buf, '\0', sizeof(buf));
   }
 
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     pmsg_error("reset failed; you may need to powercycle it\n");
     return;
   }
@@ -519,13 +519,13 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
     char config;                // Command to setup submode parameters
   } submode;
 
-  if(PDATA(pgm)->flag & BP_FLAG_XPARM_RAWFREQ) {
+  if(my.flag & BP_FLAG_XPARM_RAWFREQ) {
     submode.name = "Raw-wire";
     submode.enter = 0x05;
     submode.entered_format = "RAW%1d";
     submode.config = 0x8C;
-    PDATA(pgm)->flag |= BP_FLAG_NOPAGEDWRITE;
-    PDATA(pgm)->flag |= BP_FLAG_NOPAGEDREAD;
+    my.flag |= BP_FLAG_NOPAGEDWRITE;
+    my.flag |= BP_FLAG_NOPAGEDREAD;
   } else {
     submode.name = "SPI";
     submode.enter = 0x01;
@@ -551,20 +551,20 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
   // Expecting 'BBIOx' reply
   memset(buf, 0, sizeof(buf));
   buspirate_recv_bin(pgm, buf, 5);
-  if(sscanf((const char *) buf, "BBIO%1d", &PDATA(pgm)->binmode_version) != 1) {
+  if(sscanf((const char *) buf, "BBIO%1d", &my.binmode_version) != 1) {
     pmsg_error("binary mode not confirmed: %s\n", buf);
     buspirate_reset_from_binmode(pgm);
     return -1;
   }
-  msg_notice2("BusPirate binmode version: %d\n", PDATA(pgm)->binmode_version);
+  msg_notice2("BusPirate binmode version: %d\n", my.binmode_version);
 
-  PDATA(pgm)->flag |= BP_FLAG_IN_BINMODE;
+  my.flag |= BP_FLAG_IN_BINMODE;
 
-  if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
+  if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
     unsigned short pwm_duty;
     unsigned short pwm_period;
 
-    pwm_period = 16000/(PDATA(pgm)->cpufreq) - 1; // Oscillator runs at 32MHz, we don't use a prescaler
+    pwm_period = 16000/(my.cpufreq) - 1; // Oscillator runs at 32MHz, we don't use a prescaler
     pwm_duty = pwm_period/2;  // 50% duty cycle
 
     msg_notice2("setting up PWM for cpufreq\n");
@@ -588,13 +588,13 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
   buspirate_send_bin(pgm, buf, 1);
   memset(buf, 0, sizeof(buf));
   buspirate_recv_bin(pgm, buf, 4);
-  if(sscanf((const char *) buf, submode.entered_format, &PDATA(pgm)->submode_version) != 1) {
+  if(sscanf((const char *) buf, submode.entered_format, &my.submode_version) != 1) {
     pmsg_error("%s mode not confirmed: %s\n", submode.name, buf);
     buspirate_reset_from_binmode(pgm);
     return -1;
   }
-  msg_notice2("BusPirate %s version: %d\n", submode.name, PDATA(pgm)->submode_version);
-  if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDWRITE) {
+  msg_notice2("BusPirate %s version: %d\n", submode.name, my.submode_version);
+  if(my.flag & BP_FLAG_NOPAGEDWRITE) {
     pmsg_notice2("paged flash write disabled\n");
     pgm->paged_write = NULL;
   } else {
@@ -604,7 +604,7 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
     buspirate_recv_bin(pgm, buf, 1);
     if(buf[0] != 0x01) {
       // Disable paged write
-      PDATA(pgm)->flag |= BP_FLAG_NOPAGEDWRITE;
+      my.flag |= BP_FLAG_NOPAGEDWRITE;
       pgm->paged_write = NULL;
 
       // Return to SPI mode (0x00s have landed us back in binary bitbang mode)
@@ -624,18 +624,18 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
    * 0b0100wxyz - Configure peripherals w=power, x=pull-ups/aux2, y=AUX, z=CS
    * we want power (0x48) and all reset pins high
    */
-  PDATA(pgm)->current_peripherals_config = 0x48 | PDATA(pgm)->reset;
+  my.current_peripherals_config = 0x48 | my.reset;
   if(buspirate_uses_pullups(pgm)) {
-    PDATA(pgm)->current_peripherals_config |= 1 << 2;
+    my.current_peripherals_config |= 1 << 2;
     submode.config &= ~(1 << 3);
     pmsg_info("enabling pull-ups (open-collector)\n");
   }
-  if(buspirate_expect_bin_byte(pgm, PDATA(pgm)->current_peripherals_config, 0x01) < 0)
+  if(buspirate_expect_bin_byte(pgm, my.current_peripherals_config, 0x01) < 0)
     return -1;
   usleep(50000);                // Sleep for 50 ms after power up
 
   // 01100xxx - Set speed
-  if(buspirate_expect_bin_byte(pgm, 0x60 | PDATA(pgm)->spifreq, 0x01) < 0)
+  if(buspirate_expect_bin_byte(pgm, 0x60 | my.spifreq, 0x01) < 0)
     return -1;
 
   // Submode config
@@ -643,7 +643,7 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
     return -1;
 
   // AVR Extended Commands - test for existence
-  if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDREAD) {
+  if(my.flag & BP_FLAG_NOPAGEDREAD) {
     pmsg_notice2("paged flash read disabled\n");
     pgm->paged_load = NULL;
   } else {
@@ -660,7 +660,7 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
       msg_notice2("AVR Extended Commands version %d\n", ver);
     } else {
       msg_notice2("AVR Extended Commands not found\n");
-      PDATA(pgm)->flag |= BP_FLAG_NOPAGEDREAD;
+      my.flag |= BP_FLAG_NOPAGEDREAD;
       pgm->paged_load = NULL;
     }
   }
@@ -783,7 +783,7 @@ static void buspirate_enable(PROGRAMMER *pgm, const AVRPART *p) {
       msg_debug("**  %s", rcvd);
   }
 
-  if(!(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE)) {
+  if(!(my.flag & BP_FLAG_IN_BINMODE)) {
     msg_info("using ASCII mode\n");
     if(buspirate_start_spi_mode_ascii(pgm) < 0) {
       pmsg_error("unable to start ascii SPI mode\n");
@@ -793,7 +793,7 @@ static void buspirate_enable(PROGRAMMER *pgm, const AVRPART *p) {
 }
 
 static void buspirate_disable(const PROGRAMMER *pgm) {
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     serial_recv_timeout = 100;
     buspirate_reset_from_binmode(pgm);
   } else {
@@ -808,16 +808,16 @@ static int buspirate_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 }
 
 static void buspirate_powerup(const PROGRAMMER *pgm) {
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     // Powerup in BinMode is handled in binary mode init
     return;
   } else {
     if(buspirate_expect(pgm, "W\n", "POWER SUPPLIES ON", 1)) {
-      if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
+      if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
         char buf[25];
         int ok = 0;
 
-        snprintf(buf, sizeof(buf), "%d\n", PDATA(pgm)->cpufreq);
+        snprintf(buf, sizeof(buf), "%d\n", my.cpufreq);
         if(buspirate_expect(pgm, "g\n", "Frequency in kHz", 1)) {
           if(buspirate_expect(pgm, buf, "Duty cycle in %", 1)) {
             if(buspirate_expect(pgm, "50\n", "PWM active", 1)) {
@@ -837,11 +837,11 @@ static void buspirate_powerup(const PROGRAMMER *pgm) {
 }
 
 static void buspirate_powerdown(const PROGRAMMER *pgm) {
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     // Powerdown in BinMode is handled in binary mode init
     return;
   } else {
-    if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
+    if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
       if(!buspirate_expect(pgm, "g\n", "PWM disabled", 1)) {
         pmsg_error("did not get a response to stop PWM command\n");
       }
@@ -903,7 +903,7 @@ static int buspirate_cmd_ascii(const PROGRAMMER *pgm, const unsigned char *cmd,
 }
 
 static int buspirate_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) {
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE)
+  if(my.flag & BP_FLAG_IN_BINMODE)
     return buspirate_cmd_bin(pgm, cmd, res);
   else
     return buspirate_cmd_ascii(pgm, cmd, res);
@@ -920,7 +920,7 @@ static int buspirate_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const A
   msg_debug("buspirate_paged_load(..,%s,%d,%d,%d)\n", m->desc, m->page_size, address, n_bytes);
 
   // This should never happen, but still ...
-  if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDREAD) {
+  if(my.flag & BP_FLAG_NOPAGEDREAD) {
     pmsg_error("called while in nopagedread mode\n");
     return -1;
   }
@@ -971,12 +971,12 @@ static int buspirate_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
   unsigned char cmd_buf[4096] = { '\0' };
   unsigned char send_byte, recv_byte;
 
-  if(!(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE)) {
+  if(!(my.flag & BP_FLAG_IN_BINMODE)) {
     // Return if we are not in binary mode
     return -1;
   }
 
-  if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDWRITE) {
+  if(my.flag & BP_FLAG_NOPAGEDWRITE) {
     // Return if we've nominated not to use paged writes
     return -1;
   }
@@ -1066,10 +1066,10 @@ static int buspirate_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
   unsigned char cmd[4];
   unsigned char res[4];
 
-  if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
+  if(my.flag & BP_FLAG_IN_BINMODE) {
     // Clear configured reset pin(s): CS and/or AUX and/or AUX2
-    PDATA(pgm)->current_peripherals_config &= ~PDATA(pgm)->reset;
-    if(buspirate_expect_bin_byte(pgm, PDATA(pgm)->current_peripherals_config, 0x01) < 0)
+    my.current_peripherals_config &= ~my.reset;
+    if(buspirate_expect_bin_byte(pgm, my.current_peripherals_config, 0x01) < 0)
       return -1;
   } else
     buspirate_expect(pgm, "{\n", "CS ENABLED", 1);
@@ -1111,7 +1111,7 @@ static int buspirate_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
 // Interface - management
 static void buspirate_setup(PROGRAMMER *pgm) {
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->serial_recv_timeout = 100;
+  my.serial_recv_timeout = 100;
 }
 
 static void buspirate_teardown(PROGRAMMER *pgm) {
@@ -1174,23 +1174,23 @@ static void buspirate_bb_enable(PROGRAMMER *pgm, const AVRPART *p) {
   // Expecting 'BBIOx' reply
   memset(buf, 0, sizeof(buf));
   buspirate_recv_bin(pgm, buf, 5);
-  if(sscanf((char *) buf, "BBIO%1d", &PDATA(pgm)->binmode_version) != 1) {
+  if(sscanf((char *) buf, "BBIO%1d", &my.binmode_version) != 1) {
     pmsg_error("binary mode not confirmed: %s\n", buf);
     buspirate_reset_from_binmode(pgm);
     return;
   }
-  msg_info("BusPirate binmode version: %d\n", PDATA(pgm)->binmode_version);
+  msg_info("BusPirate binmode version: %d\n", my.binmode_version);
 
-  PDATA(pgm)->flag |= BP_FLAG_IN_BINMODE;
+  my.flag |= BP_FLAG_IN_BINMODE;
 
   // Set pin directions and an initial pin status (all high)
-  PDATA(pgm)->pin_dir = 0x12;   // AUX, SDI input; everything else output
-  buf[0] = PDATA(pgm)->pin_dir | 0x40;
+  my.pin_dir = 0x12;            // AUX, SDI input; everything else output
+  buf[0] = my.pin_dir | 0x40;
   buspirate_send_bin(pgm, buf, 1);
   buspirate_recv_bin(pgm, buf, 1);
 
-  PDATA(pgm)->pin_val = 0x3f;   // PULLUP, AUX, SDO, CLK, SDI, CS high
-  buf[0] = PDATA(pgm)->pin_val | 0x80;
+  my.pin_val = 0x3f;            // PULLUP, AUX, SDO, CLK, SDI, CS high
+  buf[0] = my.pin_val | 0x80;
   buspirate_send_bin(pgm, buf, 1);
   buspirate_recv_bin(pgm, buf, 1);
 
@@ -1229,14 +1229,14 @@ static int buspirate_bb_getpin(const PROGRAMMER *pgm, int pinfunc) {
   if(pin < 1 || pin > 5)
     return -1;
 
-  buf[0] = PDATA(pgm)->pin_dir | 0x40;
+  buf[0] = my.pin_dir | 0x40;
   if(buspirate_send_bin(pgm, buf, 1) < 0)
     return -1;
   // Read all of the previously-expected-but-unread bytes
-  while(PDATA(pgm)->unread_bytes > 0) {
+  while(my.unread_bytes > 0) {
     if(buspirate_recv_bin(pgm, buf, 1) < 0)
       return -1;
-    PDATA(pgm)->unread_bytes--;
+    my.unread_bytes--;
   }
 
   // Now read the actual response
@@ -1265,11 +1265,11 @@ static int buspirate_bb_setpin_internal(const PROGRAMMER *pgm, int pin, int valu
   msg_debug("set pin %d = %d\n", pin, value);
 
   if(value)
-    PDATA(pgm)->pin_val |= (1 << (pin - 1));
+    my.pin_val |= (1 << (pin - 1));
   else
-    PDATA(pgm)->pin_val &= ~(1 << (pin - 1));
+    my.pin_val &= ~(1 << (pin - 1));
 
-  buf[0] = PDATA(pgm)->pin_val | 0x80;
+  buf[0] = my.pin_val | 0x80;
   if(buspirate_send_bin(pgm, buf, 1) < 0)
     return -1;
   /*
@@ -1277,7 +1277,7 @@ static int buspirate_bb_setpin_internal(const PROGRAMMER *pgm, int pin, int valu
    * quick optimization that saves some USB round trips, improving read times
    * by a factor of 3.
    */
-  PDATA(pgm)->unread_bytes++;
+  my.unread_bytes++;
 
   return 0;
 }
diff --git a/src/butterfly.c b/src/butterfly.c
index 1afd3f3b..fc0d299b 100644
--- a/src/butterfly.c
+++ b/src/butterfly.c
@@ -56,7 +56,7 @@ struct pdata {
   bool autoreset;
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // Print error and return when command failed
 #define EI(x) do {                 \
@@ -251,8 +251,8 @@ static int butterfly_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   // See if programmer supports autoincrement of address
 
   EI(butterfly_send(pgm, "a", 1));
-  EI(butterfly_recv(pgm, &PDATA(pgm)->has_auto_incr_addr, 1));
-  if(PDATA(pgm)->has_auto_incr_addr == 'Y')
+  EI(butterfly_recv(pgm, &my.has_auto_incr_addr, 1));
+  if(my.has_auto_incr_addr == 'Y')
     msg_notice("programmer supports auto addr increment\n");
 
   // Check support for buffered memory access, abort if not available
@@ -264,10 +264,10 @@ static int butterfly_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     return -1;
   };
   EI(butterfly_recv(pgm, &c, 1));
-  PDATA(pgm)->buffersize = (unsigned int) (unsigned char) c << 8;
+  my.buffersize = (unsigned int) (unsigned char) c << 8;
   EI(butterfly_recv(pgm, &c, 1));
-  PDATA(pgm)->buffersize += (unsigned int) (unsigned char) c;
-  msg_notice("programmer supports buffered memory access with buffersize=%i bytes\n", PDATA(pgm)->buffersize);
+  my.buffersize += (unsigned int) (unsigned char) c;
+  msg_notice("programmer supports buffered memory access with buffersize=%i bytes\n", my.buffersize);
 
   // Get list of devices that the programmer supports
 
@@ -335,7 +335,7 @@ static int butterfly_open(PROGRAMMER *pgm, const char *port) {
     return -1;
   }
 
-  if(PDATA(pgm)->autoreset) {
+  if(my.autoreset) {
     // This code assumes a negative-logic USB to TTL serial adapter
     // Set RTS/DTR high to discharge the series-capacitor, if present
     pmsg_notice2("toggling the DTR/RTS lines to trigger a hardware reset\n");
@@ -411,7 +411,7 @@ static int butterfly_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
   if(mem_is_flash(m)) {
     int ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
 
-    PDATA(pgm)->ctype = 0;      // Invalidate read cache
+    my.ctype = 0;               // Invalidate read cache
     cmd[0] = 'B';
     cmd[1] = 0;
     cmd[2] = 2;
@@ -464,8 +464,8 @@ static int butterfly_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, co
     return -1;
   }
 
-  if(PDATA(pgm)->ctype == mtype && PDATA(pgm)->caddr == addr) {
-    *value = PDATA(pgm)->cvalue;
+  if(my.ctype == mtype && my.caddr == addr) {
+    *value = my.cvalue;
     return 0;
   }
 
@@ -476,10 +476,10 @@ static int butterfly_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, co
   EI(butterfly_send(pgm, msg, 4));
   EI(butterfly_recv(pgm, buf, sizeof(buf)));
 
-  PDATA(pgm)->ctype = mtype;
+  my.ctype = mtype;
   *value = buf[addr & 1];
-  PDATA(pgm)->cvalue = buf[1 - (addr & 1)];
-  PDATA(pgm)->caddr = addr ^ 1;
+  my.cvalue = buf[1 - (addr & 1)];
+  my.caddr = addr ^ 1;
 
   return 0;
 }
@@ -525,7 +525,7 @@ static int butterfly_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
   unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
   unsigned int max_addr = addr + n_bytes;
   char *cmd;
-  unsigned int blocksize = PDATA(pgm)->buffersize;
+  unsigned int blocksize = my.buffersize;
   int ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
   int isee = mem_is_eeprom(m);
 
@@ -535,7 +535,7 @@ static int butterfly_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
   if(isee)                      // Write single bytes to EEPROM
     blocksize = 1;
   else
-    PDATA(pgm)->ctype = 0;      // Invalidate flash byte read cache
+    my.ctype = 0;               // Invalidate flash byte read cache
 
   (ext_addr? butterfly_set_extaddr: butterfly_set_addr) (pgm, isee? addr: addr >> 1);
 
@@ -575,7 +575,7 @@ static int butterfly_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
 static int butterfly_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
   unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
   unsigned int max_addr = addr + n_bytes;
-  int blocksize = PDATA(pgm)->buffersize;
+  int blocksize = my.buffersize;
   int ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
   int isee = mem_is_eeprom(m);
 
@@ -637,7 +637,7 @@ static int butterfly_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
     extended_param = ldata(ln);
 
     if(str_eq(extended_param, "autoreset")) {
-      PDATA(pgm)->autoreset = true;
+      my.autoreset = true;
       continue;
     }
 
diff --git a/src/ch341a.c b/src/ch341a.c
index 093f4de6..5202182b 100644
--- a/src/ch341a.c
+++ b/src/ch341a.c
@@ -96,7 +96,7 @@ struct pdata {
   int USB_init;                 // Used in ch341a_open()
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // ----------------------------------------------------------------------
 
@@ -128,10 +128,10 @@ static int CH341USBTransferPart(const PROGRAMMER *pgm, enum libusb_endpoint_dire
 
   int ret, bytestransferred;
 
-  if(!PDATA(pgm)->usbhandle)
+  if(!my.usbhandle)
     return 0;
 
-  if((ret = libusb_bulk_transfer(PDATA(pgm)->usbhandle, CH341A_USB_BULK_ENDPOINT | dir,
+  if((ret = libusb_bulk_transfer(my.usbhandle, CH341A_USB_BULK_ENDPOINT | dir,
         buff, size, &bytestransferred, CH341A_USB_TIMEOUT))) {
 
     pmsg_error("libusb_bulk_transfer for IN_EP failed, return value %d (%s)\n", ret, libusb_error_name(ret));
@@ -203,9 +203,9 @@ static int ch341a_open(PROGRAMMER *pgm, const char *port) {
 
   pmsg_trace("ch341a_open(\"%s\")\n", port);
 
-  if(!PDATA(pgm)->USB_init) {
-    PDATA(pgm)->USB_init = 1;
-    libusb_init(&PDATA(pgm)->ctx);
+  if(!my.USB_init) {
+    my.USB_init = 1;
+    libusb_init(&my.ctx);
   }
 
   if(usbpid) {
@@ -218,7 +218,7 @@ static int ch341a_open(PROGRAMMER *pgm, const char *port) {
   vid = pgm->usbvid? pgm->usbvid: CH341A_VID;
 
   libusb_device **dev_list;
-  int dev_list_len = libusb_get_device_list(PDATA(pgm)->ctx, &dev_list);
+  int dev_list_len = libusb_get_device_list(my.ctx, &dev_list);
 
   for(j = 0; j < dev_list_len; ++j) {
     libusb_device *dev = dev_list[j];
@@ -237,17 +237,17 @@ static int ch341a_open(PROGRAMMER *pgm, const char *port) {
   libusb_free_device_list(dev_list, 1);
   if(handle != NULL) {
     errorCode = 0;
-    PDATA(pgm)->usbhandle = handle;
+    my.usbhandle = handle;
   }
 
   if(errorCode != 0) {
     pmsg_error("could not find USB device with vid=0x%x pid=0x%x\n", vid, pid);
     return -1;
   }
-  if((r = libusb_claim_interface(PDATA(pgm)->usbhandle, 0))) {
+  if((r = libusb_claim_interface(my.usbhandle, 0))) {
     pmsg_error("libusb_claim_interface failed, return value %d (%s)\n", r, libusb_error_name(r));
-    libusb_close(PDATA(pgm)->usbhandle);
-    libusb_exit(PDATA(pgm)->ctx);
+    libusb_close(my.usbhandle);
+    libusb_exit(my.ctx);
     return -1;
   }
   return 0;
@@ -263,11 +263,11 @@ static void ch341a_close(PROGRAMMER *pgm) {
 
   CH341ChipSelect(pgm, cs, false);
 
-  if(PDATA(pgm)->usbhandle != NULL) {
-    libusb_release_interface(PDATA(pgm)->usbhandle, 0);
-    libusb_close(PDATA(pgm)->usbhandle);
+  if(my.usbhandle != NULL) {
+    libusb_release_interface(my.usbhandle, 0);
+    libusb_close(my.usbhandle);
   }
-  libusb_exit(PDATA(pgm)->ctx);
+  libusb_exit(my.ctx);
 }
 
 static int ch341a_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
diff --git a/src/jtag3.c b/src/jtag3.c
index 02d3dc18..a3be21f8 100644
--- a/src/jtag3.c
+++ b/src/jtag3.c
@@ -133,7 +133,7 @@ struct pdata {
   unsigned char signature_cache[2];     // Used in jtag3_read_byte()
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 /*
  * pgm->flag is marked as "for private use of the programmer". The following
@@ -463,7 +463,7 @@ int jtag3_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
   buf = mmt_malloc(len + 4);
   buf[0] = TOKEN;
   buf[1] = 0;                   // Dummy
-  u16_to_b2(buf + 2, PDATA(pgm)->command_sequence);
+  u16_to_b2(buf + 2, my.command_sequence);
   memcpy(buf + 4, data, len);
 
   if(serial_send(&pgm->fd, buf, len + 4) != 0) {
@@ -514,7 +514,7 @@ static int jtag3_edbg_send(const PROGRAMMER *pgm, unsigned char *data, size_t le
       buf[3] = (this_len + 4) & 0xff;
       buf[4] = TOKEN;
       buf[5] = 0;               // Dummy
-      u16_to_b2(buf + 6, PDATA(pgm)->command_sequence);
+      u16_to_b2(buf + 6, my.command_sequence);
       if(this_len < 0) {
         pmsg_error("unexpected this_len = %d\n", this_len);
         return -1;
@@ -790,10 +790,10 @@ int jtag3_recv(const PROGRAMMER *pgm, unsigned char **msg) {
     rv &= USB_RECV_LENGTH_MASK;
     r_seqno = ((*msg)[2] << 8) | (*msg)[1];
     pmsg_debug("%s(): got message seqno %d (command_sequence == %d)\n",
-      __func__, r_seqno, PDATA(pgm)->command_sequence);
-    if(r_seqno == PDATA(pgm)->command_sequence) {
-      if(++(PDATA(pgm)->command_sequence) == 0xffff)
-        PDATA(pgm)->command_sequence = 0;
+      __func__, r_seqno, my.command_sequence);
+    if(r_seqno == my.command_sequence) {
+      if(++(my.command_sequence) == 0xffff)
+        my.command_sequence = 0;
       /*
        * We move the payload to the beginning of the buffer, to make the job
        * easier for the caller.  We have to return the original pointer though,
@@ -809,7 +809,7 @@ int jtag3_recv(const PROGRAMMER *pgm, unsigned char **msg) {
 
       return rv;
     }
-    pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, PDATA(pgm)->command_sequence);
+    pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, my.command_sequence);
 
     mmt_free(*msg);
   }
@@ -913,7 +913,7 @@ static int jtag3_unlock_erase_key(const PROGRAMMER *pgm, const AVRPART *p) {
     return -1;
   mmt_free(resp);
 
-  PDATA(pgm)->prog_enabled = 1;
+  my.prog_enabled = 1;
 
   buf[0] = 0;                   // Disable
   if(jtag3_setparm(pgm, SCOPE_AVR, SET_GET_CTXT_OPTIONS, PARM3_OPT_CHIP_ERASE_TO_ENTER, buf, 1) < 0)
@@ -936,7 +936,7 @@ static int jtag3_program_enable(const PROGRAMMER *pgm) {
   unsigned char buf[3], *resp;
   int status;
 
-  if(PDATA(pgm)->prog_enabled)
+  if(my.prog_enabled)
     return 0;
 
   buf[0] = SCOPE_AVR;
@@ -945,7 +945,7 @@ static int jtag3_program_enable(const PROGRAMMER *pgm) {
 
   if((status = jtag3_command(pgm, buf, 3, &resp, "enter progmode")) >= 0) {
     mmt_free(resp);
-    PDATA(pgm)->prog_enabled = 1;
+    my.prog_enabled = 1;
 
     return LIBAVRDUDE_SUCCESS;
   }
@@ -956,7 +956,7 @@ static int jtag3_program_enable(const PROGRAMMER *pgm) {
 static int jtag3_program_disable(const PROGRAMMER *pgm) {
   unsigned char buf[3], *resp;
 
-  if(!PDATA(pgm)->prog_enabled)
+  if(!my.prog_enabled)
     return 0;
 
   buf[0] = SCOPE_AVR;
@@ -968,7 +968,7 @@ static int jtag3_program_disable(const PROGRAMMER *pgm) {
 
   mmt_free(resp);
 
-  PDATA(pgm)->prog_enabled = 0;
+  my.prog_enabled = 0;
 
   return 0;
 }
@@ -1060,27 +1060,27 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     return -1;
 
   if(conn == PARM3_CONN_PDI || conn == PARM3_CONN_UPDI)
-    PDATA(pgm)->set_sck = jtag3_set_sck_xmega_pdi;
+    my.set_sck = jtag3_set_sck_xmega_pdi;
   else if(conn == PARM3_CONN_JTAG) {
     if(p->prog_modes & PM_PDI)
-      PDATA(pgm)->set_sck = jtag3_set_sck_xmega_jtag;
+      my.set_sck = jtag3_set_sck_xmega_jtag;
     else
-      PDATA(pgm)->set_sck = jtag3_set_sck_mega_jtag;
+      my.set_sck = jtag3_set_sck_mega_jtag;
   }
-  if(pgm->bitclock != 0.0 && PDATA(pgm)->set_sck != NULL) {
+  if(pgm->bitclock != 0.0 && my.set_sck != NULL) {
     unsigned int clock = 1E-3/pgm->bitclock;  // kHz
 
     pmsg_notice2("%s(): trying to set JTAG clock to %u kHz\n", __func__, clock);
     parm[0] = clock & 0xff;
     parm[1] = (clock >> 8) & 0xff;
-    if(PDATA(pgm)->set_sck(pgm, parm) < 0)
+    if(my.set_sck(pgm, parm) < 0)
       return -1;
   }
 
   if(conn == PARM3_CONN_JTAG) {
     pmsg_notice2("%s(): trying to set JTAG daisy-chain info to %d,%d,%d,%d\n", __func__,
-      PDATA(pgm)->jtagchain[0], PDATA(pgm)->jtagchain[1], PDATA(pgm)->jtagchain[2], PDATA(pgm)->jtagchain[3]);
-    if(jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_JTAGCHAIN, PDATA(pgm)->jtagchain, 4) < 0)
+      my.jtagchain[0], my.jtagchain[1], my.jtagchain[2], my.jtagchain[3]);
+    if(jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_JTAGCHAIN, my.jtagchain, 4) < 0)
       return -1;
   }
 
@@ -1088,51 +1088,51 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     jtag3_print_parms1(pgm, progbuf, stderr);
 
   // Read or write SUFFER register
-  if(PDATA(pgm)->suffer_get || PDATA(pgm)->suffer_set) {
+  if(my.suffer_get || my.suffer_set) {
     // Read existing SUFFER value
     if(jtag3_getparm(pgm, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
-      MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data, 1) < 0) {
+      MEDBG_REG_SUFFER_OFFSET, my.suffer_data, 1) < 0) {
       return -1;
     }
-    if(!PDATA(pgm)->suffer_set)
-      msg_info("SUFFER register value read as 0x%02x\n", PDATA(pgm)->suffer_data[0]);
+    if(!my.suffer_set)
+      msg_info("SUFFER register value read as 0x%02x\n", my.suffer_data[0]);
     // Write new SUFFER value
     else {
       if(jtag3_setparm(pgm, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
-        MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data + 1, 1) < 0) {
+        MEDBG_REG_SUFFER_OFFSET, my.suffer_data + 1, 1) < 0) {
         return -1;
       }
       msg_info("SUFFER register value changed from 0x%02x to 0x%02x\n",
-        PDATA(pgm)->suffer_data[0], PDATA(pgm)->suffer_data[1]);
+        my.suffer_data[0], my.suffer_data[1]);
     }
   }
   // Read or write Vtarg switch
-  if(PDATA(pgm)->vtarg_switch_get || PDATA(pgm)->vtarg_switch_set) {
+  if(my.vtarg_switch_get || my.vtarg_switch_set) {
     // Read existing Vtarg switch value
     if(jtag3_getparm(pgm, SCOPE_EDBG, EDBG_CTXT_CONTROL,
-      EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data, 1) < 0) {
+      EDBG_CONTROL_TARGET_POWER, my.vtarg_switch_data, 1) < 0) {
       return -1;
     }
-    if(!PDATA(pgm)->vtarg_switch_set)
-      msg_info("Vtarg switch setting read as %u: target power is switched %s\n", PDATA(pgm)->vtarg_switch_data[0],
-        PDATA(pgm)->vtarg_switch_data[0]? "on": "off");
+    if(!my.vtarg_switch_set)
+      msg_info("Vtarg switch setting read as %u: target power is switched %s\n", my.vtarg_switch_data[0],
+        my.vtarg_switch_data[0]? "on": "off");
     // Write Vtarg switch value
     else {
       if(jtag3_setparm(pgm, SCOPE_EDBG, EDBG_CTXT_CONTROL,
-        EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data + 1, 1) < 0) {
+        EDBG_CONTROL_TARGET_POWER, my.vtarg_switch_data + 1, 1) < 0) {
         return -1;
       }
-      imsg_info("Vtarg switch setting changed from %u to %u\n", PDATA(pgm)->vtarg_switch_data[0],
-        PDATA(pgm)->vtarg_switch_data[1]);
+      imsg_info("Vtarg switch setting changed from %u to %u\n", my.vtarg_switch_data[0],
+        my.vtarg_switch_data[1]);
       // Exit early is the target power switch is off and print sensible info message
-      if(PDATA(pgm)->vtarg_switch_data[1] == 0) {
+      if(my.vtarg_switch_data[1] == 0) {
         pmsg_info("turn on the Vtarg switch to establish connection with the target\n\n");
         return -1;
       }
     }
   }
   // Read or write target voltage
-  if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+  if(my.vtarg_get || my.vtarg_set) {
     // Read current target voltage set value
     unsigned char buf[2];
 
@@ -1140,14 +1140,14 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       return -1;
     double vtarg_read = b2_to_u16(buf)/1000.0;
 
-    if(PDATA(pgm)->vtarg_get)
+    if(my.vtarg_get)
       msg_info("Target voltage value read as %.2fV\n", vtarg_read);
     // Write target voltage value
     else {
-      u16_to_b2(buf, (unsigned) (PDATA(pgm)->vtarg_data*1000));
-      msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, PDATA(pgm)->vtarg_data);
+      u16_to_b2(buf, (unsigned) (my.vtarg_data*1000));
+      msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, my.vtarg_data);
       if(jtag3_setparm(pgm, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
-        msg_warning("Cannot set target voltage %.2fV\n", PDATA(pgm)->vtarg_data);
+        msg_warning("Cannot set target voltage %.2fV\n", my.vtarg_data);
         return -1;
       }
     }
@@ -1167,12 +1167,12 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       m = ldata(ln);
       if(mem_is_flash(m)) {
         if(m->readsize != 0 && m->readsize < m->page_size)
-          PDATA(pgm)->flash_pagesize = m->readsize;
+          my.flash_pagesize = m->readsize;
         else
-          PDATA(pgm)->flash_pagesize = m->page_size;
+          my.flash_pagesize = m->page_size;
         u16_to_b2(xd.flash_page_size, m->page_size);
       } else if(mem_is_eeprom(m)) {
-        PDATA(pgm)->eeprom_pagesize = m->page_size;
+        my.eeprom_pagesize = m->page_size;
         xd.eeprom_page_size = m->page_size;
         u16_to_b2(xd.eeprom_size, m->size);
         u32_to_b4(xd.nvm_eeprom_offset, m->offset);
@@ -1212,9 +1212,9 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
         xd.prog_base_msb = m->offset >> 16;
 
         if(m->readsize != 0 && m->readsize < m->page_size)
-          PDATA(pgm)->flash_pagesize = m->readsize;
+          my.flash_pagesize = m->readsize;
         else
-          PDATA(pgm)->flash_pagesize = m->page_size;
+          my.flash_pagesize = m->page_size;
         xd.flash_page_size = m->page_size & 0xFF;
         xd.flash_page_size_msb = (m->page_size) >> 8;
 
@@ -1225,7 +1225,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
         else
           xd.address_mode = UPDI_ADDRESS_MODE_16BIT;
       } else if(mem_is_eeprom(m)) {
-        PDATA(pgm)->eeprom_pagesize = m->page_size;
+        my.eeprom_pagesize = m->page_size;
         xd.eeprom_page_size = m->page_size;
 
         u16_to_b2(xd.eeprom_bytes, m->size);
@@ -1246,7 +1246,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     }
 
     // Generate UPDI high-voltage pulse if user asks for it and hardware supports it
-    if(PDATA(pgm)->use_hvupdi == true && p->hvupdi_variant != HV_UPDI_VARIANT_1) {
+    if(my.use_hvupdi == true && p->hvupdi_variant != HV_UPDI_VARIANT_1) {
       parm[0] = PARM3_UPDI_HV_NONE;
       for(LNODEID ln = lfirst(pgm->hvupdi_support); ln; ln = lnext(ln)) {
         if(*(int *) ldata(ln) == p->hvupdi_variant) {
@@ -1304,15 +1304,15 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       m = ldata(ln);
       if(mem_is_flash(m)) {
         if(m->readsize != 0 && m->readsize < m->page_size)
-          PDATA(pgm)->flash_pagesize = m->readsize;
+          my.flash_pagesize = m->readsize;
         else
-          PDATA(pgm)->flash_pagesize = m->page_size;
+          my.flash_pagesize = m->page_size;
         u16_to_b2(md.flash_page_size, m->page_size);
         u32_to_b4(md.flash_size, (flashsize = m->size));
         // Do we need it? Just a wild guess
         u32_to_b4(md.boot_address, (m->size - m->page_size*4)/2);
       } else if(mem_is_eeprom(m)) {
-        PDATA(pgm)->eeprom_pagesize = m->page_size;
+        my.eeprom_pagesize = m->page_size;
         md.eeprom_page_size = m->page_size;
         u16_to_b2(md.eeprom_size, m->size);
       }
@@ -1394,7 +1394,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   mmt_free(resp);
 
   if(pgm->read_sib) {
-    if(pgm->read_sib(pgm, p, PDATA(pgm)->sib_string) < 0) {
+    if(pgm->read_sib(pgm, p, my.sib_string) < 0) {
       pmsg_warning("cannot read SIB string from target %s\n", p->desc);
     }
   }
@@ -1406,7 +1406,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     pmsg_notice("silicon revision: %x.%x\n", chip_rev[0] >> 4, chip_rev[0] & 0x0f);
   }
 
-  PDATA(pgm)->boot_start = ULONG_MAX;
+  my.boot_start = ULONG_MAX;
   if(p->prog_modes & PM_PDI) {
     // Find the border between application and boot area
     AVRMEM *bootmem = avr_locate_boot(p);
@@ -1415,24 +1415,24 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     if(bootmem == NULL || flashmem == NULL) {
       pmsg_error("cannot locate flash or boot memories in description\n");
     } else {
-      PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
+      my.boot_start = bootmem->offset - flashmem->offset;
     }
   }
 
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
   return 0;
 }
 
 static void jtag3_disable(const PROGRAMMER *pgm) {
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  PDATA(pgm)->flash_pagecache = NULL;
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->eeprom_pagecache = NULL;
+  mmt_free(my.flash_pagecache);
+  my.flash_pagecache = NULL;
+  mmt_free(my.eeprom_pagecache);
+  my.eeprom_pagecache = NULL;
 
   /*
    * jtag3_program_disable() doesn't do anything if the device is currently not
@@ -1465,10 +1465,10 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
       }
       pmsg_notice2("%s(): JTAG chain parsed as:\n", __func__);
       imsg_notice2("%u units before, %u units after, %u bits before, %u bits after\n", ub, ua, bb, ba);
-      PDATA(pgm)->jtagchain[0] = ub;
-      PDATA(pgm)->jtagchain[1] = ua;
-      PDATA(pgm)->jtagchain[2] = bb;
-      PDATA(pgm)->jtagchain[3] = ba;
+      my.jtagchain[0] = ub;
+      my.jtagchain[1] = ua;
+      my.jtagchain[2] = bb;
+      my.jtagchain[3] = ba;
       continue;
     }
     // HVUPDI
@@ -1487,7 +1487,7 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         rv = -1;
         break;
       }
-      PDATA(pgm)->use_hvupdi = true;
+      my.use_hvupdi = true;
       continue;
     }
     // SUFFER bits
@@ -1500,21 +1500,21 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
       if(pgm->extra_features & HAS_SUFFER) {
         // Set SUFFER value
         if(str_starts(extended_param, "suffer=")) {
-          if(sscanf(extended_param, "suffer=%hhi", PDATA(pgm)->suffer_data + 1) < 1) {
+          if(sscanf(extended_param, "suffer=%hhi", my.suffer_data + 1) < 1) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          if((PDATA(pgm)->suffer_data[1] & 0x78) != 0x78) {
-            PDATA(pgm)->suffer_data[1] |= 0x78;
-            pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n", PDATA(pgm)->suffer_data[1]);
+          if((my.suffer_data[1] & 0x78) != 0x78) {
+            my.suffer_data[1] |= 0x78;
+            pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n", my.suffer_data[1]);
           }
-          PDATA(pgm)->suffer_set = true;
+          my.suffer_set = true;
           continue;
         }
         // Get SUFFER value
         if(str_eq(extended_param, "suffer")) {
-          PDATA(pgm)->suffer_get = true;
+          my.suffer_get = true;
           continue;
         }
         pmsg_error("invalid setting in -x %s; use -x suffer or -x suffer=<n>\n", extended_param);
@@ -1527,19 +1527,19 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
       if(pgm->extra_features & HAS_VTARG_SWITCH) {
         // Set Vtarget switch value
         if(str_starts(extended_param, "vtarg_switch=")) {
-          int sscanf_success = sscanf(extended_param, "vtarg_switch=%hhi", PDATA(pgm)->vtarg_switch_data + 1);
+          int sscanf_success = sscanf(extended_param, "vtarg_switch=%hhi", my.vtarg_switch_data + 1);
 
-          if(sscanf_success < 1 || PDATA(pgm)->vtarg_switch_data[1] > 1) {
+          if(sscanf_success < 1 || my.vtarg_switch_data[1] > 1) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          PDATA(pgm)->vtarg_switch_set = true;
+          my.vtarg_switch_set = true;
           continue;
         }
         // Get Vtarget switch value
         if(str_eq(extended_param, "vtarg_switch")) {
-          PDATA(pgm)->vtarg_switch_get = true;
+          my.vtarg_switch_get = true;
           continue;
         }
         pmsg_error("invalid setting in -x %s; use -x vtarg_switch or -x vtarg_switch=<0..1>\n", extended_param);
@@ -1555,18 +1555,18 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
           double vtarg_set_val = 0;
           int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
 
-          PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
+          my.vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
           if(sscanf_success < 1 || vtarg_set_val < 0) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          PDATA(pgm)->vtarg_set = true;
+          my.vtarg_set = true;
           continue;
         }
         // Get target voltage
         else if(str_eq(extended_param, "vtarg")) {
-          PDATA(pgm)->vtarg_get = true;
+          my.vtarg_get = true;
           continue;
         }
         pmsg_error("invalid setting in -x %s; use -x vtarg or -x vtarg=<dbl>\n", extended_param);
@@ -1578,12 +1578,12 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
     if(str_starts(extended_param, "mode") && (str_starts(pgmid, "pickit4") || str_starts(pgmid, "snap"))) {
       // Flag a switch to AVR mode
       if(str_caseeq(extended_param, "mode=avr")) {
-        PDATA(pgm)->pk4_snap_mode = PK4_SNAP_MODE_AVR;
+        my.pk4_snap_mode = PK4_SNAP_MODE_AVR;
         continue;
       }
       // Flag a switch to PIC mode
       if(str_caseeq(extended_param, "mode=pic")) {
-        PDATA(pgm)->pk4_snap_mode = PK4_SNAP_MODE_PIC;
+        my.pk4_snap_mode = PK4_SNAP_MODE_PIC;
         continue;
       }
       pmsg_error("invalid setting in -x %s; use -x mode=avr or -x mode=pic\n", extended_param);
@@ -1786,7 +1786,7 @@ int jtag3_open_common(PROGRAMMER *pgm, const char *port, int mode_switch) {
 static int jtag3_open(PROGRAMMER *pgm, const char *port) {
   pmsg_notice2("jtag3_open()\n");
 
-  int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
+  int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
 
   if(rc < 0)
     return rc;
@@ -1797,7 +1797,7 @@ static int jtag3_open(PROGRAMMER *pgm, const char *port) {
 static int jtag3_open_dw(PROGRAMMER *pgm, const char *port) {
   pmsg_notice2("jtag3_open_dw()\n");
 
-  int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
+  int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
 
   if(rc < 0)
     return rc;
@@ -1810,7 +1810,7 @@ static int jtag3_open_dw(PROGRAMMER *pgm, const char *port) {
 
 static int jtag3_open_pdi(PROGRAMMER *pgm, const char *port) {
   pmsg_notice2("jtag3_open_pdi()\n");
-  int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
+  int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
 
   if(rc < 0)
     return rc;
@@ -1828,7 +1828,7 @@ static int jtag3_open_updi(PROGRAMMER *pgm, const char *port) {
     msg_notice2(" %d", *(int *) ldata(ln));
   msg_notice2("\n");
 
-  int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
+  int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
 
   if(rc < 0)
     return rc;
@@ -1883,10 +1883,10 @@ static int jtag3_page_erase(const PROGRAMMER *pgm, const AVRPART *p, const AVRME
 
   if(mem_is_in_flash(m)) {
     cmd[3] = is_updi(p) || jtag3_mtype(pgm, p, m, addr) == MTYPE_FLASH? XMEGA_ERASE_APP_PAGE: XMEGA_ERASE_BOOT_PAGE;
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    my.flash_pageaddr = ~0UL;
   } else if(mem_is_eeprom(m)) {
     cmd[3] = XMEGA_ERASE_EEPROM_PAGE;
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
   } else if(mem_is_userrow(m)) {
     cmd[3] = XMEGA_ERASE_USERSIG;
   } else if(mem_is_bootrow(m)) {
@@ -1933,7 +1933,7 @@ static int jtag3_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
   cmd[1] = CMD3_WRITE_MEMORY;
   cmd[2] = 0;
   if(mem_is_flash(m)) {
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    my.flash_pageaddr = ~0UL;
     cmd[3] = jtag3_mtype(pgm, p, m, addr);
     if(p->prog_modes & PM_PDI)
       // Dynamically decide between flash/boot mtype
@@ -1955,7 +1955,7 @@ static int jtag3_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
       return n_bytes;
     }
     cmd[3] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM_PAGE;
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
   } else if(mem_is_userrow(m) || mem_is_bootrow(m)) {
     cmd[3] = MTYPE_USERSIG;
   } else if(mem_is_boot(m)) {
@@ -2126,10 +2126,10 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
   cmd[3] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_FLASH: MTYPE_FLASH_PAGE;
   if(mem_is_in_flash(mem)) {
     addr += mem->offset & (512*1024 - 1);     // Max 512 KiB flash @@@ could be max 8M
-    pagesize = PDATA(pgm)->flash_pagesize;
+    pagesize = my.flash_pagesize;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-    cache_ptr = PDATA(pgm)->flash_pagecache;
+    paddr_ptr = &my.flash_pageaddr;
+    cache_ptr = my.flash_pagecache;
   } else if(mem_is_eeprom(mem)) {
     if((pgm->flag & PGM_FL_IS_DW) || (p->prog_modes & (PM_PDI | PM_UPDI))) {
       cmd[3] = MTYPE_EEPROM;
@@ -2138,8 +2138,8 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
     }
     pagesize = mem->page_size;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-    cache_ptr = PDATA(pgm)->eeprom_pagecache;
+    paddr_ptr = &my.eeprom_pageaddr;
+    cache_ptr = my.eeprom_pagecache;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     cmd[3] = MTYPE_FUSE_BITS;
     if(!(p->prog_modes & PM_UPDI) && mem_is_a_fuse(mem))
@@ -2173,11 +2173,11 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
         p->desc, addr, AVR_SIBLEN - 1);
       return -1;
     }
-    if(!*PDATA(pgm)->sib_string) {
+    if(!*my.sib_string) {
       pmsg_error("cannot read byte from %s sib as memory not initialised\n", p->desc);
       return -1;
     }
-    *value = PDATA(pgm)->sib_string[addr];
+    *value = my.sib_string[addr];
     return 0;
   } else if(mem_is_signature(mem)) {
     cmd[3] = MTYPE_SIGN_JTAG;
@@ -2195,13 +2195,13 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
       if((status = jtag3_command(pgm, cmd, 12, &resp, "read memory")) < 0)
         return status;
 
-      PDATA(pgm)->signature_cache[0] = resp[4];
-      PDATA(pgm)->signature_cache[1] = resp[5];
+      my.signature_cache[0] = resp[4];
+      my.signature_cache[1] = resp[5];
       *value = resp[3];
       mmt_free(resp);
       return 0;
     } else if(addr <= 2) {
-      *value = PDATA(pgm)->signature_cache[addr - 1];
+      *value = my.signature_cache[addr - 1];
       return 0;
     } else {
       // Should not happen
@@ -2300,19 +2300,19 @@ static int jtag3_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRME
   cmd[2] = 0;
   cmd[3] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_FLASH: MTYPE_SPM;
   if(mem_is_flash(mem)) {
-    cache_ptr = PDATA(pgm)->flash_pagecache;
-    pagesize = PDATA(pgm)->flash_pagesize;
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    cache_ptr = my.flash_pagecache;
+    pagesize = my.flash_pagesize;
+    my.flash_pageaddr = ~0UL;
     if(pgm->flag & PGM_FL_IS_DW)
       unsupp = 1;
   } else if(mem_is_eeprom(mem)) {
     if(pgm->flag & PGM_FL_IS_DW) {
       cmd[3] = MTYPE_EEPROM;
     } else {
-      cache_ptr = PDATA(pgm)->eeprom_pagecache;
-      pagesize = PDATA(pgm)->eeprom_pagesize;
+      cache_ptr = my.eeprom_pagecache;
+      pagesize = my.eeprom_pagesize;
     }
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     cmd[3] = MTYPE_FUSE_BITS;
     if(!(p->prog_modes & PM_UPDI) && mem_is_a_fuse(mem))
@@ -2392,12 +2392,12 @@ static int jtag3_set_sck_period(const PROGRAMMER *pgm, double v) {
   parm[0] = clock & 0xff;
   parm[1] = (clock >> 8) & 0xff;
 
-  if(PDATA(pgm)->set_sck == NULL) {
+  if(my.set_sck == NULL) {
     pmsg_error("no backend to set the SCK period for\n");
     return -1;
   }
 
-  return (PDATA(pgm)->set_sck(pgm, parm) < 0)? -1: 0;
+  return (my.set_sck(pgm, parm) < 0)? -1: 0;
 }
 
 static int jtag3_get_sck_period(const PROGRAMMER *pgm, double *v) {
@@ -2769,14 +2769,14 @@ static unsigned char jtag3_mtype(const PROGRAMMER *pgm, const AVRPART *p, const
   return
     !is_pdi(p)? MTYPE_FLASH_PAGE:
     mem_is_boot(m)? MTYPE_BOOT_FLASH:
-    mem_is_flash(m) && is_pdi(p) && addr >= PDATA(pgm)->boot_start? MTYPE_BOOT_FLASH: MTYPE_FLASH;
+    mem_is_flash(m) && is_pdi(p) && addr >= my.boot_start? MTYPE_BOOT_FLASH: MTYPE_FLASH;
 }
 
 static unsigned int jtag3_memaddr(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, unsigned long addr) {
   if(is_pdi(p)) {               // Xmega
-    if(mem_is_flash(m) && addr >= PDATA(pgm)->boot_start)       // Boot is special and gets its own region
-      addr -= PDATA(pgm)->boot_start;
-    if(mem_is_in_flash(m) && !mem_is_boot(m))   // Apptable, application and flash
+    if(mem_is_flash(m) && addr >= my.boot_start) // Boot is special and gets its own region
+      addr -= my.boot_start;
+    if(mem_is_in_flash(m) && !mem_is_boot(m))    // Apptable, application and flash
       addr += avr_flash_offset(p, m, addr);
     if(mem_is_in_sigrow(m)) {
       AVRMEM *sigrow = avr_locate_sigrow(p);
@@ -2890,7 +2890,7 @@ static int jtag3_initialize_tpi(const PROGRAMMER *pgm, const AVRPART *p) {
   int status;
 
   // Read or write target voltage
-  if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+  if(my.vtarg_get || my.vtarg_set) {
     // Read current target voltage set value
     unsigned char buf[2];
 
@@ -2898,14 +2898,14 @@ static int jtag3_initialize_tpi(const PROGRAMMER *pgm, const AVRPART *p) {
       return -1;
     double vtarg_read = b2_to_u16(buf)/1000.0;
 
-    if(PDATA(pgm)->vtarg_get)
+    if(my.vtarg_get)
       msg_info("Target voltage value read as %.2fV\n", vtarg_read);
     // Write target voltage value
     else {
-      u16_to_b2(buf, (unsigned) (PDATA(pgm)->vtarg_data*1000));
-      msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, PDATA(pgm)->vtarg_data);
+      u16_to_b2(buf, (unsigned) (my.vtarg_data*1000));
+      msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, my.vtarg_data);
       if(jtag3_setparm(pgm, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
-        msg_warning("Cannot set target voltage %.2fV\n", PDATA(pgm)->vtarg_data);
+        msg_warning("Cannot set target voltage %.2fV\n", my.vtarg_data);
         return -1;
       }
     }
@@ -3096,7 +3096,7 @@ static int jtag3_chip_erase_tpi(const PROGRAMMER *pgm, const AVRPART *p) {
 static int jtag3_open_tpi(PROGRAMMER *pgm, const char *port) {
   pmsg_notice2("jtag3_open_tpi()\n");
 
-  return jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
+  return jtag3_open_common(pgm, port, my.pk4_snap_mode);
 }
 
 void jtag3_close_tpi(PROGRAMMER *pgm) {
diff --git a/src/jtagmkI.c b/src/jtagmkI.c
index 5872c006..3c732af6 100644
--- a/src/jtagmkI.c
+++ b/src/jtagmkI.c
@@ -50,7 +50,7 @@ struct pdata {
   int prog_enabled;             // Cached value of PROGRAMMING status
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 /*
  * Table of baud rates supported by the mkI ICE, accompanied by their internal
@@ -322,10 +322,10 @@ static void jtagmkI_set_devdescr(const PROGRAMMER *pgm, const AVRPART *p) {
   for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
     m = ldata(ln);
     if(mem_is_flash(m)) {
-      PDATA(pgm)->flash_pagesize = m->page_size;
-      u16_to_b2(sendbuf.dd.uiFlashPageSize, PDATA(pgm)->flash_pagesize);
+      my.flash_pagesize = m->page_size;
+      u16_to_b2(sendbuf.dd.uiFlashPageSize, my.flash_pagesize);
     } else if(mem_is_eeprom(m)) {
-      sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
+      sendbuf.dd.ucEepromPageSize = my.eeprom_pagesize = m->page_size;
     }
   }
 
@@ -370,7 +370,7 @@ static int jtagmkI_program_enable_dummy(const PROGRAMMER *pgm, const AVRPART *p)
 static int jtagmkI_program_enable(const PROGRAMMER *pgm) {
   unsigned char buf[1], resp[2];
 
-  if(PDATA(pgm)->prog_enabled)
+  if(my.prog_enabled)
     return 0;
 
   buf[0] = CMD_ENTER_PROGMODE;
@@ -387,7 +387,7 @@ static int jtagmkI_program_enable(const PROGRAMMER *pgm) {
     msg_notice2("OK\n");
   }
 
-  PDATA(pgm)->prog_enabled = 1;
+  my.prog_enabled = 1;
 
   return 0;
 }
@@ -395,7 +395,7 @@ static int jtagmkI_program_enable(const PROGRAMMER *pgm) {
 static int jtagmkI_program_disable(const PROGRAMMER *pgm) {
   unsigned char buf[1], resp[2];
 
-  if(!PDATA(pgm)->prog_enabled)
+  if(!my.prog_enabled)
     return 0;
 
   if(pgm->fd.ifd != -1) {
@@ -413,7 +413,7 @@ static int jtagmkI_program_disable(const PROGRAMMER *pgm) {
       msg_notice2("OK\n");
     }
   }
-  PDATA(pgm)->prog_enabled = 0;
+  my.prog_enabled = 0;
 
   return 0;
 }
@@ -440,13 +440,13 @@ static int jtagmkI_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 
   jtagmkI_drain(pgm, 0);
 
-  if((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
+  if((serdev->flags & SERDEV_FL_CANSETSPEED) && my.initial_baudrate != pgm->baudrate) {
     if((b = jtagmkI_get_baud(pgm->baudrate)) == 0) {
       pmsg_error("unsupported baudrate %d\n", pgm->baudrate);
     } else {
       pmsg_notice2("%s(): trying to set baudrate to %d\n", __func__, pgm->baudrate);
       if(jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
-        PDATA(pgm)->initial_baudrate = pgm->baudrate;   // Don't adjust again later
+        my.initial_baudrate = pgm->baudrate; // Don't adjust again later
         serial_setparams(&pgm->fd, pgm->baudrate, SERIAL_8N1);
       }
     }
@@ -472,15 +472,15 @@ static int jtagmkI_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   // Must set the device descriptor before entering programming mode
   jtagmkI_set_devdescr(pgm, p);
 
-  jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_LOW, PDATA(pgm)->flash_pagesize & 0xff);
-  jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_HIGH, PDATA(pgm)->flash_pagesize >> 8);
-  jtagmkI_setparm(pgm, PARM_EEPROM_PAGESIZE, PDATA(pgm)->eeprom_pagesize & 0xff);
+  jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_LOW, my.flash_pagesize & 0xff);
+  jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_HIGH, my.flash_pagesize >> 8);
+  jtagmkI_setparm(pgm, PARM_EEPROM_PAGESIZE, my.eeprom_pagesize & 0xff);
 
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
   if(jtagmkI_reset(pgm) < 0)
     return -1;
@@ -494,10 +494,10 @@ static int jtagmkI_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 }
 
 static void jtagmkI_disable(const PROGRAMMER *pgm) {
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  PDATA(pgm)->flash_pagecache = NULL;
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->eeprom_pagecache = NULL;
+  mmt_free(my.flash_pagecache);
+  my.flash_pagecache = NULL;
+  mmt_free(my.eeprom_pagecache);
+  my.eeprom_pagecache = NULL;
 
   (void) jtagmkI_program_disable(pgm);
 }
@@ -512,7 +512,7 @@ static int jtagmkI_open(PROGRAMMER *pgm, const char *port) {
   pmsg_notice2("jtagmkI_open()\n");
 
   pgm->port = port;
-  PDATA(pgm)->initial_baudrate = -1L;
+  my.initial_baudrate = -1L;
 
   for(i = 0; i < sizeof(baudtab)/sizeof(baudtab[0]); i++) {
     union pinfo pinfo;
@@ -528,7 +528,7 @@ static int jtagmkI_open(PROGRAMMER *pgm, const char *port) {
     jtagmkI_drain(pgm, 0);
 
     if(jtagmkI_getsync(pgm) == 0) {
-      PDATA(pgm)->initial_baudrate = baudtab[i].baud;
+      my.initial_baudrate = baudtab[i].baud;
       pmsg_notice2("%s(): succeeded\n", __func__);
       return 0;
     }
@@ -551,11 +551,11 @@ static void jtagmkI_close(PROGRAMMER *pgm) {
    * Revert baud rate to what it used to be when we started.  This appears to
    * make AVR Studio happier when it is about to access the ICE later on.
    */
-  if((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
-    if((b = jtagmkI_get_baud(PDATA(pgm)->initial_baudrate)) == 0) {
-      pmsg_error("unsupported baudrate %d\n", PDATA(pgm)->initial_baudrate);
+  if((serdev->flags & SERDEV_FL_CANSETSPEED) && my.initial_baudrate != pgm->baudrate) {
+    if((b = jtagmkI_get_baud(my.initial_baudrate)) == 0) {
+      pmsg_error("unsupported baudrate %d\n", my.initial_baudrate);
     } else {
-      pmsg_notice2("%s(): trying to set baudrate to %d\n", __func__, PDATA(pgm)->initial_baudrate);
+      pmsg_notice2("%s(): trying to set baudrate to %d\n", __func__, my.initial_baudrate);
       if(jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
         serial_setparams(&pgm->fd, pgm->baudrate, SERIAL_8N1);
       }
@@ -597,13 +597,13 @@ static int jtagmkI_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AV
   cmd[0] = CMD_WRITE_MEM;
   if(mem_is_flash(m)) {
     cmd[1] = MTYPE_FLASH_PAGE;
-    PDATA(pgm)->flash_pageaddr = ~0UL;
-    page_size = PDATA(pgm)->flash_pagesize;
+    my.flash_pageaddr = ~0UL;
+    page_size = my.flash_pagesize;
     is_flash = 1;
   } else if(mem_is_eeprom(m)) {
     cmd[1] = MTYPE_EEPROM_PAGE;
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
-    page_size = PDATA(pgm)->eeprom_pagesize;
+    my.eeprom_pageaddr = ~0UL;
+    page_size = my.eeprom_pagesize;
   }
   datacmd[0] = CMD_DATA;
 
@@ -790,15 +790,15 @@ static int jtagmkI_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
     cmd[1] = MTYPE_FLASH_PAGE;
     pagesize = mem->page_size;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-    cache_ptr = PDATA(pgm)->flash_pagecache;
+    paddr_ptr = &my.flash_pageaddr;
+    cache_ptr = my.flash_pagecache;
     is_flash = 1;
   } else if(mem_is_eeprom(mem)) {
     cmd[1] = MTYPE_EEPROM_PAGE;
     pagesize = mem->page_size;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-    cache_ptr = PDATA(pgm)->eeprom_pagecache;
+    paddr_ptr = &my.eeprom_pageaddr;
+    cache_ptr = my.eeprom_pagecache;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     cmd[1] = MTYPE_FUSE_BITS;
     if(mem_is_a_fuse(mem))
@@ -894,12 +894,12 @@ static int jtagmkI_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
   if(mem_is_flash(mem)) {
     cmd[1] = MTYPE_SPM;
     need_progmode = 0;
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    my.flash_pageaddr = ~0UL;
   } else if(mem_is_eeprom(mem)) {
     cmd[1] = MTYPE_EEPROM;
     need_progmode = 0;
     need_dummy_read = 1;
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     cmd[1] = MTYPE_FUSE_BITS;
     need_dummy_read = 1;
diff --git a/src/jtagmkII.c b/src/jtagmkII.c
index 4e464918..353fa747 100644
--- a/src/jtagmkII.c
+++ b/src/jtagmkII.c
@@ -101,7 +101,7 @@ struct pdata {
   char msg[64];                 // Used in jtagmkII_get_rc()
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 #define RC(x) { x, #x },
 static const struct {
@@ -175,7 +175,7 @@ static int jtagmkII_paged_load32(const PROGRAMMER *pgm, const AVRPART *p, const
 
 void jtagmkII_setup(PROGRAMMER *pgm) {
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->rts_mode = RTS_MODE_DEFAULT;
+  my.rts_mode = RTS_MODE_DEFAULT;
 }
 
 void jtagmkII_teardown(PROGRAMMER *pgm) {
@@ -238,8 +238,8 @@ static const char *jtagmkII_get_rc(const PROGRAMMER *pgm, unsigned int rc) {
     if(jtagresults[i].code == rc)
       return jtagresults[i].descr;
 
-  sprintf(PDATA(pgm)->msg, "Unknown JTAG ICE mkII result code 0x%02x", rc);
-  return PDATA(pgm)->msg;
+  sprintf(my.msg, "Unknown JTAG ICE mkII result code 0x%02x", rc);
+  return my.msg;
 }
 
 static void jtagmkII_print_memory(unsigned char *b, size_t s) {
@@ -422,7 +422,7 @@ int jtagmkII_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
 
   buf = mmt_malloc(len + 10);
   buf[0] = MESSAGE_START;
-  u16_to_b2(buf + 1, PDATA(pgm)->command_sequence);
+  u16_to_b2(buf + 1, my.command_sequence);
   u32_to_b4(buf + 3, len);
   buf[7] = TOKEN;
   memcpy(buf + 8, data, len);
@@ -594,10 +594,10 @@ int jtagmkII_recv(const PROGRAMMER *pgm, unsigned char **msg) {
     if((rv = jtagmkII_recv_frame(pgm, msg, &r_seqno)) <= 0)
       return rv;
     pmsg_debug("%s(): got message seqno %d (command_sequence == %d)\n",
-      __func__, r_seqno, PDATA(pgm)->command_sequence);
-    if(r_seqno == PDATA(pgm)->command_sequence) {
-      if(++(PDATA(pgm)->command_sequence) == 0xffff)
-        PDATA(pgm)->command_sequence = 0;
+      __func__, r_seqno, my.command_sequence);
+    if(r_seqno == my.command_sequence) {
+      if(++(my.command_sequence) == 0xffff)
+        my.command_sequence = 0;
       /*
        * We move the payload to the beginning of the buffer, to make the job
        * easier for the caller.  We have to return the original pointer though,
@@ -613,7 +613,7 @@ int jtagmkII_recv(const PROGRAMMER *pgm, unsigned char **msg) {
     if(r_seqno == 0xffff) {
       pmsg_debug("%s(): got asynchronous event\n", __func__);
     } else {
-      pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, PDATA(pgm)->command_sequence);
+      pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, my.command_sequence);
     }
     mmt_free(*msg);
   }
@@ -657,9 +657,9 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
     if(status > 0) {
       if((c = resp[0]) == RSP_SIGN_ON) {
         fwver = ((unsigned) resp[8] << 8) | (unsigned) resp[7];
-        PDATA(pgm)->fwver = fwver;
+        my.fwver = fwver;
         hwver = (unsigned) resp[9];
-        memcpy(PDATA(pgm)->serno, resp + 10, 6);
+        memcpy(my.serno, resp + 10, 6);
         if(status > 17) {
           imsg_notice2("JTAG ICE mkII sign-on message:\n");
           imsg_notice2("Communications protocol version: %u\n", (unsigned) resp[1]);
@@ -672,8 +672,8 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
           imsg_notice2("  firmware version:              %u.%02u\n", (unsigned) resp[8], (unsigned) resp[7]);
           imsg_notice2("  hardware version:              %u\n", (unsigned) resp[9]);
           imsg_notice2("Serial number:                   %02x:%02x:%02x:%02x:%02x:%02x\n",
-            PDATA(pgm)->serno[0], PDATA(pgm)->serno[1], PDATA(pgm)->serno[2],
-            PDATA(pgm)->serno[3], PDATA(pgm)->serno[4], PDATA(pgm)->serno[5]);
+            my.serno[0], my.serno[1], my.serno[2],
+            my.serno[3], my.serno[4], my.serno[5]);
           resp[status - 1] = '\0';
           imsg_notice2("Device ID:                       %s\n", resp + 16);
         }
@@ -691,7 +691,7 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
     return -1;
   }
 
-  PDATA(pgm)->device_descriptor_length = sizeof(struct device_descriptor);
+  my.device_descriptor_length = sizeof(struct device_descriptor);
   /*
    * There's no official documentation from Atmel about what firmware revision
    * matches what device descriptor length.  The algorithm below has been found
@@ -699,16 +699,16 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
    */
 #define FWVER(maj, min) ((maj << 8) | (min))
   if(!is_dragon && fwver < FWVER(3, 16)) {
-    PDATA(pgm)->device_descriptor_length -= 2;
+    my.device_descriptor_length -= 2;
     pmsg_warning("S_MCU firmware version might be too old to work correctly\n");
   } else if(!is_dragon && fwver < FWVER(4, 0)) {
-    PDATA(pgm)->device_descriptor_length -= 2;
+    my.device_descriptor_length -= 2;
   }
   if(mode != EMULATOR_MODE_SPI)
     pmsg_notice2("%s(): using a %u-byte device descriptor\n",
-      __func__, (unsigned) PDATA(pgm)->device_descriptor_length);
+      __func__, (unsigned) my.device_descriptor_length);
   if(mode == EMULATOR_MODE_SPI) {
-    PDATA(pgm)->device_descriptor_length = 0;
+    my.device_descriptor_length = 0;
     if(!is_dragon && fwver < FWVER(4, 14)) {
       pmsg_error("ISP functionality requires firmware version >= 4.14\n");
       return -1;
@@ -830,7 +830,7 @@ static int jtagmkII_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
   if(p->prog_modes & PM_Classic)
     pgm->initialize(pgm, p);
 
-  PDATA(pgm)->recently_written = 1;
+  my.recently_written = 1;
   return 0;
 }
 
@@ -870,9 +870,9 @@ static void jtagmkII_set_devdescr(const PROGRAMMER *pgm, const AVRPART *p) {
 
     if(mem_is_flash(m)) {
       if(m->page_size > 256)
-        PDATA(pgm)->flash_pagesize = 256;
+        my.flash_pagesize = 256;
       else
-        PDATA(pgm)->flash_pagesize = m->page_size;
+        my.flash_pagesize = m->page_size;
       u32_to_b4(sendbuf.dd.ulFlashSize, m->size);
       u16_to_b2(sendbuf.dd.uiFlashPageSize, m->page_size);
       u16_to_b2(sendbuf.dd.uiFlashpages, m->size/m->page_size);
@@ -881,13 +881,13 @@ static void jtagmkII_set_devdescr(const PROGRAMMER *pgm, const AVRPART *p) {
         memcpy(sendbuf.dd.ucEepromInst, p->eeprom_instr, EEPROM_INSTR_SIZE);
       }
     } else if(mem_is_eeprom(m)) {
-      sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
+      sendbuf.dd.ucEepromPageSize = my.eeprom_pagesize = m->page_size;
     }
   }
   sendbuf.dd.ucCacheType = p->prog_modes & (PM_PDI | PM_UPDI)? 0x02: 0x00;
 
   pmsg_notice2("%s(): sending set device descriptor command: ", __func__);
-  jtagmkII_send(pgm, (unsigned char *) &sendbuf, PDATA(pgm)->device_descriptor_length + sizeof(unsigned char));
+  jtagmkII_send(pgm, (unsigned char *) &sendbuf, my.device_descriptor_length + sizeof(unsigned char));
 
   status = jtagmkII_recv(pgm, &resp);
   if(status <= 0) {
@@ -928,9 +928,9 @@ static void jtagmkII_set_xmega_params(const PROGRAMMER *pgm, const AVRPART *p) {
     m = ldata(ln);
     if(mem_is_flash(m)) {
       if(m->page_size > 256)
-        PDATA(pgm)->flash_pagesize = 256;
+        my.flash_pagesize = 256;
       else
-        PDATA(pgm)->flash_pagesize = m->page_size;
+        my.flash_pagesize = m->page_size;
       u16_to_b2(sendbuf.dd.flash_page_size, m->page_size);
     } else if(mem_is_eeprom(m)) {
       sendbuf.dd.eeprom_page_size = m->page_size;
@@ -1027,7 +1027,7 @@ static int jtagmkII_program_enable(const PROGRAMMER *pgm) {
   unsigned char buf[1], *resp, c;
   int use_ext_reset;
 
-  if(PDATA(pgm)->prog_enabled)
+  if(my.prog_enabled)
     return 0;
 
   for(use_ext_reset = 0; use_ext_reset <= 1; use_ext_reset++) {
@@ -1065,7 +1065,7 @@ static int jtagmkII_program_enable(const PROGRAMMER *pgm) {
     }
   }
 
-  PDATA(pgm)->prog_enabled = 1;
+  my.prog_enabled = 1;
   return 0;
 }
 
@@ -1073,7 +1073,7 @@ static int jtagmkII_program_disable(const PROGRAMMER *pgm) {
   int status;
   unsigned char buf[1], *resp, c;
 
-  if(!PDATA(pgm)->prog_enabled)
+  if(!my.prog_enabled)
     return 0;
 
   buf[0] = CMND_LEAVE_PROGMODE;
@@ -1098,8 +1098,8 @@ static int jtagmkII_program_disable(const PROGRAMMER *pgm) {
     return -1;
   }
 
-  PDATA(pgm)->recently_written = 0;
-  PDATA(pgm)->prog_enabled = 0;
+  my.recently_written = 0;
+  my.prog_enabled = 0;
   (void) jtagmkII_reset(pgm, 0x01);
 
   return 0;
@@ -1157,8 +1157,8 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   int ok;
   const char *ifname;
 
-  if(PDATA(pgm)->rts_mode != RTS_MODE_DEFAULT) {
-    pmsg_notice("forcing serial DTR/RTS handshake lines %s\n", PDATA(pgm)->rts_mode == RTS_MODE_LOW? "LOW": "HIGH");
+  if(my.rts_mode != RTS_MODE_DEFAULT) {
+    pmsg_notice("forcing serial DTR/RTS handshake lines %s\n", my.rts_mode == RTS_MODE_LOW? "LOW": "HIGH");
   }
 
   // Abort and print error if programmer does not support the target microcontroller
@@ -1203,7 +1203,7 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       return -1;
   }
 
-  if((pgm->flag & PGM_FL_IS_JTAG) && jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, PDATA(pgm)->jtagchain) < 0) {
+  if((pgm->flag & PGM_FL_IS_JTAG) && jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, my.jtagchain) < 0) {
     pmsg_error("unable to setup JTAG chain\n");
     return -1;
   }
@@ -1217,12 +1217,12 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       return -1;
   }
   // Must set the device descriptor before entering programming mode
-  if(PDATA(pgm)->fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI)) != 0)
+  if(my.fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI)) != 0)
     jtagmkII_set_xmega_params(pgm, p);
   else
     jtagmkII_set_devdescr(pgm, p);
 
-  PDATA(pgm)->boot_start = ULONG_MAX;
+  my.boot_start = ULONG_MAX;
   if((p->prog_modes & (PM_PDI | PM_UPDI))) {
     // Find the border between application and boot area
     AVRMEM *bootmem = avr_locate_boot(p);
@@ -1232,7 +1232,7 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       if(str_starts(pgmid, "jtagmkII"))
         pmsg_error("cannot locate flash or boot memories in description\n");
     } else {
-      if(PDATA(pgm)->fwver < 0x700) {
+      if(my.fwver < 0x700) {
         // V7+ firmware does not need this anymore
         unsigned char par[4];
 
@@ -1242,17 +1242,17 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
         (void) jtagmkII_setparm(pgm, PAR_PDI_OFFSET_END, par);
       }
 
-      PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
+      my.boot_start = bootmem->offset - flashmem->offset;
     }
   }
 
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
-  if(PDATA(pgm)->fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
+  if(my.fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
     /*
      * Work around for
      * https://savannah.nongnu.org/bugs/index.php?37942
@@ -1286,10 +1286,10 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 }
 
 static void jtagmkII_disable(const PROGRAMMER *pgm) {
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  PDATA(pgm)->flash_pagecache = NULL;
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->eeprom_pagecache = NULL;
+  mmt_free(my.flash_pagecache);
+  my.flash_pagecache = NULL;
+  mmt_free(my.eeprom_pagecache);
+  my.eeprom_pagecache = NULL;
 
   /*
    * jtagmkII_program_disable() doesn't do anything if the device is currently
@@ -1328,10 +1328,10 @@ static int jtagmkII_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         }
         pmsg_notice2("%s(): JTAG chain parsed as:\n", __func__);
         imsg_notice2("%u units before, %u units after, %u bits before, %u bits after\n", ub, ua, bb, ba);
-        PDATA(pgm)->jtagchain[0] = ub;
-        PDATA(pgm)->jtagchain[1] = ua;
-        PDATA(pgm)->jtagchain[2] = bb;
-        PDATA(pgm)->jtagchain[3] = ba;
+        my.jtagchain[0] = ub;
+        my.jtagchain[1] = ua;
+        my.jtagchain[2] = bb;
+        my.jtagchain[3] = ba;
         continue;
       }
     }
@@ -1341,9 +1341,9 @@ static int jtagmkII_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
 
       if(sscanf(extended_param, "rtsdtr=%4s", rts_mode) == 1) {
         if(str_caseeq(rts_mode, "low")) {
-          PDATA(pgm)->rts_mode = RTS_MODE_LOW;
+          my.rts_mode = RTS_MODE_LOW;
         } else if(str_caseeq(rts_mode, "high")) {
-          PDATA(pgm)->rts_mode = RTS_MODE_HIGH;
+          my.rts_mode = RTS_MODE_HIGH;
         } else {
           pmsg_error("RTS/DTR mode must be LOW or HIGH\n");
           rv = -1;
@@ -1519,9 +1519,9 @@ static int jtagmkII_open_pdi(PROGRAMMER *pgm, const char *port) {
   jtagmkII_drain(pgm, 0);
 
   // Set RTS/DTR high or low based on the user specified rts_mode
-  if(PDATA(pgm)->rts_mode != RTS_MODE_DEFAULT) {
+  if(my.rts_mode != RTS_MODE_DEFAULT) {
     serial_set_dtr_rts(&pgm->fd, 0);
-    serial_set_dtr_rts(&pgm->fd, PDATA(pgm)->rts_mode == RTS_MODE_LOW? 1: 0);
+    serial_set_dtr_rts(&pgm->fd, my.rts_mode == RTS_MODE_LOW? 1: 0);
   }
 
   if(jtagmkII_getsync(pgm, EMULATOR_MODE_PDI) < 0)
@@ -1731,7 +1731,7 @@ void jtagmkII_close(PROGRAMMER *pgm) {
     pmsg_error("bad response to sign-off command: %s\n", jtagmkII_get_rc(pgm, c));
   }
 
-  if(PDATA(pgm)->rts_mode != RTS_MODE_DEFAULT) {
+  if(my.rts_mode != RTS_MODE_DEFAULT) {
     pmsg_notice("releasing DTR/RTS handshake lines\n");
     serial_set_dtr_rts(&pgm->fd, 0);
   }
@@ -1852,7 +1852,7 @@ static int jtagmkII_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
   cmd = mmt_malloc(page_size + 10);
   cmd[0] = CMND_WRITE_MEMORY;
   if(mem_is_flash(m)) {
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    my.flash_pageaddr = ~0UL;
     cmd[1] = jtagmkII_mtype(pgm, p, addr);
     if(p->prog_modes & (PM_PDI | PM_UPDI))      // Dynamically decide between flash/boot mtype
       dynamic_mtype = 1;
@@ -1873,7 +1873,7 @@ static int jtagmkII_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
       return n_bytes;
     }
     cmd[1] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM_PAGE;
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
   } else if(mem_is_userrow(m) || mem_is_bootrow(m)) {
     cmd[1] = MTYPE_USERSIG;
   } else if(mem_is_boot(m)) {
@@ -1944,7 +1944,7 @@ static int jtagmkII_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
   mmt_free(cmd);
   serial_recv_timeout = otimeout;
 
-  PDATA(pgm)->recently_written = 1;
+  my.recently_written = 1;
   return n_bytes;
 }
 
@@ -2032,7 +2032,7 @@ static int jtagmkII_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AV
   }
   serial_recv_timeout = otimeout;
 
-  PDATA(pgm)->recently_written = 0;
+  my.recently_written = 0;
   return n_bytes;
 }
 
@@ -2078,10 +2078,10 @@ static int jtagmkII_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
   addr += mem->offset;
   cmd[1] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_FLASH: MTYPE_FLASH_PAGE;
   if(mem_is_in_flash(mem)) {
-    pagesize = PDATA(pgm)->flash_pagesize;
+    pagesize = my.flash_pagesize;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-    cache_ptr = PDATA(pgm)->flash_pagecache;
+    paddr_ptr = &my.flash_pageaddr;
+    cache_ptr = my.flash_pagecache;
   } else if(mem_is_eeprom(mem)) {
     if((pgm->flag & PGM_FL_IS_DW) || (p->prog_modes & (PM_PDI | PM_UPDI))) {
       // debugWire cannot use page access for EEPROM
@@ -2090,8 +2090,8 @@ static int jtagmkII_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
       cmd[1] = MTYPE_EEPROM_PAGE;
       pagesize = mem->page_size;
       paddr = addr & ~(pagesize - 1);
-      paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-      cache_ptr = PDATA(pgm)->eeprom_pagecache;
+      paddr_ptr = &my.eeprom_pageaddr;
+      cache_ptr = my.eeprom_pagecache;
     }
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     cmd[1] = MTYPE_FUSE_BITS;
@@ -2227,7 +2227,7 @@ retry:
     *value = resp[1];
 
   mmt_free(resp);
-  PDATA(pgm)->recently_written = 0;
+  my.recently_written = 0;
   return 0;
 
 fail:
@@ -2258,14 +2258,14 @@ static int jtagmkII_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
     writesize = 2;
     if(str_eq(p->family_id, "megaAVR") || str_eq(p->family_id, "tinyAVR"))      // AVRs with UPDI except AVR-Dx/Ex
       need_progmode = 0;
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    my.flash_pageaddr = ~0UL;
     if(pgm->flag & PGM_FL_IS_DW)
       unsupp = 1;
   } else if(mem_is_eeprom(mem)) {
     cmd[1] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM;
     if(str_eq(p->family_id, "megaAVR") || str_eq(p->family_id, "tinyAVR"))      // AVRs with UPDI except AVR-Dx/Ex
       need_progmode = 0;
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     cmd[1] = MTYPE_FUSE_BITS;
     if((p->prog_modes & PM_Classic) && mem_is_a_fuse(mem))
@@ -2337,7 +2337,7 @@ retry:
   }
 
   mmt_free(resp);
-  PDATA(pgm)->recently_written = 1;
+  my.recently_written = 1;
   return 0;
 
 fail:
@@ -2533,8 +2533,8 @@ static void jtagmkII_display(const PROGRAMMER *pgm, const char *p) {
   msg_info("%sSec. MCU HW version   : %d\n", p, hw[1]);
   msg_info("%sSec. MCU FW version   : %d.%02d\n", p, fw[3], fw[2]);
   msg_info("%sSerial number         : %02x:%02x:%02x:%02x:%02x:%02x\n", p,
-    PDATA(pgm)->serno[0], PDATA(pgm)->serno[1], PDATA(pgm)->serno[2],
-    PDATA(pgm)->serno[3], PDATA(pgm)->serno[4], PDATA(pgm)->serno[5]);
+    my.serno[0], my.serno[1], my.serno[2],
+    my.serno[3], my.serno[4], my.serno[5]);
 
   jtagmkII_print_parms1(pgm, p, stderr);
 
@@ -2581,7 +2581,7 @@ static void jtagmkII_print_parms(const PROGRAMMER *pgm, FILE *fp) {
 
 static unsigned char jtagmkII_mtype(const PROGRAMMER *pgm, const AVRPART *p, unsigned long addr) {
   if(p->prog_modes & (PM_PDI | PM_UPDI)) {
-    if(addr >= PDATA(pgm)->boot_start)
+    if(addr >= my.boot_start)
       return MTYPE_BOOT_FLASH;
     else
       return MTYPE_FLASH;
@@ -2595,13 +2595,13 @@ static unsigned int jtagmkII_memaddr(const PROGRAMMER *pgm, const AVRPART *p, co
    * Xmega devices handled by V7+ firmware don't want to be told their
    * m->offset within the write memory command.
    */
-  if(PDATA(pgm)->fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
-    if(addr >= PDATA(pgm)->boot_start)
+  if(my.fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
+    if(addr >= my.boot_start)
       /*
        * All memories but "flash" are smaller than boot_start anyway, so no
        * need for an extra check we are operating on "flash"
        */
-      return addr - PDATA(pgm)->boot_start;
+      return addr - my.boot_start;
     else
       // Normal flash, or anything else
       return addr;
@@ -3021,16 +3021,16 @@ static int jtagmkII_initialize32(const PROGRAMMER *pgm, const AVRPART *p) {
   int status, j;
   unsigned char buf[6], *resp;
 
-  if(jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, PDATA(pgm)->jtagchain) < 0) {
+  if(jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, my.jtagchain) < 0) {
     pmsg_error("unable to setup JTAG chain\n");
     return -1;
   }
 
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
   for(j = 0; j < 2; ++j) {
     buf[0] = CMND_GET_IR;
@@ -3356,18 +3356,18 @@ static int jtagmkII_paged_load32(const PROGRAMMER *pgm, const AVRPART *p_unused,
 
   serial_recv_timeout = 256;
 
-  if(!(PDATA(pgm)->flags32 & FLAGS32_WRITE)) {
+  if(!(my.flags32 & FLAGS32_WRITE)) {
     status = jtagmkII_reset32(pgm, AVR32_RESET_READ);
     if(status != 0)
       gotoerr;
   }
 
   // Init SMC and set clocks
-  if(!(PDATA(pgm)->flags32 & FLAGS32_INIT_SMC)) {
+  if(!(my.flags32 & FLAGS32_INIT_SMC)) {
     status = jtagmkII_smc_init32(pgm);
     if(status != 0)
       gotoerr;                  // PLL 0
-    PDATA(pgm)->flags32 |= FLAGS32_INIT_SMC;
+    my.flags32 |= FLAGS32_INIT_SMC;
   }
 
   // msg_error("\n pageSize=%d bytes=%d pages=%d m->offset=0x%x pgm->page_size %d\n",
@@ -3438,7 +3438,7 @@ static int jtagmkII_paged_write32(const PROGRAMMER *pgm, const AVRPART *p_unused
   status = jtagmkII_reset32(pgm, AVR32_RESET_WRITE);
   if(status != 0)
     gotoerr;
-  PDATA(pgm)->flags32 |= FLAGS32_WRITE;
+  my.flags32 |= FLAGS32_WRITE;
 
   pages = (n_bytes - addr - 1)/page_size + 1;
   sPageNum = addr/page_size;
@@ -3448,11 +3448,11 @@ static int jtagmkII_paged_write32(const PROGRAMMER *pgm, const AVRPART *p_unused
   // Before any errors can happen
   cmd = mmt_malloc(pgm->page_size + 10);
   // Init SMC and set clocks
-  if(!(PDATA(pgm)->flags32 & FLAGS32_INIT_SMC)) {
+  if(!(my.flags32 & FLAGS32_INIT_SMC)) {
     status = jtagmkII_smc_init32(pgm);
     if(status != 0)
       gotoerr;                  // PLL 0
-    PDATA(pgm)->flags32 |= FLAGS32_INIT_SMC;
+    my.flags32 |= FLAGS32_INIT_SMC;
   }
 
   // First unlock the pages
@@ -3698,7 +3698,7 @@ static int jtagmkII_updi_term_keep_alive(const PROGRAMMER *pgm, const AVRPART *p
 
 // Read the signature if most recent operation was an erase or a write to ensure it finished
 static int jtagmkII_updi_end_programming(const PROGRAMMER *pgm, const AVRPART *p) {
-  return PDATA(pgm)->recently_written? avr_read(pgm, p, "signature", NULL): 0;
+  return my.recently_written? avr_read(pgm, p, "signature", NULL): 0;
 }
 
 #ifdef __OBJC__
diff --git a/src/micronucleus.c b/src/micronucleus.c
index fd75203e..813b3cd7 100644
--- a/src/micronucleus.c
+++ b/src/micronucleus.c
@@ -77,7 +77,7 @@
 #define MICRONUCLEUS_DEFAULT_TIMEOUT 500
 #define MICRONUCLEUS_MAX_MAJOR_VERSION 2
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // -----------------------------------------------------------------------------
 
@@ -497,7 +497,7 @@ static void micronucleus_teardown(PROGRAMMER *pgm) {
 static int micronucleus_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   pmsg_debug("micronucleus_initialize()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   int result = micronucleus_get_bootloader_info(pdata);
 
@@ -520,7 +520,7 @@ static void micronucleus_powerup(const PROGRAMMER *pgm) {
 static void micronucleus_powerdown(const PROGRAMMER *pgm) {
   pmsg_debug("micronucleus_powerdown()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   if(pdata->write_last_page) {
     pdata->write_last_page = false;
@@ -560,7 +560,7 @@ static int micronucleus_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p,
     return -1;
   }
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   mem->buf[0] = 0x1E;
   mem->buf[1] = pdata->signature1;
@@ -571,7 +571,7 @@ static int micronucleus_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p,
 static int micronucleus_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
   pmsg_debug("micronucleus_chip_erase()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   return micronucleus_erase_device(pdata);
 }
@@ -579,7 +579,7 @@ static int micronucleus_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
 static int micronucleus_open(PROGRAMMER *pgm, const char *port) {
   pmsg_debug("micronucleus_open(\"%s\")\n", port);
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
   const char *bus_name = NULL;
   char *dev_name = NULL;
 
@@ -705,7 +705,7 @@ static int micronucleus_open(PROGRAMMER *pgm, const char *port) {
 static void micronucleus_close(PROGRAMMER *pgm) {
   pmsg_debug("micronucleus_close()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   if(pdata->usb_handle != NULL) {
     usb_close(pdata->usb_handle);
@@ -743,7 +743,7 @@ static int micronucleus_paged_write(const PROGRAMMER *pgm, const AVRPART *p, con
   pmsg_debug("micronucleus_paged_write(page_size=0x%X, addr=0x%X, n_bytes=0x%X)\n", page_size, addr, n_bytes);
 
   if(mem_is_flash(mem)) {
-    struct pdata *pdata = PDATA(pgm);
+    struct pdata *pdata = &my;
 
     if(n_bytes > page_size) {
       pmsg_error("buffer size %u exceeds page size %u\n", n_bytes, page_size);
@@ -789,7 +789,7 @@ static int micronucleus_parseextparams(const PROGRAMMER *pgm, const LISTID xpara
 
   pmsg_debug("micronucleus_parseextparams()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   for(LNODEID node = lfirst(xparams); node; node = lnext(node)) {
     const char *extended_param = ldata(node);
diff --git a/src/pickit2.c b/src/pickit2.c
index 47cce225..91b204f2 100644
--- a/src/pickit2.c
+++ b/src/pickit2.c
@@ -122,7 +122,7 @@ struct pdata {
   int transaction_timeout;      // USB trans timeout in ms
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 #define CMD_NOP             0x5A
 #define CMD_GET_VERSION     0x76
@@ -159,8 +159,8 @@ struct pdata {
 
 static void pickit2_setup(PROGRAMMER *pgm) {
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->transaction_timeout = 1500;       // Can be changed with -x timeout=ms
-  PDATA(pgm)->clock_period = 10;        // Can be changed with -x clockrate=us or -B or -i
+  my.transaction_timeout = 1500;  // Can be changed with -x timeout=ms
+  my.clock_period = 10;         // Can be changed with -x clockrate=us or -B or -i
 }
 
 static void pickit2_teardown(PROGRAMMER *pgm) {
@@ -171,9 +171,9 @@ static void pickit2_teardown(PROGRAMMER *pgm) {
 static int pickit2_open(PROGRAMMER *pgm, const char *port) {
 
 #ifdef WIN32
-  PDATA(pgm)->usb_handle = open_hid(PICKIT2_VID, PICKIT2_PID);
+  my.usb_handle = open_hid(PICKIT2_VID, PICKIT2_PID);
 
-  if(PDATA(pgm)->usb_handle == INVALID_HANDLE_VALUE) {
+  if(my.usb_handle == INVALID_HANDLE_VALUE) {
     // No PICkit2 found
     pmsg_error("cannot find PICkit2 with vid=0x%x pid=0x%x\n", PICKIT2_VID, PICKIT2_PID);
     return -1;
@@ -182,7 +182,7 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
     short wbuf[80 - 1];
     char *cbuf = mmt_malloc(sizeof wbuf/sizeof *wbuf + (pgm->desc? strlen(pgm->desc): 0) + 2);
 
-    HidD_GetProductString(PDATA(pgm)->usb_handle, wbuf, sizeof wbuf/sizeof *wbuf);
+    HidD_GetProductString(my.usb_handle, wbuf, sizeof wbuf/sizeof *wbuf);
 
     if(pgm->desc && *pgm->desc)
       strcpy(cbuf, pgm->desc);
@@ -194,7 +194,7 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
     mmt_free(cbuf);
   }
 #else
-  if(usb_open_device(pgm, &(PDATA(pgm)->usb_handle), PICKIT2_VID, PICKIT2_PID) < 0) {
+  if(usb_open_device(pgm, &(my.usb_handle), PICKIT2_VID, PICKIT2_PID) < 0) {
     // No PICkit2 found
     pmsg_error("cannot find PICkit2 with vid=0x%x pid=0x%x\n", PICKIT2_VID, PICKIT2_PID);
     return -1;
@@ -202,9 +202,9 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
 #endif
 
   if(pgm->ispdelay > 0) {
-    PDATA(pgm)->clock_period = MIN(pgm->ispdelay, 255);
+    my.clock_period = MIN(pgm->ispdelay, 255);
   } else if(pgm->bitclock > 0.0) {
-    PDATA(pgm)->clock_period = MIN(pgm->bitclock*1e6, 255);
+    my.clock_period = MIN(pgm->bitclock*1e6, 255);
   }
 
   return 0;
@@ -213,11 +213,11 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
 static void pickit2_close(PROGRAMMER *pgm) {
 
 #ifdef WIN32
-  CloseHandle(PDATA(pgm)->usb_handle);
-  CloseHandle(PDATA(pgm)->read_event);
-  CloseHandle(PDATA(pgm)->write_event);
+  CloseHandle(my.usb_handle);
+  CloseHandle(my.read_event);
+  CloseHandle(my.write_event);
 #else
-  usb_close(PDATA(pgm)->usb_handle);
+  usb_close(my.usb_handle);
 #endif                          // WIN32
 }
 
@@ -246,7 +246,7 @@ static int pickit2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
         CMD_SET_VPP_4(5),
         CMD_EXEC_SCRIPT_2(24),
         SCR_SPI_SETUP_PINS_4,   // SDO, SDI, SCK
-        SCR_SET_ICSP_DELAY_2(PDATA(pgm)->clock_period), // Slow down the SPI
+        SCR_SET_ICSP_DELAY_2(my.clock_period), // Slow down the SPI
         SCR_VDD_ON,
         SCR_MCLR_GND_OFF,       // Let reset float high
         SCR_VPP_PWM_ON,
@@ -879,20 +879,20 @@ static int usb_read_interrupt(const PROGRAMMER *pgm, void *buff, int size, int t
   OVERLAPPED ovr;
   DWORD bytesRead = 0;
 
-  if(PDATA(pgm)->read_event == NULL) {
-    PDATA(pgm)->read_event = CreateEvent(0, 0, 0, 0);
+  if(my.read_event == NULL) {
+    my.read_event = CreateEvent(0, 0, 0, 0);
   }
 
   memset(&ovr, 0, sizeof(ovr));
-  ovr.hEvent = PDATA(pgm)->read_event;
+  ovr.hEvent = my.read_event;
 
-  ReadFile(PDATA(pgm)->usb_handle, buff, size, &bytesRead, &ovr);
-  if(WaitForSingleObject(PDATA(pgm)->read_event, timeout) == WAIT_TIMEOUT) {
-    CancelIo(PDATA(pgm)->usb_handle);
+  ReadFile(my.usb_handle, buff, size, &bytesRead, &ovr);
+  if(WaitForSingleObject(my.read_event, timeout) == WAIT_TIMEOUT) {
+    CancelIo(my.usb_handle);
     return -1;
   }
 
-  GetOverlappedResult(PDATA(pgm)->usb_handle, &ovr, &bytesRead, 0);
+  GetOverlappedResult(my.usb_handle, &ovr, &bytesRead, 0);
 
   return bytesRead > 0? (int) bytesRead: -1;
 }
@@ -902,30 +902,30 @@ static int usb_write_interrupt(const PROGRAMMER *pgm, const void *buff, int size
   OVERLAPPED ovr;
   DWORD bytesWritten = 0;
 
-  if(PDATA(pgm)->write_event == NULL) {
-    PDATA(pgm)->write_event = CreateEvent(0, 0, 0, 0);
+  if(my.write_event == NULL) {
+    my.write_event = CreateEvent(0, 0, 0, 0);
   }
 
   memset(&ovr, 0, sizeof(ovr));
-  ovr.hEvent = PDATA(pgm)->write_event;
+  ovr.hEvent = my.write_event;
 
-  WriteFile(PDATA(pgm)->usb_handle, buff, size, &bytesWritten, &ovr);
-  if(WaitForSingleObject(PDATA(pgm)->write_event, timeout) == WAIT_TIMEOUT) {
-    CancelIo(PDATA(pgm)->usb_handle);
+  WriteFile(my.usb_handle, buff, size, &bytesWritten, &ovr);
+  if(WaitForSingleObject(my.write_event, timeout) == WAIT_TIMEOUT) {
+    CancelIo(my.usb_handle);
     return -1;
   }
 
-  GetOverlappedResult(PDATA(pgm)->usb_handle, &ovr, &bytesWritten, 0);
+  GetOverlappedResult(my.usb_handle, &ovr, &bytesWritten, 0);
 
   return bytesWritten > 0? (int) bytesWritten: -1;
 }
 
 static int pickit2_write_report(const PROGRAMMER *pgm, const unsigned char report[65]) {
-  return usb_write_interrupt(pgm, report, 65, PDATA(pgm)->transaction_timeout); // XXX
+  return usb_write_interrupt(pgm, report, 65, my.transaction_timeout); // XXX
 }
 
 static int pickit2_read_report(const PROGRAMMER *pgm, unsigned char report[65]) {
-  return usb_read_interrupt(pgm, report, 65, PDATA(pgm)->transaction_timeout);
+  return usb_read_interrupt(pgm, report, 65, my.transaction_timeout);
 }
 
 #else                           // WIN32
@@ -937,8 +937,8 @@ static int usb_open_device(PROGRAMMER *pgm, struct usb_dev_handle **device, int
   usb_dev_handle *handle = NULL;
   int errorCode = USB_ERROR_NOTFOUND;
 
-  if(!PDATA(pgm)->USB_init) {
-    PDATA(pgm)->USB_init = 1;
+  if(!my.USB_init) {
+    my.USB_init = 1;
     usb_init();
   }
   usb_find_busses();
@@ -980,14 +980,14 @@ static int usb_open_device(PROGRAMMER *pgm, struct usb_dev_handle **device, int
 
 static int pickit2_write_report(const PROGRAMMER *pgm, const unsigned char report[65]) {
   // Endpoint 1 OUT??
-  return usb_interrupt_write(PDATA(pgm)->usb_handle, USB_ENDPOINT_OUT | 1, (char *) (report + 1), 64,
-    PDATA(pgm)->transaction_timeout);
+  return usb_interrupt_write(my.usb_handle, USB_ENDPOINT_OUT | 1, (char *) (report + 1), 64,
+    my.transaction_timeout);
 }
 
 static int pickit2_read_report(const PROGRAMMER *pgm, unsigned char report[65]) {
   // Endpoint 1 IN??
-  return usb_interrupt_read(PDATA(pgm)->usb_handle, USB_ENDPOINT_IN | 1, (char *) (report + 1), 64,
-    PDATA(pgm)->transaction_timeout);
+  return usb_interrupt_read(my.usb_handle, USB_ENDPOINT_IN | 1, (char *) (report + 1), 64,
+    my.transaction_timeout);
 }
 #endif                          // WIN32
 
@@ -1012,7 +1012,7 @@ static int pickit2_parseextparams(const PROGRAMMER *pgm, const LISTID extparms)
       clock_rate = (int) (1000000/(clock_period + 5e-7));     // Assume highest speed is 2MHz
 
       pmsg_notice2("%s(): effective clock rate set to 0x%02x\n", __func__, clock_rate);
-      PDATA(pgm)->clock_period = clock_period;
+      my.clock_period = clock_period;
       continue;
     }
 
@@ -1026,7 +1026,7 @@ static int pickit2_parseextparams(const PROGRAMMER *pgm, const LISTID extparms)
       }
 
       pmsg_notice2("%s(): usb timeout set to 0x%02x\n", __func__, timeout);
-      PDATA(pgm)->transaction_timeout = timeout;
+      my.transaction_timeout = timeout;
       continue;
     }
 
diff --git a/src/stk500.c b/src/stk500.c
index 1b176980..65451486 100644
--- a/src/stk500.c
+++ b/src/stk500.c
@@ -100,14 +100,14 @@ int stk500_getsync(const PROGRAMMER *pgm) {
   stk500_send(pgm, buf, 2);
   stk500_drain(pgm, 0);
 
-  if(PDATA(pgm)->retry_attempts)
-    max_sync_attempts = PDATA(pgm)->retry_attempts;
+  if(my.retry_attempts)
+    max_sync_attempts = my.retry_attempts;
   else
     max_sync_attempts = MAX_SYNC_ATTEMPTS;
 
   for(attempt = 0; attempt < max_sync_attempts; attempt++) {
     // Restart Arduino bootloader for every sync attempt
-    if(str_eq(pgm->type, "Arduino") && PDATA(pgm)->autoreset && attempt > 0) {
+    if(str_eq(pgm->type, "Arduino") && my.autoreset && attempt > 0) {
       // This code assumes a negative-logic USB to TTL serial adapter
       // Pull the RTS/DTR line low to reset AVR: it is still high from open()/last attempt
       serial_set_dtr_rts(&pgm->fd, 1);
@@ -517,7 +517,7 @@ retry:
     }
   }
   // Read or write target voltage
-  if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+  if(my.vtarg_get || my.vtarg_set) {
     // Read current target voltage set value
     unsigned int vtarg_read = 0;
 
@@ -525,17 +525,17 @@ retry:
       pmsg_error("cannot obtain V[target]\n");
       return rc;
     }
-    if(PDATA(pgm)->vtarg_get)
+    if(my.vtarg_get)
       msg_info("Target voltage value read as %.2f V\n", (vtarg_read/10.0));
     // Write target voltage value
     else {
-      msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), PDATA(pgm)->vtarg_data);
-      if(pgm->set_vtarget(pgm, PDATA(pgm)->vtarg_data) < 0)
+      msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), my.vtarg_data);
+      if(pgm->set_vtarget(pgm, my.vtarg_data) < 0)
         return -1;
     }
   }
   // Read or write analog reference voltage
-  if(PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
+  if(my.varef_get || my.varef_set) {
     // Read current analog reference voltage
     unsigned int varef_read = 0;
 
@@ -543,17 +543,17 @@ retry:
       pmsg_error("cannot obtain V[aref]\n");
       return rc;
     }
-    if(PDATA(pgm)->varef_get)
+    if(my.varef_get)
       msg_info("Analog reference voltage value read as %.2f V\n", (varef_read/10.0));
     // Write analog reference voltage
     else {
-      msg_info("Changing analog reference voltage from %.2f V to %.2f V\n", (varef_read/10.0), PDATA(pgm)->varef_data);
-      if(pgm->set_varef(pgm, 0, PDATA(pgm)->varef_data) < 0)
+      msg_info("Changing analog reference voltage from %.2f V to %.2f V\n", (varef_read/10.0), my.varef_data);
+      if(pgm->set_varef(pgm, 0, my.varef_data) < 0)
         return -1;
     }
   }
   // Read or write clock generator frequency
-  if(PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
+  if(my.fosc_get || my.fosc_set) {
     // Read current target voltage set value
     unsigned int osc_pscale = 0;
     unsigned int osc_cmatch = 0;
@@ -568,7 +568,7 @@ retry:
     if(osc_pscale) {
       int prescale = 1;
 
-      f_get = PDATA(pgm)->xtal/2;
+      f_get = my.xtal/2;
       switch(osc_pscale) {
       case 2:
         prescale = 8;
@@ -593,15 +593,15 @@ retry:
       f_get /= (osc_cmatch + 1);
       f_get = f_to_kHz_MHz(f_get, &unit_get);
     }
-    if(PDATA(pgm)->fosc_get)
+    if(my.fosc_get)
       msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
     // Write target voltage value
     else {
       const char *unit_set;
-      double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+      double f_set = f_to_kHz_MHz(my.fosc_data, &unit_set);
 
       msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
-      if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
+      if(pgm->set_fosc(pgm, my.fosc_data) < 0)
         return -1;
     }
   }
@@ -618,7 +618,7 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
     const char *extended_param = ldata(ln);
 
     if(sscanf(extended_param, "attempts=%i", &attempts) == 1) {
-      PDATA(pgm)->retry_attempts = attempts;
+      my.retry_attempts = attempts;
       pmsg_info("setting number of retry attempts to %d\n", attempts);
       continue;
     }
@@ -629,17 +629,17 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         double vtarg_set_val = -1;      // Default = invlid value
         int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
 
-        PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
+        my.vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
         if(sscanf_success < 1 || vtarg_set_val < 0) {
           pmsg_error("invalid target voltage in -x %s\n", extended_param);
           rv = -1;
           break;
         }
-        PDATA(pgm)->vtarg_set = true;
+        my.vtarg_set = true;
         continue;
       } else if((pgm->extra_features & HAS_VTARG_READ) && str_eq(extended_param, "vtarg")) {
         // Get target voltage
-        PDATA(pgm)->vtarg_get = true;
+        my.vtarg_get = true;
         continue;
       }
     }
@@ -652,24 +652,24 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         // Get new analog reference voltage for channel 0
         if(str_starts(extended_param, "varef=")) {
           sscanf_success = sscanf(extended_param, "varef=%lf", &varef_set_val);
-          PDATA(pgm)->varef_set = true;
+          my.varef_set = true;
         }
         // Get new analog reference voltage for channel 0
         else if(str_starts(extended_param, "varef0=")) {
           sscanf_success = sscanf(extended_param, "varef0=%lf", &varef_set_val);
-          PDATA(pgm)->varef_set = true;
+          my.varef_set = true;
         }
         // Get current analog reference voltage for channel 0
         else if(str_eq(extended_param, "varef") || str_eq(extended_param, "varef0")) {
-          PDATA(pgm)->varef_get = true;
+          my.varef_get = true;
           continue;
         }
         // Set analog reference voltage
-        if(PDATA(pgm)->varef_set) {
-          PDATA(pgm)->varef_data = (double) ((int) (varef_set_val*100 + .5))/100;
+        if(my.varef_set) {
+          my.varef_data = (double) ((int) (varef_set_val*100 + .5))/100;
           if(sscanf_success < 1 || varef_set_val < 0) {
             pmsg_error("invalid value in -x %s\n", extended_param);
-            PDATA(pgm)->varef_set = false;
+            my.varef_set = false;
             rv = -1;
             break;
           }
@@ -702,22 +702,22 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
               rv = -1;
               break;
             }
-            PDATA(pgm)->fosc_data = 0.0;
+            my.fosc_data = 0.0;
           }
           while(*endp == ' ')   // Remove leading spaces before unit
             ++endp;
           if(*endp == 'm' || *endp == 'M')
-            PDATA(pgm)->fosc_data = v*1e6;
+            my.fosc_data = v*1e6;
           else if(*endp == 'k' || *endp == 'K')
-            PDATA(pgm)->fosc_data = v*1e3;
+            my.fosc_data = v*1e3;
           else if(*endp == 0 || *endp == 'h' || *endp == 'H')
-            PDATA(pgm)->fosc_data = v;
-          PDATA(pgm)->fosc_set = true;
+            my.fosc_data = v;
+          my.fosc_set = true;
           continue;
         }
         // Get clock generator frequency
         else if(str_eq(extended_param, "fosc")) {
-          PDATA(pgm)->fosc_get = true;
+          my.fosc_get = true;
           continue;
         }
       }
@@ -745,11 +745,11 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         while(*endp == ' ')     // Remove leading spaces before unit
           ++endp;
         if(*endp == 'm' || *endp == 'M') // Fits also e.g. "nnnnMHz"
-          PDATA(pgm)->xtal = v*1e6;
+          my.xtal = v*1e6;
         else if(*endp == 'k' || *endp == 'K')
-          PDATA(pgm)->xtal = v*1e3;
+          my.xtal = v*1e3;
         else if(*endp == 0 || *endp == 'h' || *endp == 'H')     // "nnnn" or "nnnnHz"
-          PDATA(pgm)->xtal = v;
+          my.xtal = v;
         continue;
       }
     }
@@ -890,16 +890,16 @@ retry:
 
   // Support large flash by sending the correct extended address byte when needed
 
-  if(pgm->prog_modes & PM_SPM) {        // Bootloaders, eg, optiboot, optiboot_dx, optiboot_x
+  if(pgm->prog_modes & PM_SPM) { // Bootloaders, eg, optiboot, optiboot_dx, optiboot_x
     if(mem->size/a_div > 64*1024) { // Extended addressing needed
       ext_byte = (addr >> 16) & 0xff;
-      if(ext_byte != PDATA(pgm)->ext_addr_byte) {       // First addr load or a different 64k section
+      if(ext_byte != my.ext_addr_byte) { // First addr load or a different 64k section
         buf[0] = 0x4d;          // Protocol bytes that bootloaders expect
         buf[1] = 0x00;
         buf[2] = ext_byte;
         buf[3] = 0x00;
         if(stk500_cmd(pgm, buf, buf) == 0)
-          PDATA(pgm)->ext_addr_byte = ext_byte;
+          my.ext_addr_byte = ext_byte;
       }
       /*
        * Ensure next paged r/w will load ext addr again if page sits just below
@@ -915,19 +915,19 @@ retry:
        * exposes the discrepancy.
        */
       if((addr & 0xffff0000) != ((addr + mem->page_size/a_div) & 0xffff0000))
-        PDATA(pgm)->ext_addr_byte = 0xff;
+        my.ext_addr_byte = 0xff;
     }
   } else {                      // Programmer *not* for bootloaders? Original stk500v1 protocol!
     OPCODE *lext = mem->op[AVR_OP_LOAD_EXT_ADDR];
 
     if(lext) {
       ext_byte = (addr >> 16) & 0xff;
-      if(ext_byte != PDATA(pgm)->ext_addr_byte) {       // First addr load or a different 64k section
+      if(ext_byte != my.ext_addr_byte) { // First addr load or a different 64k section
         memset(buf, 0, 4);      // Part's load_ext_addr command is typically 4d 00 ext_addr 00
         avr_set_bits(lext, buf);
         avr_set_addr(lext, buf, addr);
         if(stk500_cmd(pgm, buf, buf) == 0)
-          PDATA(pgm)->ext_addr_byte = ext_byte;
+          my.ext_addr_byte = ext_byte;
       }
     }
   }
@@ -1215,7 +1215,7 @@ static int stk500_set_fosc(const PROGRAMMER *pgm, double v) {
 
   prescale = cmatch = 0;
   if(v > 0.0) {
-    if(v > PDATA(pgm)->xtal/2.0) {
+    if(v > my.xtal/2.0) {
       const char *unit;
 
       if(v >= 1e6) {
@@ -1226,21 +1226,21 @@ static int stk500_set_fosc(const PROGRAMMER *pgm, double v) {
         unit = "kHz";
       } else
         unit = "Hz";
-      pmsg_warning("f = %.3f %s too high, using %.3f MHz\n", v, unit, PDATA(pgm)->xtal/2e6);
-      fosc = PDATA(pgm)->xtal/2.0;
+      pmsg_warning("f = %.3f %s too high, using %.3f MHz\n", v, unit, my.xtal/2e6);
+      fosc = my.xtal/2.0;
     } else
       fosc = (unsigned) v;
 
     for(idx = 0; idx < sizeof(ps)/sizeof(ps[0]); idx++) {
-      if(fosc >= PDATA(pgm)->xtal/(256*ps[idx] * 2)) {
+      if(fosc >= my.xtal/(256*ps[idx] * 2)) {
         // This prescaler value can handle our frequency
         prescale = idx + 1;
-        cmatch = (unsigned) (PDATA(pgm)->xtal/(2*fosc*ps[idx])) - 1;
+        cmatch = (unsigned) (my.xtal/(2*fosc*ps[idx])) - 1;
         break;
       }
     }
     if(idx == sizeof(ps)/sizeof(ps[0])) {
-      pmsg_warning("f = %u Hz too low, using %u Hz\n", fosc, PDATA(pgm)->xtal/(256*1024*2));
+      pmsg_warning("f = %u Hz too low, using %u Hz\n", fosc, my.xtal/(256*1024*2));
       prescale = idx;
       cmatch = 255;
     }
@@ -1277,7 +1277,7 @@ static int stk500_get_fosc(const PROGRAMMER *pgm, double *v) {
     return rc;
   }
 
-  *v = !prescale? 0: PDATA(pgm)->xtal/((cmatch + 1)*2*ps[prescale - 1]);
+  *v = !prescale? 0: my.xtal/((cmatch + 1)*2*ps[prescale - 1]);
 
   return 0;
 }
@@ -1295,7 +1295,7 @@ static int stk500_set_sck_period(const PROGRAMMER *pgm, double v) {
   double min, max;
   int rv = 0;
 
-  min = 8.0/PDATA(pgm)->xtal;
+  min = 8.0/my.xtal;
   max = 255*min;
   dur = v/min + 0.5;
 
@@ -1322,7 +1322,7 @@ static int stk500_get_sck_period(const PROGRAMMER *pgm, double *v) {
     pmsg_error("cannot obtain Parm_STK_SCK_DURATION\n");
     return rv;
   }
-  *v = dur*8.0/PDATA(pgm)->xtal;
+  *v = dur*8.0/my.xtal;
   return 0;
 }
 
@@ -1477,7 +1477,7 @@ static void stk500_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp)
       fmsg_out(fp, "Off\n");
     else {
       int prescale = 1;
-      double f = PDATA(pgm)->xtal/2.0;
+      double f = my.xtal/2.0;
 
       switch(osc_pscale) {
       case 2:
@@ -1508,9 +1508,9 @@ static void stk500_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp)
   }
 
   stk500_getparm(pgm, Parm_STK_SCK_DURATION, &sck_duration);
-  fmsg_out(fp, "%sSCK period            : %.1f us\n", p, sck_duration*8.0e6/PDATA(pgm)->xtal + 0.0499);
+  fmsg_out(fp, "%sSCK period            : %.1f us\n", p, sck_duration*8.0e6/my.xtal + 0.0499);
 
-  double f = PDATA(pgm)->xtal;
+  double f = my.xtal;
 
   decimals = get_decimals(f);
   f = f_to_kHz_MHz(f, &unit);
@@ -1525,16 +1525,16 @@ static void stk500_print_parms(const PROGRAMMER *pgm, FILE *fp) {
 
 static void stk500_setup(PROGRAMMER *pgm) {
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->ext_addr_byte = 0xff;
-  PDATA(pgm)->xbeeResetPin = XBEE_DEFAULT_RESET_PIN;
+  my.ext_addr_byte = 0xff;
+  my.xbeeResetPin = XBEE_DEFAULT_RESET_PIN;
   // nanoSTK (Arduino Nano HW) uses 16 MHz
   if(str_starts(pgmid, "nanoSTK"))
-    PDATA(pgm)->xtal = 16000000U;
+    my.xtal = 16000000U;
   else
-    PDATA(pgm)->xtal = STK500_XTAL;
+    my.xtal = STK500_XTAL;
   // The -c arduino programmer has auto-reset enabled be default
   if(str_eq(pgm->type, "Arduino"))
-    PDATA(pgm)->autoreset = true;
+    my.autoreset = true;
 }
 
 static void stk500_teardown(PROGRAMMER *pgm) {
diff --git a/src/stk500.h b/src/stk500.h
index b5bbfd45..86029c27 100644
--- a/src/stk500.h
+++ b/src/stk500.h
@@ -62,5 +62,5 @@ struct pdata {
   bool autoreset;
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 #endif
diff --git a/src/stk500v2.c b/src/stk500v2.c
index 5df6660a..1fdcf8a9 100644
--- a/src/stk500v2.c
+++ b/src/stk500v2.c
@@ -83,7 +83,7 @@ enum hvmode {
   PPMODE, HVSPMODE
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // Data structure for displaying STK600 routing and socket cards
 struct carddata {
@@ -92,7 +92,7 @@ struct carddata {
 };
 
 static const char *pgmname(const PROGRAMMER *pgm) {
-  unsigned int i = PDATA(pgm)->pgmtype;
+  unsigned int i = my.pgmtype;
 
   const char *name[] = {        // Parallel to PGMTYPE_ definitions in stk500v2_private.h
     "unknown",
@@ -104,7 +104,7 @@ static const char *pgmname(const PROGRAMMER *pgm) {
     "JTAGICE3",
   };
 
-  return i == PGMTYPE_STK500 && PDATA(pgm)->is_scratchmonkey? "SCRATCHMONKEY" :        // STK500 with LEDs
+  return i == PGMTYPE_STK500 && my.is_scratchmonkey? "SCRATCHMONKEY" : // STK500 with LEDs
     i < sizeof name/sizeof *name? name[i]: "None";
 }
 
@@ -282,16 +282,16 @@ static int stk600_xprog_program_enable(const PROGRAMMER *pgm, const AVRPART *p);
 
 void stk500v2_setup(PROGRAMMER *pgm) {
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->command_sequence = 1;
-  PDATA(pgm)->boot_start = ULONG_MAX;
-  PDATA(pgm)->xtal = str_starts(pgmid, "scratchmonkey")? SCRATCHMONKEY_XTAL: STK500V2_XTAL;
+  my.command_sequence = 1;
+  my.boot_start = ULONG_MAX;
+  my.xtal = str_starts(pgmid, "scratchmonkey")? SCRATCHMONKEY_XTAL: STK500V2_XTAL;
 }
 
 static void stk500v2_jtagmkII_setup(PROGRAMMER *pgm) {
   void *mycookie, *theircookie;
 
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->command_sequence = 1;
+  my.command_sequence = 1;
 
   /*
    * Now, have the JTAG ICE mkII backend allocate its own private data.  Store
@@ -301,14 +301,14 @@ static void stk500v2_jtagmkII_setup(PROGRAMMER *pgm) {
   jtagmkII_setup(pgm);
   theircookie = pgm->cookie;
   pgm->cookie = mycookie;
-  PDATA(pgm)->chained_pdata = theircookie;
+  my.chained_pdata = theircookie;
 }
 
 static void stk500v2_jtag3_setup(PROGRAMMER *pgm) {
   void *mycookie, *theircookie;
 
   pgm->cookie = mmt_malloc(sizeof(struct pdata));
-  PDATA(pgm)->command_sequence = 1;
+  my.command_sequence = 1;
 
   /*
    * Now, have the JTAGICE3 backend allocate its own private data.  Store our
@@ -318,7 +318,7 @@ static void stk500v2_jtag3_setup(PROGRAMMER *pgm) {
   jtag3_setup(pgm);
   theircookie = pgm->cookie;
   pgm->cookie = mycookie;
-  PDATA(pgm)->chained_pdata = theircookie;
+  my.chained_pdata = theircookie;
 }
 
 void stk500v2_teardown(PROGRAMMER *pgm) {
@@ -328,12 +328,12 @@ void stk500v2_teardown(PROGRAMMER *pgm) {
 
 static void stk500v2_jtagmkII_teardown(PROGRAMMER *pgm) {
   if(pgm->cookie) {
-    mmt_free(PDATA(pgm)->flash_pagecache);
-    mmt_free(PDATA(pgm)->eeprom_pagecache);
+    mmt_free(my.flash_pagecache);
+    mmt_free(my.eeprom_pagecache);
 
     void *mycookie = pgm->cookie;
 
-    pgm->cookie = PDATA(pgm)->chained_pdata;
+    pgm->cookie = my.chained_pdata;
     jtagmkII_teardown(pgm);
     pgm->cookie = mycookie;
   }
@@ -346,7 +346,7 @@ static void stk500v2_jtag3_teardown(PROGRAMMER *pgm) {
   if(pgm->cookie) {
     void *mycookie = pgm->cookie;
 
-    pgm->cookie = PDATA(pgm)->chained_pdata;
+    pgm->cookie = my.chained_pdata;
     jtag3_teardown(pgm);
     pgm->cookie = mycookie;
   }
@@ -438,7 +438,7 @@ static int stk500v2_jtagmkII_send(const PROGRAMMER *pgm, unsigned char *data, si
   cmdbuf = mmt_malloc(len + 3);
   PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-  pgmcp->cookie = PDATA(pgm)->chained_pdata;
+  pgmcp->cookie = my.chained_pdata;
   cmdbuf[0] = CMND_ISP_PACKET;
   cmdbuf[1] = sz & 0xff;
   cmdbuf[2] = (sz >> 8) & 0xff;
@@ -458,7 +458,7 @@ static int stk500v2_jtag3_send(const PROGRAMMER *pgm, unsigned char *data, size_
   cmdbuf = mmt_malloc(len + 1);
   PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-  pgmcp->cookie = PDATA(pgm)->chained_pdata;
+  pgmcp->cookie = my.chained_pdata;
   cmdbuf[0] = SCOPE_AVR_ISP;
   memcpy(cmdbuf + 1, data, len);
   rv = jtag3_send(pgmcp, cmdbuf, len + 1);
@@ -471,15 +471,15 @@ static int stk500v2_jtag3_send(const PROGRAMMER *pgm, unsigned char *data, size_
 static int stk500v2_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
   unsigned char buf[275 + 6];   // Max MESSAGE_BODY of 275 bytes, 6 bytes overhead
 
-  if(PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII || PDATA(pgm)->pgmtype == PGMTYPE_STK600)
+  if(my.pgmtype == PGMTYPE_AVRISP_MKII || my.pgmtype == PGMTYPE_STK600)
     return stk500v2_send_mk2(pgm, data, len);
-  if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
+  if(my.pgmtype == PGMTYPE_JTAGICE_MKII)
     return stk500v2_jtagmkII_send(pgm, data, len);
-  if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
+  if(my.pgmtype == PGMTYPE_JTAGICE3)
     return stk500v2_jtag3_send(pgm, data, len);
 
   buf[0] = MESSAGE_START;
-  buf[1] = PDATA(pgm)->command_sequence;
+  buf[1] = my.command_sequence;
   buf[2] = len/256;
   buf[3] = len%256;
   buf[4] = TOKEN;
@@ -525,7 +525,7 @@ static int stk500v2_jtagmkII_recv(const PROGRAMMER *pgm, unsigned char *msg, siz
 
   PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-  pgmcp->cookie = PDATA(pgm)->chained_pdata;
+  pgmcp->cookie = my.chained_pdata;
   rv = jtagmkII_recv(pgmcp, &jtagmsg);
   pgm_free(pgmcp);
   if(rv <= 0) {
@@ -560,7 +560,7 @@ static int stk500v2_jtag3_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t
 
   PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-  pgmcp->cookie = PDATA(pgm)->chained_pdata;
+  pgmcp->cookie = my.chained_pdata;
   rv = jtag3_recv(pgmcp, &jtagmsg);
   pgm_free(pgmcp);
 
@@ -601,11 +601,11 @@ static int stk500v2_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsi
   long timeoutval = SERIAL_TIMEOUT;     // Seconds
   double tstart, tnow;
 
-  if(PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII || PDATA(pgm)->pgmtype == PGMTYPE_STK600)
+  if(my.pgmtype == PGMTYPE_AVRISP_MKII || my.pgmtype == PGMTYPE_STK600)
     return stk500v2_recv_mk2(pgm, msg, maxsize);
-  else if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
+  else if(my.pgmtype == PGMTYPE_JTAGICE_MKII)
     return stk500v2_jtagmkII_recv(pgm, msg, maxsize);
-  else if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
+  else if(my.pgmtype == PGMTYPE_JTAGICE3)
     return stk500v2_jtag3_recv(pgm, msg, maxsize);
 
   DEBUG("STK500V2: stk500v2_recv(): ");
@@ -630,10 +630,10 @@ static int stk500v2_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsi
       break;
     case sSEQNUM:
       DEBUGRECV("hoping for sequence ...\n");
-      if(c == PDATA(pgm)->command_sequence) {
+      if(c == my.command_sequence) {
         DEBUGRECV("got it, incrementing\n");
         state = sSIZE1;
-        PDATA(pgm)->command_sequence++;
+        my.command_sequence++;
       } else {
         DEBUGRECV("sorry\n");
         state = sSTART;
@@ -706,7 +706,7 @@ int stk500v2_getsync(const PROGRAMMER *pgm) {
 
   DEBUG("STK500V2: stk500v2_getsync()\n");
 
-  if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII || PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
+  if(my.pgmtype == PGMTYPE_JTAGICE_MKII || my.pgmtype == PGMTYPE_JTAGICE3)
     return 0;
 
   long bak_serial_recv_timeout = serial_recv_timeout;
@@ -731,22 +731,22 @@ retry:
       char *name = (char *) resp + 3;
 
       if(str_starts(name, "STK500_2")) {
-        PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+        my.pgmtype = PGMTYPE_STK500;
       } else if(str_starts(name, "SCRATCHMONKEY")) {
-        PDATA(pgm)->is_scratchmonkey = 1;
-        PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+        my.is_scratchmonkey = 1;
+        my.pgmtype = PGMTYPE_STK500;
       } else if(str_starts(name, "AVRISP_2")) {
-        PDATA(pgm)->pgmtype = PGMTYPE_AVRISP;
+        my.pgmtype = PGMTYPE_AVRISP;
       } else if(str_starts(name, "AVRISP_MK2")) {
-        PDATA(pgm)->pgmtype = PGMTYPE_AVRISP_MKII;
+        my.pgmtype = PGMTYPE_AVRISP_MKII;
       } else if(str_starts(name, "STK600")) {
-        PDATA(pgm)->pgmtype = PGMTYPE_STK600;
+        my.pgmtype = PGMTYPE_STK600;
       } else {
         unsigned int len = resp[2];
 
         resp[len + 3 >= sizeof resp? sizeof resp - 1: len + 3] = 0;
         pmsg_notice("%s(): unknown programmer %s, assuming STK500\n", __func__, name);
-        PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+        my.pgmtype = PGMTYPE_STK500;
       }
       pmsg_debug("%s(): found %s programmer\n", __func__, pgmname(pgm));
       serial_recv_timeout = bak_serial_recv_timeout;
@@ -951,7 +951,7 @@ static int stk500v2_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
   avr_set_bits(p->op[AVR_OP_CHIP_ERASE], buf + 3);
   result = stk500v2_command(pgm, buf, 7, sizeof(buf));
   usleep(p->chip_erase_delay);  // Should not be needed
-  if(PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII) { // Skip for JTAGICE mkII (FW v7.39)
+  if(my.pgmtype != PGMTYPE_JTAGICE_MKII) { // Skip for JTAGICE mkII (FW v7.39)
     pgm->initialize(pgm, p);    // Should not be needed
   }
 
@@ -1024,14 +1024,14 @@ static int stk500v2_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
   char msg[100];                // See remarks above about size needed
   int rv, tries;
 
-  PDATA(pgm)->lastpart = p;
+  my.lastpart = p;
 
   if(p->op[AVR_OP_PGM_ENABLE] == NULL) {
     pmsg_error("program enable instruction not defined for part %s\n", p->desc);
     return -1;
   }
 
-  if(PDATA(pgm)->pgmtype == PGMTYPE_STK500 || PDATA(pgm)->pgmtype == PGMTYPE_STK600)
+  if(my.pgmtype == PGMTYPE_STK500 || my.pgmtype == PGMTYPE_STK600)
     // Activate AVR-style (low active) RESET
     stk500v2_setparm_real(pgm, PARAM_RESET_POLARITY, 0x01);
 
@@ -1051,7 +1051,7 @@ retry:
   rv = stk500v2_command(pgm, buf, 12, sizeof(buf));
 
   if(rv < 0) {
-    switch(PDATA(pgm)->pgmtype) {
+    switch(my.pgmtype) {
     case PGMTYPE_STK600:
     case PGMTYPE_AVRISP_MKII:
       if(stk500v2_getparm(pgm, PARAM_STATUS_TGT_CONN, &buf[0]) != 0) {
@@ -1071,7 +1071,7 @@ retry:
 
         PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-        pgmcp->cookie = PDATA(pgm)->chained_pdata;
+        pgmcp->cookie = my.chained_pdata;
 
         cmd[0] = PARM3_CONN_DW;
         if(jtag3_setparm(pgmcp, SCOPE_AVR, 1, PARM3_CONNECTION, cmd, 1) < 0) {
@@ -1119,7 +1119,7 @@ retry:
 static int stk500pp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
   unsigned char buf[16];
 
-  PDATA(pgm)->lastpart = p;
+  my.lastpart = p;
 
   buf[0] = CMD_ENTER_PROGMODE_PP;
   buf[1] = p->hventerstabdelay;
@@ -1137,9 +1137,9 @@ static int stk500pp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
 static int stk500hvsp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
   unsigned char buf[16];
 
-  PDATA(pgm)->lastpart = p;
+  my.lastpart = p;
 
-  buf[0] = PDATA(pgm)->pgmtype == PGMTYPE_STK600? CMD_ENTER_PROGMODE_HVSP_STK600: CMD_ENTER_PROGMODE_HVSP;
+  buf[0] = my.pgmtype == PGMTYPE_STK600? CMD_ENTER_PROGMODE_HVSP_STK600: CMD_ENTER_PROGMODE_HVSP;
   buf[1] = p->hventerstabdelay;
   buf[2] = p->hvspcmdexedelay;
   buf[3] = p->synchcycles;
@@ -1157,9 +1157,9 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   LNODEID ln;
   AVRMEM *m;
 
-  if((PDATA(pgm)->pgmtype == PGMTYPE_STK600 ||
-      PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
-      PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0 && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
+  if((my.pgmtype == PGMTYPE_STK600 ||
+      my.pgmtype == PGMTYPE_AVRISP_MKII ||
+      my.pgmtype == PGMTYPE_JTAGICE_MKII) != 0 && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
     // This is an ATxmega device, must use XPROG protocol for the remaining actions
     if(p->prog_modes & PM_PDI) {
       // Find the border between application and boot area
@@ -1169,7 +1169,7 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       if(bootmem == NULL || flashmem == NULL) {
         pmsg_error("cannot locate flash or boot memories\n");
       } else {
-        PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
+        my.boot_start = bootmem->offset - flashmem->offset;
       }
     }
     // stk600_setup_xprog(pgm); [moved to pgm->enable()]
@@ -1178,75 +1178,75 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   }
 
   // Read or write target voltage
-  if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+  if(my.vtarg_get || my.vtarg_set) {
     // Read current target voltage set value
     unsigned char vtarg_read = 0;
 
     if(stk500v2_getparm(pgm, PARAM_VTARGET, &vtarg_read) < 0)
       return -1;
-    if(PDATA(pgm)->vtarg_get)
+    if(my.vtarg_get)
       msg_info("Target voltage value read as %.2f V\n", (vtarg_read/10.0));
     // Write target voltage value
     else {
-      msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), PDATA(pgm)->vtarg_data);
-      if(pgm->set_vtarget(pgm, PDATA(pgm)->vtarg_data) < 0)
+      msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), my.vtarg_data);
+      if(pgm->set_vtarget(pgm, my.vtarg_data) < 0)
         return -1;
     }
   }
 
   // Read or write analog reference voltage
-  if(PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
-    if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
+  if(my.varef_get || my.varef_set) {
+    if(my.pgmtype == PGMTYPE_STK500) {
       // STK500: Read current analog reference voltage
       unsigned char varef_read = 0;
 
       if(stk500v2_getparm(pgm, PARAM_VADJUST, &varef_read) < 0)
         return -1;
-      if(PDATA(pgm)->varef_get)
+      if(my.varef_get)
         msg_info("Analog reference voltage value read as %.2f V\n", (varef_read/10.0));
       // STK500: Write analog reference voltage
       else {
         msg_info("Changing analog reference voltage from %.2f V to %.2f V\n",
-          varef_read/10.0, PDATA(pgm)->varef_data);
-        if(pgm->set_varef(pgm, 0, PDATA(pgm)->varef_data) < 0)
+          varef_read/10.0, my.varef_data);
+        if(pgm->set_varef(pgm, 0, my.varef_data) < 0)
           return -1;
       }
-    } else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+    } else if(my.pgmtype == PGMTYPE_STK600) {
       // STK600: Read current target voltage set value
       unsigned int varef_read = 0;
 
-      if(stk500v2_getparm2(pgm, PDATA(pgm)->varef_channel == 0? PARAM2_AREF0: PARAM2_AREF1, &varef_read) < 0)
+      if(stk500v2_getparm2(pgm, my.varef_channel == 0? PARAM2_AREF0: PARAM2_AREF1, &varef_read) < 0)
         return -1;
-      if(PDATA(pgm)->varef_get)
+      if(my.varef_get)
         msg_info("Analog reference channel %d voltage read as %.2f V\n",
-          PDATA(pgm)->varef_channel, (varef_read/100.0));
+          my.varef_channel, (varef_read/100.0));
       // STK600: Write target voltage value for channel n
       else {
         msg_info("Changing analog reference channel %d voltage from %.2f V to %.2f V\n",
-          PDATA(pgm)->varef_channel, (varef_read/100.0), PDATA(pgm)->varef_data);
-        if(pgm->set_varef(pgm, PDATA(pgm)->varef_channel, PDATA(pgm)->varef_data) < 0)
+          my.varef_channel, (varef_read/100.0), my.varef_data);
+        if(pgm->set_varef(pgm, my.varef_channel, my.varef_data) < 0)
           return -1;
       }
     }
   }
 
   // Read or write clock generator frequency
-  if(PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
-    if(PDATA(pgm)->pgmtype == PGMTYPE_STK500 || PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+  if(my.fosc_get || my.fosc_set) {
+    if(my.pgmtype == PGMTYPE_STK500 || my.pgmtype == PGMTYPE_STK600) {
       const char *unit_get = { "Hz" };
       double f_get = stk500v2_fosc_value(pgm);
 
       if(f_get)
         f_get = f_to_kHz_MHz(f_get, &unit_get);
-      if(PDATA(pgm)->fosc_get)
+      if(my.fosc_get)
         msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
       // Write new osc freq
       else {
         const char *unit_set;
-        double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+        double f_set = f_to_kHz_MHz(my.fosc_data, &unit_set);
 
         msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
-        if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
+        if(pgm->set_fosc(pgm, my.fosc_data) < 0)
           return -1;
       }
     }
@@ -1257,27 +1257,27 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
    * For devices/memory that are not page oriented, treat them as page size 1
    * for EEPROM, and 2 for flash.
    */
-  PDATA(pgm)->flash_pagesize = 2;
-  PDATA(pgm)->eeprom_pagesize = 1;
+  my.flash_pagesize = 2;
+  my.eeprom_pagesize = 1;
   for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
     m = ldata(ln);
     if(mem_is_flash(m)) {
       if(m->page_size > 1) {
         if(m->page_size > 256)
-          PDATA(pgm)->flash_pagesize = 256;
+          my.flash_pagesize = 256;
         else
-          PDATA(pgm)->flash_pagesize = m->page_size;
+          my.flash_pagesize = m->page_size;
       }
     } else if(mem_is_eeprom(m)) {
       if(m->page_size > 1)
-        PDATA(pgm)->eeprom_pagesize = m->page_size;
+        my.eeprom_pagesize = m->page_size;
     }
   }
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
   if(p->flags & AVRPART_IS_AT90S1200) {
     // AT90S1200 needs a positive reset pulse after a chip erase
@@ -1302,7 +1302,7 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 
   PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-  pgmcp->cookie = PDATA(pgm)->chained_pdata;
+  pgmcp->cookie = my.chained_pdata;
 
   if(p->prog_modes & PM_debugWIRE)
     parm[0] = PARM3_ARCH_TINY;
@@ -1333,48 +1333,48 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     mmt_free(resp);
 
   // Read or write SUFFER register
-  if(PDATA(pgm)->suffer_get || PDATA(pgm)->suffer_set) {
+  if(my.suffer_get || my.suffer_set) {
     // Read existing SUFFER value
     if(jtag3_getparm(pgmcp, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
-      MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data, 1) < 0) {
+      MEDBG_REG_SUFFER_OFFSET, my.suffer_data, 1) < 0) {
 
       return -1;
     }
-    if(!PDATA(pgm)->suffer_set)
-      imsg_info("SUFFER register value read as 0x%02x\n", PDATA(pgm)->suffer_data[0]);
+    if(!my.suffer_set)
+      imsg_info("SUFFER register value read as 0x%02x\n", my.suffer_data[0]);
     // Write new SUFFER value
     else {
       if(jtag3_setparm(pgmcp, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
-        MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data + 1, 1) < 0) {
+        MEDBG_REG_SUFFER_OFFSET, my.suffer_data + 1, 1) < 0) {
 
         return -1;
       }
       imsg_info("SUFFER register value changed from 0x%02x to 0x%02x\n",
-        PDATA(pgm)->suffer_data[0], PDATA(pgm)->suffer_data[1]);
+        my.suffer_data[0], my.suffer_data[1]);
     }
   }
 
   // Read or write Vtarg switch
-  if(PDATA(pgm)->vtarg_switch_get || PDATA(pgm)->vtarg_switch_set) {
+  if(my.vtarg_switch_get || my.vtarg_switch_set) {
     // Read existing Vtarg switch value
     if(jtag3_getparm(pgmcp, SCOPE_EDBG, EDBG_CTXT_CONTROL,
-      EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data, 1) < 0) {
+      EDBG_CONTROL_TARGET_POWER, my.vtarg_switch_data, 1) < 0) {
 
       return -1;
     }
-    if(!PDATA(pgm)->vtarg_switch_set) {
+    if(!my.vtarg_switch_set) {
       pmsg_info("Vtarg switch setting read as %u: target power is switched %s\n",
-        PDATA(pgm)->vtarg_switch_data[0], PDATA(pgm)->vtarg_switch_data[0]? "on": "off");
+        my.vtarg_switch_data[0], my.vtarg_switch_data[0]? "on": "off");
     } else {                    // Write Vtarg switch value
       if(jtag3_setparm(pgmcp, SCOPE_EDBG, EDBG_CTXT_CONTROL,
-        EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data + 1, 1) < 0) {
+        EDBG_CONTROL_TARGET_POWER, my.vtarg_switch_data + 1, 1) < 0) {
 
         return -1;
       }
-      pmsg_info("Vtarg switch setting changed from %u to %u\n", PDATA(pgm)->vtarg_switch_data[0],
-        PDATA(pgm)->vtarg_switch_data[1]);
+      pmsg_info("Vtarg switch setting changed from %u to %u\n", my.vtarg_switch_data[0],
+        my.vtarg_switch_data[1]);
       // Exit early if the target power switch is off and print sensible info message
-      if(PDATA(pgm)->vtarg_switch_data[1] == 0) {
+      if(my.vtarg_switch_data[1] == 0) {
         pmsg_info("turn on the Vtarg switch to establish connection with the target\n\n");
         return -1;
       }
@@ -1382,7 +1382,7 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   }
 
   // Read or write target voltage
-  if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+  if(my.vtarg_get || my.vtarg_set) {
     // Read current target voltage set value
     unsigned char buf[2];
 
@@ -1390,14 +1390,14 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
       return -1;
     double vtarg_read = b2_to_u16(buf)/1000.0;
 
-    if(PDATA(pgm)->vtarg_get)
+    if(my.vtarg_get)
       msg_info("Target voltage value read as %.2f V\n", vtarg_read);
     // Write target voltage value
     else {
-      u16_to_b2(buf, (unsigned) (PDATA(pgm)->vtarg_data*1000));
-      msg_info("Changing target voltage from %.2f V to %.2f V\n", vtarg_read, PDATA(pgm)->vtarg_data);
+      u16_to_b2(buf, (unsigned) (my.vtarg_data*1000));
+      msg_info("Changing target voltage from %.2f V to %.2f V\n", vtarg_read, my.vtarg_data);
       if(jtag3_setparm(pgmcp, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
-        msg_warning("Cannot set target voltage %.2f V\n", PDATA(pgm)->vtarg_data);
+        msg_warning("Cannot set target voltage %.2f V\n", my.vtarg_data);
         return -1;
       }
     }
@@ -1410,27 +1410,27 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
    * For devices/memory that are not page oriented, treat them as page size 1
    * for EEPROM, and 2 for flash.
    */
-  PDATA(pgm)->flash_pagesize = 2;
-  PDATA(pgm)->eeprom_pagesize = 1;
+  my.flash_pagesize = 2;
+  my.eeprom_pagesize = 1;
   for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
     m = ldata(ln);
     if(mem_is_flash(m)) {
       if(m->page_size > 1) {
         if(m->page_size > 256)
-          PDATA(pgm)->flash_pagesize = 256;
+          my.flash_pagesize = 256;
         else
-          PDATA(pgm)->flash_pagesize = m->page_size;
+          my.flash_pagesize = m->page_size;
       }
     } else if(mem_is_eeprom(m)) {
       if(m->page_size > 1)
-        PDATA(pgm)->eeprom_pagesize = m->page_size;
+        my.eeprom_pagesize = m->page_size;
     }
   }
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
   return pgm->program_enable(pgm, p);
 }
@@ -1459,59 +1459,59 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
   }
 
   // Read or write target voltage
-  if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+  if(my.vtarg_get || my.vtarg_set) {
     // Read current target voltage set value
     unsigned char vtarg_read = 0;
 
     if(stk500v2_getparm(pgm, PARAM_VTARGET, &vtarg_read) < 0)
       return -1;
-    if(PDATA(pgm)->vtarg_get)
+    if(my.vtarg_get)
       msg_info("Target voltage value read as %.2f V\n", (vtarg_read/10.0));
     // Write target voltage value
     else {
-      msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), PDATA(pgm)->vtarg_data);
-      if(pgm->set_vtarget(pgm, PDATA(pgm)->vtarg_data) < 0)
+      msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), my.vtarg_data);
+      if(pgm->set_vtarget(pgm, my.vtarg_data) < 0)
         return -1;
     }
   }
 
   // Read or write analog reference voltage
-  if(PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
-    if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
+  if(my.varef_get || my.varef_set) {
+    if(my.pgmtype == PGMTYPE_STK500) {
       // STK500: Read current analog reference voltage
       unsigned char varef_read = 0;
 
       if(stk500v2_getparm(pgm, PARAM_VADJUST, &varef_read) < 0)
         return -1;
-      if(PDATA(pgm)->varef_get) {
+      if(my.varef_get) {
         msg_info("Analog reference voltage value read as %.2f V\n", varef_read/10.0);
       } else {                  // STK500: Write analog reference voltage
         msg_info("Changing analog reference voltage from %.2f V to %.2f V\n",
-          varef_read/10.0, PDATA(pgm)->varef_data);
-        if(pgm->set_varef(pgm, 0, PDATA(pgm)->varef_data) < 0)
+          varef_read/10.0, my.varef_data);
+        if(pgm->set_varef(pgm, 0, my.varef_data) < 0)
           return -1;
       }
-    } else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+    } else if(my.pgmtype == PGMTYPE_STK600) {
       // STK600: Read current target voltage set value
       unsigned int varef_read = 0;
 
-      if(stk500v2_getparm2(pgm, PDATA(pgm)->varef_channel == 0? PARAM2_AREF0: PARAM2_AREF1, &varef_read) < 0)
+      if(stk500v2_getparm2(pgm, my.varef_channel == 0? PARAM2_AREF0: PARAM2_AREF1, &varef_read) < 0)
         return -1;
-      if(PDATA(pgm)->varef_get) {
+      if(my.varef_get) {
         msg_info("Analog reference channel %d voltage read as %.2f V\n",
-          PDATA(pgm)->varef_channel, (varef_read/100.0));
+          my.varef_channel, (varef_read/100.0));
       } else {                  // STK600: Write target voltage value for channel n
         msg_info("Changing analog reference channel %d voltage from %.2f V to %.2f V\n",
-          PDATA(pgm)->varef_channel, (varef_read/100.0), PDATA(pgm)->varef_data);
-        if(pgm->set_varef(pgm, PDATA(pgm)->varef_channel, PDATA(pgm)->varef_data) < 0)
+          my.varef_channel, (varef_read/100.0), my.varef_data);
+        if(pgm->set_varef(pgm, my.varef_channel, my.varef_data) < 0)
           return -1;
       }
     }
   }
 
   // Read or write clock generator frequency
-  if(PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
-    if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
+  if(my.fosc_get || my.fosc_set) {
+    if(my.pgmtype == PGMTYPE_STK500) {
       // Read current target voltage set value
       unsigned char osc_pscale = 0;
       unsigned char osc_cmatch = 0;
@@ -1526,7 +1526,7 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
       if(osc_pscale) {
         int prescale = 1;
 
-        f_get = PDATA(pgm)->xtal/2;
+        f_get = my.xtal/2;
         switch(osc_pscale) {
         case 2:
           prescale = 8;
@@ -1551,18 +1551,18 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
         f_get /= (osc_cmatch + 1);
         f_get = f_to_kHz_MHz(f_get, &unit_get);
       }
-      if(PDATA(pgm)->fosc_get)
+      if(my.fosc_get)
         msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
       // Write target voltage value
       else {
         const char *unit_set;
-        double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+        double f_set = f_to_kHz_MHz(my.fosc_data, &unit_set);
 
         msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
-        if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
+        if(pgm->set_fosc(pgm, my.fosc_data) < 0)
           return -1;
       }
-    } else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+    } else if(my.pgmtype == PGMTYPE_STK600) {
       // Read current target voltage set value
       unsigned int clock_conf = 0;
 
@@ -1573,15 +1573,15 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
       double f_get = pow(2, (double) oct)*2078.0/(2 - (double) dac/1024.0);
       const char *unit_get = { "Hz" };
       f_get = f_to_kHz_MHz(f_get, &unit_get);
-      if(PDATA(pgm)->fosc_get)
+      if(my.fosc_get)
         msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
       // Write target voltage value
       else {
         const char *unit_set;
-        double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+        double f_set = f_to_kHz_MHz(my.fosc_data, &unit_set);
 
         msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
-        if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
+        if(pgm->set_fosc(pgm, my.fosc_data) < 0)
           return -1;
       }
     }
@@ -1592,27 +1592,27 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
    * For devices/memory that are not page oriented, treat them as page size 1
    * for EEPROM, and 2 for flash.
    */
-  PDATA(pgm)->flash_pagesize = 2;
-  PDATA(pgm)->eeprom_pagesize = 1;
+  my.flash_pagesize = 2;
+  my.eeprom_pagesize = 1;
   for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
     m = ldata(ln);
     if(mem_is_flash(m)) {
       if(m->page_size > 1) {
         if(m->page_size > 256)
-          PDATA(pgm)->flash_pagesize = 256;
+          my.flash_pagesize = 256;
         else
-          PDATA(pgm)->flash_pagesize = m->page_size;
+          my.flash_pagesize = m->page_size;
       }
     } else if(mem_is_eeprom(m)) {
       if(m->page_size > 1)
-        PDATA(pgm)->eeprom_pagesize = m->page_size;
+        my.eeprom_pagesize = m->page_size;
     }
   }
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
-  PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
-  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
+  mmt_free(my.flash_pagecache);
+  mmt_free(my.eeprom_pagecache);
+  my.flash_pagecache = mmt_malloc(my.flash_pagesize);
+  my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
+  my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
 
   return pgm->program_enable(pgm, p);
 }
@@ -1631,10 +1631,10 @@ static void stk500v2_jtag3_disable(const PROGRAMMER *pgm) {
   unsigned char buf[16];
   int result;
 
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  PDATA(pgm)->flash_pagecache = NULL;
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->eeprom_pagecache = NULL;
+  mmt_free(my.flash_pagecache);
+  my.flash_pagecache = NULL;
+  mmt_free(my.eeprom_pagecache);
+  my.eeprom_pagecache = NULL;
 
   buf[0] = CMD_LEAVE_PROGMODE_ISP;
   buf[1] = 1;                   // preDelay;
@@ -1671,13 +1671,13 @@ static void stk500hv_disable(const PROGRAMMER *pgm, enum hvmode mode) {
   unsigned char buf[16];
   int result;
 
-  mmt_free(PDATA(pgm)->flash_pagecache);
-  PDATA(pgm)->flash_pagecache = NULL;
-  mmt_free(PDATA(pgm)->eeprom_pagecache);
-  PDATA(pgm)->eeprom_pagecache = NULL;
+  mmt_free(my.flash_pagecache);
+  my.flash_pagecache = NULL;
+  mmt_free(my.eeprom_pagecache);
+  my.eeprom_pagecache = NULL;
 
   buf[0] = mode == PPMODE? CMD_LEAVE_PROGMODE_PP:
-    (PDATA(pgm)->pgmtype == PGMTYPE_STK600? CMD_LEAVE_PROGMODE_HVSP_STK600: CMD_LEAVE_PROGMODE_HVSP);
+    (my.pgmtype == PGMTYPE_STK600? CMD_LEAVE_PROGMODE_HVSP_STK600: CMD_LEAVE_PROGMODE_HVSP);
   buf[1] = 15;                  // p->hvleavestabdelay;
   buf[2] = 15;                  // p->resetdelay;
 
@@ -1703,9 +1703,9 @@ static void stk500hvsp_disable(const PROGRAMMER *pgm) {
 static void stk500v2_enable(PROGRAMMER *pgm, const AVRPART *p) {
   // Previously stk500v2_initialize() set up pgm
   if(pgm->initialize == stk500v2_initialize) {
-    if((PDATA(pgm)->pgmtype == PGMTYPE_STK600 ||
-        PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
-        PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0 && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
+    if((my.pgmtype == PGMTYPE_STK600 ||
+        my.pgmtype == PGMTYPE_AVRISP_MKII ||
+        my.pgmtype == PGMTYPE_JTAGICE_MKII) != 0 && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
       stk600_setup_xprog(pgm);
     } else {
       stk600_setup_isp(pgm);
@@ -1734,18 +1734,18 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
           double vtarg_set_val = -1;    // Default = invalid value
           int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
 
-          PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
+          my.vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
           if(sscanf_success < 1 || vtarg_set_val < 0) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          PDATA(pgm)->vtarg_set = true;
+          my.vtarg_set = true;
           continue;
         }
         // Get target voltage
         else if(str_eq(extended_param, "vtarg")) {
-          PDATA(pgm)->vtarg_get = true;
+          my.vtarg_get = true;
           continue;
         }
       }
@@ -1759,39 +1759,39 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         // Get new analog reference voltage for channel 0
         if(str_starts(extended_param, "varef=")) {
           sscanf_success = sscanf(extended_param, "varef=%lf", &varef_set_val);
-          PDATA(pgm)->varef_channel = 0;
-          PDATA(pgm)->varef_set = true;
+          my.varef_channel = 0;
+          my.varef_set = true;
         }
         // Get new analog reference voltage for channel 0
         else if(str_starts(extended_param, "varef0=")) {
           sscanf_success = sscanf(extended_param, "varef0=%lf", &varef_set_val);
-          PDATA(pgm)->varef_channel = 0;
-          PDATA(pgm)->varef_set = true;
+          my.varef_channel = 0;
+          my.varef_set = true;
         }
         // Get new analog reference voltage for channel 1
         else if(str_starts(extended_param, "varef1=") && str_contains(pgm->type, "STK600")) {
           sscanf_success = sscanf(extended_param, "varef1=%lf", &varef_set_val);
-          PDATA(pgm)->varef_channel = 1;
-          PDATA(pgm)->varef_set = true;
+          my.varef_channel = 1;
+          my.varef_set = true;
         }
         // Get current analog reference voltage for channel 0
         else if(str_eq(extended_param, "varef") || str_eq(extended_param, "varef0")) {
-          PDATA(pgm)->varef_get = true;
-          PDATA(pgm)->varef_channel = 0;
+          my.varef_get = true;
+          my.varef_channel = 0;
           continue;
         }
         // Get current analog reference voltage for channel 1
         else if(str_eq(extended_param, "varef1") && str_contains(pgm->type, "STK600")) {
-          PDATA(pgm)->varef_get = true;
-          PDATA(pgm)->varef_channel = 1;
+          my.varef_get = true;
+          my.varef_channel = 1;
           continue;
         }
         // Set analog reference voltage
-        if(PDATA(pgm)->varef_set) {
-          PDATA(pgm)->varef_data = (double) ((int) (varef_set_val*100 + .5))/100;
+        if(my.varef_set) {
+          my.varef_data = (double) ((int) (varef_set_val*100 + .5))/100;
           if(sscanf_success < 1 || varef_set_val < 0) {
             pmsg_error("invalid value in -x %s\n", extended_param);
-            PDATA(pgm)->varef_set = false;
+            my.varef_set = false;
             rv = -1;
             break;
           }
@@ -1819,7 +1819,7 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
             while(*endp == ' ') // Remove leading spaces
               ++endp;
             if(str_starts(endp, "off"))
-              PDATA(pgm)->fosc_data = 0.0;
+              my.fosc_data = 0.0;
             else {
               pmsg_error("invalid fosc value %s\n", endp);
               rv = -1;
@@ -1829,17 +1829,17 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
           while(*endp == ' ')   // Remove leading spaces before unit
             ++endp;
           if(*endp == 'm' || *endp == 'M')
-            PDATA(pgm)->fosc_data = v*1e6;
+            my.fosc_data = v*1e6;
           else if(*endp == 'k' || *endp == 'K')
-            PDATA(pgm)->fosc_data = v*1e3;
+            my.fosc_data = v*1e3;
           else if(*endp == 0 || *endp == 'h' || *endp == 'H' || *endp == 0)
-            PDATA(pgm)->fosc_data = v;
-          PDATA(pgm)->fosc_set = true;
+            my.fosc_data = v;
+          my.fosc_set = true;
           continue;
         }
         // Get clock generator frequency
         else if(str_eq(extended_param, "fosc")) {
-          PDATA(pgm)->fosc_get = true;
+          my.fosc_get = true;
           continue;
         }
       }
@@ -1867,11 +1867,11 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
         while(*endp == ' ')     // Remove leading spaces before unit
           ++endp;
         if(*endp == 'm' || *endp == 'M') // Fits also e.g. "nnnnMHz"
-          PDATA(pgm)->xtal = v*1e6;
+          my.xtal = v*1e6;
         else if(*endp == 'k' || *endp == 'K')
-          PDATA(pgm)->xtal = v*1e3;
+          my.xtal = v*1e3;
         else if(*endp == 0 || *endp == 'h' || *endp == 'H')     // "nnnn" or "nnnnHz"
-          PDATA(pgm)->xtal = (unsigned) v;
+          my.xtal = (unsigned) v;
         continue;
       }
     }
@@ -1932,21 +1932,21 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
       if(pgm->extra_features & HAS_SUFFER) {
         // Set SUFFER value
         if(str_starts(extended_param, "suffer=")) {
-          if(sscanf(extended_param, "suffer=%hhi", PDATA(pgm)->suffer_data + 1) < 1) {
+          if(sscanf(extended_param, "suffer=%hhi", my.suffer_data + 1) < 1) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          if((PDATA(pgm)->suffer_data[1] & 0x78) != 0x78) {
-            PDATA(pgm)->suffer_data[1] |= 0x78;
-            pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n", PDATA(pgm)->suffer_data[1]);
+          if((my.suffer_data[1] & 0x78) != 0x78) {
+            my.suffer_data[1] |= 0x78;
+            pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n", my.suffer_data[1]);
           }
-          PDATA(pgm)->suffer_set = true;
+          my.suffer_set = true;
           continue;
         }
         // Get SUFFER value
         if(str_eq(extended_param, "suffer")) {
-          PDATA(pgm)->suffer_get = true;
+          my.suffer_get = true;
           continue;
         }
         pmsg_error("invalid setting in -x %s; use -x suffer or -x suffer=<n>\n", extended_param);
@@ -1959,19 +1959,19 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
       if(pgm->extra_features & HAS_VTARG_SWITCH) {
         // Set Vtarget switch value
         if(str_starts(extended_param, "vtarg_switch=")) {
-          int sscanf_success = sscanf(extended_param, "vtarg_switch=%hhi", PDATA(pgm)->vtarg_switch_data + 1);
+          int sscanf_success = sscanf(extended_param, "vtarg_switch=%hhi", my.vtarg_switch_data + 1);
 
-          if(sscanf_success < 1 || PDATA(pgm)->vtarg_switch_data[1] > 1) {
+          if(sscanf_success < 1 || my.vtarg_switch_data[1] > 1) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          PDATA(pgm)->vtarg_switch_set = true;
+          my.vtarg_switch_set = true;
           continue;
         }
         // Get Vtarget switch value
         if(str_eq(extended_param, "vtarg_switch")) {
-          PDATA(pgm)->vtarg_switch_get = true;
+          my.vtarg_switch_get = true;
           continue;
         }
         pmsg_error("invalid setting in -x %s; use -x vtarg_switch or -x vtarg_switch=<0..1>\n", extended_param);
@@ -1987,18 +1987,18 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
           double vtarg_set_val = 0;
           int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
 
-          PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
+          my.vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
           if(sscanf_success < 1 || vtarg_set_val < 0) {
             pmsg_error("invalid value in -x %s\n", extended_param);
             rv = -1;
             break;
           }
-          PDATA(pgm)->vtarg_set = true;
+          my.vtarg_set = true;
           continue;
         }
         // Get target voltage
         else if(str_eq(extended_param, "vtarg")) {
-          PDATA(pgm)->vtarg_get = true;
+          my.vtarg_get = true;
           continue;
         }
         pmsg_error("invalid setting in -x %s; use -x vtarg or -x vtarg=<dbl>\n", extended_param);
@@ -2010,12 +2010,12 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
     if(str_starts(extended_param, "mode") && (str_starts(pgmid, "pickit4") || str_starts(pgmid, "snap"))) {
       // Flag a switch to AVR mode
       if(str_caseeq(extended_param, "mode=avr")) {
-        PDATA(pgm)->pk4_snap_mode = PK4_SNAP_MODE_AVR;
+        my.pk4_snap_mode = PK4_SNAP_MODE_AVR;
         continue;
       }
       // Flag a switch to PIC mode
       if(str_caseeq(extended_param, "mode=pic")) {
-        PDATA(pgm)->pk4_snap_mode = PK4_SNAP_MODE_PIC;
+        my.pk4_snap_mode = PK4_SNAP_MODE_PIC;
         continue;
       }
       pmsg_error("invalid setting in -x %s; use -x mode=avr or -x mode=pic\n", extended_param);
@@ -2064,11 +2064,11 @@ enum {
 
 static void scratchmonkey_led_state(const PROGRAMMER *pgm, int flag, int value) {
   if(value)
-    PDATA(pgm)->scratchmonkey_leds |= flag;
+    my.scratchmonkey_leds |= flag;
   else
-    PDATA(pgm)->scratchmonkey_leds &= ~flag;
+    my.scratchmonkey_leds &= ~flag;
 
-  stk500v2_setparm_real(pgm, PARAM_SCRATCHMONKEY_STATUS_LEDS, PDATA(pgm)->scratchmonkey_leds);
+  stk500v2_setparm_real(pgm, PARAM_SCRATCHMONKEY_STATUS_LEDS, my.scratchmonkey_leds);
 }
 
 static int scratchmonkey_rdy_led(const PROGRAMMER *pgm, int value) {
@@ -2099,13 +2099,13 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
   if(pgm->baudrate)
     pinfo.serialinfo.baud = pgm->baudrate;
 
-  PDATA(pgm)->pgmtype = PGMTYPE_UNKNOWN;
+  my.pgmtype = PGMTYPE_UNKNOWN;
 
   if(str_caseeq(port, "avrdoper")) {
 
 #if defined(HAVE_LIBHIDAPI)
     serdev = &avrdoper_serdev;
-    PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+    my.pgmtype = PGMTYPE_STK500;
 #else
     pmsg_error("avrdoper requires avrdude with libhidapi support\n");
     return -1;
@@ -2124,7 +2124,7 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
     pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
     pinfo.usbinfo.flags = 0;
     pinfo.usbinfo.pid = USB_DEVICE_AVRISPMKII;
-    PDATA(pgm)->pgmtype = PGMTYPE_AVRISP_MKII;
+    my.pgmtype = PGMTYPE_AVRISP_MKII;
     pgm->set_sck_period = stk500v2_set_sck_period_mk2;
     pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
     pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
@@ -2158,7 +2158,7 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
       return -1;
   }
 
-  if(PDATA(pgm)->is_scratchmonkey) {
+  if(my.is_scratchmonkey) {
     pgm->rdy_led = scratchmonkey_rdy_led;
     pgm->err_led = scratchmonkey_err_led;
     pgm->pgm_led = scratchmonkey_pgm_led;
@@ -2176,7 +2176,7 @@ static int stk600_open(PROGRAMMER *pgm, const char *port) {
   if(pgm->baudrate)
     pinfo.serialinfo.baud = pgm->baudrate;
 
-  PDATA(pgm)->pgmtype = PGMTYPE_UNKNOWN;
+  my.pgmtype = PGMTYPE_UNKNOWN;
 
   /*
    * If the port name starts with "usb", divert the serial routines to the USB
@@ -2190,7 +2190,7 @@ static int stk600_open(PROGRAMMER *pgm, const char *port) {
     pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
     pinfo.usbinfo.flags = 0;
     pinfo.usbinfo.pid = USB_DEVICE_STK600;
-    PDATA(pgm)->pgmtype = PGMTYPE_STK600;
+    my.pgmtype = PGMTYPE_STK600;
     pgm->set_sck_period = stk600_set_sck_period;
     pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
     pgm->fd.usb.rep = USBDEV_BULK_EP_READ_STK600;
@@ -2262,10 +2262,10 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
   if(mem_is_flash(mem)) {
     buf[0] = mode == PPMODE? CMD_READ_FLASH_PP: CMD_READ_FLASH_HVSP;
     cmdlen = 3;
-    pagesize = PDATA(pgm)->flash_pagesize;
+    pagesize = my.flash_pagesize;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-    cache_ptr = PDATA(pgm)->flash_pagecache;
+    paddr_ptr = &my.flash_pageaddr;
+    cache_ptr = my.flash_pagecache;
     addrshift = 1;
     /*
      * If bit 31 is set, this indicates that the following read/write operation
@@ -2282,8 +2282,8 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
     if(pagesize == 0)
       pagesize = 1;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-    cache_ptr = PDATA(pgm)->eeprom_pagecache;
+    paddr_ptr = &my.eeprom_pageaddr;
+    cache_ptr = my.eeprom_pagecache;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     buf[0] = mode == PPMODE? CMD_READ_FUSE_PP: CMD_READ_FUSE_HVSP;
     if(mem_is_a_fuse(mem))
@@ -2381,17 +2381,17 @@ static int stk500isp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
   if(mem_is_flash(mem) || mem_is_eeprom(mem)) {
     // Use paged access, and cache result
     if(mem_is_flash(mem)) {
-      pagesize = PDATA(pgm)->flash_pagesize;
+      pagesize = my.flash_pagesize;
       paddr = addr & ~(pagesize - 1);
-      paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-      cache_ptr = PDATA(pgm)->flash_pagecache;
+      paddr_ptr = &my.flash_pageaddr;
+      cache_ptr = my.flash_pagecache;
     } else {
       pagesize = mem->page_size;
       if(pagesize == 0)
         pagesize = 1;
       paddr = addr & ~(pagesize - 1);
-      paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-      cache_ptr = PDATA(pgm)->eeprom_pagecache;
+      paddr_ptr = &my.eeprom_pageaddr;
+      cache_ptr = my.eeprom_pagecache;
     }
 
     if(paddr == *paddr_ptr) {
@@ -2467,10 +2467,10 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
 
   if(mem_is_flash(mem)) {
     buf[0] = mode == PPMODE? CMD_PROGRAM_FLASH_PP: CMD_PROGRAM_FLASH_HVSP;
-    pagesize = PDATA(pgm)->flash_pagesize;
+    pagesize = my.flash_pagesize;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-    cache_ptr = PDATA(pgm)->flash_pagecache;
+    paddr_ptr = &my.flash_pageaddr;
+    cache_ptr = my.flash_pagecache;
     addrshift = 1;
     /*
      * If bit 31 is set, this indicates that the following read/write operation
@@ -2486,8 +2486,8 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
     if(pagesize == 0)
       pagesize = 1;
     paddr = addr & ~(pagesize - 1);
-    paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-    cache_ptr = PDATA(pgm)->eeprom_pagecache;
+    paddr_ptr = &my.eeprom_pageaddr;
+    cache_ptr = my.eeprom_pagecache;
   } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
     buf[0] = mode == PPMODE? CMD_PROGRAM_FUSE_PP: CMD_PROGRAM_FUSE_HVSP;
     pulsewidth = p->programfusepulsewidth;
@@ -2607,10 +2607,10 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
 
   if(mem_is_flash(mem) || mem_is_eeprom(mem)) {
     if(mem_is_flash(mem)) {
-      pagesize = PDATA(pgm)->flash_pagesize;
+      pagesize = my.flash_pagesize;
       paddr = addr & ~(pagesize - 1);
-      paddr_ptr = &PDATA(pgm)->flash_pageaddr;
-      cache_ptr = PDATA(pgm)->flash_pagecache;
+      paddr_ptr = &my.flash_pageaddr;
+      cache_ptr = my.flash_pagecache;
       if((mem->mode & 1) == 0)
         // Old, unpaged device, really write single bytes
         pagesize = 1;
@@ -2619,8 +2619,8 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
       if(pagesize == 0)
         pagesize = 1;
       paddr = addr & ~(pagesize - 1);
-      paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
-      cache_ptr = PDATA(pgm)->eeprom_pagecache;
+      paddr_ptr = &my.eeprom_pageaddr;
+      cache_ptr = my.eeprom_pagecache;
     }
 
     /*
@@ -2711,7 +2711,7 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
   // Determine which command is to be used
   if(mem_is_flash(m)) {
     addrshift = 1;
-    PDATA(pgm)->flash_pageaddr = ~0UL;  // Invalidate cache
+    my.flash_pageaddr = ~0UL; // Invalidate cache
     commandbuf[0] = CMD_PROGRAM_FLASH_ISP;
     /*
      * If bit 31 is set, this indicates that the following read/write operation
@@ -2722,7 +2722,7 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
       use_ext_addr = (1U << 31);
     }
   } else if(mem_is_eeprom(m)) {
-    PDATA(pgm)->eeprom_pageaddr = ~0UL; // Invalidate cache
+    my.eeprom_pageaddr = ~0UL; // Invalidate cache
     commandbuf[0] = CMD_PROGRAM_EEPROM_ISP;
   }
   commandbuf[4] = m->delay;
@@ -2836,7 +2836,7 @@ static int stk500hv_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
   // Determine which command is to be used
   if(mem_is_flash(m)) {
     addrshift = 1;
-    PDATA(pgm)->flash_pageaddr = ~0UL;
+    my.flash_pageaddr = ~0UL;
     commandbuf[0] = mode == PPMODE? CMD_PROGRAM_FLASH_PP: CMD_PROGRAM_FLASH_HVSP;
     /*
      * If bit 31 is set, this indicates that the following read/write operation
@@ -2847,7 +2847,7 @@ static int stk500hv_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
       use_ext_addr = (1U << 31);
     }
   } else if(mem_is_eeprom(m)) {
-    PDATA(pgm)->eeprom_pageaddr = ~0UL;
+    my.eeprom_pageaddr = ~0UL;
     commandbuf[0] = mode == PPMODE? CMD_PROGRAM_EEPROM_PP: CMD_PROGRAM_EEPROM_HVSP;
   }
   /*
@@ -3127,9 +3127,9 @@ static int stk500v2_set_varef(const PROGRAMMER *pgm, unsigned int chan, double v
 }
 
 static int stk500v2_get_varef(const PROGRAMMER *pgm, unsigned int chan, double *v) {
-  if(PDATA(pgm)->pgmtype == PGMTYPE_STK500)
+  if(my.pgmtype == PGMTYPE_STK500)
     *v = stk500v2_varef_value(pgm);
-  else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+  else if(my.pgmtype == PGMTYPE_STK600) {
     if(chan == 0)
       *v = stk600_varef_0_value(pgm);
     else if(chan == 1)
@@ -3154,7 +3154,7 @@ static int stk500v2_set_fosc(const PROGRAMMER *pgm, double v) {
 
   prescale = cmatch = 0;
   if(v > 0.0) {
-    if(v > PDATA(pgm)->xtal/2) {
+    if(v > my.xtal/2) {
       const char *unit;
 
       if(v >= 1e6) {
@@ -3165,21 +3165,21 @@ static int stk500v2_set_fosc(const PROGRAMMER *pgm, double v) {
         unit = "kHz";
       } else
         unit = "Hz";
-      pmsg_warning("f = %.3f %s too high, using %.3f MHz\n", v, unit, PDATA(pgm)->xtal/2e6);
-      fosc = PDATA(pgm)->xtal/2;
+      pmsg_warning("f = %.3f %s too high, using %.3f MHz\n", v, unit, my.xtal/2e6);
+      fosc = my.xtal/2;
     } else
       fosc = (unsigned) v;
 
     for(idx = 0; idx < sizeof(ps)/sizeof(ps[0]); idx++) {
-      if((unsigned) fosc >= PDATA(pgm)->xtal/(256*ps[idx] * 2)) {
+      if((unsigned) fosc >= my.xtal/(256*ps[idx] * 2)) {
         // This prescaler value can handle our frequency
         prescale = idx + 1;
-        cmatch = (unsigned) (PDATA(pgm)->xtal/(2*fosc*ps[idx])) - 1;
+        cmatch = (unsigned) (my.xtal/(2*fosc*ps[idx])) - 1;
         break;
       }
     }
     if(idx == sizeof(ps)/sizeof(ps[0])) {
-      pmsg_warning("f = %u Hz too low, %u Hz min\n", fosc, PDATA(pgm)->xtal/(256*1024*2));
+      pmsg_warning("f = %u Hz too low, %u Hz min\n", fosc, my.xtal/(256*1024*2));
       return -1;
     }
   }
@@ -3282,16 +3282,16 @@ static int stk500v2_set_sck_period(const PROGRAMMER *pgm, double v) {
   unsigned char dur;
   double f = 1/v;
 
-  if(f >= PDATA(pgm)->xtal/4.0)       // 1.8432E6
+  if(f >= my.xtal/4.0)          // 1.8432E6
     d = 0;
-  else if(f > PDATA(pgm)->xtal/16.0)  // 460.8E3
+  else if(f > my.xtal/16.0)     // 460.8E3
     d = 1;
-  else if(f > PDATA(pgm)->xtal/64.0)  // 115.2E3
+  else if(f > my.xtal/64.0)     // 115.2E3
     d = 2;
-  else if(f > PDATA(pgm)->xtal/128.0) // 57.6E3
+  else if(f > my.xtal/128.0)    // 57.6E3
     d = 3;
   else
-    d = (unsigned int) ceil(1/(24*f/(double) PDATA(pgm)->xtal) - 10.0/12.0);
+    d = (unsigned int) ceil(1/(24*f/(double) my.xtal) - 10.0/12.0);
   if(d >= 255)
     d = 254;
   dur = d;
@@ -3308,18 +3308,18 @@ static double stk500v2_sck_to_us(const PROGRAMMER *pgm, unsigned char dur) {
   double x;
 
   if(dur == 0)
-    return 4.E6/PDATA(pgm)->xtal;     // 0.5425;
+    return 4.E6/my.xtal;        // 0.5425;
   if(dur == 1)
-    return 16.E6/PDATA(pgm)->xtal;    // 2.17;
+    return 16.E6/my.xtal;       // 2.17;
   if(dur == 2)
-    return 64.E6/PDATA(pgm)->xtal;    // 8.68;
+    return 64.E6/my.xtal;       // 8.68;
   if(dur == 3)
-    return 128.E6/PDATA(pgm)->xtal;   // 17.36;
+    return 128.E6/my.xtal;      // 17.36;
 
   x = (double) dur + 10.0/12.0;
   x = 1.0/x;
   x /= 24.0;
-  x *= (double) PDATA(pgm)->xtal;
+  x *= (double) my.xtal;
   return 1e6/x;
 }
 
@@ -3354,11 +3354,11 @@ static int stk600_set_vtarget(const PROGRAMMER *pgm, double v) {
   }
 
   // Vtarget on the STK600 can only be adjusted while not being in programming mode
-  if(PDATA(pgm)->lastpart)
+  if(my.lastpart)
     pgm->disable(pgm);
   rv = stk500v2_setparm(pgm, PARAM_VTARGET, utarg);
-  if(PDATA(pgm)->lastpart)
-    pgm->program_enable(pgm, PDATA(pgm)->lastpart);
+  if(my.lastpart)
+    pgm->program_enable(pgm, my.lastpart);
 
   return rv;
 }
@@ -3554,7 +3554,7 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
   unsigned int rev = 0;
   const char *topcard_name;
 
-  if(PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII && PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
+  if(my.pgmtype != PGMTYPE_JTAGICE_MKII && my.pgmtype != PGMTYPE_JTAGICE3) {
     msg_info("%sProgrammer model      : %s\n", p, pgmname(pgm));
     stk500v2_getparm(pgm, PARAM_HW_VER, &hdw);
     stk500v2_getparm(pgm, PARAM_SW_MAJOR, &maj);
@@ -3563,7 +3563,7 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
     if(pgm->usbsn && *pgm->usbsn)
       msg_info("%sSerial number         : %s\n", p, pgm->usbsn);
     msg_info("%sFW Version Controller : %d.%02d\n", p, maj, min);
-    if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+    if(my.pgmtype == PGMTYPE_STK600) {
       stk500v2_getparm(pgm, PARAM_SW_MAJOR_PERIPHERY1, &maj_s1);
       stk500v2_getparm(pgm, PARAM_SW_MINOR_PERIPHERY1, &min_s1);
       stk500v2_getparm(pgm, PARAM_SW_MAJOR_PERIPHERY2, &maj_s2);
@@ -3573,7 +3573,7 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
     }
   }
 
-  if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
+  if(my.pgmtype == PGMTYPE_STK500) {
     stk500v2_getparm(pgm, PARAM_TOPCARD_DETECT, &topcard);
     switch(topcard) {
     case 0xAA:
@@ -3599,7 +3599,7 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
       break;
     }
     msg_info("%sTopcard               : %s\n", p, topcard_name);
-  } else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+  } else if(my.pgmtype == PGMTYPE_STK600) {
     stk500v2_getparm(pgm, PARAM_ROUTINGCARD_ID, &topcard);
     msg_info("%sRouting card          : %s\n", p,
       stk600_get_cardname(routing_cards, sizeof routing_cards/sizeof routing_cards[0], topcard));
@@ -3610,10 +3610,10 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
     msg_info("%sRC_ID table rev       : %d\n", p, rev);
     stk500v2_getparm2(pgm, PARAM2_EC_ID_TABLE_REV, &rev);
     msg_info("%sEC_ID table rev       : %d\n", p, rev);
-  } else if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3) {
+  } else if(my.pgmtype == PGMTYPE_JTAGICE3) {
     PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-    pgmcp->cookie = PDATA(pgm)->chained_pdata;
+    pgmcp->cookie = my.chained_pdata;
     jtag3_display(pgmcp, p);
     pgm_free(pgmcp);
   }
@@ -3623,19 +3623,19 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
 }
 
 static double stk500v2_vtarget_value(const PROGRAMMER *pgm) {
-  if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) {
+  if(my.pgmtype == PGMTYPE_JTAGICE_MKII) {
     unsigned char vtarget_jtag[4];
 
     memset(vtarget_jtag, 0, sizeof vtarget_jtag);
     PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-    pgmcp->cookie = PDATA(pgm)->chained_pdata;
+    pgmcp->cookie = my.chained_pdata;
     jtagmkII_getparm(pgmcp, PAR_OCD_VTARGET, vtarget_jtag);
     pgm_free(pgmcp);
     return b2_to_u16(vtarget_jtag)/1000.0;
   }
 
-  if(PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
+  if(my.pgmtype != PGMTYPE_JTAGICE3) {
     unsigned char vtarget = 0;
 
     stk500v2_getparm(pgm, PARAM_VTARGET, &vtarget);
@@ -3649,7 +3649,7 @@ static double stk500v2_sck_duration_value(const PROGRAMMER *pgm) {
   unsigned char sck_duration = 0;
   unsigned int sck_stk600 = 0;
 
-  switch(PDATA(pgm)->pgmtype) {
+  switch(my.pgmtype) {
   case PGMTYPE_STK500:
     return stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration) < 0? 0: stk500v2_sck_to_us(pgm, sck_duration);
 
@@ -3675,7 +3675,7 @@ static double stk500v2_sck_duration_value(const PROGRAMMER *pgm) {
     return stk500v2_getparm2(pgm, PARAM2_SCK_DURATION, &sck_stk600) < 0? 0: (sck_stk600 + 1)/8.0;
 
   default:
-    return sck_duration*8.0e6/PDATA(pgm)->xtal + 0.05;
+    return sck_duration*8.0e6/my.xtal + 0.05;
   }
   return 0;
 }
@@ -3710,7 +3710,7 @@ static double stk500v2_fosc_value(const PROGRAMMER *pgm) {
   int prescale;
   double fosc = 0.0;
 
-  switch(PDATA(pgm)->pgmtype) {
+  switch(my.pgmtype) {
   case PGMTYPE_STK500:
     if(stk500v2_getparm(pgm, PARAM_OSC_PSCALE, &osc_pscale) < 0)
       return 0.0;
@@ -3720,7 +3720,7 @@ static double stk500v2_fosc_value(const PROGRAMMER *pgm) {
       return 0.0;
 
     prescale = 1;
-    fosc = PDATA(pgm)->xtal/2;
+    fosc = my.xtal/2;
 
     switch(osc_pscale) {
     case 2:
@@ -3773,7 +3773,7 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
     fmsg_out(fp, "%sVtarget               : %.1f V\n", p, stk500v2_vtarget_value(pgm));
   }
 
-  switch(PDATA(pgm)->pgmtype) {
+  switch(my.pgmtype) {
   case PGMTYPE_STK500:
     if(pgm->extra_features & HAS_VAREF_ADJ) {
       fmsg_out(fp, "%sVaref                 : %.1f V\n", p, stk500v2_varef_value(pgm));
@@ -3792,7 +3792,7 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
     // SCK duration is always available
     fmsg_out(fp, "%sSCK period            : %.1f us\n", p, stk500v2_sck_duration_value(pgm));
     // XTAL frequency is always available
-    double f = PDATA(pgm)->xtal;
+    double f = my.xtal;
 
     decimals = get_decimals(f);
     f = f_to_kHz_MHz(f, &unit);
@@ -3816,7 +3816,7 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
       }
       PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-      pgmcp->cookie = PDATA(pgm)->chained_pdata;
+      pgmcp->cookie = my.chained_pdata;
       pgmcp->id = lcreat(NULL, 0);
       // Copy pgm->id contents over to pgmcp->id
       for(LNODEID ln = lfirst(pgm->id); ln; ln = lnext(ln))
@@ -3920,7 +3920,7 @@ static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
   stk500v2_drain(pgm, 0);
 
   mycookie = pgm->cookie;
-  pgm->cookie = PDATA(pgm)->chained_pdata;
+  pgm->cookie = my.chained_pdata;
   if((rv = jtagmkII_getsync(pgm, EMULATOR_MODE_SPI)) != 0) {
     if(rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
       pmsg_error("unable to sync with the JTAG ICE mkII in ISP mode\n");
@@ -3929,7 +3929,7 @@ static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
   }
   pgm->cookie = mycookie;
 
-  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
+  my.pgmtype = PGMTYPE_JTAGICE_MKII;
 
   if(pgm->bitclock != 0.0) {
     if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
@@ -3946,7 +3946,7 @@ static void stk500v2_jtagmkII_close(PROGRAMMER *pgm) {
   pmsg_notice2("stk500v2_jtagmkII_close()\n");
 
   mycookie = pgm->cookie;
-  pgm->cookie = PDATA(pgm)->chained_pdata;
+  pgm->cookie = my.chained_pdata;
   jtagmkII_close(pgm);
   pgm->cookie = mycookie;
 }
@@ -3958,7 +3958,7 @@ static void stk500v2_jtag3_close(PROGRAMMER *pgm) {
   pmsg_notice2("stk500v2_jtag3_close()\n");
 
   mycookie = pgm->cookie;
-  pgm->cookie = PDATA(pgm)->chained_pdata;
+  pgm->cookie = my.chained_pdata;
   jtag3_close(pgm);
   pgm->cookie = mycookie;
 }
@@ -4016,7 +4016,7 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
   stk500v2_drain(pgm, 0);
 
   mycookie = pgm->cookie;
-  pgm->cookie = PDATA(pgm)->chained_pdata;
+  pgm->cookie = my.chained_pdata;
   if(jtagmkII_getsync(pgm, EMULATOR_MODE_SPI) != 0) {
     pmsg_error("unable to sync with the AVR Dragon in ISP mode\n");
     pgm->cookie = mycookie;
@@ -4024,7 +4024,7 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
   }
   pgm->cookie = mycookie;
 
-  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
+  my.pgmtype = PGMTYPE_JTAGICE_MKII;
 
   if(pgm->bitclock != 0.0) {
     if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
@@ -4088,14 +4088,14 @@ static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
 
   PROGRAMMER *pgmcp = pgm_dup(pgm);
 
-  pgmcp->cookie = PDATA(pgm)->chained_pdata;
+  pgmcp->cookie = my.chained_pdata;
   if(jtagmkII_getsync(pgmcp, EMULATOR_MODE_HV) != 0) {
     pmsg_error("unable to sync with the AVR Dragon in HV mode\n");
     pgm_free(pgmcp);
     return -1;
   }
   pgm_free(pgmcp);
-  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
+  my.pgmtype = PGMTYPE_JTAGICE_MKII;
 
   if(pgm->bitclock != 0.0) {
     if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
@@ -4118,12 +4118,12 @@ static int stk500v2_jtag3_open(PROGRAMMER *pgm, const char *port) {
 
   pmsg_notice2("%s()\n", __func__);
 
-  rv = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
+  rv = jtag3_open_common(pgm, port, my.pk4_snap_mode);
   if(rv < 0)
     return rv;
 
   mycookie = pgm->cookie;
-  pgm->cookie = PDATA(pgm)->chained_pdata;
+  pgm->cookie = my.chained_pdata;
   if((rv = jtag3_getsync(pgm, 42)) != 0) {
     if(rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
       pmsg_error("unable to sync with the JTAGICE3 in ISP mode\n");
@@ -4132,7 +4132,7 @@ static int stk500v2_jtag3_open(PROGRAMMER *pgm, const char *port) {
   }
   pgm->cookie = mycookie;
 
-  PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE3;
+  my.pgmtype = PGMTYPE_JTAGICE3;
 
   if(pgm->bitclock != 0.0) {
     if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
@@ -4271,7 +4271,7 @@ static int stk600_xprog_program_enable(const PROGRAMMER *pgm, const AVRPART *p)
 }
 
 static unsigned char stk600_xprog_mtype(const PROGRAMMER *pgm, unsigned long addr) {
-  if(addr >= PDATA(pgm)->boot_start)
+  if(addr >= my.boot_start)
     return XPRG_MEM_TYPE_BOOT;
   else
     return XPRG_MEM_TYPE_APPL;
diff --git a/src/teensy.c b/src/teensy.c
index d993b4d2..e9fabe1e 100644
--- a/src/teensy.c
+++ b/src/teensy.c
@@ -59,7 +59,7 @@
 
 #define TEENSY_CONNECT_WAIT 100
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // -----------------------------------------------------------------------------
 
@@ -229,7 +229,7 @@ static void teensy_teardown(PROGRAMMER *pgm) {
 static int teensy_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   pmsg_debug("teensy_initialize()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   int result = teensy_get_bootloader_info(pdata, p);
 
@@ -252,7 +252,7 @@ static void teensy_powerup(const PROGRAMMER *pgm) {
 static void teensy_powerdown(const PROGRAMMER *pgm) {
   pmsg_debug("teensy_powerdown()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   if(pdata->erase_flash) {
     teensy_erase_flash(pdata);
@@ -286,7 +286,7 @@ static int teensy_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p, const
     return -1;
   }
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   memcpy(mem->buf, pdata->sig_bytes, sizeof(pdata->sig_bytes));
 
@@ -296,7 +296,7 @@ static int teensy_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p, const
 static int teensy_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
   pmsg_debug("teensy_chip_erase()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   // Schedule a chip erase, either at first write or on powerdown.
   pdata->erase_flash = true;
@@ -307,7 +307,7 @@ static int teensy_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
 static int teensy_open(PROGRAMMER *pgm, const char *port) {
   pmsg_debug("teensy_open(\"%s\")\n", port);
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
   const char *bus_name = NULL;
   char *dev_name = NULL;
 
@@ -400,7 +400,7 @@ static int teensy_open(PROGRAMMER *pgm, const char *port) {
 static void teensy_close(PROGRAMMER *pgm) {
   pmsg_debug("teensy_close()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   if(pdata->hid_handle != NULL) {
     hid_close(pdata->hid_handle);
@@ -438,7 +438,7 @@ static int teensy_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
   pmsg_debug("teensy_paged_write(page_size=0x%X, addr=0x%X, n_bytes=0x%X)\n", page_size, addr, n_bytes);
 
   if(mem_is_flash(mem)) {
-    struct pdata *pdata = PDATA(pgm);
+    struct pdata *pdata = &my;
 
     if(n_bytes > page_size) {
       pmsg_error("buffer size %u exceeds page size %u\n", n_bytes, page_size);
@@ -485,7 +485,7 @@ static int teensy_parseextparams(const PROGRAMMER *pgm, const LISTID xparams) {
 
   pmsg_debug("teensy_parseextparams()\n");
 
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   for(LNODEID node = lfirst(xparams); node; node = lnext(node)) {
     const char *extended_param = ldata(node);
diff --git a/src/usbasp.c b/src/usbasp.c
index 840f2bfb..2fb717c5 100644
--- a/src/usbasp.c
+++ b/src/usbasp.c
@@ -88,12 +88,12 @@ struct pdata {
   int USB_init;                 // Used in both usbOpenDevice() variants
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 #ifdef USE_LIBUSB_1_0
 static const char *errstr(const PROGRAMMER *pgm, int result) {
-  char *msg = PDATA(pgm)->msg;
-  size_t msgsiz = sizeof(PDATA(pgm)->msg);
+  char *msg = my.msg;
+  size_t msgsiz = sizeof(my.msg);
   int n = 0;
 
   switch(result) {
@@ -212,21 +212,21 @@ static int usbasp_tpi_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const
 // Dispatching wrappers
 
 static int usbasp_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) {
-  return PDATA(pgm)->use_tpi? usbasp_tpi_cmd(pgm, cmd, res): usbasp_spi_cmd(pgm, cmd, res);
+  return my.use_tpi? usbasp_tpi_cmd(pgm, cmd, res): usbasp_spi_cmd(pgm, cmd, res);
 }
 
 static int usbasp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
-  return PDATA(pgm)->use_tpi? usbasp_tpi_program_enable(pgm, p): usbasp_spi_program_enable(pgm, p);
+  return my.use_tpi? usbasp_tpi_program_enable(pgm, p): usbasp_spi_program_enable(pgm, p);
 }
 
 static int usbasp_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
-  return PDATA(pgm)->use_tpi? usbasp_tpi_chip_erase(pgm, p): usbasp_spi_chip_erase(pgm, p);
+  return my.use_tpi? usbasp_tpi_chip_erase(pgm, p): usbasp_spi_chip_erase(pgm, p);
 }
 
 static int usbasp_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
   unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
 
-  return PDATA(pgm)->use_tpi?
+  return my.use_tpi?
     usbasp_tpi_paged_load(pgm, p, m, page_size, addr, n_bytes):
     usbasp_spi_paged_load(pgm, p, m, page_size, addr, n_bytes);
 }
@@ -234,19 +234,19 @@ static int usbasp_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
 static int usbasp_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
   unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
 
-  return PDATA(pgm)->use_tpi?
+  return my.use_tpi?
     usbasp_tpi_paged_write(pgm, p, m, page_size, addr, n_bytes):
     usbasp_spi_paged_write(pgm, p, m, page_size, addr, n_bytes);
 }
 
 static int usbasp_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
-  return PDATA(pgm)->use_tpi? usbasp_tpi_set_sck_period(pgm, sckperiod): usbasp_spi_set_sck_period(pgm, sckperiod);
+  return my.use_tpi? usbasp_tpi_set_sck_period(pgm, sckperiod): usbasp_spi_set_sck_period(pgm, sckperiod);
 }
 
 static int usbasp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
   unsigned long addr, unsigned char *value) {
 
-  return PDATA(pgm)->use_tpi?
+  return my.use_tpi?
     usbasp_tpi_read_byte(pgm, p, m, addr, value):
     avr_read_byte_default(pgm, p, m, addr, value);
 }
@@ -264,7 +264,7 @@ static int usbasp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
     return -1;
   }
 
-  return PDATA(pgm)->use_tpi?
+  return my.use_tpi?
     usbasp_tpi_write_byte(pgm, p, m, addr, data):
     avr_write_byte_default(pgm, p, m, addr, data);
 }
@@ -288,7 +288,7 @@ static int usbasp_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
 
     if(str_eq(extended_param, "section_config")) {
       pmsg_notice2("%s(): set section_e to 1 (config section)\n", __func__);
-      PDATA(pgm)->section_e = 1;
+      my.section_e = 1;
       continue;
     }
 
@@ -388,7 +388,7 @@ static int usbasp_transmit(const PROGRAMMER *pgm,
   }
 
 #ifdef USE_LIBUSB_1_0
-  nbytes = libusb_control_transfer(PDATA(pgm)->usbhandle,
+  nbytes = libusb_control_transfer(my.usbhandle,
     (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | (receive << 7)) & 0xff,
     functionid & 0xff,
     ((send[1] << 8) | send[0]) & 0xffff, ((send[3] << 8) | send[2]) & 0xffff, buffer, buffersize & 0xffff, 5000);
@@ -397,7 +397,7 @@ static int usbasp_transmit(const PROGRAMMER *pgm,
     return -1;
   }
 #else
-  nbytes = usb_control_msg(PDATA(pgm)->usbhandle,
+  nbytes = usb_control_msg(my.usbhandle,
     USB_TYPE_VENDOR | USB_RECIP_DEVICE | (receive << 7),
     functionid, (send[1] << 8) | send[0], (send[3] << 8) | send[2], (char *) buffer, buffersize, 5000);
   if(nbytes < 0) {
@@ -456,13 +456,13 @@ static int usbOpenDevice(const PROGRAMMER *pgm, libusb_device_handle ** device,
   int j;
   int r;
 
-  if(!PDATA(pgm)->USB_init) {
-    PDATA(pgm)->USB_init = 1;
-    libusb_init(&PDATA(pgm)->ctx);
+  if(!my.USB_init) {
+    my.USB_init = 1;
+    libusb_init(&my.ctx);
   }
 
   libusb_device **dev_list;
-  int dev_list_len = libusb_get_device_list(PDATA(pgm)->ctx, &dev_list);
+  int dev_list_len = libusb_get_device_list(my.ctx, &dev_list);
 
   for(j = 0; j < dev_list_len; ++j) {
     libusb_device *dev = dev_list[j];
@@ -546,8 +546,8 @@ static int usbOpenDevice(const PROGRAMMER *pgm, usb_dev_handle ** device, int ve
   usb_dev_handle *handle = NULL;
   int errorCode = USB_ERROR_NOTFOUND;
 
-  if(!PDATA(pgm)->USB_init) {
-    PDATA(pgm)->USB_init = 1;
+  if(!my.USB_init) {
+    my.USB_init = 1;
     usb_init();
   }
   usb_find_busses();
@@ -634,10 +634,10 @@ static int usbasp_open(PROGRAMMER *pgm, const char *port) {
     pid = USBASP_SHARED_PID;
   }
   vid = pgm->usbvid? pgm->usbvid: USBASP_SHARED_VID;
-  if(usbOpenDevice(pgm, &PDATA(pgm)->usbhandle, vid, pgm->usbvendor, pid, pgm->usbproduct, port) != 0) {
+  if(usbOpenDevice(pgm, &my.usbhandle, vid, pgm->usbvendor, pid, pgm->usbproduct, port) != 0) {
     if(str_eq(pgmid, "usbasp")) {
       // Check if device with old VID/PID is available
-      if(usbOpenDevice(pgm, &PDATA(pgm)->usbhandle, USBASP_OLD_VID, "www.fischl.de",
+      if(usbOpenDevice(pgm, &my.usbhandle, USBASP_OLD_VID, "www.fischl.de",
         USBASP_OLD_PID, "USBasp", port) == 0) {
 
         cx->usb_access_error = 0;
@@ -669,26 +669,26 @@ static int usbasp_open(PROGRAMMER *pgm, const char *port) {
 static void usbasp_close(PROGRAMMER *pgm) {
   pmsg_debug("usbasp_close()\n");
 
-  if(PDATA(pgm)->usbhandle != NULL) {
+  if(my.usbhandle != NULL) {
     unsigned char temp[4];
 
     memset(temp, 0, sizeof(temp));
 
-    if(PDATA(pgm)->use_tpi) {
+    if(my.use_tpi) {
       usbasp_transmit(pgm, 1, USBASP_FUNC_TPI_DISCONNECT, temp, temp, sizeof(temp));
     } else {
       usbasp_transmit(pgm, 1, USBASP_FUNC_DISCONNECT, temp, temp, sizeof(temp));
     }
 
 #ifdef USE_LIBUSB_1_0
-    libusb_close(PDATA(pgm)->usbhandle);
+    libusb_close(my.usbhandle);
 #else
-    usb_close(PDATA(pgm)->usbhandle);
+    usb_close(my.usbhandle);
 #endif
   }
 
 #ifdef USE_LIBUSB_1_0
-  libusb_exit(PDATA(pgm)->ctx);
+  libusb_exit(my.ctx);
 #else
   // Nothing for usb 0.1?
 #endif
@@ -710,7 +710,7 @@ static void usbasp_display(const PROGRAMMER *pgm, const char *p) {
 static int usbasp_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
   unsigned char temp[4];
   unsigned char res[4];
-  struct pdata *pdata = PDATA(pgm);
+  struct pdata *pdata = &my;
 
   pmsg_debug("usbasp_initialize()\n");
 
@@ -832,7 +832,7 @@ static int usbasp_spi_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const
   }
 
   // Set blocksize depending on sck frequency
-  if((PDATA(pgm)->sckfreq_hz > 0) && (PDATA(pgm)->sckfreq_hz < 10000)) {
+  if((my.sckfreq_hz > 0) && (my.sckfreq_hz < 10000)) {
     blocksize = USBASP_READBLOCKSIZE/10;
   } else {
     blocksize = USBASP_READBLOCKSIZE;
@@ -898,7 +898,7 @@ static int usbasp_spi_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
   }
 
   // Set blocksize depending on sck frequency
-  if((PDATA(pgm)->sckfreq_hz > 0) && (PDATA(pgm)->sckfreq_hz < 10000)) {
+  if((my.sckfreq_hz > 0) && (my.sckfreq_hz < 10000)) {
     blocksize = USBASP_WRITEBLOCKSIZE/10;
   } else {
     blocksize = USBASP_WRITEBLOCKSIZE;
@@ -977,7 +977,7 @@ static int usbasp_spi_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
   memset(res, 0, sizeof(res));
 
   // Reset global sck frequency to auto
-  PDATA(pgm)->sckfreq_hz = 0;
+  my.sckfreq_hz = 0;
 
   if(sckperiod == 0) {
     // Auto sck set
@@ -993,7 +993,7 @@ static int usbasp_spi_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
     // Check if programmer is capable of 3 MHz SCK, if not then ommit 3 MHz setting
     size_t i;
 
-    if(PDATA(pgm)->sck_3mhz) {
+    if(my.sck_3mhz) {
       pmsg_notice2("connected USBasp is capable of 3 MHz SCK\n");
       i = 0;
     } else {
@@ -1017,7 +1017,7 @@ static int usbasp_spi_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
     }
 
     // Save used sck frequency
-    PDATA(pgm)->sckfreq_hz = usefreq;
+    my.sckfreq_hz = usefreq;
 
     pmsg_info("set SCK frequency to %i Hz\n", usefreq);
   }
@@ -1126,7 +1126,7 @@ static int usbasp_tpi_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
   int pr_1;
   int nvm_cmd;
 
-  switch(PDATA(pgm)->section_e) {
+  switch(my.section_e) {
     // Config bits section erase
   case 1:
     pr_0 = 0x41;
diff --git a/src/usbtiny.c b/src/usbtiny.c
index c9b9c536..4266e429 100644
--- a/src/usbtiny.c
+++ b/src/usbtiny.c
@@ -70,7 +70,7 @@ struct pdata {
   int retries;
 };
 
-#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+#define my (*(struct pdata *) (pgm->cookie))
 
 // ----------------------------------------------------------------------
 
@@ -89,7 +89,7 @@ static int usb_control(const PROGRAMMER *pgm, unsigned int requestid,
 
   int nbytes;
 
-  nbytes = usb_control_msg(PDATA(pgm)->usb_handle,
+  nbytes = usb_control_msg(my.usb_handle,
     USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, requestid,
     val, index,                 // 2 bytes each of data
     NULL, 0,                    // No data buffer in control message
@@ -120,12 +120,12 @@ static int usb_in(const PROGRAMMER *pgm,
   timeout = USB_TIMEOUT + (buflen*bitclk)/1000;
 
   for(i = 0; i < 10; i++) {
-    nbytes = usb_control_msg(PDATA(pgm)->usb_handle,
+    nbytes = usb_control_msg(my.usb_handle,
       USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, requestid, val, index, (char *) buffer, buflen, timeout);
     if(nbytes == buflen) {
       return nbytes;
     }
-    PDATA(pgm)->retries++;
+    my.retries++;
   }
   msg_error("\n");
   pmsg_error("%s (expected %d, got %d)\n", usb_strerror(), buflen, nbytes);
@@ -134,9 +134,9 @@ static int usb_in(const PROGRAMMER *pgm,
 
 // Report the number of retries, and reset the counter.
 static void check_retries(const PROGRAMMER *pgm, const char *operation) {
-  if(PDATA(pgm)->retries > 0)
-    pmsg_info("%d retries during %s\n", PDATA(pgm)->retries, operation);
-  PDATA(pgm)->retries = 0;
+  if(my.retries > 0)
+    pmsg_info("%d retries during %s\n", my.retries, operation);
+  my.retries = 0;
 }
 
 // Wrapper for simple usb_control_msg messages to send data to programmer
@@ -151,7 +151,7 @@ static int usb_out(const PROGRAMMER *pgm,
    */
   timeout = USB_TIMEOUT + (buflen*bitclk)/1000;
 
-  nbytes = usb_control_msg(PDATA(pgm)->usb_handle,
+  nbytes = usb_control_msg(my.usb_handle,
     USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, requestid, val, index, (char *) buffer, buflen, timeout);
   if(nbytes != buflen) {
     msg_error("\n");
@@ -202,7 +202,7 @@ static unsigned short tpi_frame(unsigned char b) {
 static int usbtiny_tpi_tx(const PROGRAMMER *pgm, unsigned char b0) {
   unsigned char res[4];
 
-  if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*PDATA(pgm)->sck_period) < 0)
+  if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*my.sck_period) < 0)
     return -1;
   msg_debug("CMD_TPI_TX: [0x%02x]\n", b0);
   return 1;
@@ -213,7 +213,7 @@ static int usbtiny_tpi_txtx(const PROGRAMMER *pgm, unsigned char b0, unsigned ch
   unsigned char res[4];
 
   if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), tpi_frame(b1), res, sizeof(res),
-    8*sizeof(res)*PDATA(pgm)->sck_period) < 0) {
+    8*sizeof(res)*my.sck_period) < 0) {
 
     return -1;
   }
@@ -231,7 +231,7 @@ static int usbtiny_tpi_txrx(const PROGRAMMER *pgm, unsigned char b0) {
   unsigned char res[4], r;
   short w;
 
-  if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*PDATA(pgm)->sck_period) < 0)
+  if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*my.sck_period) < 0)
     return -1;
 
   w = (res[2] << 8) | res[3];
@@ -305,7 +305,7 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
   usb_find_busses();            // Have libusb scan all the usb buses available
   usb_find_devices();           // Have libusb scan all the usb devices available
 
-  PDATA(pgm)->usb_handle = NULL;
+  my.usb_handle = NULL;
 
   if(pgm->usbvid)
     vid = pgm->usbvid;
@@ -330,10 +330,10 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
         // If -P was given, match device by device name and bus name
         if(name != NULL && (NULL == dev_name || !str_eq(bus->dirname, bus_name) || !str_eq(dev->filename, dev_name)))
           continue;
-        PDATA(pgm)->usb_handle = usb_open(dev); // Attempt to connect to device
+        my.usb_handle = usb_open(dev); // Attempt to connect to device
 
         // Wrong permissions or something?
-        if(!PDATA(pgm)->usb_handle) {
+        if(!my.usb_handle) {
           pmsg_warning("cannot open USB device: %s\n", usb_strerror());
           continue;
         }
@@ -345,7 +345,7 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
     pmsg_error("invalid -P %s; use -P usb:bus:device\n", name);
     return -1;
   }
-  if(!PDATA(pgm)->usb_handle) {
+  if(!my.usb_handle) {
     pmsg_error("cannot find USBtiny device (0x%x/0x%x)\n", vid, pid);
     return -1;
   }
@@ -355,19 +355,19 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
 
 // Clean up the handle for the usbtiny
 static void usbtiny_close(PROGRAMMER *pgm) {
-  if(!PDATA(pgm)->usb_handle)   // Not a valid handle, bail!
+  if(!my.usb_handle)            // Not a valid handle, bail!
     return;
-  usb_close(PDATA(pgm)->usb_handle);    // Ask libusb to clean up
-  PDATA(pgm)->usb_handle = NULL;
+  usb_close(my.usb_handle);     // Ask libusb to clean up
+  my.usb_handle = NULL;
 }
 
 /* A simple calculator function determines the maximum size of data we can
    shove through a USB connection without getting errors */
 static void usbtiny_set_chunk_size(const PROGRAMMER *pgm, int period) {
-  PDATA(pgm)->chunk_size = CHUNK_SIZE; // Start with the maximum (default)
-  while(PDATA(pgm)->chunk_size > 8 && period > 16) {
+  my.chunk_size = CHUNK_SIZE;   // Start with the maximum (default)
+  while(my.chunk_size > 8 && period > 16) {
     // Reduce the chunk size for a slow SCK to reduce the maximum time of a single USB transfer
-    PDATA(pgm)->chunk_size >>= 1;
+    my.chunk_size >>= 1;
     period >>= 1;
   }
 }
@@ -375,24 +375,24 @@ static void usbtiny_set_chunk_size(const PROGRAMMER *pgm, int period) {
 /* Given a SCK bit-clock speed (in useconds) we verify its an OK speed and tell the
    USBtiny to update itself to the new frequency */
 static int usbtiny_set_sck_period(const PROGRAMMER *pgm, double v) {
-  PDATA(pgm)->sck_period = (int) (v*1e6 + 0.5);       // Convert from us to int, the 0.5 is for rounding up
+  my.sck_period = (int) (v*1e6 + 0.5); // Convert from us to int, the 0.5 is for rounding up
 
   // Make sure its not 0, as that will confuse the usbtiny
-  if(PDATA(pgm)->sck_period < SCK_MIN)
-    PDATA(pgm)->sck_period = SCK_MIN;
+  if(my.sck_period < SCK_MIN)
+    my.sck_period = SCK_MIN;
 
   // We can't go slower, due to the byte-size of the clock variable
-  if(PDATA(pgm)->sck_period > SCK_MAX)
-    PDATA(pgm)->sck_period = SCK_MAX;
+  if(my.sck_period > SCK_MAX)
+    my.sck_period = SCK_MAX;
 
-  pmsg_notice("setting SCK period to %d usec\n", PDATA(pgm)->sck_period);
+  pmsg_notice("setting SCK period to %d usec\n", my.sck_period);
 
   // Send the command to the usbtiny device; MEME: for at90's fix resetstate?
-  if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_LOW, 0) < 0)
+  if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_LOW, 0) < 0)
     return -1;
 
   // With the new speed, we'll have to update how much data we send per usb transfer
-  usbtiny_set_chunk_size(pgm, PDATA(pgm)->sck_period);
+  usbtiny_set_chunk_size(pgm, my.sck_period);
   return 0;
 }
 
@@ -406,11 +406,11 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     usbtiny_set_sck_period(pgm, pgm->bitclock);
   } else {
     // -B option not specified: use default
-    PDATA(pgm)->sck_period = SCK_DEFAULT;
-    pmsg_notice("using SCK period of %d usec\n", PDATA(pgm)->sck_period);
-    if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_LOW, 0) < 0)
+    my.sck_period = SCK_DEFAULT;
+    pmsg_notice("using SCK period of %d usec\n", my.sck_period);
+    if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_LOW, 0) < 0)
       return -1;
-    usbtiny_set_chunk_size(pgm, PDATA(pgm)->sck_period);
+    usbtiny_set_chunk_size(pgm, my.sck_period);
   }
 
   // Let the device wake up.
@@ -426,7 +426,7 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 
     memset(res, 0xaa, sizeof(res));
     if(usb_in(pgm, USBTINY_SPI, LITTLE_TO_BIG_16(0x1234), LITTLE_TO_BIG_16(0x5678),
-      res, 4, 32*PDATA(pgm)->sck_period) < 0) {
+      res, 4, 32*my.sck_period) < 0) {
 
       pmsg_error("usb_in() failed\n");
       return -1;
@@ -439,7 +439,7 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     }
 
     // Keep TPIDATA high for >= 16 clock cycles:
-    if(usb_in(pgm, USBTINY_SPI, 0xffff, 0xffff, res, 4, 32*PDATA(pgm)->sck_period) < 0) {
+    if(usb_in(pgm, USBTINY_SPI, 0xffff, 0xffff, res, 4, 32*my.sck_period) < 0) {
       pmsg_error("unable to switch chip into TPI mode\n");
       return -1;
     }
@@ -449,8 +449,8 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
     if(pgm->program_enable(pgm, p) >= 0)
       break;
     // No response, RESET and try again
-    if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_HIGH, 0) < 0 ||
-      usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_LOW, 0) < 0)
+    if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_HIGH, 0) < 0 ||
+      usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_LOW, 0) < 0)
       return -1;
     usleep(50000);
   }
@@ -462,7 +462,7 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
 static int usbtiny_setpin(const PROGRAMMER *pgm, int pinfunc, int value) {
   // USBtiny is not a bit bang device, but it can set RESET
   if(pinfunc == PIN_AVR_RESET) {
-    if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, value? RESET_HIGH: RESET_LOW, 0) < 0)
+    if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, value? RESET_HIGH: RESET_LOW, 0) < 0)
       return -1;
     usleep(50000);
     return 0;
@@ -472,7 +472,7 @@ static int usbtiny_setpin(const PROGRAMMER *pgm, int pinfunc, int value) {
 
 // Tell the USBtiny to release the output pins, etc
 static void usbtiny_powerdown(const PROGRAMMER *pgm) {
-  if(!PDATA(pgm)->usb_handle)
+  if(!my.usb_handle)
     return;                     // Wasn't connected in the first place
   usb_control(pgm, USBTINY_POWERDOWN, 0, 0, 1);
 }
@@ -487,7 +487,7 @@ static int usbtiny_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned
 
   nbytes = usb_in(pgm, USBTINY_SPI, (cmd[1] << 8) | cmd[0], // Convert to 16-bit words
     (cmd[3] << 8) | cmd[2],     //  "
-    res, 4, 8*PDATA(pgm)->sck_period);
+    res, 4, 8*my.sck_period);
   if(nbytes < 0)
     return -1;
   check_retries(pgm, "SPI command");
@@ -635,7 +635,7 @@ static int usbtiny_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVR
   }
 
   for(; addr < maxaddr; addr += chunk) {
-    chunk = PDATA(pgm)->chunk_size; // Start with the maximum chunk size possible
+    chunk = my.chunk_size;      // Start with the maximum chunk size possible
     if(addr + chunk > maxaddr)
       chunk = maxaddr - addr;
 
@@ -645,7 +645,7 @@ static int usbtiny_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVR
         addr,                   // Address in memory
         m->buf + addr,          // Pointer to where we store data
         chunk,                  // Number of bytes
-        32*PDATA(pgm)->sck_period) < 0) { // Each byte gets turned into a 4-byte SPI cmd
+        32*my.sck_period) < 0) { // Each byte gets turned into a 4-byte SPI cmd
       // usb_in() multiplies this per byte
       return -1;
     }
@@ -688,7 +688,7 @@ static int usbtiny_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AV
 
   for(; addr < maxaddr; addr += chunk) {
     // Start with the max chunk size
-    chunk = PDATA(pgm)->chunk_size;
+    chunk = my.chunk_size;
     if(addr + chunk > maxaddr) {
       chunk = maxaddr - addr;
     }
@@ -703,7 +703,7 @@ static int usbtiny_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AV
         m->buf + addr,          // Pointer to data
         chunk,                  // Number of bytes to write
         // Each byte gets turned into a 4-byte SPI cmd; usb_out() multiplies this per byte; then add the cmd-delay
-        32*PDATA(pgm)->sck_period + delay) < 0) {
+        32*my.sck_period + delay) < 0) {
       return -1;
     }
 
diff --git a/src/wiring.c b/src/wiring.c
index c5b76d33..ca6186d2 100644
--- a/src/wiring.c
+++ b/src/wiring.c
@@ -58,7 +58,7 @@ struct wiringpdata {
 
 // pdata is stk500v2's private data (inherited)
 
-#define WIRINGPDATA(pgm) ((struct wiringpdata *)(((struct pdata *)(pgm->cookie)) -> chained_pdata))
+#define mywiring (*(struct wiringpdata *) (((struct pdata *) (pgm->cookie)) -> chained_pdata))
 
 static void wiring_setup(PROGRAMMER *pgm) {
   // First, have STK500v2 backend allocate its own private data
@@ -92,7 +92,7 @@ static int wiring_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         break;
       }
       pmsg_notice2("%s(): snooze time set to %d ms\n", __func__, val);
-      WIRINGPDATA(pgm)->snoozetime = val;
+      mywiring.snoozetime = val;
       continue;
     }
 
@@ -105,12 +105,12 @@ static int wiring_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         break;
       }
       pmsg_notice2("%s(): delay set to %d ms\n", __func__, val);
-      WIRINGPDATA(pgm)->delay = val;
+      mywiring.delay = val;
       continue;
     }
 
     if(str_eq(extended_param, "noautoreset")) {
-      WIRINGPDATA(pgm)->noautoreset = true;
+      mywiring.noautoreset = true;
       continue;
     }
 
@@ -144,14 +144,14 @@ static int wiring_open(PROGRAMMER *pgm, const char *port) {
   serial_open(port, pinfo, &pgm->fd);
 
   // If we have a snoozetime, then we wait and do NOT toggle DTR/RTS
-  if(WIRINGPDATA(pgm)->snoozetime > 0) {
-    timetosnooze = WIRINGPDATA(pgm)->snoozetime;
+  if(mywiring.snoozetime > 0) {
+    timetosnooze = mywiring.snoozetime;
 
     pmsg_notice2("%s(): snoozing for %d ms\n", __func__, timetosnooze);
     while(timetosnooze--)
       usleep(1000);
     pmsg_notice2("%s(): done snoozing\n", __func__);
-  } else if(WIRINGPDATA(pgm)->noautoreset == false) {
+  } else if(mywiring.noautoreset == false) {
     // This code assumes a negative-logic USB to TTL serial adapter
     // Set RTS/DTR high to discharge the series-capacitor, if present
     pmsg_notice2("%s(): releasing DTR/RTS\n", __func__);
@@ -167,7 +167,7 @@ static int wiring_open(PROGRAMMER *pgm, const char *port) {
     // Set the RTS/DTR line back to high, so direct connection to reset works
     serial_set_dtr_rts(&pgm->fd, 0);
 
-    int delay = WIRINGPDATA(pgm)->delay;
+    int delay = mywiring.delay;
 
     if((100 + delay) > 0)
       usleep((100 + delay)*1000);     // Wait until board comes out of reset
diff --git a/src/xbee.c b/src/xbee.c
index e2321875..4d77039a 100644
--- a/src/xbee.c
+++ b/src/xbee.c
@@ -1424,7 +1424,7 @@ static int xbee_open(PROGRAMMER *pgm, const char *port) {
   // Wireless is lossier than normal serial
   serial_recv_timeout = 1000;
 
-  serdev = &PDATA(pgm)->xbee_serdev;
+  serdev = &my.xbee_serdev;
   serdev->open = xbeedev_open;
   serdev->close = xbeedev_close;
   serdev->rawclose = xbeedev_close;
@@ -1438,7 +1438,7 @@ static int xbee_open(PROGRAMMER *pgm, const char *port) {
     return -1;
   }
 
-  xbeedev_setresetpin(&pgm->fd, PDATA(pgm)->xbeeResetPin);
+  xbeedev_setresetpin(&pgm->fd, my.xbeeResetPin);
 
   // Clear DTR and RTS
   serial_set_dtr_rts(&pgm->fd, 0);
@@ -1514,7 +1514,7 @@ static int xbee_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
         break;
       }
 
-      PDATA(pgm)->xbeeResetPin = resetpin;
+      my.xbeeResetPin = resetpin;
       continue;
     }
 
@@ -1542,7 +1542,7 @@ void xbee_initpgm(PROGRAMMER *pgm) {
   /*
    * This behaves like an Arduino, but with packet encapsulation of the serial
    * streams, XBee device management, and XBee GPIO for the Auto-Reset feature.
-   * stk500.c sets PDATA(pgm)->xbeeResetPin
+   * stk500.c sets my.xbeeResetPin
    */
   stk500_initpgm(pgm);