gdbflasher 1.0.0

data/lib/gdbflasher/mcu.rb

@@ -0,0 +1,208 @@
+module GdbFlasher
+
+class MCU
+  def initialize(connection)
+    @connection = connection
+    @symbol_table = {}
+
+    helper_hex = File.join HELPERS, helper_name + ".hex"
+    helper_sym = File.join HELPERS, helper_name + ".sym"
+
+    File.open(helper_sym, "r") do |f|
+      f.each_line do |line|
+        line.rstrip!
+
+        address, symbol = line.split(" ")
+
+        @symbol_table[symbol.intern] = address.to_i 16
+      end
+    end
+
+    helper = nil
+    File.open(helper_hex, "r") { |f| helper = IHex.load f }
+
+    connection.reset
+    connection.get_stop_reply
+
+    helper.segments.each do |segment|
+      connection.write_memory segment.base, segment.data
+    end
+
+    initialize_environment
+
+    @connection.insert_breakpoint 0, @symbol_table[:trap], breakpoint_kind
+
+    call_helper :initialize
+  end
+
+  def finalize
+    call_helper :finalize
+
+    @connection.remove_breakpoint 0, @symbol_table[:trap], breakpoint_kind
+  end
+
+  def program_ihex(ihex, extra = {})
+    sectors = []
+    sector_actions = []
+
+    sector_map = self.class.const_get :SECTORS
+
+    sector_map.each_index do |i|
+      sector_begin, sector_end = sector_map[i]
+
+      sector_segment = nil
+
+      ihex.segments.each do |segment|
+        intersection = segment.intersect sector_begin, sector_end
+
+        if intersection.size > 0
+          if sector_segment.nil?
+            sector_segment = IHex::Segment.new
+            sector_segment.base = sector_begin
+            sector_segment.data = blank_byte.chr * (sector_end - sector_begin + 1)
+
+            sectors << sector_segment
+          end
+
+          affected_range = intersection.base - sector_begin...intersection.base + intersection.size - sector_begin
+          sector_segment.data[affected_range] = intersection.data
+        end
+      end
+    end
+
+    if extra[:read_disallowed]
+      sector_actions = [ [ :erase, :program ] ] * sectors.count
+    else
+      puts "Checking sectors"
+
+      sectors.each do |sector|
+        data = @connection.read_memory sector.base, sector.size
+
+        if data == sector.data
+          sector_actions << [ ]
+        elsif is_blank(data)
+          sector_actions << [ :program, :verify ]
+        elsif is_blank(sector.data)
+          sector_actions << [ :erase, :verify ]
+        else
+          sector_actions << [ :erase, :program, :verify ]
+        end
+      end
+    end
+
+    puts "Programming sectors:"
+    sectors.each_index do |i|
+      sector = sectors[i]
+      actions = sector_actions[i]
+
+      next if actions.empty?
+
+      sector_id = sector_map.index { |i| i[0] == sector.base }
+
+      printf " - %08X - %08X: ", sector.base, sector.base + sector.size - 1
+
+      actions.each do |action|
+        case action
+        when :erase
+          print "erase, "
+
+          status = erase sector_id
+          if status != 0
+            puts "failure!"
+            warn "Unable to erase sector #{sector_id}, vendor-specific error #{status}"
+
+            return false
+          end
+
+        when :program
+          print "program, "
+
+          offset = 0
+          page_size = @symbol_table[:PAGE_SIZE]
+          buffer = @symbol_table[:page_buffer]
+
+          while offset < sector.size
+            @connection.write_memory buffer, sector.data[offset...offset + page_size]
+            status = program sector.base + offset
+
+            if status != 0
+              puts "failure!"
+              warn "Unable to program page #{(sector.base + offset).to_s 16}, vendor-specific error #{status}"
+
+              return false
+            end
+
+            offset += page_size
+          end
+
+        when :verify
+          print "verify, "
+
+          data = @connection.read_memory sector.base, sector.size
+
+          if data != sector.data
+            puts "failure!"
+            warn "Verification of sector #{sector_id} failed."
+
+            return false
+          end
+        end
+      end
+
+      print "all ok.\n"
+    end
+
+    true
+  end
+
+  protected
+
+  def blank_byte
+    0xFF
+  end
+
+  def erase(sector_id)
+    call_helper :erase, sector_id
+  end
+
+  def program(offset)
+    call_helper :program, offset
+  end
+
+  def is_blank(string)
+    string.bytes.all? { |byte| byte == blank_byte }
+  end
+
+  def initialize_environment
+
+  end
+
+  def breakpoint_kind
+    4 # ARM breakpoint
+  end
+
+  def lr_offset
+    0
+  end
+
+  def call_helper(func, r0 = 0, r1 = 0, r2 = 0, r3 = 0)
+    regs = @connection.read_registers
+    regs[0..3] = r0, r1, r2, r3
+    regs[14] = @symbol_table[:trap] | lr_offset
+    regs[15] = @symbol_table[func]
+    @connection.write_registers regs
+
+    reply = @connection.continue
+
+    regs = @connection.read_registers
+
+    if reply.signal != 0x05 || regs[15] != @symbol_table[:trap]
+      raise "Target stopped by signal #{reply.signal}, PC = #{regs[15].to_s 16}"
+    end
+
+    regs[0]
+  end
+
+end
+
+end

data/lib/gdbflasher/server_connection.rb

@@ -0,0 +1,334 @@
+require "socket"
+
+module GdbFlasher
+  class ServerConnection
+    class StopReply
+      attr_accessor :signal, :attributes
+
+      def initialize(signal, attributes = {})
+        @signal = signal
+        @attributes = attributes
+      end
+    end
+
+    def initialize
+      @socket = nil
+    end
+
+    def connect(address)
+      raise "Already connected" unless @socket.nil?
+
+      delimiter = address.rindex ':'
+      raise ArgumentError, "Port must be specified" if delimiter.nil?
+      host = address[0...delimiter]
+      port = address[delimiter + 1..-1].to_i
+
+      @buf = ""
+      @features = {}
+      @need_ack = true
+
+      begin
+        @socket = TCPSocket.new host, port
+        @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+        # Query stub features
+        command("qSupported").split(';').each do |feature|
+          if feature[-1] == '-'
+            @features.delete feature[0...-1].intern
+          elsif feature[-1] == '+'
+            @features[feature[0...-1].intern] = true
+          else
+            sep = feature.index '='
+
+            if sep.nil?
+              raise "Unexpected item in qSupported response: #{sep}"
+            end
+
+            @features[feature[0...sep].intern] = feature[sep + 1..-1]
+          end
+        end
+
+        if @features[:PacketSize].nil?
+          raise "PacketSize isn't present in qSupported response"
+        end
+
+        if @features[:QStartNoAckMode]
+          response = command("QStartNoAckMode")
+
+          if response != "OK"
+            raise "Unable to enter NoAck mode: #{response}"
+          end
+
+          @need_ack = false
+        end
+
+        # Load target description
+        if @features[:"qXfer:features:read"]
+          description = read_xfer "features", "target.xml"
+
+          # TODO: parse target description and use register map from it.
+        end
+
+      rescue Exception => e
+        @socket.close unless @socket.nil?
+        @socket = nil
+
+        raise e
+      end
+    end
+
+    def close
+      @socket.close
+      @socket = nil
+    end
+
+    def read_registers
+      response = command "g"
+
+      if (response[0] != 'E' || response.length != 3) && response.length % 8 != 0
+        raise "Malformed 'g' response"
+      end
+
+      if response[0] == 'E'
+        raise "GDB server error: #{response[1..2].to_i 16}"
+      end
+
+      Array.new response.length / 8 do |i|
+        big2native response[i * 8...(i + 1) * 8].to_i(16)
+      end
+    end
+
+    def write_registers(regs)
+      send_packet "G" + regs.map { |r| sprintf "%08x", native2big(r) }.join
+    end
+
+    def write_memory(base, string)
+      max_size = (@features[:PacketSize].to_i - 19) & ~1
+
+      offset = 0
+      data = string.unpack("C*").map { |byte| sprintf "%02X", byte }.join
+
+      while offset < data.length
+        chunk_size = [ max_size, data.length - offset ].min
+
+        response = command "M#{base.to_s 16},#{(chunk_size / 2).to_s 16}:#{data[offset...offset + chunk_size]}"
+
+        if response != "OK"
+          raise "Memory write failed: #{response}"
+        end
+
+        base += chunk_size / 2
+        offset += chunk_size
+      end
+    end
+
+    def read_memory(base, size)
+      max_size = (@features[:PacketSize].to_i - 19) & ~1
+      offset = 0
+      data = ""
+      size *= 2
+
+      while offset < size
+        chunk_size = [ max_size, size - offset ].min
+
+        response = command "m#{base.to_s 16},#{(chunk_size / 2).to_s 16}"
+
+        if response[0] == "E"
+          raise "Memory read failed: #{response}"
+        end
+
+        data += response
+
+        base += chunk_size / 2
+        offset += chunk_size
+      end
+
+      Array.new(data.length / 2) do |i|
+        data[i * 2..i * 2 + 1].to_i 16
+      end.pack("C*")
+    end
+
+    def insert_breakpoint(type, address, kind)
+      response = command "Z#{type.to_s 16},#{address.to_s 16},#{kind.to_s 16}"
+
+      if response != "OK"
+        raise "Breakpoint insertion failed: #{response}"
+      end
+    end
+
+    def remove_breakpoint(type, address, kind)
+      response = command "z#{type.to_s 16},#{address.to_s 16},#{kind.to_s 16}"
+
+      if response != "OK"
+        raise "Breakpoint removal failed: #{response}"
+      end
+    end
+
+    def continue
+      parse_stop_reply command("c")
+    end
+
+    def step
+      parse_stop_reply command("s")
+    end
+
+    def reset
+      reply = command "r"
+
+      if reply != "OK"
+        raise "Reset failed: #{reply}"
+      end
+    end
+
+    def get_stop_reply
+      parse_stop_reply command("?")
+    end
+
+    def write_register(reg, value)
+      reply = command sprintf("P%x=%08x", reg, big2native(value))
+
+      if reply != "OK"
+        raise "Register write failed: #{reply}"
+      end
+    end
+
+    protected
+
+    def parse_stop_reply(reply)
+      case reply[0]
+      when 'S'
+        StopReply.new reply[1..2].to_i(16)
+
+      when 'T'
+        pairs = reply[3..-1].split ';'
+        values = {}
+        pairs.each do |pair|
+          key, value = pair.split ':'
+
+          if key.match /^[0-9a-fA-F]+/
+            values[key.to_i 16] = value.to_i 16
+          else
+            values[key] = value
+          end
+        end
+
+        StopReply.new reply[1..2].to_i(16), values
+
+      else
+        raise "Unknown stop reply: #{reply}"
+      end
+    end
+
+    def read_xfer(object, annex)
+      offset = 0
+      size = @features[:PacketSize].to_i - 4
+      contents = ""
+
+      loop do
+        response = command "qXfer:#{object}:read:#{annex}:#{offset}:#{size}"
+
+        offset += response.length - 1
+        contents += response[1..-1]
+
+        if response[0] == 'l'
+          break
+        elsif response[0] != 'm'
+          raise "qXfer failed: #{response}"
+
+        end
+      end
+
+      contents
+    end
+
+    def command(s, extra = {})
+      send_packet s, extra
+
+      response = receive_packet
+    end
+
+    def send_packet(data, extra = {})
+      data = data.dup
+
+      if extra[:escape]
+        i = 0
+
+        while i < data.length
+          byte = data[i]
+
+          if byte == '$' || byte == '#' || byte == 0x7d.chr
+            data.insert i, 0x7d.chr
+
+            i += 1
+          end
+
+          i += 1
+        end
+      end
+
+      message = sprintf "$%s#%02x", data, data.sum(8)
+
+      if !@features[:PacketSize].nil? && @features[:PacketSize].to_i < message.length
+        raise "Internal error: message is too long"
+      end
+
+      @socket.write message
+
+      if @need_ack
+        loop do
+          ack = @socket.read 1
+
+          case ack
+          when '+'
+            break
+
+          when '-'
+            @socket.write message
+
+          else
+            raise "Unexpected response from server: #{ack}"
+          end
+        end
+      end
+    end
+
+    def receive_packet
+      loop do
+        @buf += @socket.readpartial 4096
+
+        if @buf[0] != '$'
+          raise "Invalid response from server"
+        end
+
+        idx = @buf.index '#'
+
+        if !idx.nil? && idx + 2 <= @buf.length
+          message = @buf.slice! 0..idx + 2
+
+          data = message[1..-4]
+
+          if @need_ack
+            checksum = data.sum 8
+            if checksum != message[-2..-1].to_i(16)
+              @socket.write '-'
+            else
+              @socket.write '+'
+
+              return data
+            end
+          else
+            return data
+          end
+        end
+      end
+    end
+
+    def native2big(v)
+      [ v ].pack("N").unpack("L")[0]
+    end
+
+    def big2native(v)
+      [ v ].pack("L").unpack("N")[0]
+    end
+  end
+end

data/lib/gdbflasher/version.rb

@@ -0,0 +1,3 @@
+module GdbFlasher
+  VERSION = "1.0.0"
+end

data/lib/gdbflasher.rb

@@ -0,0 +1,21 @@
+require "gdbflasher/version"
+require "gdbflasher/ihex"
+require "gdbflasher/server_connection"
+require "gdbflasher/mcu"
+require "gdbflasher/cortexm"
+require "gdbflasher/mcu/stm32f4xx"
+require "gdbflasher/mcu/stm32l1xx"
+require "gdbflasher/mcu/stm32f10xx_hd"
+require "gdbflasher/mcu/stm32f10xx_md"
+
+
+module GdbFlasher
+  MCU_CLASSES = {
+    stm32f4xx:     Stm32f4xx,
+    stm32l1xx:     Stm32l1xx,
+    stm32f10xx_hd: Stm32f10xxHD,
+    stm32f10xx_md: Stm32f10xxMD
+  }
+
+  HELPERS = File.join File.dirname(__FILE__), "..", "helpers"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: gdbflasher
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Sergey Gridasov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: gdbflasher is a gdbserver-compatible tool for loading firmware into ARM
+  MCUs.
+email:
+- grindars@gmail.com
+executables:
+- gdbflasher
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/gdbflasher
+- gdbflasher.gemspec
+- helper_sources/Makefile
+- helper_sources/stm32f10xx_hd.S
+- helper_sources/stm32f10xx_hd.lds
+- helper_sources/stm32f10xx_md.S
+- helper_sources/stm32f10xx_md.lds
+- helper_sources/stm32f4xx.S
+- helper_sources/stm32f4xx.lds
+- helper_sources/stm32l1xx.S
+- helper_sources/stm32l1xx.lds
+- helpers/stm32f10xx_hd.hex
+- helpers/stm32f10xx_hd.sym
+- helpers/stm32f10xx_md.hex
+- helpers/stm32f10xx_md.sym
+- helpers/stm32f4xx.hex
+- helpers/stm32f4xx.sym
+- helpers/stm32l1xx.hex
+- helpers/stm32l1xx.sym
+- lib/gdbflasher.rb
+- lib/gdbflasher/cortexm.rb
+- lib/gdbflasher/ihex.rb
+- lib/gdbflasher/mcu.rb
+- lib/gdbflasher/mcu/stm32f10xx_hd.rb
+- lib/gdbflasher/mcu/stm32f10xx_md.rb
+- lib/gdbflasher/mcu/stm32f4xx.rb
+- lib/gdbflasher/mcu/stm32l1xx.rb
+- lib/gdbflasher/server_connection.rb
+- lib/gdbflasher/version.rb
+homepage: https://github.com/grindars/gdbflasher
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Retargetable flasher for ARM microcontrollers
+test_files: []