[Piklab-svn] SF.net SVN: piklab:[2941] trunk/piklab_kde4

[<az...@us...>]

Revision: 2941
          http://piklab.svn.sourceforge.net/piklab/?rev=2941&view=rev
Author:   azhyd
Date:     2012-08-05 19:14:42 +0000 (Sun, 05 Aug 2012)
Log Message:
-----------
+ more work on pickit3 (almost there)
+ add udev rules file

Modified Paths:
--------------
    trunk/piklab_kde4/CMakeLists.txt
    trunk/piklab_kde4/src/devices/pic/prog/pic_prog.cpp
    trunk/piklab_kde4/src/devices/pic/prog/pic_prog_specific.cpp
    trunk/piklab_kde4/src/progs/pickit3/base/pickit3.cpp
    trunk/piklab_kde4/src/progs/pickit3/base/pickit3.h
    trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.cpp
    trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.h
    trunk/piklab_kde4/test/gputils/blinker/blinker.piklab
    trunk/piklab_kde4/test/gputils/blinker18/blinker_18.piklab

Added Paths:
-----------
    trunk/piklab_kde4/udev/
    trunk/piklab_kde4/udev/26-microchip.rules
    trunk/piklab_kde4/udev/CMakeLists.txt

Modified: trunk/piklab_kde4/CMakeLists.txt
===================================================================
--- trunk/piklab_kde4/CMakeLists.txt	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/CMakeLists.txt	2012-08-05 19:14:42 UTC (rev 2941)
@@ -30,5 +30,6 @@
 if(NOT WIN32)
   add_subdirectory(po)
   add_subdirectory(man)
+  add_subdirectory(udev)
   install(FILES README Changelog COPYING DESTINATION share/doc/piklab)
 endif(NOT WIN32)

Modified: trunk/piklab_kde4/src/devices/pic/prog/pic_prog.cpp
===================================================================
--- trunk/piklab_kde4/src/devices/pic/prog/pic_prog.cpp	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/src/devices/pic/prog/pic_prog.cpp	2012-08-05 19:14:42 UTC (rev 2941)
@@ -131,7 +131,7 @@
     _deviceMemory->setArray(Pic::MemoryRangeType::Config, data);
     _hasProtectedCode = _deviceMemory->isProtected(Pic::Protection::ProgramProtected, Pic::MemoryRangeType::Code);
     _hasProtectedEeprom = _deviceMemory->isProtected(Pic::Protection::ProgramProtected, Pic::MemoryRangeType::Eeprom);
-    log(Log::DebugLevel::Normal, QString("  protected: code=%1 data=%2")
+    log(Log::DebugLevel::Extra, QString("  protected: code=%1 data=%2")
                           .arg(_hasProtectedCode ? "true" : "false").arg(_hasProtectedEeprom ? "true" : "false"));
     // read calibration
     if ( !readCalibration() ) return false;
@@ -470,6 +470,7 @@
     }
     memory.setDebugOn(group().isDebugger());
   }
+
   if (memory.hasJTagOn()) {
     if (issueWarnings) log(Log::LineType::Warning, i18n("Disabling JTAGEN configuration bit."));
     memory.setJTagOn(false);

Modified: trunk/piklab_kde4/src/devices/pic/prog/pic_prog_specific.cpp
===================================================================
--- trunk/piklab_kde4/src/devices/pic/prog/pic_prog_specific.cpp	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/src/devices/pic/prog/pic_prog_specific.cpp	2012-08-05 19:14:42 UTC (rev 2941)
@@ -14,10 +14,10 @@
   uint start = 0;
   for (; start<data.count(); start++)
     if ( data[start]!=device().mask(type) ) break;
-  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Normal, QString("start before align: %1").arg(start));
+  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Extra, QString("start before align: %1").arg(start));
   uint align = device().nbWordsWriteAlignment(type);
   start -= start % align;
-  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Normal, QString("start after align: %1 (align=%2)").arg(start).arg(align));
+  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Extra, QString("start after align: %1 (align=%2)").arg(start).arg(align));
   return start;
 }
 
@@ -27,12 +27,12 @@
   uint end = data.count() - 1;
   for (; end>0; end--)
     if ( data[end]!=device().mask(type) ) break;
-  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Normal, QString("end before align: %1").arg(end));
+  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Extra, QString("end before align: %1").arg(end));
   uint align = device().nbWordsWriteAlignment(type);
   if ( (end+1) % align ) end += align - (end+1) % align;
   // this can happen when the last word is calibration...
   if (end >= data.count()) end = data.count() - 1;
-  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Normal, QString("end after align: %1 (align=%2)").arg(end).arg(align));
+  const_cast<PicSpecific *>(this)->log(Log::DebugLevel::Extra, QString("end after align: %1 (align=%2)").arg(end).arg(align));
   return end;
 }
 
@@ -43,7 +43,7 @@
   if ( wordOffset!=data.count() ) {
     uint end = (force || !(capabilities() & VariableSizeReadWrite) ? data.count()-1 : findNonMaskEnd(Pic::MemoryRangeType::Code, data));
     nbWords = end - wordOffset + 1;
-    log(Log::DebugLevel::Normal, QString("    start=%1 nbWords=%2 total=%3 force=%4 varOffset=%5 varSize=%6")
+    log(Log::DebugLevel::Extra, QString("    start=%1 nbWords=%2 total=%3 force=%4 varOffset=%5 varSize=%6")
       .arg(toHexLabel(wordOffset, device().nbCharsAddress()))
       .arg(toHexLabel(nbWords, device().nbCharsAddress()))
       .arg(toHexLabel(data.count(), device().nbCharsAddress()))
@@ -96,7 +96,7 @@
       && !(capabilities() & VariableOffsetReadWrite)) {
     qFatal("Variable-offset-read/write capability is needed for 18J and 24F families...");
   }
-  
+
   if (type == Pic::MemoryRangeType::Config
       && configInCodeArea) {
     const uint align = device().nbWordsWriteAlignment(Pic::MemoryRangeType::Code);

Modified: trunk/piklab_kde4/src/progs/pickit3/base/pickit3.cpp
===================================================================
--- trunk/piklab_kde4/src/progs/pickit3/base/pickit3.cpp	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/src/progs/pickit3/base/pickit3.cpp	2012-08-05 19:14:42 UTC (rev 2941)
@@ -14,10 +14,6 @@
 #include "progs/pickit3/base/pickit3_data.h"
 #include "devices/pic/pic/pic_group.h"
 
-using namespace std;
-
-#include <iostream>
-
 //-----------------------------------------------------------------------------
 const Pickit3::ProgRegion::Data Pickit3::ProgRegion::DATA[Nb_Types] = {
   { Pic::MemoryRangeType::Code,             0x01,  0x01  },
@@ -136,10 +132,10 @@
   }
 
   in.resize(size);
-  for (uint i = 0; i < 60 && i < size; ++i) in[i] = data[i+offset];
-  for (uint k = 60; k < size; k += 64) {
+  for (uint i = 0; i < 60-offset && i < size; ++i) in[i] = data[i+offset];
+  for (uint i = 60-offset; i < size; i += 64) {
     if (!port().receive(data)) return false;
-    for (uint i = 0; i < 64 && k+i < size; ++i) in[k+i] = data[i];
+    for (uint k = 0; k < 64 && i+k < size; ++k) in[i+k] = data[k];
   }
   return true;
 }
@@ -247,8 +243,6 @@
   return true;
 }
 
-#include <iostream>
-
 ByteArray Pickit3::Hardware::createConfigPacket() const
 {
   ByteArray data(334, 0x0, PrintEscapeAll);
@@ -436,21 +430,28 @@
 
 bool Pickit3::Hardware::connectToDevice(BitValue& deviceId)
 {
-  if (!setBracketStatus(true)) return false;
+  if (!beginBracket()) return false;
   ByteArray in;
   if (!commandWithComplexResponse(0x70, in)) return false;
   deviceId = in.getValue(0, 4);
-  return setBracketStatus(false);
+  return endBracket();
 }
 
-bool Pickit3::Hardware::setBracketStatus(bool on)
+bool Pickit3::Hardware::beginBracket()
 {
   ByteArray in;
   ByteArray out(2, 0x0, PrintEscapeAll);
-  out[0] = on ? 1 : 0;
+  out[0] = 0x01;
   return commandWithComplexResponse(0xA0, in, &out);
 }
 
+bool Pickit3::Hardware::endBracket()
+{
+  ByteArray in;
+  ByteArray out(2, 0x0, PrintEscapeAll);
+  return commandWithComplexResponse(0xA0, in, &out);
+}
+
 bool Pickit3::Hardware::getSysVoltages()
 {
   ByteArray in;
@@ -467,27 +468,58 @@
   return commandWithSimpleResponse(0x93, in, &out);
 }
 
-ByteArray Pickit3::Hardware::createOpDescriptor(Pic::MemoryRangeType type, uint offset, uint size) const
+ByteArray Pickit3::Hardware::createOpDescriptor(ProgOptions options) const
 {
   ByteArray data(0x42, 0x00, PrintEscapeAll);
   data.setValue(0x40, 0, 2);
+  data.setValue(uint(options), 6, 4);
+  return data;
+}
+
+void Pickit3::Hardware::addMemRangeToOpDescriptor(Pic::MemoryRangeType type, uint offset, uint size, ByteArray& data)
+{
   ProgRegion progRegion = getProgRegion(type);
-  data.setValue(progRegion.data().opType, 2, 4);
-  ProgOptions options = NoProgOption;
-  data.setValue(uint(options), 6, 4);
+  BitValue v = data.getValue(2, 4);
+  v |= progRegion.data().opType;
+  data.setValue(v, 2, 4);
   uint i = 10 + progRegion.type() * 8;
   data.setValue(offset, i, 4);
   data.setValue(offset + size - 1, i+4, 4);
-  return data;
 }
 
-bool Pickit3::Hardware::setOpDescriptor(Pic::MemoryRangeType type, uint offset, uint size)
+void Pickit3::Hardware::addMemRangeToOpDescriptor(Pic::MemoryRangeType type, ByteArray& data)
 {
-  ByteArray out = createOpDescriptor(type, offset, size);
+  uint size = device().nbWords(type) * device().nbBytesWord(type);
+  addMemRangeToOpDescriptor(type, 0, size, data);
+}
+
+bool Pickit3::Hardware::eraseRange(Pic::MemoryRangeType type)
+{
+  ProgOptions options = NoProgOption;
+  ByteArray out = createOpDescriptor(options);
+  addMemRangeToOpDescriptor(type, out);
   ByteArray in;
-  return commandWithSimpleResponse(0x50, in, &out);
+  if (!commandWithSimpleResponse(0x50, in, &out)) return false;
+  if (!beginBracket()) return false;
+  if (!commandWithComplexResponse(0x53, in)) return false;
+  return endBracket();
 }
 
+bool Pickit3::Hardware::eraseAll()
+{
+  ProgOptions options = NoProgOption;
+  ByteArray out = createOpDescriptor(options);
+  addMemRangeToOpDescriptor(Pic::MemoryRangeType::Code, out);
+  addMemRangeToOpDescriptor(Pic::MemoryRangeType::Eeprom, out);
+  addMemRangeToOpDescriptor(Pic::MemoryRangeType::UserId, out);
+  addMemRangeToOpDescriptor(Pic::MemoryRangeType::Config, out);
+  ByteArray in;
+  if (!commandWithSimpleResponse(0x50, in, &out)) return false;
+  if (!beginBracket()) return false;
+  if (!commandWithComplexResponse(0x53, in)) return false;
+  return endBracket();
+}
+
 bool Pickit3::Hardware::getMem(Pic::MemoryRangeType type, uint offset, uint size, ByteArray& in)
 {
   ByteArray out(0x0A, 0x00, PrintEscapeAll);
@@ -499,24 +531,70 @@
   return commandWithComplexResponse(0x61, in, &out);
 }
 
-bool Pickit3::Hardware::read(Pic::MemoryRangeType type, uint wordOffset, Device::Array& data)
+bool Pickit3::Hardware::read(Pic::MemoryRangeType type, uint wordOffset, Device::Array& data, const ::Programmer::VerifyData *vdata)
 {
   if (!setDebugOption()) return false;
-  if (!setBracketStatus(true)) return false;
+  if (!beginBracket()) return false;
   uint nbBytesWord = device().nbBytesWord(type);
   uint offset = wordOffset * nbBytesWord;
   uint nbBytes = data.size() * nbBytesWord;
   for (uint i = offset; i < nbBytes; i += 0x600) {
     uint size = std::min(uint(0x600), nbBytes - i);
-    if (!setOpDescriptor(type, i, size)) return false;
-    ByteArray dummy;
-    if (!commandWithComplexResponse(0x54, dummy)) return false;
+    ProgOptions options = NoProgOption;
+    ByteArray out = createOpDescriptor(options);
+    addMemRangeToOpDescriptor(type, i, size, out);
     ByteArray in;
+    if (!commandWithSimpleResponse(0x50, in, &out)) return false;
+    if (!commandWithComplexResponse(0x54, in)) return false;
     if (!getMem(type, i, size, in)) return false;
     for (uint k = 0; k < size; k += nbBytesWord) {
       uint index = (i + k) / nbBytesWord;
       data[index] = in.getValue(k, nbBytesWord);
+      if (vdata != NULL) {
+        if ( !verifyWord(index, data[index], type, *vdata) ) return false;
+      }
     }
+    if ( type==Pic::MemoryRangeType::Code || type==Pic::MemoryRangeType::Eeprom )
+      _base.progressMonitor().addTaskProgress(size / nbBytesWord);
   }
-  return setBracketStatus(false);
+  return endBracket();
 }
+
+bool Pickit3::Hardware::setMem(Pic::MemoryRangeType type, uint offset, const ByteArray& out)
+{
+  ByteArray in;
+  ByteArray data(0x0A, 0x00, PrintEscapeAll);
+  ProgRegion progRegion = getProgRegion(type);
+  data.setValue(progRegion.data().memType, 0, 2);
+  data.setValue(offset, 2, 4);
+  data.setValue(out.size(), 6, 4);
+  return commandWithSimpleResponse(0x60, in, &data) && sendBulk(out);
+}
+
+bool Pickit3::Hardware::write(Pic::MemoryRangeType type, uint wordOffset, const Device::Array &data)
+{
+  if (!setDebugOption()) return false;
+  if (!beginBracket()) return false;
+  uint nbBytesWord = device().nbBytesWord(type);
+  uint offset = wordOffset * nbBytesWord;
+  uint nbBytes = data.size() * nbBytesWord;
+  for (uint i = offset; i < nbBytes; i += 0x600) {
+    uint size = std::min(uint(0x600), nbBytes - i);
+    ProgOptions options = DoNotVerify;
+    ByteArray out = createOpDescriptor(options);
+    addMemRangeToOpDescriptor(type, i, size, out);
+    ByteArray in;
+    if (!commandWithSimpleResponse(0x50, in, &out)) return false;
+    out.resize(size);
+    for (uint k = 0; k < size; k += nbBytesWord) {
+      uint index = (i + k) / nbBytesWord;
+      out.setValue(data[index], k, nbBytesWord);
+    }
+    if (!setMem(type, i, out)) return false;
+    if ( type==Pic::MemoryRangeType::Code || type==Pic::MemoryRangeType::Eeprom )
+      _base.progressMonitor().addTaskProgress(size / nbBytesWord);
+    ByteArray dummy;
+    if (!commandWithComplexResponse(0x51, dummy)) return false;
+  }
+  return endBracket();
+}

Modified: trunk/piklab_kde4/src/progs/pickit3/base/pickit3.h
===================================================================
--- trunk/piklab_kde4/src/progs/pickit3/base/pickit3.h	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/src/progs/pickit3/base/pickit3.h	2012-08-05 19:14:42 UTC (rev 2941)
@@ -198,9 +198,11 @@
   Hardware(::Programmer::Base &base);
 
   bool setPower(PowerOptions, uint vdd); // mV
-  bool setBracketStatus(bool on);
   bool connectToDevice(BitValue& deviceId);
-  bool read(Pic::MemoryRangeType type, uint wordOffset, Device::Array& in);
+  bool eraseRange(Pic::MemoryRangeType type);
+  bool eraseAll();
+  bool read(Pic::MemoryRangeType type, uint wordOffset, Device::Array& in, const ::Programmer::VerifyData *vdata);
+  bool write(Pic::MemoryRangeType type, uint wordOffset, const Device::Array& data);
 
 private:
   virtual bool internalConnectHardware();
@@ -213,10 +215,14 @@
   bool getSysVoltages();
   ByteArray createConfigPacket() const;
   bool sendConfigPacket();
+  bool beginBracket();
+  bool endBracket();
   bool setDebugOption();
-  ByteArray createOpDescriptor(Pic::MemoryRangeType type, uint offset, uint size) const;
-  bool setOpDescriptor(Pic::MemoryRangeType type, uint offset, uint size);
+  ByteArray createOpDescriptor(ProgOptions options) const;
+  void addMemRangeToOpDescriptor(Pic::MemoryRangeType type, uint offset, uint size, ByteArray& data);
+  void addMemRangeToOpDescriptor(Pic::MemoryRangeType type, ByteArray& data);
   bool getMem(Pic::MemoryRangeType type, uint offset, uint size, ByteArray& in);
+  bool setMem(Pic::MemoryRangeType type, uint offset, const ByteArray& out);
 
   bool command(uchar cmd, const ByteArray* out = NULL);
   bool commandWithSimpleResponse(uchar cmd, ByteArray& in, const ByteArray* out = NULL);

Modified: trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.cpp
===================================================================
--- trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.cpp	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.cpp	2012-08-05 19:14:42 UTC (rev 2941)
@@ -39,15 +39,24 @@
   return hardware().setPower(options, vdd * 1000);
 }
 
+bool Pickit3::DeviceSpecific::doEraseRange(Pic::MemoryRangeType type)
+{
+  return hardware().eraseRange(type);
+}
+
+bool Pickit3::DeviceSpecific::doErase(bool)
+{
+  return hardware().eraseAll();
+}
+
 bool Pickit3::DeviceSpecific::doRead(Pic::MemoryRangeType type, uint wordOffset, Device::Array &data, const ::Programmer::VerifyData *vdata)
 {
-  if (vdata != NULL) return false;
-  else return hardware().read(type, wordOffset, data);
+  return hardware().read(type, wordOffset, data, vdata);
 }
 
-bool Pickit3::DeviceSpecific::doWrite(Pic::MemoryRangeType type, uint wordOffset, const Device::Array &data, bool force)
+bool Pickit3::DeviceSpecific::doWrite(Pic::MemoryRangeType type, uint wordOffset, const Device::Array &data, bool)
 {
-  return false;
+  return hardware().write(type, wordOffset, data);
 }
 
 //-----------------------------------------------------------------------------

Modified: trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.h
===================================================================
--- trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.h	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/src/progs/pickit3/base/pickit3_prog.h	2012-08-05 19:14:42 UTC (rev 2941)
@@ -44,8 +44,8 @@
   virtual bool setPowerOn();
   virtual bool setPowerOff();
   virtual bool setTargetPowerOn(bool on);
-  virtual bool doEraseRange(Pic::MemoryRangeType) { return false; }
-  virtual bool doErase(bool) { return false; }
+  virtual bool doEraseRange(Pic::MemoryRangeType type);
+  virtual bool doErase(bool);
   virtual bool doRead(Pic::MemoryRangeType type, uint wordOffset, Device::Array &data, const ::Programmer::VerifyData *vdata);
   virtual bool doWrite(Pic::MemoryRangeType type, uint wordOffset, const Device::Array &data, bool force);
 };
@@ -56,9 +56,9 @@
 public:
   virtual QString name() const { return "pickit3"; }
   virtual QString label() const { return i18n("Pickit3"); }
-  virtual ::Programmer::Properties properties() const { return ::Programmer::Programmer | ::Programmer::CanReadMemory | ::Programmer::HasConnectedState; }
+  virtual ::Programmer::Properties properties() const { return ::Programmer::Programmer | ::Programmer::CanReadMemory | ::Programmer::HasConnectedState | ::Programmer::CanReleaseReset; }
   virtual ::Programmer::TargetPowerMode targetPowerMode() const { return ::Programmer::TargetExternallyPowered; }
-  virtual bool isPortSupported(PortType type) const { return ( type==PortType::HID ); }
+  virtual bool isPortSupported(PortType type) const { return type == PortType::USB; }
   virtual bool canReadVoltage(Device::VoltageType) const { return false; }
 
 protected:

Modified: trunk/piklab_kde4/test/gputils/blinker/blinker.piklab
===================================================================
--- trunk/piklab_kde4/test/gputils/blinker/blinker.piklab	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/test/gputils/blinker/blinker.piklab	2012-08-05 19:14:42 UTC (rev 2941)
@@ -12,9 +12,9 @@
     <is_library>true</is_library>
     <output_type>executable</output_type>
     <programmer>gpsim</programmer>
-    <watched_registers>
-      <item>112 2 </item>
-    </watched_registers>
+    <opened_files>
+      <item>blinker.asm</item>
+    </opened_files>
   </general>
   <assembler>
     <warning_level>0</warning_level>

Modified: trunk/piklab_kde4/test/gputils/blinker18/blinker_18.piklab
===================================================================
--- trunk/piklab_kde4/test/gputils/blinker18/blinker_18.piklab	2012-08-04 23:26:53 UTC (rev 2940)
+++ trunk/piklab_kde4/test/gputils/blinker18/blinker_18.piklab	2012-08-05 19:14:42 UTC (rev 2941)
@@ -12,9 +12,6 @@
     <version>0.1</version>
     <tool>gputils</tool>
     <programmer>icd2</programmer>
-    <opened_files>
-      <item>blinker_18.asm</item>
-    </opened_files>
     <watched_registers>
       <item>4034 2 </item>
     </watched_registers>

Added: trunk/piklab_kde4/udev/26-microchip.rules
===================================================================
--- trunk/piklab_kde4/udev/26-microchip.rules	                        (rev 0)
+++ trunk/piklab_kde4/udev/26-microchip.rules	2012-08-05 19:14:42 UTC (rev 2941)
@@ -0,0 +1,10 @@
+#Pickit
+ATTR{idVendor}=="04d8", ATTR{idProduct}=="0032", MODE="0660", GROUP="microchip"
+#Pickit2
+ATTR{idVendor}=="04d8", ATTR{idProduct}=="0033", MODE="0660", GROUP="microchip"
+#Pickit3
+ATTR{idVendor}=="04d8", ATTR{idProduct}=="900a", MODE="0660", GROUP="microchip"
+#ICD2
+ATTR{idVendor}=="04d8", ATTR{idProduct}=="8000", MODE="0660", GROUP="microchip"
+#ICD21
+ATTR{idVendor}=="04d8", ATTR{idProduct}=="8001", MODE="0660", GROUP="microchip"

Added: trunk/piklab_kde4/udev/CMakeLists.txt
===================================================================
--- trunk/piklab_kde4/udev/CMakeLists.txt	                        (rev 0)
+++ trunk/piklab_kde4/udev/CMakeLists.txt	2012-08-05 19:14:42 UTC (rev 2941)
@@ -0,0 +1,4 @@
+
+if(EXISTS /lib/udev/rules.d/)
+  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/26-microchip.rules DESTINATION /lib/udev/rules.d/)
+endif(EXISTS /lib/udev/rules.d/)

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.