Merge pull request #447 from NordicSemiconductor/feature/new-secure-dfu-op-codes

philips77 · web-flow · commit af8f87aa68c5 · 2021-07-30T12:10:34.000+02:00
New Secure DFU op codes, including Abort
diff --git a/iOSDFULibrary/Classes/Implementation/GenericDFU/DFUPeripheral.swift b/iOSDFULibrary/Classes/Implementation/GenericDFU/DFUPeripheral.swift
@@ -200,6 +200,14 @@ internal class BaseDFUPeripheral<TD : BasePeripheralDelegate> : NSObject, BaseDF
         delegate = nil
     }
     
+    func resetDevice() {
+        if let peripheral = peripheral, peripheral.state != .disconnected {
+            disconnect()
+        } else {
+            peripheralDidDisconnect()
+        }
+    }
+    
     // MARK: - DFU Controller API
     
     func pause() -> Bool {
@@ -405,17 +413,6 @@ internal class BaseDFUPeripheral<TD : BasePeripheralDelegate> : NSObject, BaseDF
         delegate?.peripheralDidDisconnect()
     }
     
-    /**
-     This method should reset the device, preferably switching it to application mode.
-     */
-    func resetDevice() {
-        if let peripheral = peripheral, peripheral.state != .disconnected {
-            disconnect()
-        } else {
-            peripheralDidDisconnect()
-        }
-    }
-    
     // MARK: - Private methods
     
     /**
diff --git a/iOSDFULibrary/Classes/Implementation/LegacyDFU/Services/LegacyDFUService.swift b/iOSDFULibrary/Classes/Implementation/LegacyDFU/Services/LegacyDFUService.swift
@@ -48,7 +48,6 @@ import CoreBluetooth
     private var dfuControlPointCharacteristic : DFUControlPoint?
     private var dfuVersionCharacteristic      : DFUVersion?
     
-
     /// This method returns true if DFU Control Point characteristc has been discovered.
     /// A device without this characteristic is not supported and even can't be resetted
     /// by sending a Reset command.
diff --git a/iOSDFULibrary/Classes/Implementation/SecureDFU/Characteristics/SecureDFUControlPoint.swift b/iOSDFULibrary/Classes/Implementation/SecureDFU/Characteristics/SecureDFUControlPoint.swift
@@ -31,11 +31,19 @@
 import CoreBluetooth
 
 internal enum SecureDFUOpCode : UInt8 {
+    case getProtocolVersion   = 0x0  // not supported by this library
     case createObject         = 0x01
     case setPRNValue          = 0x02
     case calculateChecksum    = 0x03
     case execute              = 0x04
+ // case no-such-op-code      = 0x05
     case readObjectInfo       = 0x06
+    case getMtu               = 0x07 // not supported by this library
+    case write                = 0x08 // not supported by this library
+    case ping                 = 0x09 // not supported by this library
+    case getHwVersion         = 0x0A // not supported by this library
+    case getFwVersion         = 0x0B // not supported by this library
+    case abort                = 0x0C
     case responseCode         = 0x60
 
     var code: UInt8 {
@@ -98,17 +106,40 @@ internal enum SecureDFUProcedureType : UInt8 {
     }
 }
 
+internal enum SecureDFUImageType : UInt8 {
+    case softdevice  = 0x00
+    case application = 0x01
+    case bootloader  = 0x02
+    
+    var description: String{
+        switch self{
+            case .softdevice:  return "Soft Device"
+            case .application: return "Application"
+            case .bootloader:  return "Bootloader"
+        }
+    }
+}
+
 internal enum SecureDFURequest {
-    case createCommandObject(withSize : UInt32)
-    case createDataObject(withSize : UInt32)
+    case getProtocolVersion
+    case createCommandObject(withSize: UInt32)
+    case createDataObject(withSize: UInt32)
     case readCommandObjectInfo
     case readDataObjectInfo
-    case setPacketReceiptNotification(value : UInt16)
+    case setPacketReceiptNotification(value: UInt16)
     case calculateChecksumCommand
     case executeCommand
+    case getMtu
+    case write(bytes: Data)
+    case ping(id: UInt8)
+    case getHwVersion
+    case getFwVersion(image: SecureDFUImageType)
+    case abort
 
     var data : Data {
         switch self {
+        case .getProtocolVersion:
+            return Data([SecureDFUOpCode.getProtocolVersion.code])
         case .createDataObject(let aSize):
             var data = Data([SecureDFUOpCode.createObject.code, SecureDFUProcedureType.data.rawValue])
             data += aSize.littleEndian
@@ -117,10 +148,6 @@ internal enum SecureDFURequest {
             var data = Data([SecureDFUOpCode.createObject.code, SecureDFUProcedureType.command.rawValue])
             data += aSize.littleEndian
             return data
-        case .readCommandObjectInfo:
-            return Data([SecureDFUOpCode.readObjectInfo.code, SecureDFUProcedureType.command.rawValue])
-        case .readDataObjectInfo:
-            return Data([SecureDFUOpCode.readObjectInfo.code, SecureDFUProcedureType.data.rawValue])
         case .setPacketReceiptNotification(let aSize):
             var data = Data([SecureDFUOpCode.setPRNValue.code])
             data += aSize.littleEndian
@@ -129,19 +156,45 @@ internal enum SecureDFURequest {
             return Data([SecureDFUOpCode.calculateChecksum.code])
         case .executeCommand:
             return Data([SecureDFUOpCode.execute.code])
+        case .readCommandObjectInfo:
+            return Data([SecureDFUOpCode.readObjectInfo.code, SecureDFUProcedureType.command.rawValue])
+        case .readDataObjectInfo:
+            return Data([SecureDFUOpCode.readObjectInfo.code, SecureDFUProcedureType.data.rawValue])
+        case .getMtu:
+            return Data([SecureDFUOpCode.getMtu.code])
+        case .write(let bytes):
+            var data = Data([SecureDFUOpCode.write.code])
+            data += bytes
+            data += UInt16(bytes.count).littleEndian
+            return data
+        case .ping(let id):
+            return Data([SecureDFUOpCode.ping.code, id])
+        case .getHwVersion:
+            return Data([SecureDFUOpCode.getHwVersion.code])
+        case .getFwVersion(let image):
+            return Data([SecureDFUOpCode.getFwVersion.code, image.rawValue])
+        case .abort:
+            return Data([SecureDFUOpCode.abort.code])
         }
     }
 
     var description : String {
         switch self {
+        case .getProtocolVersion:            return "Get Protocol Version (Op Code = 0)"
         case .createCommandObject(let size): return "Create Command Object (Op Code = 1, Type = 1, Size: \(size)b)"
         case .createDataObject(let size):    return "Create Data Object (Op Code = 1, Type = 2, Size: \(size)b)"
-        case .readCommandObjectInfo:         return "Read Command Object Info (Op Code = 6, Type = 1)"
-        case .readDataObjectInfo:            return "Read Data Object Info (Op Code = 6, Type = 2)"
         case .setPacketReceiptNotification(let number):
                                              return "Packet Receipt Notif Req (Op Code = 2, Value = \(number))"
         case .calculateChecksumCommand:      return "Calculate Checksum (Op Code = 3)"
         case .executeCommand:                return "Execute Object (Op Code = 4)"
+        case .readCommandObjectInfo:         return "Read Command Object Info (Op Code = 6, Type = 1)"
+        case .readDataObjectInfo:            return "Read Data Object Info (Op Code = 6, Type = 2)"
+        case .getMtu:                        return "Get MTU (Op Code = 7)"
+        case .write(let bytes):              return "Write (Op Code = 8, Data = 0x\(bytes.hexString), Length = \(bytes.count))"
+        case .ping(let id):                  return "Ping (Op Code = 9, ID = \(id))"
+        case .getHwVersion:                  return "Get HW Version (Op Code = 10)"
+        case .getFwVersion(let image):       return "Get FW Version (Op Code = 11, Type = \(image.rawValue))"
+        case .abort:                         return "Abort (Op Code = 12)"
         }
     }
 }
@@ -155,7 +208,7 @@ internal enum SecureDFUResultCode : UInt8 {
     case invalidObject         = 0x05
     case signatureMismatch     = 0x06
     case unsupportedType       = 0x07
-    case operationNotpermitted = 0x08
+    case operationNotPermitted = 0x08
     case operationFailed       = 0x0A
     case extendedError         = 0x0B
     
@@ -176,7 +229,7 @@ internal enum SecureDFUResultCode : UInt8 {
             case .insufficientResources: return "Insufficient resources"
             case .invalidObject:         return "Invalid object"
             case .signatureMismatch:     return "Signature mismatch"
-            case .operationNotpermitted: return "Operation not permitted"
+            case .operationNotPermitted: return "Operation not permitted"
             case .unsupportedType:       return "Unsupported type"
             case .operationFailed:       return "Operation failed"
             case .extendedError:         return "Extended error"
diff --git a/iOSDFULibrary/Classes/Implementation/SecureDFU/Peripheral/SecureDFUPeripheral.swift b/iOSDFULibrary/Classes/Implementation/SecureDFU/Peripheral/SecureDFUPeripheral.swift
@@ -329,4 +329,12 @@ internal class SecureDFUPeripheral : BaseCommonDFUPeripheral<SecureDFUExecutor,
             }
         )
     }
+    
+    override func resetDevice() {
+        guard let dfuService = dfuService, dfuService.supportsReset() else {
+            super.resetDevice()
+            return
+        }
+        dfuService.sendReset(onError: defaultErrorCallback)
+    }
 }
diff --git a/iOSDFULibrary/Classes/Implementation/SecureDFU/Services/SecureDFUService.swift b/iOSDFULibrary/Classes/Implementation/SecureDFU/Services/SecureDFUService.swift
@@ -47,6 +47,17 @@ import CoreBluetooth
     private let service                       : CBService
     private var dfuPacketCharacteristic       : SecureDFUPacket?
     private var dfuControlPointCharacteristic : SecureDFUControlPoint?
+    
+    /// This method returns true if DFU Control Point characteristc has been discovered.
+    /// A device without this characteristic is not supported and even can't be resetted
+    /// by sending a Reset command.
+    internal func supportsReset() -> Bool {
+        // The Abort (0x0C) command has been added to DFU bootloader in SDK 15.
+        // https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v15.0.0/lib_dfu_transport.html?cp=8_5_3_3_5_2
+        // For earlier SDKs there is no way to reset the bootloader other than
+        // disconnecting and waiting for it to time out after few minutes.
+        return dfuControlPointCharacteristic != nil
+    }
 
     private var paused  = false
     private var aborted = false
@@ -55,7 +66,7 @@ import CoreBluetooth
     private var success          : Callback?
     /// A temporary callback used to report an operation error.
     private var report           : ErrorCallback?
-    /// A temporaty callback used to report progress status.
+    /// A temporary callback used to report progress status.
     private var progressDelegate : DFUProgressDelegate?
     private var progressQueue    : DispatchQueue?
     
@@ -323,10 +334,19 @@ import CoreBluetooth
      
      - parameter report: A callback called when writing characteristic failed.
      */
-    private func sendReset(onError report: @escaping ErrorCallback) {
+    func sendReset(onError report: @escaping ErrorCallback) {
         aborted = true
-        // There is no command to reset a Secure DFU device. We can just disconnect.
-        targetPeripheral?.disconnect()
+        // Upon sending the Abort request the device will immediately reboot in application
+        // mode. There will be no notification with status success returned.
+        dfuControlPointCharacteristic?.send(.abort,
+            onSuccess: nil, // Device will disconnected immediately.
+            onError: { [weak self] _, _ in
+                // Seems like the Abort request is not supported (indicating SDK 12-14).
+                // We can just disconnect. The bootloader should reset to app mode after
+                // a timeout.
+                self?.targetPeripheral?.disconnect()
+            }
+        )
     }
     
     //MARK: - Packet commands

Original file line number	Diff line number	Diff line change
`@@ -329,4 +329,12 @@ internal class SecureDFUPeripheral : BaseCommonDFUPeripheral<SecureDFUExecutor,`
`329`	`329`	`}`
`330`	`330`	`)`
`331`	`331`	`}`
	`332`	`+`
	`333`	`+ override func resetDevice() {`
	`334`	`+ guard let dfuService = dfuService, dfuService.supportsReset() else {`
	`335`	`+ super.resetDevice()`
	`336`	`+ return`
	`337`	`+ }`
	`338`	`+ dfuService.sendReset(onError: defaultErrorCallback)`
	`339`	`+ }`
`332`	`340`	`}`