0001-CH341A-Programmer.patch

From f0d397634120bbc2e0c2d8d3afca4b5a8b8ce96d Mon Sep 17 00:00:00 2001
From: -=Alx=- <alx@kreatur.ru>
Date: Tue, 20 Sep 2016 19:06:28 +0300
Subject: [PATCH] CH341A Programmer

---
 avrdude/Makefile.am     |   2 +
 avrdude/avrdude.conf.in |  11 ++
 avrdude/ch341a.c        | 442 ++++++++++++++++++++++++++++++++++++++++++++++++
 avrdude/ch341a.h        |  65 +++++++
 avrdude/pgm_type.c      |   2 +
 5 files changed, 518 insertions(+)
 create mode 100644 avrdude/ch341a.c
 create mode 100644 avrdude/ch341a.h

diff --git a/avrdude/Makefile.am b/avrdude/Makefile.am
index d1ed478..67609d2 100644
--- a/avrdude/Makefile.am
+++ b/avrdude/Makefile.am
@@ -168,6 +168,8 @@ libavrdude_a_SOURCES = \
 	tpi.h \
 	usbasp.c \
 	usbasp.h \
+	ch341a.c \
+	ch341a.h \
 	usbdevs.h \
 	usb_hidapi.c \
 	usb_libusb.c \
diff --git a/avrdude/avrdude.conf.in b/avrdude/avrdude.conf.in
index b247e52..d402aa7 100644
--- a/avrdude/avrdude.conf.in
+++ b/avrdude/avrdude.conf.in
@@ -844,6 +844,17 @@ programmer
 ;
 
 programmer
+  id    = "ch341a";
+  desc  = "ch341a programmer";
+  type  = "ch341a";
+  connection_type = usb;
+  usbvid     = 0x1A86;
+  usbpid     = 0x5512;
+  usbvendor  = "wch.cn";
+  usbproduct = "CH341A";
+;
+
+programmer
   id    = "nibobee";
   desc  = "NIBObee";
   type  = "usbasp";
diff --git a/avrdude/ch341a.c b/avrdude/ch341a.c
new file mode 100644
index 0000000..2842467
--- /dev/null
+++ b/avrdude/ch341a.c
@@ -0,0 +1,442 @@
+/*
+ * avrdude - A Downloader/Uploader for AVR device programmers
+ *
+ * avrdude support for CH341
+ * Copyright (C) 2016  Alexey Sadkov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Interface to the CH341A programmer.
+ *
+ */
+#include "ac_cfg.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "avrdude.h"
+#include "libavrdude.h"
+
+#include "ch341a.h"
+#include "usbdevs.h"
+
+#if defined(HAVE_LIBUSB_1_0)
+
+#ifdef HAVE_LIBUSB_1_0
+# define USE_LIBUSB_1_0
+# if defined(HAVE_LIBUSB_1_0_LIBUSB_H)
+#  include <libusb-1.0/libusb.h>
+# else
+#  include <libusb.h>
+# endif
+#endif
+
+#ifdef USE_LIBUSB_1_0
+
+static libusb_context *ctx = NULL;
+
+static int libusb_to_errno(int result)
+{
+    switch (result) {
+    case LIBUSB_SUCCESS:
+        return 0;
+    case LIBUSB_ERROR_IO:
+        return EIO;
+    case LIBUSB_ERROR_INVALID_PARAM:
+        return EINVAL;
+    case LIBUSB_ERROR_ACCESS:
+        return EACCES;
+    case LIBUSB_ERROR_NO_DEVICE:
+        return ENXIO;
+    case LIBUSB_ERROR_NOT_FOUND:
+        return ENOENT;
+    case LIBUSB_ERROR_BUSY:
+        return EBUSY;
+#ifdef ETIMEDOUT
+    case LIBUSB_ERROR_TIMEOUT:
+        return ETIMEDOUT;
+#endif
+#ifdef EOVERFLOW
+    case LIBUSB_ERROR_OVERFLOW:
+        return EOVERFLOW;
+#endif
+    case LIBUSB_ERROR_PIPE:
+        return EPIPE;
+    case LIBUSB_ERROR_INTERRUPTED:
+        return EINTR;
+    case LIBUSB_ERROR_NO_MEM:
+        return ENOMEM;
+    case LIBUSB_ERROR_NOT_SUPPORTED:
+        return ENOSYS;
+    default:
+        return ERANGE;
+    }
+}
+
+#endif
+
+/*
+ * Private data for this programmer.
+ */
+struct pdata
+{
+  libusb_device_handle *usbhandle;
+  int sckfreq_hz;
+};
+
+#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+
+// ----------------------------------------------------------------------
+/* Prototypes */
+static void ch341a_setup(PROGRAMMER * pgm);
+static void ch341a_teardown(PROGRAMMER * pgm);
+static int  ch341a_open(PROGRAMMER * pgm, char * port);
+static void ch341a_close(PROGRAMMER * pgm);
+static int ch341a_initialize(PROGRAMMER * pgm, AVRPART * p);
+static int ch341a_spi_cmd(PROGRAMMER * pgm, const unsigned char *cmd, unsigned char *res);
+static int ch341a_spi(PROGRAMMER * pgm, const unsigned char *in, unsigned char *out, unsigned int size);
+static int ch341a_spi_program_enable(PROGRAMMER * pgm, AVRPART * p);
+static int ch341a_spi_chip_erase(PROGRAMMER * pgm, AVRPART * p);
+static int ch341a_spi_transfer(PROGRAMMER * pgm, const unsigned char *cmd, unsigned char *res);
+// dummy functions
+static void ch341a_disable(PROGRAMMER * pgm);
+static void ch341a_enable(PROGRAMMER * pgm);
+static void ch341a_display(PROGRAMMER * pgm, const char * p);
+
+
+/* ch341 requires LSB first, swap the bit order before send and after receive */
+static unsigned char swap_byte(unsigned char byte) {
+    byte = ((byte >> 1) & 0x55) | ((byte << 1) & 0xaa);
+    byte = ((byte >> 2) & 0x33) | ((byte << 2) & 0xcc);
+    byte = ((byte >> 4) & 0x0f) | ((byte << 4) & 0xf0);
+    return byte;
+}
+
+static int CH341USBTransferPart(PROGRAMMER * pgm, enum libusb_endpoint_direction dir, unsigned char *buff, unsigned int size) {
+    int ret, bytestransferred;
+
+    if (!PDATA(pgm)->usbhandle)
+        return 0;
+
+    if ((ret = libusb_bulk_transfer(PDATA(pgm)->usbhandle, CH341A_USB_BULK_ENDPOINT | dir, buff, size, &bytestransferred, CH341A_USB_TIMEOUT))) {
+        avrdude_message(MSG_INFO, "%s: Error: libusb_bulk_transfer for IN_EP failed: %d (%s)\n", progname, ret, libusb_error_name(ret));
+        return -1;
+    }
+    return bytestransferred;
+}
+
+static bool CH341USBTransfer(PROGRAMMER * pgm, enum libusb_endpoint_direction dir, unsigned char *buff, unsigned int size)
+{
+    int pos = 0, bytestransferred;
+    while (size) {
+        bytestransferred = CH341USBTransferPart(pgm, dir, buff + pos, size);
+        if (bytestransferred <= 0)
+            return false;
+        pos += bytestransferred;
+        size -= bytestransferred;
+    }
+    return true;
+}
+/* The assumed map between UIO command bits, pins on CH341A chip and pins on SPI chip:
+ * UIO  CH341A  SPI CH341A SPI name
+ * 0    D0/15   CS/1    (CS0)
+ * 1    D1/16   unused  (CS1)
+ * 2    D2/17   unused  (CS2)
+ * 3    D3/18   SCK/6   (DCK)
+ * 4    D4/19   unused  (DOUT2)
+ * 5    D5/20   SI/5    (DOUT)
+ * - The UIO stream commands seem to only have 6 bits of output, and D6/D7 are the SPI inputs,
+ *  mapped as follows:
+ *  D6/21   unused  (DIN2)
+ *  D7/22   SO/2    (DIN)
+ */
+bool CH341ChipSelect(PROGRAMMER * pgm, unsigned int cs, bool enable) {
+    unsigned char res[4];
+    unsigned char cmd[4];
+    memset(cmd, 0, sizeof(cmd));
+    memset(res, 0, sizeof(res));
+    avrdude_message(MSG_DEBUG, "%s: ch341a_ChipSelect()\n", progname);
+    if (cs > 2) {
+        avrdude_message(MSG_INFO, "%s: Error: invalid CS pin %d, 0~2 are available\n", progname, cs);
+        return false;
+    }
+    cmd[0] = CH341A_CMD_UIO_STREAM;
+    if (enable)
+        cmd[1] = CH341A_CMD_UIO_STM_OUT | ( 0x37 & ~(1<<cs));
+    else
+        cmd[1] = CH341A_CMD_UIO_STM_OUT | 0x37;
+    cmd[2] = CH341A_CMD_UIO_STM_DIR | 0x3F;
+    cmd[3] = CH341A_CMD_UIO_STM_END;
+    return CH341USBTransferPart(pgm, LIBUSB_ENDPOINT_OUT, cmd, 4);
+}
+
+static int ch341a_open(PROGRAMMER * pgm, char * port) {
+    LNODEID usbpid = lfirst(pgm->usbpid);
+    int                   pid, vid, j, r;
+    int                   errorCode = USB_ERROR_NOTFOUND;
+    libusb_device_handle *handle = NULL;
+    static int            didUsbInit = 0;
+
+    avrdude_message(MSG_DEBUG, "%s: ch341a_open(\"%s\")\n", progname, port);
+
+    if(!didUsbInit) {
+        didUsbInit = 1;
+        libusb_init(&ctx);
+    }
+
+    if (usbpid) {
+        pid = *(int *)(ldata(usbpid));
+        if (lnext(usbpid))
+            avrdude_message(MSG_INFO, "%s: Warning: using PID 0x%04x, ignoring remaining PIDs in list\n",
+                            progname, pid);
+    } else {
+        pid = CH341A_PID;
+    }
+    vid = pgm->usbvid? pgm->usbvid: CH341A_VID;
+
+    libusb_device **dev_list;
+    int dev_list_len = libusb_get_device_list(ctx, &dev_list);
+
+    for (j=0; j<dev_list_len; ++j) {
+        libusb_device *dev = dev_list[j];
+        struct libusb_device_descriptor descriptor;
+        libusb_get_device_descriptor(dev, &descriptor);
+        if (descriptor.idVendor == vid && descriptor.idProduct == pid) {
+            r = libusb_open(dev, &handle);
+            if (!handle) {
+                errorCode = USB_ERROR_ACCESS;
+                avrdude_message(MSG_INFO, "%s: Warning: cannot open USB device: %s\n",
+                                progname, strerror(libusb_to_errno(r)));
+                continue;
+            }
+        }
+    }
+    libusb_free_device_list(dev_list,1);
+    if (handle != NULL) {
+        errorCode = 0;
+        PDATA(pgm)->usbhandle = handle;
+    }
+
+    if (errorCode!= 0) {
+        avrdude_message(MSG_INFO, "%s: error: could not find USB device with vid=0x%x pid=0x%x",
+                        progname, vid, pid);
+        avrdude_message(MSG_INFO, "\n");
+        return -1;
+    }
+    if ((r = libusb_claim_interface(PDATA(pgm)->usbhandle, 0))) {
+        fprintf(stderr, "%s: error: libusb_claim_interface failed: %d (%s)\n", progname, r, libusb_error_name(r));
+        libusb_close(PDATA(pgm)->usbhandle);
+        libusb_exit(ctx);
+    }
+    return 0;
+}
+
+static void ch341a_close(PROGRAMMER * pgm) {
+    avrdude_message(MSG_DEBUG, "%s: ch341a_close()\n", progname);
+    CH341ChipSelect(pgm, 0,false);
+
+    if (PDATA(pgm)->usbhandle!=NULL) {
+        libusb_release_interface(PDATA(pgm)->usbhandle, 0);
+        libusb_close(PDATA(pgm)->usbhandle);
+    }
+    libusb_exit(ctx);
+}
+
+static int ch341a_initialize(PROGRAMMER * pgm, AVRPART * p) {
+    avrdude_message(MSG_DEBUG, "%s: ch341a_initialize()\n", progname);
+    CH341ChipSelect(pgm, 0,false);
+    usleep(20 * 1000);
+    CH341ChipSelect(pgm, 0,true);
+    return pgm->program_enable(pgm, p);
+}
+
+static int ch341a_spi_transfer(PROGRAMMER * pgm, const unsigned char *cmd, unsigned char *res) {
+    unsigned char pkt[CH341A_PACKET_LENGTH];
+    unsigned int i;
+    int ret, bytestransferred;
+    int size=sizeof(cmd);
+
+    avrdude_message(MSG_DEBUG, "%s: ch341a_spi_transfer(0x%02x, 0x%02x, 0x%02x, 0x%02x)%s",
+                    progname, cmd[0], cmd[1], cmd[2], cmd[3], verbose > 3? "...\n": "\n");
+
+    if (size > CH341A_PACKET_LENGTH - 1)
+        size = CH341A_PACKET_LENGTH - 1;
+
+    for (i = 0; i < size; i++) {
+        pkt[i] = cmd[i];
+    }
+	
+    if (CH341USBTransferPart(pgm, LIBUSB_ENDPOINT_OUT, pkt, size)<=0 || CH341USBTransferPart(pgm, LIBUSB_ENDPOINT_IN, pkt, size)<=0) {
+        avrdude_message(MSG_INFO, "%s: failed to transfer data to/from CH341\n", progname);
+        return -1;
+    }
+
+    for (i = 0; i < size; i++) {
+        res[i] = pkt[i];
+    }
+    return size;
+}
+static int ch341a_spi_cmd(PROGRAMMER * pgm, const unsigned char *cmd, unsigned char *res) {
+    return pgm->spi(pgm, cmd, res, 4);
+}
+static int ch341a_spi(PROGRAMMER * pgm, const unsigned char *in, unsigned char *out, unsigned int size) {
+    unsigned char pkt[CH341A_PACKET_LENGTH];
+    unsigned int i;
+
+    if (!size)
+        return 0;
+
+    if (size > CH341A_PACKET_LENGTH - 1)
+        size = CH341A_PACKET_LENGTH - 1;
+
+    pkt[0] = CH341A_CMD_SPI_STREAM;
+
+    for (i = 0; i < size; i++)
+        pkt[i + 1] = swap_byte(in[i]);
+
+    if (!CH341USBTransfer(pgm, LIBUSB_ENDPOINT_OUT, pkt, size +1))
+    {
+        fprintf(stderr, "Error: failed to transfer data to CH341\n");
+        return -1;
+    }
+
+    if (!CH341USBTransfer(pgm, LIBUSB_ENDPOINT_IN, pkt, size))
+    {
+        fprintf(stderr, "Error: failed to transfer data from CH341\n");
+        return -1;
+    }
+
+    for (i = 0; i < size; i++)
+        out[i] = swap_byte(pkt[i]);
+
+    return size;
+}
+static int ch341a_spi_program_enable(PROGRAMMER * pgm, AVRPART * p) {
+    unsigned char res[4];
+    unsigned char cmd[4];
+    memset(cmd, 0, sizeof(cmd));
+    memset(res, 0, sizeof(res));
+
+    cmd[0] = 0;
+    avrdude_message(MSG_DEBUG, "%s: ch341a_program_enable() %s\n",
+                    progname, p->op[AVR_OP_PGM_ENABLE]);
+
+    if (p->op[AVR_OP_PGM_ENABLE] == NULL) {
+        avrdude_message(MSG_INFO, "program enable instruction not defined for part \"%s\"\n", p->desc);
+        return -1;
+    }
+    avr_set_bits(p->op[AVR_OP_PGM_ENABLE], cmd);
+    pgm->cmd(pgm, cmd, res);
+
+    avrdude_message(MSG_DEBUG, "program_enable(): sending command. Resp = %x %x %x %x \n", (int)res[0], (int)res[1], (int)res[2], (int)res[3]);
+    // check for sync character
+    if (res[2] != cmd[1])
+        return -2;
+    return 0;
+}
+static int  ch341a_spi_chip_erase(struct programmer_t * pgm, AVRPART * p) {
+    unsigned char cmd[4];
+    unsigned char res[4];
+    if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
+        avrdude_message(MSG_INFO, "chip erase instruction not defined for part \"%s\"\n", p->desc);
+        return -1;
+    }
+    memset(cmd, 0, sizeof(cmd));
+    avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd);
+    pgm->cmd(pgm, cmd, res);
+    usleep(p->chip_erase_delay);
+    pgm->initialize(pgm, p);
+    return 0;
+}
+
+
+void ch341a_initpgm(PROGRAMMER * pgm) {
+    strcpy(pgm->type, "ch341a");
+    /*
+    * mandatory functions
+    */
+    pgm->initialize     = ch341a_initialize;
+    pgm->display        = ch341a_display;
+    pgm->enable         = ch341a_enable;
+    pgm->disable        = ch341a_disable;
+    pgm->program_enable = ch341a_spi_program_enable;
+    pgm->chip_erase     = ch341a_spi_chip_erase;
+    pgm->cmd            = ch341a_spi_cmd;
+    pgm->spi            = ch341a_spi;
+    pgm->open           = ch341a_open;
+    pgm->close          = ch341a_close;
+    pgm->read_byte      = avr_read_byte_default;
+    pgm->write_byte     = avr_write_byte_default;
+
+    /*
+    * optional functions
+    */
+
+    //pgm->paged_write    = ch341a_spi_paged_write;
+    //pgm->paged_load     = ch341a_spi_paged_load;
+    pgm->setup          = ch341a_setup;
+    pgm->teardown       = ch341a_teardown;
+
+}
+
+/* Interface - management */
+static void ch341a_setup(PROGRAMMER * pgm) {
+    if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
+        avrdude_message(MSG_INFO, "%s: ch341a_setup(): Out of memory allocating private data\n",
+                        progname);
+        exit(1);
+    }
+    memset(pgm->cookie, 0, sizeof(struct pdata));
+}
+
+static void ch341a_teardown(PROGRAMMER * pgm) {
+    free(pgm->cookie);
+}
+/* Dummy functions */
+static void ch341a_disable(PROGRAMMER * pgm) {
+    /* Do nothing. */
+    return;
+}
+
+static void ch341a_enable(PROGRAMMER * pgm) {
+    /* Do nothing. */
+    return;
+}
+
+static void ch341a_display(PROGRAMMER * pgm, const char * p) {
+    return;
+}
+
+
+// ----------------------------------------------------------------------
+#else /* HAVE_LIBUSB */
+
+static int ch341a_nousb_open (struct programmer_t *pgm, char * name) {
+    avrdude_message(MSG_INFO, "%s: error: no usb support. please compile again with libusb installed.\n",
+                    progname);
+    return -1;
+}
+
+void ch341a_initpgm(PROGRAMMER * pgm) {
+    strcpy(pgm->type, "ch341a");
+    pgm->open = ch341a_nousb_open;
+}
+
+#endif  /* HAVE_LIBUSB */
+const char ch341a_desc[] = "Driver for \"ch341a\"-type programmers";
\ No newline at end of file
diff --git a/avrdude/ch341a.h b/avrdude/ch341a.h
new file mode 100644
index 0000000..ae8be35
--- /dev/null
+++ b/avrdude/ch341a.h
@@ -0,0 +1,65 @@
+/*
+ * avrdude - A Downloader/Uploader for AVR device programmers
+ *
+ * avrdude support for CH341
+ * Copyright (C) 2016  Alexey Sadkov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef ch341a_h
+#define ch341a_h
+
+#define CH341A_VID					0x1A86
+#define CH341A_PID					0x5512
+
+#define CH341A_PACKET_LENGTH		0x20
+
+#define CH341A_USB_BULK_ENDPOINT	0x02
+#define CH341A_PACKET_LENGTH		0x20
+
+#define CH341A_USB_TIMEOUT			15000
+
+#define CH341A_CMD_SPI_STREAM		0xA8	//SPI command
+#define CH341A_CMD_UIO_STREAM		0xAB	//UIO command
+
+#define	CH341A_CMD_UIO_STM_IN		0x00	// UIO Interface In ( D0 ~ D7 )
+#define	CH341A_CMD_UIO_STM_DIR		0x40	// UIO interface Dir( set dir of D0~D5 )
+#define	CH341A_CMD_UIO_STM_OUT		0x80	// UIO Interface Output(D0~D5)
+#define	CH341A_CMD_UIO_STM_END		0x20	// UIO Interface End Command
+
+#define	 CH341A_CMD_I2C_STREAM		0xAA
+#define	 CH341A_CMD_I2C_STM_SET		0x60 // bit 2: SPI with two data pairs D5,D4=out, D7,D6=in
+#define	 CH341A_CMD_I2C_STM_END		0x00
+
+
+/* USB error identifiers */
+#define USB_ERROR_NOTFOUND  1
+#define USB_ERROR_ACCESS    2
+#define USB_ERROR_IO        3
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const char ch341a_desc[];
+void ch341a_initpgm (PROGRAMMER * pgm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ch341a_h */
diff --git a/avrdude/pgm_type.c b/avrdude/pgm_type.c
index 7724987..ac8449a 100644
--- a/avrdude/pgm_type.c
+++ b/avrdude/pgm_type.c
@@ -48,6 +48,7 @@
 #include "stk500generic.h"
 #include "stk500v2.h"
 #include "usbasp.h"
+#include "ch341a.h"
 #include "usbtiny.h"
 #include "wiring.h"
 
@@ -92,6 +93,7 @@ const PROGRAMMER_TYPE programmers_types[] = {
         {"stk600hvsp", stk600hvsp_initpgm, stk600hvsp_desc},
         {"stk600pp", stk600pp_initpgm, stk600pp_desc},
         {"usbasp", usbasp_initpgm, usbasp_desc},
+        {"ch341a", ch341a_initpgm, ch341a_desc},
         {"usbtiny", usbtiny_initpgm, usbtiny_desc},
         {"wiring", wiring_initpgm, wiring_desc},
 };
-- 
2.7.1.windows.1