stc15: fix RC oscillator baudrate switch packet

It looks like it wasn't correct. The last value sent is probably supposed to be the trim value for the chosen trim frequency. Addresses grigorig/stcgal#16.
stc12+: drop checksum verification for flashing
2016-06-09 16:15:09 +02:00 · 2016-05-28 11:25:44 +02:00 · 2016-05-20 03:22:24 +02:00 · 2016-05-20 02:59:35 +02:00 · 2016-05-20 02:55:23 +02:00 · 2016-05-20 02:54:57 +02:00
12 changed files with 809 additions and 676 deletions
--- a/README.md
+++ b/README.md
@ -111,17 +111,18 @@ Most importantly, ```-p``` sets the serial port to be used for programming.
 ### Protocols

 STC MCUs use a variety of related but incompatible protocols for the
-BSL. The protocol can be specified with the ```-P``` flag. Optionally,
-experimental protocol autodetection can be used. The mapping between
-protocols and MCU series is as follows:
+BSL. The protocol can be specified with the ```-P``` flag. By default
+UART protocol autodetection is used. The mapping between protocols
+and MCU series is as follows:

-* ```stc89``` STC 89/90 series
-* ```stc12a``` STC12Cx052AD and possibly others
-* ```stc12``` Most STC10/11/12 series (default)
+* ```stc89``` STC89/90 series
+* ```stc12a``` STC12x052 series and possibly others
+* ```stc12b``` STC12x52 series, STC12x56 series and possibly others
+* ```stc12``` Most STC10/11/12 series
 * ```stc15a``` STC15x104E and STC15x204E(A) series
 * ```stc15``` Most STC15 series
 * ```usb15``` USB support on STC15W4 series
-* ```auto``` Automatic detection of UART based protocols
+* ```auto``` Automatic detection of UART based protocols (default)

 The text files in the doc/ subdirectory provide an overview over
 the reverse engineered protocols used by the BSLs. For more details,
@ -240,7 +241,9 @@ Option key                    | Possible values   | Protocols/Models    | Descri
 ```ale_enabled```             | true/false        | STC89 only          | ALE pin enabled if true, normal GPIO if false
 ```xram_enabled```            | true/false        | STC89 only          | Use internal XRAM (STC89 only)
 ```watchdog_por_enabled```    | true/false        | All                 | Watchdog state after power-on reset (POR)
-```low_voltage_reset ```      | true/false        | STC12A+             | Low-voltage reset (brownout)
+```low_voltage_reset```       | low/high          | STC12A/STC12        | Low-voltage reset level (low: ~3.3V, high: ~3.7V)
+```low_voltage_reset```       | true/false        | STC12               | Enable RESET2 pin low voltage detect
+```low_voltage_reset```       | true/false        | STC15A              | Enable low-voltage reset (brownout)
 ```clock_source```            | internal/external | STC12A+ with XTAL   | Use internal (RC) or external (crystal) clock
 ```watchdog_stop_idle```      | true/false        | STC12A+             | Stop watchdog in IDLE mode
 ```watchdog_prescale```       | 2,4,8,...,256     | STC12A+             | Watchdog timer prescaler, must be a power of two.
--- a/debian/changelog
+++ b/debian/changelog
@ -1,3 +1,10 @@
+stcgal (1.2) unstable; urgency=low
+
+  * Update to 1.2
+  * Add optional python3-usb dependency
+
+ -- Grigori Goronzy <greg@chown.ath.cx>  Fri, 20 May 2016 03:21:25 +0200
+
 stcgal (1.0git) unstable; urgency=low

  * Initial Debianized Release
--- a/debian/control
+++ b/debian/control
@ -10,17 +10,17 @@ X-Python3-Version: >= 3.2
 Package: stcgal
 Architecture: all
 Depends: ${misc:Depends}, python3, python3-serial
+Recommends: python3-usb (>= 1.0.0~b2)
 Description: STC MCU ISP flash tool
- stcgal is a command line flash programming tool for STC MCU Ltd. 8051
- compatible microcontrollers. The name was inspired by avrdude.
+ stcgal is a command line flash programming tool for STC MCU Ltd.
+ 8051 compatible microcontrollers. The name was inspired by avrdude.
 .
- STC microcontrollers have a UART based boot strap loader (BSL). It
- utilizes a packet-based protocol to flash the code memory and
- IAP memory over a serial link. This is referred to as in-system
- programming (ISP). The BSL is also used to configure various
- (fuse-like) device options. Unfortunately, this protocol is not
- publicly documented and STC only provide a (crude) Windows GUI
- application for programming.
+ STC microcontrollers have an UART/USB based boot strap loader (BSL). It
+ utilizes a packet-based protocol to flash the code memory and IAP
+ memory over a serial link. This is referred to as in-system programming
+ (ISP). The BSL is also used to configure various (fuse-like) device
+ options. Unfortunately, this protocol is not publicly documented and
+ STC only provide a (crude) Windows GUI application for programming.
 .
 stcgal is a full-featured Open Source replacement for STC's Windows
 software; it supports a wide range of MCUs, it is very portable and
--- a/doc/dump-mcu.py
+++ b/doc/dump-mcu.py
@ -25,12 +25,12 @@ for i in range(MCU_TABLE_SIZE):
    inp.seek(mcu_name_offset)
    name_str = inp.read(16).split(b'\00')[0].decode("ascii")

-    # XXX: 1 KB are reserved one *some* MCUs for some reason
-    #if ee_size > 0 and not name_str.startswith("IAP"):
-    #    ee_size -= 1024
+    # TODO: With some MCUs, the amount of available EEPROM depends on the BSL version.
+    # Generally, newer BSLs free up a KB of additional EEPROM. Currently, always the
+    # maximum amount (with newer BSL) is reported.

-    # STC12C54xx always have 12 KB eeprom
-    if name_str.startswith("STC12C54"):
+    # STC12x54xx always have 12 KB eeprom
+    if name_str.startswith("STC12C54") or name_str.startswith("STC12LE54"):
        ee_size = 12 * 1024

    print("MCUModel(name='%s', magic=0x%02x%02x, total=%d, code=%d, eeprom=%d)," %
--- a/doc/stc12a-options.txt
+++ b/doc/stc12a-options.txt
@ -4,7 +4,7 @@ Placement of configuration values
 "~" means the bit is a negated boolean. Sometimes values overlap,
 depending on MCU model.

-In STC12A series, the first 4 MCS bytes have active
+In STC12A series, the first 7 MCS bytes have active
 values. Generally, unused bits should be set to 1.

 MCS0
@ -47,14 +47,9 @@ MSB     7       6       5       4       3       2       1       0       LSB
         (or others, depends on MCU model) are held low on POR.


-MCS3
----

-Unused.
-
-
-MCS4
----
+MCS3 (at index 6!)
+------------------

 MSB     7       6       5       4       3       2       1       0       LSB
                LVD
--- a/doc/stc15-options.txt
+++ b/doc/stc15-options.txt
@ -111,7 +111,31 @@ in set options packet:
 46 B9 6A 00 4B 04 00 00 5A A5 FF FF FF 00 FF FF
 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
 00 00 FF A8 FF EE FF E0 FF FD 03 FF FF FF FF FF
+^^
+MCSP
 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
 FF FD FF FF FF 75 BF F7 BC 9F 3A 80 16
   ^^
   MCSY
+
+password setting
+
+the password is sent with packet type 0x07 and checked before erase with packet type 0x05. setting the password uses two fields.
+index 22 of the option block encodes the password length in bytes (MCSP, see above). bit 3 in MCS3 decides whether the password
+will be checked. if the bit is set, no password check occurs. if it is reset, a password check occurs.
+
+quick dump from USB-ISP packets:
+
+set: foobar
+0000   ff ff ff 00 ff ff 00 05 ff ff ff ff ff ff ff 07  ................
+0010   ff ff ff ff ff ff ff 07 ff 06 01 ff 6e ff 36 58  ............n.6X
+0020   ff 00 ff f5 03 ff ff 0c ff ff ff ff ff ff ff 07  ................
+0030   ff ff ff ff ff ff ff 07 ff ff ff ff ff ff ec 1a  ................
+0040   ff ff ff 99 7f f7 bc 38 9f 61                    .......8.a
+
+reset:
+0000   ff ff ff 00 ff ff 00 05 ff ff ff ff ff ff ff 07  ................
+0010   ff ff ff ff ff ff ff 07 ff 00 01 ff 6e ff 36 5e  ............n.6^
+0020   ff 00 ff fd 03 ff ff 04 ff ff ff ff ff ff ff 07  ................
+0030   ff ff ff ff ff ff ff 07 ff ff ff ff ff ff ec 1a  ................
+0040   ff ff ff 99 7f f7 bc 38 9f 61                    .......8.a
--- a/doc/usb15-protocol.txt
+++ b/doc/usb15-protocol.txt
@ -0,0 +1,35 @@
+STC15 series USB ISP protocol
+=============================
+
+- host does OUT and IN control transfers for write and read
+- IN transfer with wLength = 132, wValue = 0, wIndex = 0, bRequest = 0 are used for all reads
+- OUT transfers with arbitrary size are used for writes
+
+- packets from MCU
+  always start with 0x46 0xb9, similar to serial protocols
+  third byte is packet length
+  followed by data bytes
+  8 bit checksum at the end, looks like 8 bit modular subtraction
+
+- packet types
+  most likely derived from the serial protocol, at least partially
+
+  info packet
+  - same as with serial protocol
+
+  option packet
+  - generally same as with serial protocol, some header stuff omitted
+
+- flash data
+  wIndex specifies write address
+  wValue is 0xa55a
+  bRequest is 0x22 for first packet, 0x02 for the following ones
+  unusually encoded: a total of 128 bytes per packet, with every 7 byte checksummed in some way, for a total of 18x7 byte segments and a final 2 byte segment
+  checksum: 8 bit inverted modular sum
+
+- option packet
+  wIndex is 0
+  wValue is 0xa55a
+  bRequest is 4
+  seems to use the same checksumming scheme
+
--- a/stcgal/init.py
+++ b/stcgal/init.py
@ -1 +1 @@
-__version__ = "1.0"
+__version__ = "1.2"
--- a/stcgal/frontend.py
+++ b/stcgal/frontend.py
@ -37,6 +37,8 @@ class StcGal:
            self.protocol = Stc89Protocol(opts.port, opts.handshake, opts.baud)
        elif opts.protocol == "stc12a":
            self.protocol = Stc12AProtocol(opts.port, opts.handshake, opts.baud)
+        elif opts.protocol == "stc12b":
+            self.protocol = Stc12BProtocol(opts.port, opts.handshake, opts.baud)
        elif opts.protocol == "stc12":
            self.protocol = Stc12Protocol(opts.port, opts.handshake, opts.baud)
        elif opts.protocol == "stc15a":
@ -109,9 +111,9 @@ class StcGal:
                bindata = bindata[0:code_size]
            bindata += eedata

-        # pad to 256 byte boundary
-        if len(bindata) % 256:
-            bindata += bytes(256 - len(bindata) % 256)
+        # pad to 512 byte boundary
+        if len(bindata) % 512:
+            bindata += b'\xff' * (512 - len(bindata) % 512)

        if self.opts.option: self.emit_options(self.opts.option)

@ -194,7 +196,7 @@ def cli():
    parser.add_argument("code_image", help="code segment file to flash (BIN/HEX)", type=argparse.FileType("rb"), nargs='?')
    parser.add_argument("eeprom_image", help="eeprom segment file to flash (BIN/HEX)", type=argparse.FileType("rb"), nargs='?')
    parser.add_argument("-a", "--autoreset", help="cycle power automatically by asserting DTR", action="store_true")
-    parser.add_argument("-P", "--protocol", help="protocol version", choices=["stc89", "stc12a", "stc12", "stc15a", "stc15", "usb15", "auto"], default="stc12")
+    parser.add_argument("-P", "--protocol", help="protocol version (default: auto)", choices=["stc89", "stc12a", "stc12b", "stc12", "stc15a", "stc15", "usb15", "auto"], default="auto")
    parser.add_argument("-p", "--port", help="serial port device", default="/dev/ttyUSB0")
    parser.add_argument("-b", "--baud", help="transfer baud rate (default: 19200)", type=BaudType(), default=19200)
    parser.add_argument("-l", "--handshake", help="handshake baud rate (default: 2400)", type=BaudType(), default=2400)
--- a/stcgal/models.py
+++ b/stcgal/models.py
@ -839,28 +839,28 @@ class MCUModelDatabase:
        MCUModel(name='STC12C5420', magic=0xe014, total=32768, code=20480, eeprom=12288),
        MCUModel(name='STC12C5424', magic=0xe018, total=32768, code=24576, eeprom=12288),
        MCUModel(name='STC12C5428', magic=0xe01c, total=32768, code=28672, eeprom=12288),
-        MCUModel(name='STC12LE5401AD', magic=0xe0e1, total=32768, code=1024, eeprom=22016),
-        MCUModel(name='STC12LE5402AD', magic=0xe0e2, total=32768, code=2048, eeprom=20992),
-        MCUModel(name='STC12LE5404AD', magic=0xe0e4, total=32768, code=4096, eeprom=18944),
-        MCUModel(name='STC12LE5406AD', magic=0xe0e6, total=32768, code=6144, eeprom=16896),
-        MCUModel(name='STC12LE5408AD', magic=0xe0e8, total=32768, code=8192, eeprom=10752),
-        MCUModel(name='STC12LE5410AD', magic=0xe0ea, total=32768, code=10240, eeprom=4608),
-        MCUModel(name='STC12LE5412AD', magic=0xe0ec, total=32768, code=12288, eeprom=11776),
+        MCUModel(name='STC12LE5401AD', magic=0xe0e1, total=32768, code=1024, eeprom=12288),
+        MCUModel(name='STC12LE5402AD', magic=0xe0e2, total=32768, code=2048, eeprom=12288),
+        MCUModel(name='STC12LE5404AD', magic=0xe0e4, total=32768, code=4096, eeprom=12288),
+        MCUModel(name='STC12LE5406AD', magic=0xe0e6, total=32768, code=6144, eeprom=12288),
+        MCUModel(name='STC12LE5408AD', magic=0xe0e8, total=32768, code=8192, eeprom=12288),
+        MCUModel(name='STC12LE5410AD', magic=0xe0ea, total=32768, code=10240, eeprom=12288),
+        MCUModel(name='STC12LE5412AD', magic=0xe0ec, total=32768, code=12288, eeprom=12288),
        MCUModel(name='STC12LE5416AD', magic=0xe0f0, total=32768, code=16384, eeprom=12288),
-        MCUModel(name='STC12LE5420AD', magic=0xe0f4, total=32768, code=20480, eeprom=8192),
-        MCUModel(name='STC12LE5424AD', magic=0xe0f8, total=32768, code=24576, eeprom=4096),
-        MCUModel(name='STC12LE5428AD', magic=0xe0fc, total=32768, code=28672, eeprom=0),
-        MCUModel(name='STC12LE5401', magic=0xe081, total=32768, code=1024, eeprom=22016),
-        MCUModel(name='STC12LE5402', magic=0xe082, total=32768, code=2048, eeprom=20992),
-        MCUModel(name='STC12LE5404', magic=0xe084, total=32768, code=4096, eeprom=18944),
-        MCUModel(name='STC12LE5406', magic=0xe086, total=32768, code=6144, eeprom=16896),
-        MCUModel(name='STC12LE5408', magic=0xe088, total=32768, code=8192, eeprom=10752),
-        MCUModel(name='STC12LE5410', magic=0xe08a, total=32768, code=10240, eeprom=4608),
-        MCUModel(name='STC12LE5412', magic=0xe08c, total=32768, code=12288, eeprom=11776),
+        MCUModel(name='STC12LE5420AD', magic=0xe0f4, total=32768, code=20480, eeprom=12288),
+        MCUModel(name='STC12LE5424AD', magic=0xe0f8, total=32768, code=24576, eeprom=12288),
+        MCUModel(name='STC12LE5428AD', magic=0xe0fc, total=32768, code=28672, eeprom=12288),
+        MCUModel(name='STC12LE5401', magic=0xe081, total=32768, code=1024, eeprom=12288),
+        MCUModel(name='STC12LE5402', magic=0xe082, total=32768, code=2048, eeprom=12288),
+        MCUModel(name='STC12LE5404', magic=0xe084, total=32768, code=4096, eeprom=12288),
+        MCUModel(name='STC12LE5406', magic=0xe086, total=32768, code=6144, eeprom=12288),
+        MCUModel(name='STC12LE5408', magic=0xe088, total=32768, code=8192, eeprom=12288),
+        MCUModel(name='STC12LE5410', magic=0xe08a, total=32768, code=10240, eeprom=12288),
+        MCUModel(name='STC12LE5412', magic=0xe08c, total=32768, code=12288, eeprom=12288),
        MCUModel(name='STC12LE5416', magic=0xe090, total=32768, code=16384, eeprom=12288),
-        MCUModel(name='STC12LE5420', magic=0xe094, total=32768, code=20480, eeprom=8192),
-        MCUModel(name='STC12LE5424', magic=0xe098, total=32768, code=24576, eeprom=4096),
-        MCUModel(name='STC12LE5428', magic=0xe09c, total=32768, code=28672, eeprom=0),
+        MCUModel(name='STC12LE5420', magic=0xe094, total=32768, code=20480, eeprom=12288),
+        MCUModel(name='STC12LE5424', magic=0xe098, total=32768, code=24576, eeprom=12288),
+        MCUModel(name='STC12LE5428', magic=0xe09c, total=32768, code=28672, eeprom=12288),
        MCUModel(name='STC12C1052AD', magic=0xf211, total=8192, code=1024, eeprom=5120),
        MCUModel(name='STC12C2052AD', magic=0xf212, total=8192, code=2048, eeprom=4096),
        MCUModel(name='STC12C3052AD', magic=0xf213, total=8192, code=3072, eeprom=3072),
--- a/stcgal/options.py
+++ b/stcgal/options.py
@ -0,0 +1,608 @@
+#
+# Copyright (c) 2013-2016 Grigori Goronzy <greg@chown.ath.cx>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+import struct
+from stcgal.utils import Utils
+
+class BaseOption:
+    def print(self):
+        print("Target options:")
+        for name, get_func, _ in self.options:
+            print("  %s=%s" % (name, get_func()))
+
+    def set_option(self, name, value):
+        for opt, _, set_func in self.options:
+            if opt == name:
+                print("Option %s=%s" % (name, value))
+                set_func(value)
+                return
+        raise ValueError("unknown")
+
+    def get_option(self, name):
+        for opt, get_func, _ in self.options:
+            if opt == name:
+                return get_func(name)
+        raise ValueError("unknown")
+
+    def get_msr(self):
+        return bytes(self.msr)
+
+
+class Stc89Option(BaseOption):
+    """Manipulation STC89 series option byte"""
+
+    def __init__(self, msr):
+        self.msr = msr
+        self.options = (
+            ("cpu_6t_enabled", self.get_t6, self.set_t6),
+            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
+            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
+            ("clock_gain", self.get_clock_gain, self.set_clock_gain),
+            ("ale_enabled", self.get_ale, self.set_ale),
+            ("xram_enabled", self.get_xram, self.set_xram),
+            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
+        )
+
+    def get_msr(self):
+        return self.msr
+
+    def get_t6(self):
+        return not bool(self.msr & 1)
+
+    def set_t6(self, val):
+        val = Utils.to_bool(val);
+        self.msr &= 0xfe
+        self.msr |= 0x01 if not bool(val) else 0x00
+
+    def get_pindetect(self):
+        return not bool(self.msr & 4)
+
+    def set_pindetect(self, val):
+        val = Utils.to_bool(val);
+        self.msr &= 0xfb
+        self.msr |= 0x04 if not bool(val) else 0x00
+
+    def get_ee_erase(self):
+        return not bool(self.msr & 8)
+
+    def set_ee_erase(self, val):
+        val = Utils.to_bool(val);
+        self.msr &= 0xf7
+        self.msr |= 0x08 if not bool(val) else 0x00
+
+    def get_clock_gain(self):
+        gain = bool(self.msr & 16)
+        return "high" if gain else "low"
+
+    def set_clock_gain(self, val):
+        gains = {"low": 0, "high": 0x10}
+        if val not in gains.keys():
+            raise ValueError("must be one of %s" % list(gains.keys()))
+        self.msr &= 0xef
+        self.msr |= gains[val]
+
+    def get_ale(self):
+        return bool(self.msr & 32)
+
+    def set_ale(self, val):
+        val = Utils.to_bool(val);
+        self.msr &= 0xdf
+        self.msr |= 0x20 if bool(val) else 0x00
+
+    def get_xram(self):
+        return bool(self.msr & 64)
+
+    def set_xram(self, val):
+        val = Utils.to_bool(val);
+        self.msr &= 0xbf
+        self.msr |= 0x40 if bool(val) else 0x00
+
+    def get_watchdog(self):
+        return not bool(self.msr & 128)
+
+    def set_watchdog(self, val):
+        val = Utils.to_bool(val);
+        self.msr &= 0x7f
+        self.msr |= 0x80 if not bool(val) else 0x00
+
+
+class Stc12AOption(BaseOption):
+    """Manipulate STC12A series option bytes"""
+
+    def __init__(self, msr):
+        assert len(msr) == 4
+        self.msr = bytearray(msr)
+
+        """list of options and their handlers"""
+        self.options = (
+            ("low_voltage_reset", self.get_low_voltage_detect, self.set_low_voltage_detect),
+            ("clock_source", self.get_clock_source, self.set_clock_source),
+            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
+            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
+            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
+            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
+            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
+        )
+
+    def get_low_voltage_detect(self):
+        lvd = bool(self.msr[3] & 64)
+        return "high" if not lvd else "low"
+
+    def set_low_voltage_detect(self, val):
+        lvds = {"low": 1, "high": 0}
+        if val not in lvds.keys():
+            raise ValueError("must be one of %s" % list(sources.keys()))
+        self.msr[3] &= 0xbf
+        self.msr[3] |= lvds[val] << 6
+
+    def get_clock_source(self):
+        source = bool(self.msr[0] & 2)
+        return "external" if source else "internal"
+
+    def set_clock_source(self, val):
+        sources = {"internal": 0, "external": 1}
+        if val not in sources.keys():
+            raise ValueError("must be one of %s" % list(sources.keys()))
+        self.msr[0] &= 0xfd
+        self.msr[0] |= sources[val] << 1
+
+    def get_watchdog(self):
+        return not bool(self.msr[1] & 32)
+
+    def set_watchdog(self, val):
+        val = Utils.to_bool(val);
+        self.msr[1] &= 0xdf
+        self.msr[1] |= 0x20 if not val else 0x00
+
+    def get_watchdog_idle(self):
+        return not bool(self.msr[1] & 8)
+
+    def set_watchdog_idle(self, val):
+        val = Utils.to_bool(val);
+        self.msr[1] &= 0xf7
+        self.msr[1] |= 0x08 if not val else 0x00
+
+    def get_watchdog_prescale(self):
+        return 2 ** (((self.msr[1]) & 0x07) + 1)
+
+    def set_watchdog_prescale(self, val):
+        val = Utils.to_int(val)
+        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
+        if val not in wd_vals.keys():
+            raise ValueError("must be one of %s" % list(wd_vals.keys()))
+        self.msr[1] &= 0xf8
+        self.msr[1] |= wd_vals[val]
+
+    def get_ee_erase(self):
+        return not bool(self.msr[2] & 2)
+
+    def set_ee_erase(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xfd
+        self.msr[2] |= 0x02 if not val else 0x00
+
+    def get_pindetect(self):
+        return not bool(self.msr[2] & 1)
+
+    def set_pindetect(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xfe
+        self.msr[2] |= 0x01 if not val else 0x00
+
+
+class Stc12Option(BaseOption):
+    """Manipulate STC10/11/12 series option bytes"""
+
+    def __init__(self, msr):
+        assert len(msr) == 4
+        self.msr = bytearray(msr)
+
+        """list of options and their handlers"""
+        self.options = (
+            ("reset_pin_enabled", self.get_reset_pin_enabled, self.set_reset_pin_enabled),
+            ("low_voltage_reset", self.get_low_voltage_detect, self.set_low_voltage_detect),
+            ("oscillator_stable_delay", self.get_osc_stable_delay, self.set_osc_stable_delay),
+            ("por_reset_delay", self.get_por_delay, self.set_por_delay),
+            ("clock_gain", self.get_clock_gain, self.set_clock_gain),
+            ("clock_source", self.get_clock_source, self.set_clock_source),
+            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
+            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
+            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
+            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
+            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
+        )
+
+    def get_reset_pin_enabled(self):
+        return bool(self.msr[0] & 1)
+
+    def set_reset_pin_enabled(self, val):
+        val = Utils.to_bool(val);
+        self.msr[0] &= 0xfe
+        self.msr[0] |= 0x01 if bool(val) else 0x00
+
+    def get_low_voltage_detect(self):
+        return not bool(self.msr[0] & 64)
+
+    def set_low_voltage_detect(self, val):
+        val = Utils.to_bool(val);
+        self.msr[0] &= 0xbf
+        self.msr[0] |= 0x40 if not val else 0x00
+
+    def get_osc_stable_delay(self):
+        return 2 ** (((self.msr[0] >> 4) & 0x03) + 12)
+
+    def set_osc_stable_delay(self, val):
+        val = Utils.to_int(val)
+        osc_vals = {4096: 0, 8192: 1, 16384: 2, 32768: 3}
+        if val not in osc_vals.keys():
+            raise ValueError("must be one of %s" % list(osc_vals.keys()))
+        self.msr[0] &= 0xcf
+        self.msr[0] |= osc_vals[val] << 4
+
+    def get_por_delay(self):
+        delay = not bool(self.msr[1] & 128)
+        return "long" if delay else "short"
+
+    def set_por_delay(self, val):
+        delays = {"short": 1, "long": 0}
+        if val not in delays.keys():
+            raise ValueError("must be one of %s" % list(delays.keys()))
+        self.msr[1] &= 0x7f
+        self.msr[1] |= delays[val] << 7
+
+    def get_clock_gain(self):
+        gain = bool(self.msr[1] & 64)
+        return "high" if gain else "low"
+
+    def set_clock_gain(self, val):
+        gains = {"low": 0, "high": 1}
+        if val not in gains.keys():
+            raise ValueError("must be one of %s" % list(gains.keys()))
+        self.msr[1] &= 0xbf
+        self.msr[1] |= gains[val] << 6
+
+    def get_clock_source(self):
+        source = bool(self.msr[1] & 2)
+        return "external" if source else "internal"
+
+    def set_clock_source(self, val):
+        sources = {"internal": 0, "external": 1}
+        if val not in sources.keys():
+            raise ValueError("must be one of %s" % list(sources.keys()))
+        self.msr[1] &= 0xfd
+        self.msr[1] |= sources[val] << 1
+
+    def get_watchdog(self):
+        return not bool(self.msr[2] & 32)
+
+    def set_watchdog(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xdf
+        self.msr[2] |= 0x20 if not val else 0x00
+
+    def get_watchdog_idle(self):
+        return not bool(self.msr[2] & 8)
+
+    def set_watchdog_idle(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xf7
+        self.msr[2] |= 0x08 if not val else 0x00
+
+    def get_watchdog_prescale(self):
+        return 2 ** (((self.msr[2]) & 0x07) + 1)
+
+    def set_watchdog_prescale(self, val):
+        val = Utils.to_int(val)
+        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
+        if val not in wd_vals.keys():
+            raise ValueError("must be one of %s" % list(wd_vals.keys()))
+        self.msr[2] &= 0xf8
+        self.msr[2] |= wd_vals[val]
+
+    def get_ee_erase(self):
+        return not bool(self.msr[3] & 2)
+
+    def set_ee_erase(self, val):
+        val = Utils.to_bool(val);
+        self.msr[3] &= 0xfd
+        self.msr[3] |= 0x02 if not val else 0x00
+
+    def get_pindetect(self):
+        return not bool(self.msr[3] & 1)
+
+    def set_pindetect(self, val):
+        val = Utils.to_bool(val);
+        self.msr[3] &= 0xfe
+        self.msr[3] |= 0x01 if not val else 0x00
+
+
+class Stc15AOption(BaseOption):
+    def __init__(self, msr):
+        assert len(msr) == 13
+        self.msr = bytearray(msr)
+
+        self.options = (
+            ("reset_pin_enabled", self.get_reset_pin_enabled, self.set_reset_pin_enabled),
+            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
+            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
+            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
+            ("low_voltage_reset", self.get_lvrs, self.set_lvrs),
+            ("low_voltage_threshold", self.get_low_voltage, self.set_low_voltage),
+            ("eeprom_lvd_inhibit", self.get_eeprom_lvd, self.set_eeprom_lvd),
+            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
+            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
+        )
+
+    def set_trim(self, val):
+        self.msr[3:5] = struct.pack(">H", val)
+
+    def get_reset_pin_enabled(self):
+        return bool(self.msr[0] & 16)
+
+    def set_reset_pin_enabled(self, val):
+        val = Utils.to_bool(val);
+        self.msr[0] &= 0xef
+        self.msr[0] |= 0x10 if bool(val) else 0x00
+
+    def get_watchdog(self):
+        return not bool(self.msr[2] & 32)
+
+    def set_watchdog(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xdf
+        self.msr[2] |= 0x20 if not val else 0x00
+
+    def get_watchdog_idle(self):
+        return not bool(self.msr[2] & 8)
+
+    def set_watchdog_idle(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xf7
+        self.msr[2] |= 0x08 if not val else 0x00
+
+    def get_watchdog_prescale(self):
+        return 2 ** (((self.msr[2]) & 0x07) + 1)
+
+    def set_watchdog_prescale(self, val):
+        val = Utils.to_int(val)
+        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
+        if val not in wd_vals.keys():
+            raise ValueError("must be one of %s" % list(wd_vals.keys()))
+        self.msr[2] &= 0xf8
+        self.msr[2] |= wd_vals[val]
+
+    def get_lvrs(self):
+        return bool(self.msr[1] & 64)
+
+    def set_lvrs(self, val):
+        val = Utils.to_bool(val);
+        self.msr[1] &= 0xbf
+        self.msr[1] |= 0x40 if val else 0x00
+
+    def get_eeprom_lvd(self):
+        return bool(self.msr[1] & 128)
+
+    def set_eeprom_lvd(self, val):
+        val = Utils.to_bool(val);
+        self.msr[1] &= 0x7f
+        self.msr[1] |= 0x80 if val else 0x00
+
+    def get_low_voltage(self):
+        return self.msr[1] & 0x07
+
+    def set_low_voltage(self, val):
+        val = Utils.to_int(val)
+        if val not in range(0, 8):
+            raise ValueError("must be one of %s" % list(range(0, 8)))
+        self.msr[1] &= 0xf8
+        self.msr[1] |= val
+
+    def get_ee_erase(self):
+        return not bool(self.msr[12] & 2)
+
+    def set_ee_erase(self, val):
+        val = Utils.to_bool(val);
+        self.msr[12] &= 0xfd
+        self.msr[12] |= 0x02 if not val else 0x00
+
+    def get_pindetect(self):
+        return not bool(self.msr[12] & 1)
+
+    def set_pindetect(self, val):
+        val = Utils.to_bool(val);
+        self.msr[12] &= 0xfe
+        self.msr[12] |= 0x01 if not val else 0x00
+
+
+class Stc15Option(BaseOption):
+    def __init__(self, msr):
+        assert len(msr) >= 4
+        self.msr = bytearray(msr)
+
+        self.options = (
+            ("reset_pin_enabled", self.get_reset_pin_enabled, self.set_reset_pin_enabled),
+            ("clock_source", self.get_clock_source, self.set_clock_source),
+            ("clock_gain", self.get_clock_gain, self.set_clock_gain),
+            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
+            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
+            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
+            ("low_voltage_reset", self.get_lvrs, self.set_lvrs),
+            ("low_voltage_threshold", self.get_low_voltage, self.set_low_voltage),
+            ("eeprom_lvd_inhibit", self.get_eeprom_lvd, self.set_eeprom_lvd),
+            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
+            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
+            ("por_reset_delay", self.get_por_delay, self.set_por_delay),
+            ("rstout_por_state", self.get_p33_state, self.set_p33_state),
+            ("uart2_passthrough", self.get_uart_passthrough, self.set_uart_passthrough),
+            ("uart2_pin_mode", self.get_uart_pin_mode, self.set_uart_pin_mode),
+        )
+
+        if len(msr) > 4:
+            self.options += ("cpu_core_voltage", self.get_core_voltage, self.set_core_voltage),
+
+    def get_reset_pin_enabled(self):
+        return not bool(self.msr[2] & 16)
+
+    def set_reset_pin_enabled(self, val):
+        val = Utils.to_bool(val);
+        self.msr[2] &= 0xef
+        self.msr[2] |= 0x10 if not bool(val) else 0x00
+
+    def get_clock_source(self):
+        source = bool(self.msr[2] & 0x01)
+        return "internal" if source else "external"
+
+    def set_clock_source(self, val):
+        sources = {"internal": 1, "external": 0}
+        if val not in sources.keys():
+            raise ValueError("must be one of %s" % list(sources.keys()))
+        self.msr[2] &= 0xfe
+        self.msr[2] |= sources[val]
+
+    def get_clock_gain(self):
+        gain = bool(self.msr[2] & 0x02)
+        return "high" if gain else "low"
+
+    def set_clock_gain(self, val):
+        gains = {"low": 0, "high": 1}
+        if val not in gains.keys():
+            raise ValueError("must be one of %s" % list(gains.keys()))
+        self.msr[2] &= 0xfd
+        self.msr[2] |= gains[val] << 1
+
+    def get_watchdog(self):
+        return not bool(self.msr[0] & 32)
+
+    def set_watchdog(self, val):
+        val = Utils.to_bool(val);
+        self.msr[0] &= 0xdf
+        self.msr[0] |= 0x20 if not val else 0x00
+
+    def get_watchdog_idle(self):
+        return not bool(self.msr[0] & 8)
+
+    def set_watchdog_idle(self, val):
+        val = Utils.to_bool(val);
+        self.msr[0] &= 0xf7
+        self.msr[0] |= 0x08 if not val else 0x00
+
+    def get_watchdog_prescale(self):
+        return 2 ** (((self.msr[0]) & 0x07) + 1)
+
+    def set_watchdog_prescale(self, val):
+        val = Utils.to_int(val)
+        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
+        if val not in wd_vals.keys():
+            raise ValueError("must be one of %s" % list(wd_vals.keys()))
+        self.msr[0] &= 0xf8
+        self.msr[0] |= wd_vals[val]
+
+    def get_lvrs(self):
+        return not bool(self.msr[1] & 64)
+
+    def set_lvrs(self, val):
+        val = Utils.to_bool(val);
+        self.msr[1] &= 0xbf
+        self.msr[1] |= 0x40 if not val else 0x00
+
+    def get_eeprom_lvd(self):
+        return bool(self.msr[1] & 128)
+
+    def set_eeprom_lvd(self, val):
+        val = Utils.to_bool(val);
+        self.msr[1] &= 0x7f
+        self.msr[1] |= 0x80 if val else 0x00
+
+    def get_low_voltage(self):
+        return self.msr[1] & 0x07
+
+    def set_low_voltage(self, val):
+        val = Utils.to_int(val)
+        if val not in range(0, 8):
+            raise ValueError("must be one of %s" % list(range(0, 8)))
+        self.msr[1] &= 0xf8
+        self.msr[1] |= val
+
+    def get_ee_erase(self):
+        return bool(self.msr[3] & 2)
+
+    def set_ee_erase(self, val):
+        val = Utils.to_bool(val);
+        self.msr[3] &= 0xfd
+        self.msr[3] |= 0x02 if val else 0x00
+
+    def get_pindetect(self):
+        return not bool(self.msr[3] & 1)
+
+    def set_pindetect(self, val):
+        val = Utils.to_bool(val);
+        self.msr[3] &= 0xfe
+        self.msr[3] |= 0x01 if not val else 0x00
+
+    def get_por_delay(self):
+        delay = bool(self.msr[2] & 128)
+        return "long" if delay else "short"
+
+    def set_por_delay(self, val):
+        delays = {"short": 0, "long": 1}
+        if val not in delays.keys():
+            raise ValueError("must be one of %s" % list(delays.keys()))
+        self.msr[2] &= 0x7f
+        self.msr[2] |= delays[val] << 7
+
+    def get_p33_state(self):
+        return "high" if self.msr[2] & 0x08 else "low"
+
+    def set_p33_state(self, val):
+        val = Utils.to_bool(val)
+        self.msr[2] &= 0xf7
+        self.msr[2] |= 0x08 if val else 0x00
+
+    def get_uart_passthrough(self):
+        return bool(self.msr[2] & 0x40)
+
+    def set_uart_passthrough(self, val):
+        val = Utils.to_bool(val)
+        self.msr[2] &= 0xbf
+        self.msr[2] |= 0x40 if val else 0x00
+
+    def get_uart_pin_mode(self):
+        return "push-pull" if bool(self.msr[2] & 0x20) else "normal"
+
+    def set_uart_pin_mode(self, val):
+        delays = {"normal": 0, "push-pull": 1}
+        if val not in delays.keys():
+            raise ValueError("must be one of %s" % list(delays.keys()))
+        self.msr[2] &= 0xdf
+        self.msr[2] |= 0x20 if val else 0x00
+
+    def get_core_voltage(self):
+        if self.msr[4] == 0xea: return "low"
+        elif self.msr[4] == 0xf7: return "mid"
+        elif self.msr[4] == 0xfd: return "high"
+        else: return "unknown"
+
+    def set_core_voltage(self, val):
+        volt_vals = {"low": 0xea, "mid": 0xf7, "high": 0xfd}
+        if val not in volt_vals.keys():
+            raise ValueError("must be one of %s" % list(volt_vals.keys()))
+        self.msr[4] = volt_vals[val]
--- a/stcgal/protocols.py
+++ b/stcgal/protocols.py
@ -21,11 +21,12 @@
 #

 import serial
-import sys, os, time, struct, re
+import sys, os, time, struct, re, errno
 import argparse
 import collections
 from stcgal.models import MCUModelDatabase
 from stcgal.utils import Utils
+from stcgal.options import *
 import functools

 try:
@ -45,588 +46,6 @@ class StcProtocolException(Exception):
    pass


-class BaseOption:
-    def print(self):
-        print("Target options:")
-        for name, get_func, _ in self.options:
-            print("  %s=%s" % (name, get_func()))
-
-    def set_option(self, name, value):
-        for opt, _, set_func in self.options:
-            if opt == name:
-                print("Option %s=%s" % (name, value))
-                set_func(value)
-                return
-        raise ValueError("unknown")
-
-    def get_option(self, name):
-        for opt, get_func, _ in self.options:
-            if opt == name:
-                return get_func(name)
-        raise ValueError("unknown")
-
-    def get_msr(self):
-        return bytes(self.msr)
-
-
-class Stc89Option(BaseOption):
-    """Manipulation STC89 series option byte"""
-
-    def __init__(self, msr):
-        self.msr = msr
-        self.options = (
-            ("cpu_6t_enabled", self.get_t6, self.set_t6),
-            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
-            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
-            ("clock_gain", self.get_clock_gain, self.set_clock_gain),
-            ("ale_enabled", self.get_ale, self.set_ale),
-            ("xram_enabled", self.get_xram, self.set_xram),
-            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
-        )
-
-    def get_msr(self):
-        return self.msr
-
-    def get_t6(self):
-        return not bool(self.msr & 1)
-
-    def set_t6(self, val):
-        val = Utils.to_bool(val);
-        self.msr &= 0xfe
-        self.msr |= 0x01 if not bool(val) else 0x00
-
-    def get_pindetect(self):
-        return not bool(self.msr & 4)
-
-    def set_pindetect(self, val):
-        val = Utils.to_bool(val);
-        self.msr &= 0xfb
-        self.msr |= 0x04 if not bool(val) else 0x00
-
-    def get_ee_erase(self):
-        return not bool(self.msr & 8)
-
-    def set_ee_erase(self, val):
-        val = Utils.to_bool(val);
-        self.msr &= 0xf7
-        self.msr |= 0x08 if not bool(val) else 0x00
-
-    def get_clock_gain(self):
-        gain = bool(self.msr & 16)
-        return "high" if gain else "low"
-
-    def set_clock_gain(self, val):
-        gains = {"low": 0, "high": 0x10}
-        if val not in gains.keys():
-            raise ValueError("must be one of %s" % list(gains.keys()))
-        self.msr &= 0xef
-        self.msr |= gains[val]
-
-    def get_ale(self):
-        return bool(self.msr & 32)
-
-    def set_ale(self, val):
-        val = Utils.to_bool(val);
-        self.msr &= 0xdf
-        self.msr |= 0x20 if bool(val) else 0x00
-
-    def get_xram(self):
-        return bool(self.msr & 64)
-
-    def set_xram(self, val):
-        val = Utils.to_bool(val);
-        self.msr &= 0xbf
-        self.msr |= 0x40 if bool(val) else 0x00
-
-    def get_watchdog(self):
-        return not bool(self.msr & 128)
-
-    def set_watchdog(self, val):
-        val = Utils.to_bool(val);
-        self.msr &= 0x7f
-        self.msr |= 0x80 if not bool(val) else 0x00
-
-
-class Stc12AOption(BaseOption):
-    """Manipulate STC12A series option bytes"""
-
-    def __init__(self, msr):
-        assert len(msr) == 5
-        self.msr = bytearray(msr)
-
-        """list of options and their handlers"""
-        self.options = (
-            ("low_voltage_reset", self.get_low_voltage_detect, self.set_low_voltage_detect),
-            ("clock_source", self.get_clock_source, self.set_clock_source),
-            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
-            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
-            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
-            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
-            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
-        )
-
-    def get_low_voltage_detect(self):
-        return not bool(self.msr[4] & 64)
-
-    def set_low_voltage_detect(self, val):
-        val = Utils.to_bool(val);
-        self.msr[4] &= 0xbf
-        self.msr[4] |= 0x40 if not val else 0x00
-
-    def get_clock_source(self):
-        source = bool(self.msr[0] & 2)
-        return "external" if source else "internal"
-
-    def set_clock_source(self, val):
-        sources = {"internal": 0, "external": 1}
-        if val not in sources.keys():
-            raise ValueError("must be one of %s" % list(sources.keys()))
-        self.msr[0] &= 0xfd
-        self.msr[0] |= sources[val] << 1
-
-    def get_watchdog(self):
-        return not bool(self.msr[1] & 32)
-
-    def set_watchdog(self, val):
-        val = Utils.to_bool(val);
-        self.msr[1] &= 0xdf
-        self.msr[1] |= 0x20 if not val else 0x00
-
-    def get_watchdog_idle(self):
-        return not bool(self.msr[1] & 8)
-
-    def set_watchdog_idle(self, val):
-        val = Utils.to_bool(val);
-        self.msr[1] &= 0xf7
-        self.msr[1] |= 0x08 if not val else 0x00
-
-    def get_watchdog_prescale(self):
-        return 2 ** (((self.msr[1]) & 0x07) + 1)
-
-    def set_watchdog_prescale(self, val):
-        val = Utils.to_int(val)
-        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
-        if val not in wd_vals.keys():
-            raise ValueError("must be one of %s" % list(wd_vals.keys()))
-        self.msr[1] &= 0xf8
-        self.msr[1] |= wd_vals[val]
-
-    def get_ee_erase(self):
-        return not bool(self.msr[2] & 2)
-
-    def set_ee_erase(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xfd
-        self.msr[2] |= 0x02 if not val else 0x00
-
-    def get_pindetect(self):
-        return not bool(self.msr[2] & 1)
-
-    def set_pindetect(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xfe
-        self.msr[2] |= 0x01 if not val else 0x00
-
-
-class Stc12Option(BaseOption):
-    """Manipulate STC10/11/12 series option bytes"""
-
-    def __init__(self, msr):
-        assert len(msr) == 4
-        self.msr = bytearray(msr)
-
-        """list of options and their handlers"""
-        self.options = (
-            ("reset_pin_enabled", self.get_reset_pin_enabled, self.set_reset_pin_enabled),
-            ("low_voltage_reset", self.get_low_voltage_detect, self.set_low_voltage_detect),
-            ("oscillator_stable_delay", self.get_osc_stable_delay, self.set_osc_stable_delay),
-            ("por_reset_delay", self.get_por_delay, self.set_por_delay),
-            ("clock_gain", self.get_clock_gain, self.set_clock_gain),
-            ("clock_source", self.get_clock_source, self.set_clock_source),
-            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
-            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
-            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
-            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
-            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
-        )
-
-    def get_reset_pin_enabled(self):
-        return bool(self.msr[0] & 1)
-
-    def set_reset_pin_enabled(self, val):
-        val = Utils.to_bool(val);
-        self.msr[0] &= 0xfe
-        self.msr[0] |= 0x01 if bool(val) else 0x00
-
-    def get_low_voltage_detect(self):
-        return not bool(self.msr[0] & 64)
-
-    def set_low_voltage_detect(self, val):
-        val = Utils.to_bool(val);
-        self.msr[0] &= 0xbf
-        self.msr[0] |= 0x40 if not val else 0x00
-
-    def get_osc_stable_delay(self):
-        return 2 ** (((self.msr[0] >> 4) & 0x03) + 12)
-
-    def set_osc_stable_delay(self, val):
-        val = Utils.to_int(val)
-        osc_vals = {4096: 0, 8192: 1, 16384: 2, 32768: 3}
-        if val not in osc_vals.keys():
-            raise ValueError("must be one of %s" % list(osc_vals.keys()))
-        self.msr[0] &= 0xcf
-        self.msr[0] |= osc_vals[val] << 4
-
-    def get_por_delay(self):
-        delay = not bool(self.msr[1] & 128)
-        return "long" if delay else "short"
-
-    def set_por_delay(self, val):
-        delays = {"short": 1, "long": 0}
-        if val not in delays.keys():
-            raise ValueError("must be one of %s" % list(delays.keys()))
-        self.msr[1] &= 0x7f
-        self.msr[1] |= delays[val] << 7
-
-    def get_clock_gain(self):
-        gain = bool(self.msr[1] & 64)
-        return "high" if gain else "low"
-
-    def set_clock_gain(self, val):
-        gains = {"low": 0, "high": 1}
-        if val not in gains.keys():
-            raise ValueError("must be one of %s" % list(gains.keys()))
-        self.msr[1] &= 0xbf
-        self.msr[1] |= gains[val] << 6
-
-    def get_clock_source(self):
-        source = bool(self.msr[1] & 2)
-        return "external" if source else "internal"
-
-    def set_clock_source(self, val):
-        sources = {"internal": 0, "external": 1}
-        if val not in sources.keys():
-            raise ValueError("must be one of %s" % list(sources.keys()))
-        self.msr[1] &= 0xfd
-        self.msr[1] |= sources[val] << 1
-
-    def get_watchdog(self):
-        return not bool(self.msr[2] & 32)
-
-    def set_watchdog(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xdf
-        self.msr[2] |= 0x20 if not val else 0x00
-
-    def get_watchdog_idle(self):
-        return not bool(self.msr[2] & 8)
-
-    def set_watchdog_idle(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xf7
-        self.msr[2] |= 0x08 if not val else 0x00
-
-    def get_watchdog_prescale(self):
-        return 2 ** (((self.msr[2]) & 0x07) + 1)
-
-    def set_watchdog_prescale(self, val):
-        val = Utils.to_int(val)
-        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
-        if val not in wd_vals.keys():
-            raise ValueError("must be one of %s" % list(wd_vals.keys()))
-        self.msr[2] &= 0xf8
-        self.msr[2] |= wd_vals[val]
-
-    def get_ee_erase(self):
-        return not bool(self.msr[3] & 2)
-
-    def set_ee_erase(self, val):
-        val = Utils.to_bool(val);
-        self.msr[3] &= 0xfd
-        self.msr[3] |= 0x02 if not val else 0x00
-
-    def get_pindetect(self):
-        return not bool(self.msr[3] & 1)
-
-    def set_pindetect(self, val):
-        val = Utils.to_bool(val);
-        self.msr[3] &= 0xfe
-        self.msr[3] |= 0x01 if not val else 0x00
-
-
-class Stc15AOption(BaseOption):
-    def __init__(self, msr):
-        assert len(msr) == 13
-        self.msr = bytearray(msr)
-
-        self.options = (
-            ("reset_pin_enabled", self.get_reset_pin_enabled, self.set_reset_pin_enabled),
-            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
-            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
-            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
-            ("low_voltage_reset", self.get_lvrs, self.set_lvrs),
-            ("low_voltage_threshold", self.get_low_voltage, self.set_low_voltage),
-            ("eeprom_lvd_inhibit", self.get_eeprom_lvd, self.set_eeprom_lvd),
-            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
-            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
-        )
-
-    def set_trim(self, val):
-        self.msr[3:5] = struct.pack(">H", val)
-
-    def get_reset_pin_enabled(self):
-        return bool(self.msr[0] & 16)
-
-    def set_reset_pin_enabled(self, val):
-        val = Utils.to_bool(val);
-        self.msr[0] &= 0xef
-        self.msr[0] |= 0x10 if bool(val) else 0x00
-
-    def get_watchdog(self):
-        return not bool(self.msr[2] & 32)
-
-    def set_watchdog(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xdf
-        self.msr[2] |= 0x20 if not val else 0x00
-
-    def get_watchdog_idle(self):
-        return not bool(self.msr[2] & 8)
-
-    def set_watchdog_idle(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xf7
-        self.msr[2] |= 0x08 if not val else 0x00
-
-    def get_watchdog_prescale(self):
-        return 2 ** (((self.msr[2]) & 0x07) + 1)
-
-    def set_watchdog_prescale(self, val):
-        val = Utils.to_int(val)
-        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
-        if val not in wd_vals.keys():
-            raise ValueError("must be one of %s" % list(wd_vals.keys()))
-        self.msr[2] &= 0xf8
-        self.msr[2] |= wd_vals[val]
-
-    def get_lvrs(self):
-        return bool(self.msr[1] & 64)
-
-    def set_lvrs(self, val):
-        val = Utils.to_bool(val);
-        self.msr[1] &= 0xbf
-        self.msr[1] |= 0x40 if val else 0x00
-
-    def get_eeprom_lvd(self):
-        return bool(self.msr[1] & 128)
-
-    def set_eeprom_lvd(self, val):
-        val = Utils.to_bool(val);
-        self.msr[1] &= 0x7f
-        self.msr[1] |= 0x80 if val else 0x00
-
-    def get_low_voltage(self):
-        return self.msr[1] & 0x07
-
-    def set_low_voltage(self, val):
-        val = Utils.to_int(val)
-        if val not in range(0, 8):
-            raise ValueError("must be one of %s" % list(range(0, 8)))
-        self.msr[1] &= 0xf8
-        self.msr[1] |= val
-
-    def get_ee_erase(self):
-        return not bool(self.msr[12] & 2)
-
-    def set_ee_erase(self, val):
-        val = Utils.to_bool(val);
-        self.msr[12] &= 0xfd
-        self.msr[12] |= 0x02 if not val else 0x00
-
-    def get_pindetect(self):
-        return not bool(self.msr[12] & 1)
-
-    def set_pindetect(self, val):
-        val = Utils.to_bool(val);
-        self.msr[12] &= 0xfe
-        self.msr[12] |= 0x01 if not val else 0x00
-
-
-class Stc15Option(BaseOption):
-    def __init__(self, msr):
-        assert len(msr) >= 4
-        self.msr = bytearray(msr)
-
-        self.options = (
-            ("reset_pin_enabled", self.get_reset_pin_enabled, self.set_reset_pin_enabled),
-            ("clock_source", self.get_clock_source, self.set_clock_source),
-            ("clock_gain", self.get_clock_gain, self.set_clock_gain),
-            ("watchdog_por_enabled", self.get_watchdog, self.set_watchdog),
-            ("watchdog_stop_idle", self.get_watchdog_idle, self.set_watchdog_idle),
-            ("watchdog_prescale", self.get_watchdog_prescale, self.set_watchdog_prescale),
-            ("low_voltage_reset", self.get_lvrs, self.set_lvrs),
-            ("low_voltage_threshold", self.get_low_voltage, self.set_low_voltage),
-            ("eeprom_lvd_inhibit", self.get_eeprom_lvd, self.set_eeprom_lvd),
-            ("eeprom_erase_enabled", self.get_ee_erase, self.set_ee_erase),
-            ("bsl_pindetect_enabled", self.get_pindetect, self.set_pindetect),
-            ("por_reset_delay", self.get_por_delay, self.set_por_delay),
-            ("rstout_por_state", self.get_p33_state, self.set_p33_state),
-            ("uart2_passthrough", self.get_uart_passthrough, self.set_uart_passthrough),
-            ("uart2_pin_mode", self.get_uart_pin_mode, self.set_uart_pin_mode),
-        )
-
-        if len(msr) > 4:
-            self.options += ("cpu_core_voltage", self.get_core_voltage, self.set_core_voltage),
-
-    def get_reset_pin_enabled(self):
-        return not bool(self.msr[2] & 16)
-
-    def set_reset_pin_enabled(self, val):
-        val = Utils.to_bool(val);
-        self.msr[2] &= 0xef
-        self.msr[2] |= 0x10 if not bool(val) else 0x00
-
-    def get_clock_source(self):
-        source = bool(self.msr[2] & 0x01)
-        return "internal" if source else "external"
-
-    def set_clock_source(self, val):
-        sources = {"internal": 1, "external": 0}
-        if val not in sources.keys():
-            raise ValueError("must be one of %s" % list(sources.keys()))
-        self.msr[2] &= 0xfe
-        self.msr[2] |= sources[val]
-
-    def get_clock_gain(self):
-        gain = bool(self.msr[2] & 0x02)
-        return "high" if gain else "low"
-
-    def set_clock_gain(self, val):
-        gains = {"low": 0, "high": 1}
-        if val not in gains.keys():
-            raise ValueError("must be one of %s" % list(gains.keys()))
-        self.msr[2] &= 0xfd
-        self.msr[2] |= gains[val] << 1
-
-    def get_watchdog(self):
-        return not bool(self.msr[0] & 32)
-
-    def set_watchdog(self, val):
-        val = Utils.to_bool(val);
-        self.msr[0] &= 0xdf
-        self.msr[0] |= 0x20 if not val else 0x00
-
-    def get_watchdog_idle(self):
-        return not bool(self.msr[0] & 8)
-
-    def set_watchdog_idle(self, val):
-        val = Utils.to_bool(val);
-        self.msr[0] &= 0xf7
-        self.msr[0] |= 0x08 if not val else 0x00
-
-    def get_watchdog_prescale(self):
-        return 2 ** (((self.msr[0]) & 0x07) + 1)
-
-    def set_watchdog_prescale(self, val):
-        val = Utils.to_int(val)
-        wd_vals = {2: 0, 4: 1, 8: 2, 16: 3, 32: 4, 64: 5, 128: 6, 256: 7}
-        if val not in wd_vals.keys():
-            raise ValueError("must be one of %s" % list(wd_vals.keys()))
-        self.msr[0] &= 0xf8
-        self.msr[0] |= wd_vals[val]
-
-    def get_lvrs(self):
-        return not bool(self.msr[1] & 64)
-
-    def set_lvrs(self, val):
-        val = Utils.to_bool(val);
-        self.msr[1] &= 0xbf
-        self.msr[1] |= 0x40 if not val else 0x00
-
-    def get_eeprom_lvd(self):
-        return bool(self.msr[1] & 128)
-
-    def set_eeprom_lvd(self, val):
-        val = Utils.to_bool(val);
-        self.msr[1] &= 0x7f
-        self.msr[1] |= 0x80 if val else 0x00
-
-    def get_low_voltage(self):
-        return self.msr[1] & 0x07
-
-    def set_low_voltage(self, val):
-        val = Utils.to_int(val)
-        if val not in range(0, 8):
-            raise ValueError("must be one of %s" % list(range(0, 8)))
-        self.msr[1] &= 0xf8
-        self.msr[1] |= val
-
-    def get_ee_erase(self):
-        return bool(self.msr[3] & 2)
-
-    def set_ee_erase(self, val):
-        val = Utils.to_bool(val);
-        self.msr[3] &= 0xfd
-        self.msr[3] |= 0x02 if val else 0x00
-
-    def get_pindetect(self):
-        return not bool(self.msr[3] & 1)
-
-    def set_pindetect(self, val):
-        val = Utils.to_bool(val);
-        self.msr[3] &= 0xfe
-        self.msr[3] |= 0x01 if not val else 0x00
-
-    def get_por_delay(self):
-        delay = bool(self.msr[2] & 128)
-        return "long" if delay else "short"
-
-    def set_por_delay(self, val):
-        delays = {"short": 0, "long": 1}
-        if val not in delays.keys():
-            raise ValueError("must be one of %s" % list(delays.keys()))
-        self.msr[2] &= 0x7f
-        self.msr[2] |= delays[val] << 7
-
-    def get_p33_state(self):
-        return "high" if self.msr[2] & 0x08 else "low"
-
-    def set_p33_state(self, val):
-        val = Utils.to_bool(val)
-        self.msr[2] &= 0xf7
-        self.msr[2] |= 0x08 if val else 0x00
-
-    def get_uart_passthrough(self):
-        return bool(self.msr[2] & 0x40)
-
-    def set_uart_passthrough(self, val):
-        val = Utils.to_bool(val)
-        self.msr[2] &= 0xbf
-        self.msr[2] |= 0x40 if val else 0x00
-
-    def get_uart_pin_mode(self):
-        return "push-pull" if bool(self.msr[2] & 0x20) else "normal"
-
-    def set_uart_pin_mode(self, val):
-        delays = {"normal": 0, "push-pull": 1}
-        if val not in delays.keys():
-            raise ValueError("must be one of %s" % list(delays.keys()))
-        self.msr[2] &= 0xdf
-        self.msr[2] |= 0x20 if val else 0x00
-
-    def get_core_voltage(self):
-        if self.msr[4] == 0xea: return "low"
-        elif self.msr[4] == 0xf7: return "mid"
-        elif self.msr[4] == 0xfd: return "high"
-        else: return "unknown"
-
-    def set_core_voltage(self, val):
-        volt_vals = {"low": 0xea, "mid": 0xf7, "high": 0xfd}
-        if val not in volt_vals.keys():
-            raise ValueError("must be one of %s" % list(volt_vals.keys()))
-        self.msr[4] = volt_vals[val]
-
-
 class StcBaseProtocol:
    """Basic functionality for STC BSL protocols"""

@ -775,6 +194,7 @@ class StcBaseProtocol:

        protocol_database = [("stc89", "STC(89|90)(C|LE)\d"),
                             ("stc12a", "STC12(C|LE)\d052"),
+                             ("stc12b", "STC12(C|LE)(52|56)"),
                             ("stc12", "(STC|IAP)(10|11|12)\D"),
                             ("stc15a", "(STC|IAP)15[FL][01]0\d(E|EA|)$"),
                             ("stc15", "(STC|IAP|IRC)15\D")]
@ -1012,6 +432,7 @@ class Stc89Protocol(StcBaseProtocol):

        # check new baudrate
        print("Switching to %d baud: " % self.baud_transfer, end="")
+        sys.stdout.flush()
        brt, brt_csum, iap, delay = self.calculate_baud()
        print("checking ", end="")
        sys.stdout.flush()
@ -1109,7 +530,37 @@ class Stc89Protocol(StcBaseProtocol):
        print("done")


-class Stc12AProtocol(Stc89Protocol):
+class Stc12AOptionsMixIn:
+    def program_options(self):
+        print("Setting options: ", end="")
+        sys.stdout.flush()
+        msr = self.options.get_msr()
+        packet = bytes([0x8d, msr[0], msr[1], msr[2], 0xff, msr[3]])
+        packet += struct.pack(">I", int(self.mcu_clock_hz))
+        packet += bytes([msr[3]])
+        packet += bytes([0xff, msr[0], msr[1], 0xff, 0xff, 0xff, 0xff, msr[2]])
+        packet += bytes([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
+        packet += struct.pack(">I", int(self.mcu_clock_hz))
+        packet += bytes([0xff, 0xff, 0xff])
+
+        self.write_packet(packet)
+        response = self.read_packet()
+        if response[0] != 0x80:
+            raise StcProtocolException("incorrect magic in option packet")
+
+        # XXX: this is done by STC-ISP on newer parts. not sure why, but let's
+        # just replicate it, just to be sure.
+        if self.bsl_version >= 0x66:
+            packet = bytes([0x50])
+            self.write_packet(packet)
+            response = self.read_packet()
+            if response[0] != 0x10:
+                raise StcProtocolException("incorrect magic in option packet")
+
+        print("done")
+
+
+class Stc12AProtocol(Stc12AOptionsMixIn, Stc89Protocol):

    """countdown value for flash erase"""
    ERASE_COUNTDOWN = 0x0d
@ -1130,6 +581,8 @@ class Stc12AProtocol(Stc89Protocol):
        self.mcu_bsl_version = "%d.%d%s" % (bl_version >> 4, bl_version & 0x0f,
                                           chr(bl_stepping))

+        self.bsl_version = bl_version
+
    def calculate_baud(self):
        """Calculate MCU baudrate setting.

@ -1160,7 +613,7 @@ class Stc12AProtocol(Stc89Protocol):
        """Initialize options"""

        # create option state
-        self.options = Stc12AOption(status_packet[23:28])
+        self.options = Stc12AOption(status_packet[23:26] + status_packet[29:30])
        self.options.print()

    def handshake(self):
@ -1228,23 +681,34 @@ class Stc12AProtocol(Stc89Protocol):
            raise StcProtocolException("incorrect magic in erase packet")
        print("done")

+
+class Stc12OptionsMixIn:
    def program_options(self):
        print("Setting options: ", end="")
        sys.stdout.flush()
        msr = self.options.get_msr()
+        # XXX: it's not 100% clear if the index of msr[3] is consistent
+        # between devices, so write it to both indices.
        packet = bytes([0x8d, msr[0], msr[1], msr[2], msr[3],
-                        msr[4]])
+                        0xff, 0xff, 0xff, 0xff, msr[3], 0xff,
+                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff])

        packet += struct.pack(">I", int(self.mcu_clock_hz))
        self.write_packet(packet)
        response = self.read_packet()
-        if response[0] != 0x80:
+        if response[0] != 0x50:
            raise StcProtocolException("incorrect magic in option packet")
        print("done")

+        # If UID wasn't sent with erase acknowledge, it should be in this packet
+        if not self.uid:
+            self.uid = response[18:25]

-class Stc12Protocol(StcBaseProtocol):
-    """Protocol handler for STC 10/11/12 series"""
+        print("Target UID: %s" % Utils.hexstr(self.uid))
+
+
+class Stc12BaseProtocol(StcBaseProtocol):
+    """Base class for STC 10/11/12 series protocol handlers"""

    """block size for programming flash"""
    PROGRAM_BLOCKSIZE = 128
@ -1306,6 +770,8 @@ class Stc12Protocol(StcBaseProtocol):
        self.mcu_bsl_version = "%d.%d%s" % (bl_version >> 4, bl_version & 0x0f,
                                           chr(bl_stepping))

+        self.bsl_version = bl_version
+
    def calculate_baud(self):
        """Calculate MCU baudrate setting.

@ -1336,7 +802,7 @@ class Stc12Protocol(StcBaseProtocol):
        """Initialize options"""

        # create option state
-        self.options = Stc12Option(status_packet[23:27])
+        self.options = Stc12Option(status_packet[23:26] + status_packet[27:28])
        self.options.print()

    def handshake(self):
@ -1425,8 +891,6 @@ class Stc12Protocol(StcBaseProtocol):
            response = self.read_packet()
            if response[0] != 0x00:
                raise StcProtocolException("incorrect magic in write packet")
-            elif response[1] != csum:
-                raise StcProtocolException("verification checksum mismatch")
            print(".", end="")
            sys.stdout.flush()
        print(" done")
@ -1441,26 +905,19 @@ class Stc12Protocol(StcBaseProtocol):
            raise StcProtocolException("incorrect magic in finish packet")
        print("done")

-    def program_options(self):
-        print("Setting options: ", end="")
-        sys.stdout.flush()
-        msr = self.options.get_msr()
-        packet = bytes([0x8d, msr[0], msr[1], msr[2], msr[3],
-                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff])

-        packet += struct.pack(">I", int(self.mcu_clock_hz))
-        self.write_packet(packet)
-        response = self.read_packet()
-        if response[0] != 0x50:
-            raise StcProtocolException("incorrect magic in option packet")
-        print("done")
+class Stc12Protocol(Stc12OptionsMixIn, Stc12BaseProtocol):
+    """STC 10/11/12 series protocol handler"""

-        # If UID wasn't sent with erase acknowledge, it should be in this packet
-        if not self.uid:
-            self.uid = response[18:25]
+    def __init__(self, port, handshake, baud):
+        Stc12BaseProtocol.__init__(self, port, handshake, baud)

-        print("Target UID: %s" % Utils.hexstr(self.uid))
+
+class Stc12BProtocol(Stc12AOptionsMixIn, Stc12BaseProtocol):
+    """STC 10/11/12 variant protocol handler"""
+
+    def __init__(self, port, handshake, baud):
+        Stc12BaseProtocol.__init__(self, port, handshake, baud)


 class Stc15AProtocol(Stc12Protocol):
@ -1836,7 +1293,7 @@ class Stc15Protocol(Stc15AProtocol):
        # This is a bit of a hack, but it works.
        bauds = self.baud_transfer if (self.mcu_magic >> 8) == 0xf2 else self.baud_transfer * 4
        packet += struct.pack(">H", int(65535 - program_speed / bauds))
-        packet += struct.pack(">H", int(65535 - (program_speed / bauds) * 1.5))
+        packet += bytes(user_trim)
        iap_wait = self.get_iap_delay(program_speed)
        packet += bytes([iap_wait])
        self.write_packet(packet)
@ -1997,12 +1454,6 @@ class StcUsb15Protocol(Stc15Protocol):
    """PID of STC devices"""
    USB_PID = 0x4312

-    """Control transfer from host to device"""
-    USB_HOST2DEV = usb.util.CTRL_TYPE_VENDOR | usb.util.CTRL_RECIPIENT_DEVICE | usb.util.CTRL_OUT
-
-    """Control transfer from device to host"""
-    USB_DEV2HOST = usb.util.CTRL_TYPE_VENDOR | usb.util.CTRL_RECIPIENT_DEVICE | usb.util.CTRL_IN
-
    def __init__(self):
        # XXX: this is really ugly!
        Stc15Protocol.__init__(self, "", 0, 0, 0)
@ -2016,7 +1467,8 @@ class StcUsb15Protocol(Stc15Protocol):
    def read_packet(self):
        """Read a packet from the MCU"""

-        packet = self.dev.ctrl_transfer(self.USB_DEV2HOST, 0, 0, 0, 132).tobytes()
+        dev2host = usb.util.CTRL_TYPE_VENDOR | usb.util.CTRL_RECIPIENT_DEVICE | usb.util.CTRL_IN
+        packet = self.dev.ctrl_transfer(dev2host, 0, 0, 0, 132).tobytes()
        if len(packet) < 5 or packet[0] != 0x46 or packet[1] != 0xb9:
            self.dump_packet(packet)
            raise StcFramingException("incorrect frame start")
@ -2049,7 +1501,8 @@ class StcUsb15Protocol(Stc15Protocol):
            i += 7

        self.dump_packet(chunks, request, value, index, receive=False)
-        self.dev.ctrl_transfer(self.USB_HOST2DEV, request, value, index, chunks);
+        host2dev = usb.util.CTRL_TYPE_VENDOR | usb.util.CTRL_RECIPIENT_DEVICE | usb.util.CTRL_OUT
+        self.dev.ctrl_transfer(host2dev, request, value, index, chunks);

    def connect(self, autoreset=False):
        """Connect to USB device and read info packet"""
@ -2069,9 +1522,15 @@ class StcUsb15Protocol(Stc15Protocol):
                if self.dev:
                    self.dev.set_configuration()
                    self.status_packet = self.read_packet()
-                else:
-                    time.sleep(0.5)
-            except (StcFramingException, usb.core.USBError): pass
+                    if len(self.status_packet) < 38:
+                        self.status_packet = None
+                        raise StcFramingException
+                else: raise StcFramingException
+            except StcFramingException:
+                time.sleep(0.5)
+            except usb.core.USBError as err:
+                if err.errno == errno.EACCES:
+                    raise IOError(err.strerror)

        self.initialize_model()
        print("done")
Author	SHA1	Message	Date
Grigori Goronzy	b4c7f34d39	stc15: fix RC oscillator baudrate switch packet It looks like it wasn't correct. The last value sent is probably supposed to be the trim value for the chosen trim frequency. Addresses grigorig/stcgal#16.	2016-06-09 16:15:09 +02:00
Grigori Goronzy	65a7759647	stc12+: drop checksum verification for flashing It's not needed on STC12 and up. All transfers are error checked with parity and a 16-bit modular sum already. STC15 dropped the verification checksum on the protocol level, it's not sent with the write status packet, which is a testament to this not being needed. Some parts store the UID in the last bytes of flash memory and this verification actually caused incorrect verification failures because of the verification, which apparently read the UID on verification readback. Fixes grigorig/stcgal#15.	2016-05-28 11:25:44 +02:00
Grigori Goronzy	8ad77586d4	Update version to 1.2	2016-05-20 03:22:24 +02:00
Grigori Goronzy	276c696fa4	frontend: enable protocol autodetection by default It seems to work rather well after some extended testing. Also clean up and update the protocol documentation while at it.	2016-05-20 02:59:35 +02:00
Grigori Goronzy	26ef34991b	usb15: abort if permission denied Don't ignore permission denied when looking for a suitable USB device. Otherwise users don't notice what the problem is, stcgal will just keep waiting on the prompt.	2016-05-20 02:55:23 +02:00
Grigori Goronzy	f90fe4152b	Add STC12B protocol variant This is just like STC12, but with the STC12A option packet. Used by STC12xx52 series, STC12xx56 series and possibly others. Fixes grigorig/stcgal#14.	2016-05-20 02:54:57 +02:00
Grigori Goronzy	d6ef028dc7	Extract mix-ins for STC12 and STC12A options This simplifies code down the line. No functional change intended.	2016-05-20 02:44:50 +02:00
Grigori Goronzy	979d7f513f	Get rid of USB bmRequestType constants These constants were calculated on class loading, which didn't work without pyusb. USB support is going to remain optional.	2016-05-18 16:40:09 +02:00
Grigori Goronzy	fce2f01232	Extract option classes into separate file	2016-05-18 02:38:13 +02:00
Grigori Goronzy	854f36100b	stc12: fix option handling MCS3 index was wrong. Also, write MCS3 to two possible indices in the option set packet. Addresses grigorig/stcgal#14.	2016-05-18 02:14:02 +02:00
Grigori Goronzy	92f4def11a	stc12a: revamp option handling Completely revamp option handling. This fixes a wrong index of MCS4, which is now renamed to MCS3. Now programming should be exactly similar to STC-ISP 6.85M. This also renames the values of the low_voltage_reset option for clarity. Also update the documentation and clarity the meaning of the option according to protocol family. Addresses grigorig/stcgal#14.	2016-05-18 01:40:08 +02:00
Grigori Goronzy	6c0af88551	frontend: always pad to 512 bytes, fill with 0xff This seems to be the default of STC-ISP, so let's use it for possibly improved compatibility.	2016-05-18 00:56:16 +02:00
Grigori Goronzy	366a3a5bd3	Fix EEPROM size of STC12x54 series in MCU database	2016-05-15 02:39:51 +02:00
Grigori Goronzy	c046e886e3	usb15: add protocol notes	2016-05-15 02:31:36 +02:00
Grigori Goronzy	7ba95eab68	stc15/usb15: add password feature notes I'm not going to implement this right now as it is rather dangerous.	2016-05-15 02:30:25 +02:00
Grigori Goronzy	61a4fa0e4f	stc89: add missing output flush	2016-05-14 21:37:27 +02:00
Grigori Goronzy	da5f6678c5	usb15: sanity check on status packet reads If a previous stcgal invocation is aborted, we can be in a bad state upon connect. Add a simple sanity check based on packet length to detect this and drop unsuitable packets.	2016-05-14 21:03:07 +02:00
Grigori Goronzy	a8f141584d	Merge branch 'usbisp' It is still experimental, but the changes are not very invasive, so why not include it right now. Closes grigorig/stcgal#10.	2016-05-14 13:26:57 +02:00