-
Notifications
You must be signed in to change notification settings - Fork 1
/
DATDrive.m
executable file
·1168 lines (1037 loc) · 53.8 KB
/
DATDrive.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* DATXtract - an application for reading audio DAT tapes
Copyright © 2002-2007 Peter DiCamillo
This code is distributed under the license specified by the COPYING file
at the top-level directory of this distribution. */
#import "DATDrive.h"
@implementation DATDrive
- (id)init {
self = [super init];
// initialize variables
owner = NULL;
drive_service = 0;
interface = NULL;
plugInInterface = NULL;
return self;
}
- (void) setOwnerObject:(id)the_owner {
owner = the_owner;
}
- (void) writeToLog:(char *)logtext {
if (owner != NULL) {
[owner writeToLog:logtext];
}
}
- (int) locateDrive {
mach_port_t masterPort;
CFMutableDictionaryRef matchingDict;
CFMutableDictionaryRef subDict;
kern_return_t kr;
char errmsg[128];
// first create a master_port for my task
kr = IOMasterPort ( MACH_PORT_NULL, &masterPort );
if ( kr || !masterPort ) {
sprintf(errmsg, "ERR: Couldn't create a master IOKit Port(%08x)\n", kr);
[self writeToLog:errmsg];
return -1;
}
// Create the dictionaries
matchingDict = CFDictionaryCreateMutable ( kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
subDict = CFDictionaryCreateMutable ( kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
// Create a dictionary with the "SCSITaskDeviceCategory" key = "SCSITaskUserClientDevice"
CFDictionarySetValue (subDict, CFSTR ( kIOPropertySCSITaskDeviceCategory ),
CFSTR ( kIOPropertySCSITaskUserClientDevice ) );
// Add the dictionary to the main dictionary with the key "IOPropertyMatch" to
// narrow the search to the above dictionary.
CFDictionarySetValue (matchingDict, CFSTR ( kIOPropertyMatchKey ),
subDict );
// get the service we want
drive_service = IOServiceGetMatchingService(masterPort, matchingDict);
// Now done with the master_port
mach_port_deallocate ( mach_task_self ( ), masterPort );
masterPort = 0;
// handle results
if (drive_service == 0) {
return -1;
}
return 0;
}
- (int) setupInterface {
SInt32 score;
HRESULT herr;
kern_return_t err;
char errmsg[128];
NSRunLoop * currentLoop;
interface = NULL;
plugInInterface = NULL;
// Check that we found a drive
if (drive_service == 0) {
[self writeToLog:"setupInterface called with no drive"];
return -1;
}
// Create the IOCFPlugIn interface so we can query it.
err = IOCreatePlugInInterfaceForService (
drive_service,
kIOSCSITaskDeviceUserClientTypeID,
kIOCFPlugInInterfaceID,
&plugInInterface,
&score);
if (err != noErr) {
sprintf (errmsg, "IOCreatePlugInInterfaceForService returned %d\n", err);
[self writeToLog:errmsg];
return -1;
}
// Query the interface for the SCSITaskDeviceInterface.
herr = (*plugInInterface)->QueryInterface (
plugInInterface,
CFUUIDGetUUIDBytes(kIOSCSITaskDeviceInterfaceID),
(LPVOID)&interface);
if (herr != S_OK) {
sprintf(errmsg, "QueryInterface returned %ld\n", herr);
[self writeToLog:errmsg];
return -1;
}
// Get exclusive access to the device
err = (*interface)->ObtainExclusiveAccess(interface);
if ( err != noErr ) {
sprintf(errmsg, "ObtainExclusiveAccess returned %d\n", err);
[self writeToLog:errmsg];
return -1;
}
// Add run loop dispatcher in case we need it
currentLoop = [NSRunLoop currentRunLoop];
err = (*interface)->AddCallbackDispatcherToRunLoop(interface, [currentLoop getCFRunLoop]);
if ( err != noErr ) {
sprintf(errmsg, "AddCallbackDispatcherToRunLoop returned %d\n", err);
[self writeToLog:errmsg];
return -1;
}
return 0;
}
- (void) releaseInterface {
if (interface != NULL) {
// Remove run loop dispatcher
(*interface)->RemoveCallbackDispatcherFromRunLoop(interface);
// Release exclusive access
(*interface)->ReleaseExclusiveAccess(interface);
// Release the SCSITaskDeviceInterface.
(*interface)->Release(interface);
interface = NULL;
}
if (plugInInterface != NULL) {
// Destroy plugin interface
IODestroyPlugInInterface(plugInInterface);
plugInInterface = NULL;
}
}
- (int) TestUnitReady:(int *)status withString:(char *)status_string
withKey:(UInt8 *)result_key withCode:(UInt16 *)result_code {
SCSITaskStatus taskStatus;
SCSI_Sense_Data senseData;
SCSICommandDescriptorBlock cdb;
SCSITaskInterface ** task = NULL;
IOReturn err = 0;
UInt64 transferCount = 0;
char errmsg[128];
UInt8 key;
UInt8 ASC;
UInt8 ASCQ;
UInt16 code;
// initial result
*status = kSCSITaskStatus_No_Status;
status_string[0] = 0;
// Create a task now that we have exclusive access
task = (*interface )->CreateSCSITask(interface);
if (task == NULL) {
sprintf(errmsg, "CreateSCSITask failed");
[self writeToLog:errmsg];
return -1;
}
// zero the senseData and CDB
memset ( &senseData, 0, sizeof ( senseData ) );
memset ( cdb, 0, sizeof ( cdb ) );
// TEST_UNIT_READY is all zeros in the CDB, so we don't actually
// have to set any values.
// Set the actual cdb in the task
err = ( *task )->SetCommandDescriptorBlock ( task, cdb, kSCSICDBSize_6Byte );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting CDB");
[self writeToLog:errmsg];
}
// Set the timeout in the task
err = ( *task )->SetTimeoutDuration ( task, 5000 );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting Timeout");
[self writeToLog:errmsg];
}
// Send it!
err = ( *task )->ExecuteTaskSync ( task, &senseData, &taskStatus, &transferCount );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Executing Task");
[self writeToLog:errmsg];
( *task )->Release ( task );
return -1;
}
*status = taskStatus;
// Task status is not GOOD, return any sense string if they apply.
if ( taskStatus == kSCSITaskStatus_GOOD ) {
strcpy(status_string, "Ready");
}
else if ( taskStatus == kSCSITaskStatus_CHECK_CONDITION ) {
key = *result_key = senseData.SENSE_KEY & 0x0F;
ASC = senseData.ADDITIONAL_SENSE_CODE;
ASCQ = senseData.ADDITIONAL_SENSE_CODE_QUALIFIER;
code = *result_code = ( ( UInt16 ) ASC << 8 ) | ASCQ;
get_sense_string(status_string, key, ASC, ASCQ, code, false);
}
else {
sprintf(status_string, "taskStatus = 0x%08x\n", taskStatus);
}
// Release the task interface
( *task )->Release ( task );
return 0;
}
- (int) Inquiry:(DriveInfo *)info {
SCSICmd_INQUIRY_StandardData inqBuffer;
SCSITaskStatus taskStatus;
SCSI_Sense_Data senseData;
SCSICommandDescriptorBlock cdb;
SCSITaskInterface ** task = NULL;
UInt8 * bufPtr = ( UInt8 * ) &inqBuffer;
IOReturn err = 0;
UInt32 index = 0;
UInt64 transferCount = 0;
IOVirtualRange * range = NULL;
char errmsg[128];
int result;
// Create a task now that we have exclusive access
task = (*interface)->CreateSCSITask(interface);
if (task == NULL) {
sprintf(errmsg, "CreateSCSITask failed");
[self writeToLog:errmsg];
return -1;
}
// Zero the buffer.
memset(bufPtr, 0, sizeof(SCSICmd_INQUIRY_StandardData));
// Allocate a virtual range for the buffer. If we had more than 1 scatter-gather entry,
// we would allocate more than 1 IOVirtualRange.
range = (IOVirtualRange *) malloc(sizeof(IOVirtualRange));
if ( range == NULL ) {
sprintf(errmsg, "ERROR Mallocing IOVirtualRange");
[self writeToLog:errmsg];
}
// zero the senseData and CDB
memset(&senseData, 0, sizeof (senseData));
memset(cdb, 0, sizeof(cdb));
// Set up the range. The address is just the buffer's address. The length is
//our request size.
range->address = (IOVirtualAddress)bufPtr;
range->length = sizeof(SCSICmd_INQUIRY_StandardData);
// We're going to execute an INQUIRY to the device as a
// test of exclusive commands.
cdb[0] = 0x12 /* inquiry */;
cdb[4] = sizeof(SCSICmd_INQUIRY_StandardData);
// Set the actual cdb in the task
err = (*task)->SetCommandDescriptorBlock(task, cdb, kSCSICDBSize_6Byte);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting CDB");
[self writeToLog:errmsg];
}
// Set the scatter-gather entry in the task
err = (*task)->SetScatterGatherEntries(task, range, 1,
sizeof(SCSICmd_INQUIRY_StandardData),
kSCSIDataTransfer_FromTargetToInitiator);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting SG Entries");
[self writeToLog:errmsg];
}
// Set the timeout in the task
err = (*task)->SetTimeoutDuration(task, 10000);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting Timeout");
[self writeToLog:errmsg];
}
// Send it!
err = (*task)->ExecuteTaskSync(task, &senseData, &taskStatus, &transferCount);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Executing Task");
[self writeToLog:errmsg];
}
// Get information
if (taskStatus == kSCSITaskStatus_GOOD) {
for (index = 8; index < 16; index++) {
if (bufPtr[index] == 0) break;
(info->vendorID)[index-8] = bufPtr[index];
}
(info->vendorID)[index-8] = 0;
blank_trim(info->vendorID);
for (index = 16; index < 32; index++) {
if (bufPtr[index] == 0) break;
(info->productID)[index-16] = bufPtr[index];
}
(info-> productID)[index-16] = 0;
blank_trim(info->productID);
for (index = 32; index < 36; index++) {
if (bufPtr[index] == 0) break;
(info->firmwareRevLevel)[index-32] = bufPtr[index];
}
(info->firmwareRevLevel)[index-32] = 0;
blank_trim(info->firmwareRevLevel);
result = 0;
}
else {
result = -1;
}
// Be a good citizen and cleanup
free (range);
// Release the task interface
(*task)->Release(task);
return result;
}
- (int) getMyMode:(int *)current_mode {
unsigned char senseResult[100];
SCSITaskStatus taskStatus;
SCSI_Sense_Data senseData;
SCSICommandDescriptorBlock cdb;
SCSITaskInterface ** task = NULL;
IOReturn err = 0;
UInt64 transferCount = 0;
IOVirtualRange * range = NULL;
char errmsg[128];
int result;
// Create a task now that we have exclusive access
task = (*interface)->CreateSCSITask(interface);
if (task == NULL) {
sprintf(errmsg, "CreateSCSITask failed");
[self writeToLog:errmsg];
return -1;
}
// Zero the buffer.
memset(senseResult, 0, sizeof(senseResult));
// Allocate a virtual range for the buffer. If we had more than 1 scatter-gather entry,
// we would allocate more than 1 IOVirtualRange.
range = (IOVirtualRange *) malloc(sizeof(IOVirtualRange));
if ( range == NULL ) {
sprintf(errmsg, "ERROR Mallocing IOVirtualRange");
[self writeToLog:errmsg];
}
// zero the senseData and CDB
memset(&senseData, 0, sizeof (senseData));
memset(cdb, 0, sizeof(cdb));
// Set up the range. The address is just the buffer's address. The length is
// our request size.
range->address = (IOVirtualAddress)senseResult;
range->length = sizeof(senseResult);
// We're going to execute a MODE SENSE to the device
cdb[0] = 0x1a /* mode sense */;
cdb[4] = sizeof(senseResult);
// Set the actual cdb in the task
err = (*task)->SetCommandDescriptorBlock(task, cdb, kSCSICDBSize_6Byte);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting CDB");
[self writeToLog:errmsg];
}
// Set the scatter-gather entry in the task
err = (*task)->SetScatterGatherEntries(task, range, 1,
sizeof(senseResult),
kSCSIDataTransfer_FromTargetToInitiator);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting SG Entries");
[self writeToLog:errmsg];
}
// Set the timeout in the task
err = (*task)->SetTimeoutDuration(task, 10000);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting Timeout");
[self writeToLog:errmsg];
}
// Send it!
err = (*task)->ExecuteTaskSync(task, &senseData, &taskStatus, &transferCount);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Executing Task");
[self writeToLog:errmsg];
}
// Get information
result = -1;
*current_mode = -1;
if (taskStatus == kSCSITaskStatus_GOOD) {
if (transferCount >= 5) {
if (senseResult[4] == 0x80) {
*current_mode = AUDIO_MODE;
result = 0;
}
else if (senseResult[4] == 0x13) {
*current_mode = DATA_MODE;
result = 0;
}
}
}
// Be a good citizen and cleanup
free (range);
// Release the task interface
(*task)->Release(task);
/* sprintf(errmsg, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
senseResult[0],
senseResult[1],
senseResult[2],
senseResult[3],
senseResult[4],
senseResult[5],
senseResult[6],
senseResult[7],
senseResult[8],
senseResult[9],
senseResult[10],
senseResult[11]);
[self writeToLog:errmsg]; */
return result;
}
- (int) setMyMode:(int)mode_wanted{
unsigned char mode_setting[12] =
{0x00, 0x00, 0x10, 0x08, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
SCSITaskStatus taskStatus;
SCSI_Sense_Data senseData;
SCSICommandDescriptorBlock cdb;
SCSITaskInterface ** task = NULL;
IOReturn err = 0;
UInt64 transferCount = 0;
IOVirtualRange * range = NULL;
char errmsg[128];
int result;
// check mode is valid
if ((mode_wanted != DATA_MODE) && (mode_wanted != AUDIO_MODE)) {
return -1;
}
// set data for mode wanted
if (mode_wanted == DATA_MODE) {
mode_setting[4] = 0x13;
}
else {
mode_setting[4] = 0x80;
}
// Create a task now that we have exclusive access
task = (*interface)->CreateSCSITask(interface);
if (task == NULL) {
sprintf(errmsg, "CreateSCSITask failed");
[self writeToLog:errmsg];
return -1;
}
// Allocate a virtual range for the buffer. If we had more than 1 scatter-gather entry,
// we would allocate more than 1 IOVirtualRange.
range = (IOVirtualRange *) malloc(sizeof(IOVirtualRange));
if ( range == NULL ) {
sprintf(errmsg, "ERROR Mallocing IOVirtualRange");
[self writeToLog:errmsg];
}
// zero the senseData and CDB
memset(&senseData, 0, sizeof (senseData));
memset(cdb, 0, sizeof(cdb));
// Set up the range. The address is just the buffer's address. The length is
// our request size.
range->address = (IOVirtualAddress)mode_setting;
range->length = sizeof(mode_setting);
// We're going to execute a MODE SELECT to the device
cdb[0] = 0x15 /* mode select */;
cdb[4] = sizeof(mode_setting);
// Set the actual cdb in the task
err = (*task)->SetCommandDescriptorBlock(task, cdb, kSCSICDBSize_6Byte);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting CDB");
[self writeToLog:errmsg];
}
// Set the scatter-gather entry in the task
err = (*task)->SetScatterGatherEntries(task, range, 1,
sizeof(mode_setting),
kSCSIDataTransfer_FromInitiatorToTarget);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting SG Entries");
[self writeToLog:errmsg];
}
// Set the timeout in the task
err = (*task)->SetTimeoutDuration(task, 10000);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting Timeout");
[self writeToLog:errmsg];
}
// Send it!
err = (*task)->ExecuteTaskSync(task, &senseData, &taskStatus, &transferCount);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Executing Task");
[self writeToLog:errmsg];
}
// Get information
result = -1;
if (taskStatus == kSCSITaskStatus_GOOD) {
if (transferCount == 12) {
result = 0;
}
}
// Be a good citizen and cleanup
free (range);
// Release the task interface
(*task)->Release(task);
return result;
}
- (int) loadUnload:(Boolean)do_unload
withCallback:(SCSITaskCallbackFunction)the_callback {
SCSICommandDescriptorBlock cdb;
SCSITaskInterface ** task = NULL;
IOReturn err = 0;
char errmsg[128];
// Create a task now that we have exclusive access
task = (*interface )->CreateSCSITask(interface);
if (task == NULL) {
sprintf(errmsg, "CreateSCSITask failed");
[self writeToLog:errmsg];
return -1;
}
// define the cdb
memset(cdb, 0, sizeof(SCSICommandDescriptorBlock));
cdb[0] = 0x1b;
if (!do_unload) cdb[4] = 0x01;
// Set the actual cdb in the task
err = ( *task )->SetCommandDescriptorBlock ( task, cdb, kSCSICDBSize_6Byte );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting CDB");
[self writeToLog:errmsg];
}
// Set the timeout in the task
err = ( *task )->SetTimeoutDuration ( task, 300000 );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting Timeout");
[self writeToLog:errmsg];
}
// Set the callback
err = (*task)->SetTaskCompletionCallback(task, the_callback, task);
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting Callback");
[self writeToLog:errmsg];
( *task )->Release ( task );
return -1;
}
// Send it!
err = ( *task )->ExecuteTaskAsync ( task );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Executing Task");
[self writeToLog:errmsg];
( *task )->Release ( task );
return -1;
}
return 0;
}
- (int) readWithBuffer:(unsigned char *)buff
withCallback:(SCSITaskCallbackFunction)the_callback
{
SCSICommandDescriptorBlock cdb;
SCSITaskInterface ** task = NULL;
IOReturn err = 0;
IOVirtualRange * range = NULL;
char errmsg[128];
// Create a task now that we have exclusive access
task = (*interface )->CreateSCSITask(interface);
if (task == NULL) {
sprintf(errmsg, "CreateSCSITask failed");
[self writeToLog:errmsg];
return -1;
}
// Allocate a virtual range for the buffer. If we had more than 1 scatter-gather entry,
// we would allocate more than 1 IOVirtualRange.
range = &global_range;
// Set up the range. The address is just the buffer's address. The length is
// our request size.
range->address = (IOVirtualAddress)buff;
range->length = DAT_FRAME_SIZE;
// define the cdb
memset(cdb, 0, sizeof(SCSICommandDescriptorBlock));
cdb[0] = 0x08;
cdb[3] = DAT_FRAME_SIZE_MSB;
cdb[4] = DAT_FRAME_SIZE_LSB;
// Set the actual cdb in the task
err = ( *task )->SetCommandDescriptorBlock ( task, cdb, kSCSICDBSize_6Byte );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting CDB");
[self writeToLog:errmsg];
}
// Set the scatter-gather entry in the task
err = (*task)->SetScatterGatherEntries(task, range, 1,
DAT_FRAME_SIZE,
kSCSIDataTransfer_FromTargetToInitiator);
if (err != kIOReturnSuccess) {
sprintf(errmsg, "ERROR Setting SG Entries");
[self writeToLog:errmsg];
}
// Set the timeout in the task
err = ( *task )->SetTimeoutDuration ( task, 10000 );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting Timeout");
[self writeToLog:errmsg];
}
// Set the callback
err = (*task)->SetTaskCompletionCallback(task, the_callback, task);
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Setting Callback");
[self writeToLog:errmsg];
( *task )->Release ( task );
return -1;
}
// Send it!
err = ( *task )->ExecuteTaskAsync ( task );
if ( err != kIOReturnSuccess ) {
sprintf(errmsg, "ERROR Executing Task");
[self writeToLog:errmsg];
( *task )->Release ( task );
return -1;
}
return 0;
}
@end
// Utilities
void blank_trim(char *text) // used by Inquiry
{
short i, len;
len = strlen(text);
if (len == 0) return;
for (i = (len - 1); i >= 0; i--) {
if (text[i] == ' ') {
text[i] = 0;
}
else {
break;
}
}
}
void
get_sense_string(char *str, UInt8 key, UInt8 ASC, UInt8 ASCQ,
UInt16 code, Boolean addRawValues)
{
if ( addRawValues )
{
sprintf ( str, "Key: $%02x, ASC: $%02x, ASCQ: $%02x, Code: $%04x ",
key, ASC, ASCQ, code );
}
else
str[0] = '\0';
switch ( key )
{
case 0x0: strcat ( str, "No Sense" ); break;
case 0x1: strcat ( str, "Recovered Error" ); break;
case 0x2: strcat ( str, "Not Ready" ); break;
case 0x3: strcat ( str, "Medium Error" ); break;
case 0x4: strcat ( str, "Hardware Error" ); break;
case 0x5: strcat ( str, "Illegal Request" ); break;
case 0x6: strcat ( str, "Unit Attention" ); break;
case 0x7: strcat ( str, "Data Protect" ); break;
case 0x8: strcat ( str, "Blank Check" ); break;
case 0x9: strcat ( str, "Vendor-Specific" ); break;
case 0xA: strcat ( str, "Copy Aborted" ); break;
case 0xB: strcat ( str, "Aborted Command" ); break;
case 0xC: strcat ( str, "Equal (now obsolete)" ); break;
case 0xD: strcat ( str, "Volume Overflow" ); break;
case 0xE: strcat ( str, "Miscompare" ); break;
default: strcat ( str, "Unknown Sense Code" ); break;
}
strcat ( str, ", " );
switch ( code )
{
case 0x0000: strcat ( str, "No additional sense information" ); break;
case 0x0001: strcat ( str, "Filemark detected" ); break;
case 0x0002: strcat ( str, "End of partition/medium detected" ); break;
case 0x0003: strcat ( str, "Setmark detected" ); break;
case 0x0004: strcat ( str, "Beginning of partition/medium detected" ); break;
case 0x0005: strcat ( str, "End of data detected" ); break;
case 0x0006: strcat ( str, "I/O process termination" ); break;
case 0x0011: strcat ( str, "Play operation in progress" ); break;
case 0x0012: strcat ( str, "Play operation paused" ); break;
case 0x0013: strcat ( str, "Play operation successfully completed" ); break;
case 0x0014: strcat ( str, "Play operation stopped due to error" ); break;
case 0x0015: strcat ( str, "No current audio status to return" ); break;
case 0x0016: strcat ( str, "Operation in progress" ); break;
case 0x0017: strcat ( str, "Cleaning requested" ); break;
case 0x0100: strcat ( str, "Mechanical positioning or changer error" ); break;
case 0x0200: strcat ( str, "No seek complete" ); break;
case 0x0300: strcat ( str, "Peripheral device write fault" ); break;
case 0x0301: strcat ( str, "No write current" ); break;
case 0x0302: strcat ( str, "Excessive write errors" ); break;
case 0x0400: strcat ( str, "Logical unit not ready, cause not reportable" ); break;
case 0x0401: strcat ( str, "Logical unit not ready, in process of becoming ready" ); break;
case 0x0402: strcat ( str, "Logical unit not ready, initializing command required" ); break;
case 0x0403: strcat ( str, "Logical unit not ready, manual intervention required" ); break;
case 0x0404: strcat ( str, "Logical unit not ready, format in progress" ); break;
case 0x0407: strcat ( str, "Logical unit not ready, operation in progress" ); break;
case 0x0408: strcat ( str, "Logical unit not ready, long write in progress" ); break;
case 0x0409: strcat ( str, "Logical unit not ready, self-test in progress" ); break;
case 0x0500: strcat ( str, "Logical unit does not respond to selection" ); break;
case 0x0501: strcat ( str, "Media load - Eject failed" ); break;
case 0x0600: strcat ( str, "No reference position found" ); break;
case 0x0700: strcat ( str, "Multiple peripheral devices selected" ); break;
case 0x0800: strcat ( str, "Logical unit communication failure" ); break;
case 0x0801: strcat ( str, "Logical unit communication time-out" ); break;
case 0x0802: strcat ( str, "Logical unit communication parity error" ); break;
case 0x0803: strcat ( str, "Logical unit communication CRC error (Ultra-DMA/32)" ); break;
case 0x0804: strcat ( str, "Unreachable copy target" ); break;
case 0x0900: strcat ( str, "Track following error" ); break;
case 0x0901: strcat ( str, "Tracking servo failure" ); break;
case 0x0902: strcat ( str, "Focus servo failure" ); break;
case 0x0903: strcat ( str, "Spindle servo failure" ); break;
case 0x0904: strcat ( str, "Head select fault" ); break;
case 0x0A00: strcat ( str, "Error log overflow" ); break;
case 0x0B00: strcat ( str, "Warning" ); break;
case 0x0B01: strcat ( str, "Warning, specified temperature exceeded" ); break;
case 0x0B02: strcat ( str, "Warning, enclosure degraded" ); break;
case 0x0C00: strcat ( str, "Write error" ); break;
case 0x0C01: strcat ( str, "Write error, recovered with auto reallocation" ); break;
case 0x0C02: strcat ( str, "Write error, auto reallocation failed" ); break;
case 0x0C03: strcat ( str, "Write error, recommend reassignment" ); break;
case 0x0C04: strcat ( str, "Compression check miscompare error" ); break;
case 0x0C05: strcat ( str, "Data expansion occurred during compression" ); break;
case 0x0C06: strcat ( str, "Block not compressible" ); break;
case 0x0C07: strcat ( str, "Write error, recovery needed" ); break;
case 0x0C08: strcat ( str, "Write error, recovery failed" ); break;
case 0x0C09: strcat ( str, "Write error, loss of streaming" ); break;
case 0x0C0A: strcat ( str, "Write error, padding blocks added" ); break;
case 0x1000: strcat ( str, "ID, CRC or ECC error" ); break;
case 0x1100: strcat ( str, "Unrecovered read error" ); break;
case 0x1101: strcat ( str, "Read retries exhausted" ); break;
case 0x1102: strcat ( str, "Error too long to correct" ); break;
case 0x1103: strcat ( str, "Multiple read errors" ); break;
case 0x1104: strcat ( str, "Unrecovered read error - auto reallocate failed" ); break;
case 0x1105: strcat ( str, "L-EC uncorrectable error" ); break;
case 0x1106: strcat ( str, "CIRC unrecovered error" ); break;
case 0x1107: strcat ( str, "Re-synchronization error" ); break;
case 0x1108: strcat ( str, "Incomplete block read" ); break;
case 0x1109: strcat ( str, "No gap found" ); break;
case 0x110A: strcat ( str, "Miscorrected error" ); break;
case 0x110B: strcat ( str, "Unrecovered read error - recommend reassignment" ); break;
case 0x110C: strcat ( str, "Unrecovered read error - recommend rewrite the data" ); break;
case 0x110D: strcat ( str, "De-compression CRC error" ); break;
case 0x110E: strcat ( str, "Cannot decompress using declared algorithm" ); break;
case 0x110F: strcat ( str, "Error reading UPC/EAN number" ); break;
case 0x1110: strcat ( str, "Error reading ISRC number" ); break;
case 0x1111: strcat ( str, "Read error, loss of streaming" ); break;
case 0x1200: strcat ( str, "Address mark not found for ID field" ); break;
case 0x1300: strcat ( str, "Address mark not found for data field" ); break;
case 0x1400: strcat ( str, "Recorded entity not found" ); break;
case 0x1401: strcat ( str, "Record not found" ); break;
case 0x1402: strcat ( str, "Filemark or setmark not found" ); break;
case 0x1403: strcat ( str, "End of data not found" ); break;
case 0x1404: strcat ( str, "Block sequence error" ); break;
case 0x1405: strcat ( str, "Record not found - recommend reassignment" ); break;
case 0x1406: strcat ( str, "Record not found - data auto-reallocated" ); break;
case 0x1500: strcat ( str, "Random positioning error" ); break;
case 0x1501: strcat ( str, "Mechanical positioning or changer error" ); break;
case 0x1502: strcat ( str, "Positioning error detected by read of medium" ); break;
case 0x1600: strcat ( str, "Data synchronization mark error" ); break;
case 0x1601: strcat ( str, "Data sync error - data rewritten" ); break;
case 0x1602: strcat ( str, "Data sync error - recommend rewrite" ); break;
case 0x1603: strcat ( str, "Data sync error - data auto-reallocated" ); break;
case 0x1604: strcat ( str, "Data sync error - recommend reassignment" ); break;
case 0x1700: strcat ( str, "Recovered data with no error correction applied" ); break;
case 0x1701: strcat ( str, "Recovered data with retries" ); break;
case 0x1702: strcat ( str, "Recovered data with positive head offset" ); break;
case 0x1703: strcat ( str, "Recovered data with negative head offset" ); break;
case 0x1704: strcat ( str, "Recovered data with retries and/or CIRC applied" ); break;
case 0x1705: strcat ( str, "Recovered data using previous sector ID" ); break;
case 0x1706: strcat ( str, "Recovered data without ECC, data auto-reallocated" ); break;
case 0x1707: strcat ( str, "Recovered data without ECC, recommend reassignment" ); break;
case 0x1708: strcat ( str, "Recovered data without ECC, recommend rewrite" ); break;
case 0x1709: strcat ( str, "Recivered data without ECC, data rewritten" ); break;
case 0x1800: strcat ( str, "Recovered data with error correction applied" ); break;
case 0x1801: strcat ( str, "Recovered data with error correction & retries applied" ); break;
case 0x1802: strcat ( str, "Recovered data, the data was auto-reallocated" ); break;
case 0x1803: strcat ( str, "Recovered data with CIRC" ); break;
case 0x1804: strcat ( str, "Recovered data with L-EC" ); break;
case 0x1805: strcat ( str, "Recovered data, recommend reassignment" ); break;
case 0x1806: strcat ( str, "Recovered data, recommend rewrite" ); break;
case 0x1807: strcat ( str, "Recovered data with ECC, data rewritten" ); break;
case 0x1808: strcat ( str, "Recovered data with linking" ); break;
case 0x1900: strcat ( str, "Defect list error" ); break;
case 0x1901: strcat ( str, "Defect list not available" ); break;
case 0x1902: strcat ( str, "Defect list error in primary list" ); break;
case 0x1903: strcat ( str, "Defect list error in grown list" ); break;
case 0x1A00: strcat ( str, "Parameter list length error" ); break;
case 0x1B00: strcat ( str, "Synchronous data transfer error" ); break;
case 0x1C00: strcat ( str, "Defect list not found" ); break;
case 0x1C01: strcat ( str, "Primary defect list not found" ); break;
case 0x1C02: strcat ( str, "Grown defect list not found" ); break;
case 0x1D00: strcat ( str, "Miscompare during verify operation" ); break;
case 0x1E00: strcat ( str, "Recovered ID with ECC correction" ); break;
case 0x1F00: strcat ( str, "Partial defect list transfer" ); break;
case 0x2000: strcat ( str, "Invalid command operation code" ); break;
case 0x2100: strcat ( str, "Logical block address out of range" ); break;
case 0x2101: strcat ( str, "Invalid element address" ); break;
case 0x2102: strcat ( str, "Invalid address for write" ); break;
case 0x2200: strcat ( str, "Illegal function" ); break;
case 0x2400: strcat ( str, "Invalid field in CDB" ); break;
case 0x2401: strcat ( str, "CDB decryption error" ); break;
case 0x2500: strcat ( str, "Logical unit not supported" ); break;
case 0x2600: strcat ( str, "Invalid field in parameter list" ); break;
case 0x2601: strcat ( str, "Parameter not supported" ); break;
case 0x2602: strcat ( str, "Parameter value invalid" ); break;
case 0x2603: strcat ( str, "Threshold parameters not supported" ); break;
case 0x2604: strcat ( str, "Invalid release of active persistent reservation" ); break;
case 0x2605: strcat ( str, "Data decryption error" ); break;
case 0x2606: strcat ( str, "Too many target descriptors" ); break;
case 0x2607: strcat ( str, "Unsupported target descriptor type code" ); break;
case 0x2608: strcat ( str, "Too many segment descriptors" ); break;
case 0x2609: strcat ( str, "Unsupported segment descriptor type code" ); break;
case 0x260A: strcat ( str, "Unexpected inexact segment" ); break;
case 0x260B: strcat ( str, "Inline data length exceeded" ); break;
case 0x260C: strcat ( str, "Invalid operation for copy source or destination" ); break;
case 0x260D: strcat ( str, "Copy segment granularity violation" ); break;
case 0x2700: strcat ( str, "Write protected" ); break;
case 0x2701: strcat ( str, "Hardware write protected" ); break;
case 0x2702: strcat ( str, "Logical unit software write protected" ); break;
case 0x2703: strcat ( str, "Associated write protect" ); break;
case 0x2704: strcat ( str, "Persistent write protect" ); break;
case 0x2705: strcat ( str, "Permanent write protect" ); break;
case 0x2800: strcat ( str, "Not ready to ready transition, medium may have changed" ); break;
case 0x2801: strcat ( str, "Import or export element accessed" ); break;
case 0x2900: strcat ( str, "Power on, reset or bus device reset occurred" ); break;
case 0x2901: strcat ( str, "Power on occured" ); break;
case 0x2902: strcat ( str, "SCSI bus reset occurred" ); break;
case 0x2903: strcat ( str, "Bus device reset function occurred" ); break;
case 0x2904: strcat ( str, "Device internal reset" ); break;
case 0x2905: strcat ( str, "Transceiver mode changed to single-ended" ); break;
case 0x2906: strcat ( str, "Transceiver mode changed to LVD" ); break;
case 0x2A00: strcat ( str, "Parameters changed" ); break;
case 0x2A01: strcat ( str, "Mode parameters changed" ); break;
case 0x2A02: strcat ( str, "Log parameters changed" ); break;
case 0x2A03: strcat ( str, "Reservations preempted" ); break;
case 0x2A04: strcat ( str, "Reservations released" ); break;
case 0x2A05: strcat ( str, "Registrations preempted" ); break;
case 0x2B00: strcat ( str, "Copy cannot execute since host cannot disconnect" ); break;
case 0x2C00: strcat ( str, "Command sequence error" ); break;
case 0x2C01: strcat ( str, "Too many windows specified" ); break;
case 0x2C02: strcat ( str, "Invalid combination of windows specified" ); break;
case 0x2C03: strcat ( str, "Current program area is not empty" ); break;
case 0x2C04: strcat ( str, "Current program area is empty" ); break;
case 0x2C05: strcat ( str, "Persistent prevent conflict" ); break;
case 0x2D00: strcat ( str, "Overwrite error on update in place" ); break;
case 0x2E00: strcat ( str, "Insufficient time for operation" ); break;
case 0x2F00: strcat ( str, "Commands cleared by anther initiator" ); break;
case 0x3000: strcat ( str, "Incompatible medium installed" ); break;
case 0x3001: strcat ( str, "Cannot read medium, unknown format" ); break;
case 0x3002: strcat ( str, "Cannot read medium, incompatible format" ); break;
case 0x3003: strcat ( str, "Cleaning cartridge installed" ); break;
case 0x3004: strcat ( str, "Cannot write medium, unknown format" ); break;
case 0x3005: strcat ( str, "Cannot write medium, incompatible format" ); break;
case 0x3006: strcat ( str, "Cannot format medium, incompatible medium" ); break;
case 0x3007: strcat ( str, "Cleaning failure" ); break;
case 0x3008: strcat ( str, "Cannot write, application code mismatch" ); break;
case 0x3009: strcat ( str, "Current session not fixated for append" ); break;
case 0x3100: strcat ( str, "Medium format corrupted" ); break;
case 0x3101: strcat ( str, "Format command failed" ); break;
case 0x3102: strcat ( str, "Zoned formatting failed due to spare linking" ); break;
case 0x3200: strcat ( str, "No defect spare location available" ); break;
case 0x3201: strcat ( str, "Defect list update failure" ); break;
case 0x3300: strcat ( str, "Tape length error" ); break;
case 0x3400: strcat ( str, "Enclosure failure" ); break;
case 0x3500: strcat ( str, "Enclosure services failure" ); break;
case 0x3501: strcat ( str, "Unsupported enclosure function" ); break;
case 0x3502: strcat ( str, "Enclosure services unavailable" ); break;
case 0x3503: strcat ( str, "Enclosure services transfer failure" ); break;
case 0x3504: strcat ( str, "Enclosure services transfer refused" ); break;
case 0x3600: strcat ( str, "Ribbon, ink, or toner failure" ); break;
case 0x3700: strcat ( str, "Rounded parameter" ); break;
case 0x3800: strcat ( str, "Event status notification" ); break;
case 0x3802: strcat ( str, "ESN - Power management class event" ); break;
case 0x3804: strcat ( str, "ESN - Media class event" ); break;
case 0x3806: strcat ( str, "ESN - Device busy class event" ); break;
case 0x3900: strcat ( str, "Saving parameters not supported" ); break;
case 0x3A00: strcat ( str, "Medium not present" ); break;
case 0x3A01: strcat ( str, "Medium not present, tray closed" ); break;
case 0x3A02: strcat ( str, "Medium not present, tray open" ); break;
case 0x3A03: strcat ( str, "Medium not present, loadable" ); break;
case 0x3A04: strcat ( str, "Medium not present, medium auxiliary memory accessible" ); break;
case 0x3B00: strcat ( str, "Sequential positioning error" ); break;
case 0x3B01: strcat ( str, "Tape position error at beginning of medium" ); break;
case 0x3B02: strcat ( str, "Tape position error at end of medium" ); break;
case 0x3B03: strcat ( str, "Tape or electronic vertical forms unit not ready" ); break;
case 0x3B04: strcat ( str, "Slew failure" ); break;
case 0x3B05: strcat ( str, "Paper jam" ); break;
case 0x3B06: strcat ( str, "Failed to sense top-of-form" ); break;
case 0x3B07: strcat ( str, "Failed to sense bottom-of-form" ); break;
case 0x3B08: strcat ( str, "Reposition error" ); break;
case 0x3B09: strcat ( str, "Read past end of medium" ); break;
case 0x3B0A: strcat ( str, "Read past beginning of medium" ); break;
case 0x3B0B: strcat ( str, "Position past end of medium" ); break;
case 0x3B0C: strcat ( str, "Position past beginning of medium" ); break;
case 0x3B0D: strcat ( str, "Medium destination element full" ); break;
case 0x3B0E: strcat ( str, "Medium source element empty" ); break;
case 0x3B0F: strcat ( str, "End of medium reached" ); break;
case 0x3B11: strcat ( str, "Medium magazine not accessible" ); break;
case 0x3B12: strcat ( str, "Medium magazine removed" ); break;
case 0x3B13: strcat ( str, "Medium magazine inserted" ); break;
case 0x3B14: strcat ( str, "Medium magazine locked" ); break;
case 0x3B15: strcat ( str, "Medium magazine unlocked" ); break;
case 0x3B16: strcat ( str, "Mechanical positioning or changer error" ); break;