Fix ICode SLI/SLIX/SLIX2 detection using UID type indicator bits

Previously all NXP ICode tags were detected as "ICode SLIX". Now properly
differentiates between SLI, SLIX, and SLIX2 by checking bits 36 and 37 in
UID4 per NXP datasheet (SL2S2602):

- Bits (0,0) -> ICode SLI (112 bytes)
- Bits (1,0) -> ICode SLIX (896 bytes)
- Bits (0,1) -> ICode SLIX2 (320 bytes)

This fixes an issue where SLIX2 tags (like Prusa OpenPrintTag) were
incorrectly reported as SLIX.

Author: AlbertMN

internal/core/card.go

@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"strconv"
 	"sync"
 	"time"
 
@@ -426,10 +427,38 @@ func detectCardType(card *scard.Card, cardInfo *Card) {
 			// 0xE0 = NXP (ICode SLI/Slix/Slix-2)
 			uid := cardInfo.UID
 			if len(uid) >= 16 && uid[14:16] == "e0" {
-				// NXP ICode family (SLI, Slix, Slix2)
-				cardInfo.Type = "ICode SLIX"
+				// NXP ICode family - differentiate SLI/SLIX/SLIX2 using type indicator bits
+				// Per NXP datasheet (SL2S2602), UID4 (hex position 8-9) contains bits 40:33
+				// Bits 37 and 36 indicate the ICODE type:
+				//   Bit 37=0, Bit 36=0: ICODE SLI
+				//   Bit 37=1, Bit 36=0: ICODE SLIX
+				//   Bit 37=0, Bit 36=1: ICODE SLIX2
+				//   Bit 37=1, Bit 36=1: RFU
 				cardInfo.Writable = true
-				cardInfo.Size = 896 // ICode SLIX2 has 2560 bits = 320 bytes, SLIX has 896 bytes
+				if len(uid) >= 10 {
+					uid4Byte, err := strconv.ParseUint(uid[8:10], 16, 8)
+					if err == nil {
+						bit37 := (uid4Byte >> 4) & 1 // bit 4 of the byte
+						bit36 := (uid4Byte >> 3) & 1 // bit 3 of the byte
+						switch {
+						case bit37 == 0 && bit36 == 1:
+							cardInfo.Type = "ICode SLIX2"
+							cardInfo.Size = 320 // SLIX2 has 2560 bits = 320 bytes
+							return
+						case bit37 == 1 && bit36 == 0:
+							cardInfo.Type = "ICode SLIX"
+							cardInfo.Size = 896 // SLIX has 896 bytes
+							return
+						case bit37 == 0 && bit36 == 0:
+							cardInfo.Type = "ICode SLI"
+							cardInfo.Size = 112 // SLI has 896 bits = 112 bytes
+							return
+						}
+					}
+				}
+				// Fallback if we couldn't parse type bits
+				cardInfo.Type = "ICode SLIX"
+				cardInfo.Size = 896
 				return
 			}
 			// Generic ISO 15693
@@ -1161,7 +1190,7 @@ func readNDEFData(card *scard.Card, cardInfo *Card) {
 				}
 			}
 		}
-	} else if cardInfo.Type == "ICode SLIX" || cardInfo.Type == "ISO 15693" {
+	} else if cardInfo.Type == "ICode SLIX" || cardInfo.Type == "ICode SLIX2" || cardInfo.Type == "ICode SLI" || cardInfo.Type == "ISO 15693" {
 		// ISO 15693 (Type 5) tags: NDEF starts at block 1 (after CC at block 0)
 		maxBlocks := 79 // 80 blocks total, skip CC at block 0
 		for blockNum := 1; blockNum < 1+maxBlocks; blockNum++ {

internal/core/card_detection_test.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"strconv"
 	"testing"
 )
 
@@ -409,25 +410,49 @@ func TestCCBasedDetection(t *testing.T) {
 	}
 }
 
-// TestICodeSLIXDetection tests ICode SLIX detection from UID manufacturer byte
+// TestICodeSLIXDetection tests ICode SLI/SLIX/SLIX2 detection from UID type indicator bits
+// Per NXP datasheet (SL2S2602), UID4 (hex position 8-9) contains bits 40:33
+// Bits 37 and 36 indicate the ICODE type:
+//
+//	Bit 37=0, Bit 36=0: ICODE SLI
+//	Bit 37=1, Bit 36=0: ICODE SLIX
+//	Bit 37=0, Bit 36=1: ICODE SLIX2
+//	Bit 37=1, Bit 36=1: RFU
 func TestICodeSLIXDetection(t *testing.T) {
 	tests := []struct {
 		name         string
 		uid          string
 		atr          string
 		expectedType string
+		expectedSize int
 	}{
 		{
-			name:         "ICode SLIX with NXP manufacturer (0xE0)",
-			uid:          "80391566080104e0",
+			name:         "ICode SLIX2 - bits (0,1)",
+			uid:          "80391566080104e0", // UID4=08: bit37=0, bit36=1 -> SLIX2
+			atr:          "3b8f8001804f0ca0000003060b00140000000077",
+			expectedType: "ICode SLIX2",
+			expectedSize: 320,
+		},
+		{
+			name:         "ICode SLIX - bits (1,0)",
+			uid:          "80391566100104e0", // UID4=10: bit37=1, bit36=0 -> SLIX
 			atr:          "3b8f8001804f0ca0000003060b00140000000077",
 			expectedType: "ICode SLIX",
+			expectedSize: 896,
+		},
+		{
+			name:         "ICode SLI - bits (0,0)",
+			uid:          "80391566000104e0", // UID4=00: bit37=0, bit36=0 -> SLI
+			atr:          "3b8f8001804f0ca0000003060b00140000000077",
+			expectedType: "ICode SLI",
+			expectedSize: 112,
 		},
 		{
 			name:         "Generic ISO 15693 (non-NXP)",
-			uid:          "8039156608010400",
+			uid:          "8039156608010400", // Manufacturer != 0xE0
 			atr:          "3b8f8001804f0ca0000003060b00140000000077",
 			expectedType: "ISO 15693",
+			expectedSize: 1024,
 		},
 	}
 
@@ -438,17 +463,43 @@ func TestICodeSLIXDetection(t *testing.T) {
 				t.Fatal("ATR should contain ISO 15693 pattern '03060b'")
 			}
 
-			// Check UID manufacturer byte (last 2 chars in UID)
+			// Simulate the detection logic
 			var detectedType string
-			if len(tt.uid) >= 16 && tt.uid[14:16] == "e0" {
-				detectedType = "ICode SLIX"
+			var detectedSize int
+			uid := tt.uid
+
+			if len(uid) >= 16 && uid[14:16] == "e0" {
+				// NXP ICode family - check type indicator bits
+				if len(uid) >= 10 {
+					uid4Byte, _ := strconv.ParseUint(uid[8:10], 16, 8)
+					bit37 := (uid4Byte >> 4) & 1
+					bit36 := (uid4Byte >> 3) & 1
+					switch {
+					case bit37 == 0 && bit36 == 1:
+						detectedType = "ICode SLIX2"
+						detectedSize = 320
+					case bit37 == 1 && bit36 == 0:
+						detectedType = "ICode SLIX"
+						detectedSize = 896
+					case bit37 == 0 && bit36 == 0:
+						detectedType = "ICode SLI"
+						detectedSize = 112
+					default:
+						detectedType = "ICode SLIX"
+						detectedSize = 896
+					}
+				}
 			} else {
 				detectedType = "ISO 15693"
+				detectedSize = 1024
 			}
 
 			if detectedType != tt.expectedType {
 				t.Errorf("expected type %s, got %s", tt.expectedType, detectedType)
 			}
+			if detectedSize != tt.expectedSize {
+				t.Errorf("expected size %d, got %d", tt.expectedSize, detectedSize)
+			}
 		})
 	}
 }