Initial commit (v0.1)

Author: static-void

Makefile

@@ -0,0 +1,14 @@
+rtd_prog: main.cpp crc.o gff.o i2c.o
+	${CXX} ${CPPFLAGS} ${CXXFLAGS} ${LDFLAGS} crc.o gff.o i2c.o main.cpp -o rtd_prog
+
+crc.o: crc.cpp crc.h
+	${CXX} ${CPPFLAGS} ${CXXFLAGS} -c -o crc.o crc.cpp
+
+gff.o: gff.cpp gff.h
+	${CXX} ${CPPFLAGS} ${CXXFLAGS} -c -o gff.o gff.cpp
+
+i2c.o: i2clinux.cpp i2c.h
+	${CXX} ${CPPFLAGS} ${CXXFLAGS} -c -o i2c.o i2clinux.cpp
+
+clean:
+	rm -f *.o rtd_prog

README.md

@@ -1,2 +1,35 @@
 # rtd266x_programmer
 Programmer for RTD266X using linux and i2c-dev
+
+This allows you to program these devices just using a VGA cable plugged in to your graphics card (it uses the I2C from the DDC pins).
+
+This is based on the code here https://github.com/ghent360/RTD-2660-Programmer that uses an external USB I2C interface and MS windows.
+
+Using it
+--------
+
+Make sure to "modprobe i2c-dev"
+
+Then run "i2cdetect -l". I get the following output:
+
+i2c-0	i2c       	i915 gmbus ssc                  	I2C adapter
+i2c-1	i2c       	i915 gmbus vga                  	I2C adapter
+i2c-2	i2c       	i915 gmbus panel                	I2C adapter
+i2c-3	i2c       	i915 gmbus dpc                  	I2C adapter
+i2c-4	i2c       	i915 gmbus dpb                  	I2C adapter
+i2c-5	i2c       	i915 gmbus dpd                  	I2C adapter
+i2c-6	i2c       	DPDDC-B                         	I2C adapter
+i2c-7	i2c       	DPDDC-C                         	I2C adapter
+i2c-8	i2c       	DPDDC-D                         	I2C adapter
+
+Clearly i2c-1 is the i2c bus connected to the VGA DDC pins. Now I can plug a VGA cable between my laptop and the RTD2660 board and run "rtd_prog -d 1 -b backup.bin" to backup my firmware.
+
+Usage: rtd_prog -d <device #> [-option[s]]
+Options:
+  -d <device #> : Specify the i2c bus to use, e.g. -d 1 means /dev/i2c-1
+  -b <file>     : Backup the current firmware on the RTD266X to a file
+  -f <file>     : Flash a file to the RTD266X
+
+Building
+--------
+No special requirements. On ubuntu I needed to "sudo apt-get install i2c-tools libi2c-dev" and that's it. Then just run "make"

crc.cpp

@@ -0,0 +1,24 @@
+#include "crc.h"
+
+static unsigned gCrc = 0;
+
+void InitCRC() {
+  gCrc = 0;
+}
+
+void ProcessCRC(const uint8_t *data, int len)
+{
+	int i, j;
+	for (j = len; j; j--, data++) {
+		gCrc ^= (*data << 8);
+		for(i = 8; i; i--) {
+			if (gCrc & 0x8000)
+				gCrc ^= (0x1070 << 3);
+			gCrc <<= 1;
+		}
+	}
+}
+
+uint8_t GetCRC() {
+	return (uint8_t)(gCrc >> 8);
+}

crc.h

@@ -0,0 +1,11 @@
+#ifndef __CRC_H__
+#define __CRC_H__
+
+#include <stdint.h>
+
+void InitCRC();
+void ProcessCRC(const uint8_t *data, int len);
+uint8_t GetCRC();
+
+#endif /* __CRC_H__ */
+

gff.cpp

@@ -0,0 +1,130 @@
+#include "gff.h"
+
+class CBitStream {
+public:
+  CBitStream(uint8_t* data_ptr, uint32_t data_len)
+    : mask_(0x80),
+      data_ptr_(data_ptr),
+      data_len_(data_len) {}
+
+  bool HasData() const { return mask_ != 0 || data_len_ != 0; }
+  uint32_t DataSize() const { return data_len_; }
+  bool ReadBit() {
+    if (!mask_) {
+      NextMask();
+    }
+    bool result = (*data_ptr_ & mask_) != 0;
+    mask_ >>= 1;
+    return result;
+  }
+
+private:
+  void NextMask() {
+    if (data_len_) {
+      mask_ = 0x80;
+      data_ptr_++;
+      data_len_--;
+    }
+  }
+
+  uint8_t  mask_;
+  uint8_t* data_ptr_;
+  uint32_t data_len_;
+};
+
+static uint8_t gff_decode_nibble(CBitStream* bit_stream) {
+  uint8_t zero_cnt = 0;
+  bool bit;
+
+  do {
+    if (!bit_stream->HasData()) return 0xf0;
+
+    bit = bit_stream->ReadBit();
+    if (bit) break;
+    zero_cnt++;
+  } while (zero_cnt < 6);
+
+  if (zero_cnt > 5) {
+    if (bit_stream->DataSize() == 1) {
+      return 0xf0;
+    }
+    return 0xff;
+  }
+
+  switch (zero_cnt) {
+  case 0:
+    return 0;
+
+  case 1:
+    bit = bit_stream->ReadBit();
+    return (bit) ? 0xf : 1;
+
+  case 2:
+    bit = bit_stream->ReadBit();
+    return (bit) ? 8 : 2;
+
+  case 3:
+    bit = bit_stream->ReadBit();
+    return (bit) ? 7 : 0xc;
+
+  case 4:
+    bit = bit_stream->ReadBit();
+    if (bit) {
+      bit = bit_stream->ReadBit();
+      return (bit) ? 9 : 4;
+    } else {
+      bit = bit_stream->ReadBit();
+      if (bit) {
+        bit = bit_stream->ReadBit();
+        return (bit) ? 5 : 0xa;
+      } else {
+        bit = bit_stream->ReadBit();
+        return (bit) ? 0xb : 3;
+      }
+    }
+    break;
+
+  case 5:
+    bit = bit_stream->ReadBit();
+    if (bit) {
+      bit = bit_stream->ReadBit();
+      return (bit) ? 0xd : 0xe;
+    } else {
+      bit = bit_stream->ReadBit();
+      return (bit) ? 6 : 0xff;
+    }
+    break;
+  }
+  return 0xff;
+}
+
+uint32_t ComputeGffDecodedSize(uint8_t* data_ptr, uint32_t data_len) {
+  CBitStream bs(data_ptr, data_len);
+  uint32_t cnt = 0;
+  while (bs.HasData()) {
+    uint8_t b = gff_decode_nibble(&bs);
+    if (b == 0xff) return 0;
+    if (b == 0xf0) return cnt;  // End of file
+
+    b = gff_decode_nibble(&bs);
+    if (b > 0xf) return 0;  // Error or odd number of nibbles
+    cnt++;
+  }
+  return cnt;
+}
+
+bool DecodeGff(uint8_t* data_ptr, uint32_t data_len, uint8_t* dest) {
+  CBitStream bs(data_ptr, data_len);
+  while (bs.HasData()) {
+    uint8_t n1 = gff_decode_nibble(&bs);
+    if (n1 == 0xf0) return true;  // End of file
+    if (n1 == 0xff) return false;
+
+    uint8_t n2 = gff_decode_nibble(&bs);
+    if (n2 > 0xf) return false;
+
+    uint8_t byte = (n1 << 4) | n2;
+    *dest++ = byte;
+  }
+  return true;
+}

gff.h

@@ -0,0 +1,10 @@
+#ifndef __GFF_H__
+#define __GFF_H__
+
+#include <stdint.h>
+
+uint32_t ComputeGffDecodedSize(uint8_t* data_ptr, uint32_t data_len);
+bool DecodeGff(uint8_t* data_ptr, uint32_t data_len, uint8_t* dest);
+
+#endif /* __GFF_H__ */
+

i2c.h

@@ -0,0 +1,17 @@
+#ifndef __I2C_H__
+#define __I2C_H__
+
+#include <stdint.h>
+
+bool InitI2C(int adapter_nr);
+bool CloseI2C();
+
+bool SetI2CAddr(uint8_t addr);
+
+bool WriteReg(uint8_t reg, uint8_t value);
+uint8_t ReadReg(uint8_t reg);
+int32_t ReadBytesFromAddr(uint8_t reg, uint8_t* dest, uint8_t len);
+bool WriteBytesToAddr(uint8_t reg, uint8_t* values, uint8_t len);
+
+#endif /* __I2C_H__ */
+

i2clinux.cpp

@@ -0,0 +1,83 @@
+#include "i2c.h"
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+extern "C"
+{
+  #include <linux/i2c-dev.h>
+}
+
+static int file;
+static char filename[20];
+
+bool
+InitI2C(int adapter_nr) {
+  snprintf(filename, 19, "/dev/i2c-%d", adapter_nr);
+  file = open(filename, O_RDWR);
+  if (file < 0) {
+    /* ERROR HANDLING; you can check errno to see what went wrong */
+    fprintf(stderr, "Error: could not open %s\n", filename);
+    return false;
+  }
+  return true;
+}
+
+bool
+CloseI2C() {
+  if (close(file) < 0) {
+    fprintf(stderr, "Error: could not close %s\n", filename);
+    return false;
+  }
+  return true;
+}
+
+bool
+SetI2CAddr(uint8_t addr) {
+  if (ioctl(file, I2C_SLAVE, addr) < 0) {
+    /* ERROR HANDLING; you can check errno to see what went wrong */
+    fprintf(stderr, "Error: could not set slave address to %x\n", addr);
+    return false;
+  }
+  return true;
+}
+
+bool
+WriteReg(uint8_t reg, uint8_t value) {
+  if (i2c_smbus_write_byte_data(file, reg, value) < 0) {
+    fprintf(stderr, "Error: could not write to register %d\n", reg);
+    return false;
+  }
+  return true;
+}
+
+uint8_t
+ReadReg(uint8_t reg) {
+  int32_t result;
+  if ((result = i2c_smbus_read_byte_data(file, reg)) == -1)
+    fprintf(stderr, "Error: could not read from register %d\n", reg);
+
+  return (uint8_t)result;
+}
+
+int32_t
+ReadBytesFromAddr(uint8_t reg, uint8_t* dest, uint8_t len) {
+  int read;
+  //if ((*len = i2c_smbus_read_block_data(file, reg, dest)) == -1) {
+  if ((read = i2c_smbus_read_i2c_block_data(file, reg, len, dest)) == -1) {
+    fprintf(stderr, "Error: could not read block from register %d\n", reg);
+    return -1;
+  }
+  return read;
+}
+
+bool
+WriteBytesToAddr(uint8_t reg, uint8_t* values, uint8_t len) {
+  //if (i2c_smbus_write_block_data(file, reg, len, values) < 0) {
+  if (i2c_smbus_write_i2c_block_data(file, reg, len, values) < 0) {
+    fprintf(stderr, "Error: could not write block data to register %d\n", reg);
+    return false;
+  }
+  return true;
+}
+