?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: cpa self-test, WARN_ON()
[wrt350n-kernel.git] / drivers / usb / storage / isd200.c
blob178e8c2a8a2feb41f03fd7d16117347647f6247b
1 /* Transport & Protocol Driver for In-System Design, Inc. ISD200 ASIC
2 *
3 * $Id: isd200.c,v 1.16 2002/04/22 03:39:43 mdharm Exp $
4 *
5 * Current development and maintenance:
6 * (C) 2001-2002 Björn Stenberg (bjorn@haxx.se)
7 *
8 * Developed with the assistance of:
9 * (C) 2002 Alan Stern <stern@rowland.org>
10 *
11 * Initial work:
12 * (C) 2000 In-System Design, Inc. (support@in-system.com)
13 *
14 * The ISD200 ASIC does not natively support ATA devices. The chip
15 * does implement an interface, the ATA Command Block (ATACB) which provides
16 * a means of passing ATA commands and ATA register accesses to a device.
17 *
18 * This program is free software; you can redistribute it and/or modify it
19 * under the terms of the GNU General Public License as published by the
20 * Free Software Foundation; either version 2, or (at your option) any
21 * later version.
22 *
23 * This program is distributed in the hope that it will be useful, but
24 * WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 * General Public License for more details.
27 *
28 * You should have received a copy of the GNU General Public License along
29 * with this program; if not, write to the Free Software Foundation, Inc.,
30 * 675 Mass Ave, Cambridge, MA 02139, USA.
31 *
32 * History:
33 *
34 * 2002-10-19: Removed the specialized transfer routines.
35 * (Alan Stern <stern@rowland.harvard.edu>)
36 * 2001-02-24: Removed lots of duplicate code and simplified the structure.
37 * (bjorn@haxx.se)
38 * 2002-01-16: Fixed endianness bug so it works on the ppc arch.
39 * (Luc Saillard <luc@saillard.org>)
40 * 2002-01-17: All bitfields removed.
41 * (bjorn@haxx.se)
42 */
43
44
45 /* Include files */
46
47 #include <linux/jiffies.h>
48 #include <linux/errno.h>
49 #include <linux/slab.h>
50 #include <linux/hdreg.h>
51 #include <linux/ide.h>
52 #include <linux/scatterlist.h>
53
54 #include <scsi/scsi.h>
55 #include <scsi/scsi_cmnd.h>
56 #include <scsi/scsi_device.h>
57
58 #include "usb.h"
59 #include "transport.h"
60 #include "protocol.h"
61 #include "debug.h"
62 #include "scsiglue.h"
63 #include "isd200.h"
64
65
66 /* Timeout defines (in Seconds) */
67
68 #define ISD200_ENUM_BSY_TIMEOUT 35
69 #define ISD200_ENUM_DETECT_TIMEOUT 30
70 #define ISD200_DEFAULT_TIMEOUT 30
71
72 /* device flags */
73 #define DF_ATA_DEVICE 0x0001
74 #define DF_MEDIA_STATUS_ENABLED 0x0002
75 #define DF_REMOVABLE_MEDIA 0x0004
76
77 /* capability bit definitions */
78 #define CAPABILITY_DMA 0x01
79 #define CAPABILITY_LBA 0x02
80
81 /* command_setX bit definitions */
82 #define COMMANDSET_REMOVABLE 0x02
83 #define COMMANDSET_MEDIA_STATUS 0x10
84
85 /* ATA Vendor Specific defines */
86 #define ATA_ADDRESS_DEVHEAD_STD 0xa0
87 #define ATA_ADDRESS_DEVHEAD_LBA_MODE 0x40
88 #define ATA_ADDRESS_DEVHEAD_SLAVE 0x10
89
90 /* Action Select bits */
91 #define ACTION_SELECT_0 0x01
92 #define ACTION_SELECT_1 0x02
93 #define ACTION_SELECT_2 0x04
94 #define ACTION_SELECT_3 0x08
95 #define ACTION_SELECT_4 0x10
96 #define ACTION_SELECT_5 0x20
97 #define ACTION_SELECT_6 0x40
98 #define ACTION_SELECT_7 0x80
99
100 /* Register Select bits */
101 #define REG_ALTERNATE_STATUS 0x01
102 #define REG_DEVICE_CONTROL 0x01
103 #define REG_ERROR 0x02
104 #define REG_FEATURES 0x02
105 #define REG_SECTOR_COUNT 0x04
106 #define REG_SECTOR_NUMBER 0x08
107 #define REG_CYLINDER_LOW 0x10
108 #define REG_CYLINDER_HIGH 0x20
109 #define REG_DEVICE_HEAD 0x40
110 #define REG_STATUS 0x80
111 #define REG_COMMAND 0x80
112
113 /* ATA error definitions not in <linux/hdreg.h> */
114 #define ATA_ERROR_MEDIA_CHANGE 0x20
115
116 /* ATA command definitions not in <linux/hdreg.h> */
117 #define ATA_COMMAND_GET_MEDIA_STATUS 0xDA
118 #define ATA_COMMAND_MEDIA_EJECT 0xED
119
120 /* ATA drive control definitions */
121 #define ATA_DC_DISABLE_INTERRUPTS 0x02
122 #define ATA_DC_RESET_CONTROLLER 0x04
123 #define ATA_DC_REENABLE_CONTROLLER 0x00
124
125 /*
126 * General purpose return codes
127 */
128
129 #define ISD200_ERROR -1
130 #define ISD200_GOOD 0
131
132 /*
133 * Transport return codes
134 */
135
136 #define ISD200_TRANSPORT_GOOD 0 /* Transport good, command good */
137 #define ISD200_TRANSPORT_FAILED 1 /* Transport good, command failed */
138 #define ISD200_TRANSPORT_ERROR 2 /* Transport bad (i.e. device dead) */
139
140 /* driver action codes */
141 #define ACTION_READ_STATUS 0
142 #define ACTION_RESET 1
143 #define ACTION_REENABLE 2
144 #define ACTION_SOFT_RESET 3
145 #define ACTION_ENUM 4
146 #define ACTION_IDENTIFY 5
147
148
149 /*
150 * ata_cdb struct
151 */
152
153
154 union ata_cdb {
155 struct {
156 unsigned char SignatureByte0;
157 unsigned char SignatureByte1;
158 unsigned char ActionSelect;
159 unsigned char RegisterSelect;
160 unsigned char TransferBlockSize;
161 unsigned char WriteData3F6;
162 unsigned char WriteData1F1;
163 unsigned char WriteData1F2;
164 unsigned char WriteData1F3;
165 unsigned char WriteData1F4;
166 unsigned char WriteData1F5;
167 unsigned char WriteData1F6;
168 unsigned char WriteData1F7;
169 unsigned char Reserved[3];
170 } generic;
171
172 struct {
173 unsigned char SignatureByte0;
174 unsigned char SignatureByte1;
175 unsigned char ActionSelect;
176 unsigned char RegisterSelect;
177 unsigned char TransferBlockSize;
178 unsigned char AlternateStatusByte;
179 unsigned char ErrorByte;
180 unsigned char SectorCountByte;
181 unsigned char SectorNumberByte;
182 unsigned char CylinderLowByte;
183 unsigned char CylinderHighByte;
184 unsigned char DeviceHeadByte;
185 unsigned char StatusByte;
186 unsigned char Reserved[3];
187 } read;
188
189 struct {
190 unsigned char SignatureByte0;
191 unsigned char SignatureByte1;
192 unsigned char ActionSelect;
193 unsigned char RegisterSelect;
194 unsigned char TransferBlockSize;
195 unsigned char DeviceControlByte;
196 unsigned char FeaturesByte;
197 unsigned char SectorCountByte;
198 unsigned char SectorNumberByte;
199 unsigned char CylinderLowByte;
200 unsigned char CylinderHighByte;
201 unsigned char DeviceHeadByte;
202 unsigned char CommandByte;
203 unsigned char Reserved[3];
204 } write;
205 };
206
207
208 /*
209 * Inquiry data structure. This is the data returned from the target
210 * after it receives an inquiry.
211 *
212 * This structure may be extended by the number of bytes specified
213 * in the field AdditionalLength. The defined size constant only
214 * includes fields through ProductRevisionLevel.
215 */
216
217 /*
218 * DeviceType field
219 */
220 #define DIRECT_ACCESS_DEVICE 0x00 /* disks */
221 #define DEVICE_REMOVABLE 0x80
222
223 struct inquiry_data {
224 unsigned char DeviceType;
225 unsigned char DeviceTypeModifier;
226 unsigned char Versions;
227 unsigned char Format;
228 unsigned char AdditionalLength;
229 unsigned char Reserved[2];
230 unsigned char Capability;
231 unsigned char VendorId[8];
232 unsigned char ProductId[16];
233 unsigned char ProductRevisionLevel[4];
234 unsigned char VendorSpecific[20];
235 unsigned char Reserved3[40];
236 } __attribute__ ((packed));
237
238 /*
239 * INQUIRY data buffer size
240 */
241
242 #define INQUIRYDATABUFFERSIZE 36
243
244
245 /*
246 * ISD200 CONFIG data struct
247 */
248
249 #define ATACFG_TIMING 0x0f
250 #define ATACFG_ATAPI_RESET 0x10
251 #define ATACFG_MASTER 0x20
252 #define ATACFG_BLOCKSIZE 0xa0
253
254 #define ATACFGE_LAST_LUN 0x07
255 #define ATACFGE_DESC_OVERRIDE 0x08
256 #define ATACFGE_STATE_SUSPEND 0x10
257 #define ATACFGE_SKIP_BOOT 0x20
258 #define ATACFGE_CONF_DESC2 0x40
259 #define ATACFGE_INIT_STATUS 0x80
260
261 #define CFG_CAPABILITY_SRST 0x01
262
263 struct isd200_config {
264 unsigned char EventNotification;
265 unsigned char ExternalClock;
266 unsigned char ATAInitTimeout;
267 unsigned char ATAConfig;
268 unsigned char ATAMajorCommand;
269 unsigned char ATAMinorCommand;
270 unsigned char ATAExtraConfig;
271 unsigned char Capability;
272 }__attribute__ ((packed));
273
274
275 /*
276 * ISD200 driver information struct
277 */
278
279 struct isd200_info {
280 struct inquiry_data InquiryData;
281 struct hd_driveid *id;
282 struct isd200_config ConfigData;
283 unsigned char *RegsBuf;
284 unsigned char ATARegs[8];
285 unsigned char DeviceHead;
286 unsigned char DeviceFlags;
287
288 /* maximum number of LUNs supported */
289 unsigned char MaxLUNs;
290 struct scsi_cmnd srb;
291 struct scatterlist sg;
292 };
293
294
295 /*
296 * Read Capacity Data - returned in Big Endian format
297 */
298
299 struct read_capacity_data {
300 __be32 LogicalBlockAddress;
301 __be32 BytesPerBlock;
302 };
303
304 /*
305 * Read Block Limits Data - returned in Big Endian format
306 * This structure returns the maximum and minimum block
307 * size for a TAPE device.
308 */
309
310 struct read_block_limits {
311 unsigned char Reserved;
312 unsigned char BlockMaximumSize[3];
313 unsigned char BlockMinimumSize[2];
314 };
315
316
317 /*
318 * Sense Data Format
319 */
320
321 #define SENSE_ERRCODE 0x7f
322 #define SENSE_ERRCODE_VALID 0x80
323 #define SENSE_FLAG_SENSE_KEY 0x0f
324 #define SENSE_FLAG_BAD_LENGTH 0x20
325 #define SENSE_FLAG_END_OF_MEDIA 0x40
326 #define SENSE_FLAG_FILE_MARK 0x80
327 struct sense_data {
328 unsigned char ErrorCode;
329 unsigned char SegmentNumber;
330 unsigned char Flags;
331 unsigned char Information[4];
332 unsigned char AdditionalSenseLength;
333 unsigned char CommandSpecificInformation[4];
334 unsigned char AdditionalSenseCode;
335 unsigned char AdditionalSenseCodeQualifier;
336 unsigned char FieldReplaceableUnitCode;
337 unsigned char SenseKeySpecific[3];
338 } __attribute__ ((packed));
339
340 /*
341 * Default request sense buffer size
342 */
343
344 #define SENSE_BUFFER_SIZE 18
345
346 /***********************************************************************
347 * Helper routines
348 ***********************************************************************/
349
350 /**************************************************************************
351 * isd200_build_sense
352 *
353 * Builds an artificial sense buffer to report the results of a
354 * failed command.
355 *
356 * RETURNS:
357 * void
358 */
359 static void isd200_build_sense(struct us_data *us, struct scsi_cmnd *srb)
360 {
361 struct isd200_info *info = (struct isd200_info *)us->extra;
362 struct sense_data *buf = (struct sense_data *) &srb->sense_buffer[0];
363 unsigned char error = info->ATARegs[IDE_ERROR_OFFSET];
364
365 if(error & ATA_ERROR_MEDIA_CHANGE) {
366 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
367 buf->AdditionalSenseLength = 0xb;
368 buf->Flags = UNIT_ATTENTION;
369 buf->AdditionalSenseCode = 0;
370 buf->AdditionalSenseCodeQualifier = 0;
371 } else if(error & MCR_ERR) {
372 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
373 buf->AdditionalSenseLength = 0xb;
374 buf->Flags = UNIT_ATTENTION;
375 buf->AdditionalSenseCode = 0;
376 buf->AdditionalSenseCodeQualifier = 0;
377 } else if(error & TRK0_ERR) {
378 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
379 buf->AdditionalSenseLength = 0xb;
380 buf->Flags = NOT_READY;
381 buf->AdditionalSenseCode = 0;
382 buf->AdditionalSenseCodeQualifier = 0;
383 } else if(error & ECC_ERR) {
384 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
385 buf->AdditionalSenseLength = 0xb;
386 buf->Flags = DATA_PROTECT;
387 buf->AdditionalSenseCode = 0;
388 buf->AdditionalSenseCodeQualifier = 0;
389 } else {
390 buf->ErrorCode = 0;
391 buf->AdditionalSenseLength = 0;
392 buf->Flags = 0;
393 buf->AdditionalSenseCode = 0;
394 buf->AdditionalSenseCodeQualifier = 0;
395 }
396 }
397
398
399 /***********************************************************************
400 * Transport routines
401 ***********************************************************************/
402
403 /**************************************************************************
404 * isd200_set_srb(), isd200_srb_set_bufflen()
405 *
406 * Two helpers to facilitate in initialization of scsi_cmnd structure
407 * Will need to change when struct scsi_cmnd changes
408 */
409 static void isd200_set_srb(struct isd200_info *info,
410 enum dma_data_direction dir, void* buff, unsigned bufflen)
411 {
412 struct scsi_cmnd *srb = &info->srb;
413
414 if (buff)
415 sg_init_one(&info->sg, buff, bufflen);
416
417 srb->sc_data_direction = dir;
418 srb->request_buffer = buff ? &info->sg : NULL;
419 srb->request_bufflen = bufflen;
420 srb->use_sg = buff ? 1 : 0;
421 }
422
423 static void isd200_srb_set_bufflen(struct scsi_cmnd *srb, unsigned bufflen)
424 {
425 srb->request_bufflen = bufflen;
426 }
427
428
429 /**************************************************************************
430 * isd200_action
431 *
432 * Routine for sending commands to the isd200
433 *
434 * RETURNS:
435 * ISD status code
436 */
437 static int isd200_action( struct us_data *us, int action,
438 void* pointer, int value )
439 {
440 union ata_cdb ata;
441 struct scsi_device srb_dev;
442 struct isd200_info *info = (struct isd200_info *)us->extra;
443 struct scsi_cmnd *srb = &info->srb;
444 int status;
445
446 memset(&ata, 0, sizeof(ata));
447 memset(&srb_dev, 0, sizeof(srb_dev));
448 srb->device = &srb_dev;
449 ++srb->serial_number;
450
451 ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
452 ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
453 ata.generic.TransferBlockSize = 1;
454
455 switch ( action ) {
456 case ACTION_READ_STATUS:
457 US_DEBUGP(" isd200_action(READ_STATUS)\n");
458 ata.generic.ActionSelect = ACTION_SELECT_0|ACTION_SELECT_2;
459 ata.generic.RegisterSelect =
460 REG_CYLINDER_LOW | REG_CYLINDER_HIGH |
461 REG_STATUS | REG_ERROR;
462 isd200_set_srb(info, DMA_FROM_DEVICE, pointer, value);
463 break;
464
465 case ACTION_ENUM:
466 US_DEBUGP(" isd200_action(ENUM,0x%02x)\n",value);
467 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
468 ACTION_SELECT_3|ACTION_SELECT_4|
469 ACTION_SELECT_5;
470 ata.generic.RegisterSelect = REG_DEVICE_HEAD;
471 ata.write.DeviceHeadByte = value;
472 isd200_set_srb(info, DMA_NONE, NULL, 0);
473 break;
474
475 case ACTION_RESET:
476 US_DEBUGP(" isd200_action(RESET)\n");
477 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
478 ACTION_SELECT_3|ACTION_SELECT_4;
479 ata.generic.RegisterSelect = REG_DEVICE_CONTROL;
480 ata.write.DeviceControlByte = ATA_DC_RESET_CONTROLLER;
481 isd200_set_srb(info, DMA_NONE, NULL, 0);
482 break;
483
484 case ACTION_REENABLE:
485 US_DEBUGP(" isd200_action(REENABLE)\n");
486 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
487 ACTION_SELECT_3|ACTION_SELECT_4;
488 ata.generic.RegisterSelect = REG_DEVICE_CONTROL;
489 ata.write.DeviceControlByte = ATA_DC_REENABLE_CONTROLLER;
490 isd200_set_srb(info, DMA_NONE, NULL, 0);
491 break;
492
493 case ACTION_SOFT_RESET:
494 US_DEBUGP(" isd200_action(SOFT_RESET)\n");
495 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_5;
496 ata.generic.RegisterSelect = REG_DEVICE_HEAD | REG_COMMAND;
497 ata.write.DeviceHeadByte = info->DeviceHead;
498 ata.write.CommandByte = WIN_SRST;
499 isd200_set_srb(info, DMA_NONE, NULL, 0);
500 break;
501
502 case ACTION_IDENTIFY:
503 US_DEBUGP(" isd200_action(IDENTIFY)\n");
504 ata.generic.RegisterSelect = REG_COMMAND;
505 ata.write.CommandByte = WIN_IDENTIFY;
506 isd200_set_srb(info, DMA_FROM_DEVICE, info->id,
507 sizeof(struct hd_driveid));
508 break;
509
510 default:
511 US_DEBUGP("Error: Undefined action %d\n",action);
512 return ISD200_ERROR;
513 }
514
515 memcpy(srb->cmnd, &ata, sizeof(ata.generic));
516 srb->cmd_len = sizeof(ata.generic);
517 status = usb_stor_Bulk_transport(srb, us);
518 if (status == USB_STOR_TRANSPORT_GOOD)
519 status = ISD200_GOOD;
520 else {
521 US_DEBUGP(" isd200_action(0x%02x) error: %d\n",action,status);
522 status = ISD200_ERROR;
523 /* need to reset device here */
524 }
525
526 return status;
527 }
528
529 /**************************************************************************
530 * isd200_read_regs
531 *
532 * Read ATA Registers
533 *
534 * RETURNS:
535 * ISD status code
536 */
537 static int isd200_read_regs( struct us_data *us )
538 {
539 struct isd200_info *info = (struct isd200_info *)us->extra;
540 int retStatus = ISD200_GOOD;
541 int transferStatus;
542
543 US_DEBUGP("Entering isd200_IssueATAReadRegs\n");
544
545 transferStatus = isd200_action( us, ACTION_READ_STATUS,
546 info->RegsBuf, sizeof(info->ATARegs) );
547 if (transferStatus != ISD200_TRANSPORT_GOOD) {
548 US_DEBUGP(" Error reading ATA registers\n");
549 retStatus = ISD200_ERROR;
550 } else {
551 memcpy(info->ATARegs, info->RegsBuf, sizeof(info->ATARegs));
552 US_DEBUGP(" Got ATA Register[IDE_ERROR_OFFSET] = 0x%x\n",
553 info->ATARegs[IDE_ERROR_OFFSET]);
554 }
555
556 return retStatus;
557 }
558
559
560 /**************************************************************************
561 * Invoke the transport and basic error-handling/recovery methods
562 *
563 * This is used by the protocol layers to actually send the message to
564 * the device and receive the response.
565 */
566 static void isd200_invoke_transport( struct us_data *us,
567 struct scsi_cmnd *srb,
568 union ata_cdb *ataCdb )
569 {
570 int need_auto_sense = 0;
571 int transferStatus;
572 int result;
573
574 /* send the command to the transport layer */
575 memcpy(srb->cmnd, ataCdb, sizeof(ataCdb->generic));
576 srb->cmd_len = sizeof(ataCdb->generic);
577 transferStatus = usb_stor_Bulk_transport(srb, us);
578
579 /* if the command gets aborted by the higher layers, we need to
580 * short-circuit all other processing
581 */
582 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
583 US_DEBUGP("-- command was aborted\n");
584 goto Handle_Abort;
585 }
586
587 switch (transferStatus) {
588
589 case USB_STOR_TRANSPORT_GOOD:
590 /* Indicate a good result */
591 srb->result = SAM_STAT_GOOD;
592 break;
593
594 case USB_STOR_TRANSPORT_NO_SENSE:
595 US_DEBUGP("-- transport indicates protocol failure\n");
596 srb->result = SAM_STAT_CHECK_CONDITION;
597 return;
598
599 case USB_STOR_TRANSPORT_FAILED:
600 US_DEBUGP("-- transport indicates command failure\n");
601 need_auto_sense = 1;
602 break;
603
604 case USB_STOR_TRANSPORT_ERROR:
605 US_DEBUGP("-- transport indicates transport error\n");
606 srb->result = DID_ERROR << 16;
607 /* Need reset here */
608 return;
609
610 default:
611 US_DEBUGP("-- transport indicates unknown error\n");
612 srb->result = DID_ERROR << 16;
613 /* Need reset here */
614 return;
615 }
616
617 if ((scsi_get_resid(srb) > 0) &&
618 !((srb->cmnd[0] == REQUEST_SENSE) ||
619 (srb->cmnd[0] == INQUIRY) ||
620 (srb->cmnd[0] == MODE_SENSE) ||
621 (srb->cmnd[0] == LOG_SENSE) ||
622 (srb->cmnd[0] == MODE_SENSE_10))) {
623 US_DEBUGP("-- unexpectedly short transfer\n");
624 need_auto_sense = 1;
625 }
626
627 if (need_auto_sense) {
628 result = isd200_read_regs(us);
629 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
630 US_DEBUGP("-- auto-sense aborted\n");
631 goto Handle_Abort;
632 }
633 if (result == ISD200_GOOD) {
634 isd200_build_sense(us, srb);
635 srb->result = SAM_STAT_CHECK_CONDITION;
636
637 /* If things are really okay, then let's show that */
638 if ((srb->sense_buffer[2] & 0xf) == 0x0)
639 srb->result = SAM_STAT_GOOD;
640 } else {
641 srb->result = DID_ERROR << 16;
642 /* Need reset here */
643 }
644 }
645
646 /* Regardless of auto-sense, if we _know_ we have an error
647 * condition, show that in the result code
648 */
649 if (transferStatus == USB_STOR_TRANSPORT_FAILED)
650 srb->result = SAM_STAT_CHECK_CONDITION;
651 return;
652
653 /* abort processing: the bulk-only transport requires a reset
654 * following an abort */
655 Handle_Abort:
656 srb->result = DID_ABORT << 16;
657
658 /* permit the reset transfer to take place */
659 clear_bit(US_FLIDX_ABORTING, &us->flags);
660 /* Need reset here */
661 }
662
663 #ifdef CONFIG_USB_STORAGE_DEBUG
664 static void isd200_log_config( struct isd200_info* info )
665 {
666 US_DEBUGP(" Event Notification: 0x%x\n",
667 info->ConfigData.EventNotification);
668 US_DEBUGP(" External Clock: 0x%x\n",
669 info->ConfigData.ExternalClock);
670 US_DEBUGP(" ATA Init Timeout: 0x%x\n",
671 info->ConfigData.ATAInitTimeout);
672 US_DEBUGP(" ATAPI Command Block Size: 0x%x\n",
673 (info->ConfigData.ATAConfig & ATACFG_BLOCKSIZE) >> 6);
674 US_DEBUGP(" Master/Slave Selection: 0x%x\n",
675 info->ConfigData.ATAConfig & ATACFG_MASTER);
676 US_DEBUGP(" ATAPI Reset: 0x%x\n",
677 info->ConfigData.ATAConfig & ATACFG_ATAPI_RESET);
678 US_DEBUGP(" ATA Timing: 0x%x\n",
679 info->ConfigData.ATAConfig & ATACFG_TIMING);
680 US_DEBUGP(" ATA Major Command: 0x%x\n",
681 info->ConfigData.ATAMajorCommand);
682 US_DEBUGP(" ATA Minor Command: 0x%x\n",
683 info->ConfigData.ATAMinorCommand);
684 US_DEBUGP(" Init Status: 0x%x\n",
685 info->ConfigData.ATAExtraConfig & ATACFGE_INIT_STATUS);
686 US_DEBUGP(" Config Descriptor 2: 0x%x\n",
687 info->ConfigData.ATAExtraConfig & ATACFGE_CONF_DESC2);
688 US_DEBUGP(" Skip Device Boot: 0x%x\n",
689 info->ConfigData.ATAExtraConfig & ATACFGE_SKIP_BOOT);
690 US_DEBUGP(" ATA 3 State Supsend: 0x%x\n",
691 info->ConfigData.ATAExtraConfig & ATACFGE_STATE_SUSPEND);
692 US_DEBUGP(" Descriptor Override: 0x%x\n",
693 info->ConfigData.ATAExtraConfig & ATACFGE_DESC_OVERRIDE);
694 US_DEBUGP(" Last LUN Identifier: 0x%x\n",
695 info->ConfigData.ATAExtraConfig & ATACFGE_LAST_LUN);
696 US_DEBUGP(" SRST Enable: 0x%x\n",
697 info->ConfigData.ATAExtraConfig & CFG_CAPABILITY_SRST);
698 }
699 #endif
700
701 /**************************************************************************
702 * isd200_write_config
703 *
704 * Write the ISD200 Configuration data
705 *
706 * RETURNS:
707 * ISD status code
708 */
709 static int isd200_write_config( struct us_data *us )
710 {
711 struct isd200_info *info = (struct isd200_info *)us->extra;
712 int retStatus = ISD200_GOOD;
713 int result;
714
715 #ifdef CONFIG_USB_STORAGE_DEBUG
716 US_DEBUGP("Entering isd200_write_config\n");
717 US_DEBUGP(" Writing the following ISD200 Config Data:\n");
718 isd200_log_config(info);
719 #endif
720
721 /* let's send the command via the control pipe */
722 result = usb_stor_ctrl_transfer(
723 us,
724 us->send_ctrl_pipe,
725 0x01,
726 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
727 0x0000,
728 0x0002,
729 (void *) &info->ConfigData,
730 sizeof(info->ConfigData));
731
732 if (result >= 0) {
733 US_DEBUGP(" ISD200 Config Data was written successfully\n");
734 } else {
735 US_DEBUGP(" Request to write ISD200 Config Data failed!\n");
736 retStatus = ISD200_ERROR;
737 }
738
739 US_DEBUGP("Leaving isd200_write_config %08X\n", retStatus);
740 return retStatus;
741 }
742
743
744 /**************************************************************************
745 * isd200_read_config
746 *
747 * Reads the ISD200 Configuration data
748 *
749 * RETURNS:
750 * ISD status code
751 */
752 static int isd200_read_config( struct us_data *us )
753 {
754 struct isd200_info *info = (struct isd200_info *)us->extra;
755 int retStatus = ISD200_GOOD;
756 int result;
757
758 US_DEBUGP("Entering isd200_read_config\n");
759
760 /* read the configuration information from ISD200. Use this to */
761 /* determine what the special ATA CDB bytes are. */
762
763 result = usb_stor_ctrl_transfer(
764 us,
765 us->recv_ctrl_pipe,
766 0x02,
767 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
768 0x0000,
769 0x0002,
770 (void *) &info->ConfigData,
771 sizeof(info->ConfigData));
772
773
774 if (result >= 0) {
775 US_DEBUGP(" Retrieved the following ISD200 Config Data:\n");
776 #ifdef CONFIG_USB_STORAGE_DEBUG
777 isd200_log_config(info);
778 #endif
779 } else {
780 US_DEBUGP(" Request to get ISD200 Config Data failed!\n");
781 retStatus = ISD200_ERROR;
782 }
783
784 US_DEBUGP("Leaving isd200_read_config %08X\n", retStatus);
785 return retStatus;
786 }
787
788
789 /**************************************************************************
790 * isd200_atapi_soft_reset
791 *
792 * Perform an Atapi Soft Reset on the device
793 *
794 * RETURNS:
795 * NT status code
796 */
797 static int isd200_atapi_soft_reset( struct us_data *us )
798 {
799 int retStatus = ISD200_GOOD;
800 int transferStatus;
801
802 US_DEBUGP("Entering isd200_atapi_soft_reset\n");
803
804 transferStatus = isd200_action( us, ACTION_SOFT_RESET, NULL, 0 );
805 if (transferStatus != ISD200_TRANSPORT_GOOD) {
806 US_DEBUGP(" Error issuing Atapi Soft Reset\n");
807 retStatus = ISD200_ERROR;
808 }
809
810 US_DEBUGP("Leaving isd200_atapi_soft_reset %08X\n", retStatus);
811 return retStatus;
812 }
813
814
815 /**************************************************************************
816 * isd200_srst
817 *
818 * Perform an SRST on the device
819 *
820 * RETURNS:
821 * ISD status code
822 */
823 static int isd200_srst( struct us_data *us )
824 {
825 int retStatus = ISD200_GOOD;
826 int transferStatus;
827
828 US_DEBUGP("Entering isd200_SRST\n");
829
830 transferStatus = isd200_action( us, ACTION_RESET, NULL, 0 );
831
832 /* check to see if this request failed */
833 if (transferStatus != ISD200_TRANSPORT_GOOD) {
834 US_DEBUGP(" Error issuing SRST\n");
835 retStatus = ISD200_ERROR;
836 } else {
837 /* delay 10ms to give the drive a chance to see it */
838 msleep(10);
839
840 transferStatus = isd200_action( us, ACTION_REENABLE, NULL, 0 );
841 if (transferStatus != ISD200_TRANSPORT_GOOD) {
842 US_DEBUGP(" Error taking drive out of reset\n");
843 retStatus = ISD200_ERROR;
844 } else {
845 /* delay 50ms to give the drive a chance to recover after SRST */
846 msleep(50);
847 }
848 }
849
850 US_DEBUGP("Leaving isd200_srst %08X\n", retStatus);
851 return retStatus;
852 }
853
854
855 /**************************************************************************
856 * isd200_try_enum
857 *
858 * Helper function for isd200_manual_enum(). Does ENUM and READ_STATUS
859 * and tries to analyze the status registers
860 *
861 * RETURNS:
862 * ISD status code
863 */
864 static int isd200_try_enum(struct us_data *us, unsigned char master_slave,
865 int detect )
866 {
867 int status = ISD200_GOOD;
868 unsigned long endTime;
869 struct isd200_info *info = (struct isd200_info *)us->extra;
870 unsigned char *regs = info->RegsBuf;
871 int recheckAsMaster = 0;
872
873 if ( detect )
874 endTime = jiffies + ISD200_ENUM_DETECT_TIMEOUT * HZ;
875 else
876 endTime = jiffies + ISD200_ENUM_BSY_TIMEOUT * HZ;
877
878 /* loop until we detect !BSY or timeout */
879 while(1) {
880 #ifdef CONFIG_USB_STORAGE_DEBUG
881 char* mstr = master_slave == ATA_ADDRESS_DEVHEAD_STD ?
882 "Master" : "Slave";
883 #endif
884
885 status = isd200_action( us, ACTION_ENUM, NULL, master_slave );
886 if ( status != ISD200_GOOD )
887 break;
888
889 status = isd200_action( us, ACTION_READ_STATUS,
890 regs, 8 );
891 if ( status != ISD200_GOOD )
892 break;
893
894 if (!detect) {
895 if (regs[IDE_STATUS_OFFSET] & BUSY_STAT ) {
896 US_DEBUGP(" %s status is still BSY, try again...\n",mstr);
897 } else {
898 US_DEBUGP(" %s status !BSY, continue with next operation\n",mstr);
899 break;
900 }
901 }
902 /* check for BUSY_STAT and */
903 /* WRERR_STAT (workaround ATA Zip drive) and */
904 /* ERR_STAT (workaround for Archos CD-ROM) */
905 else if (regs[IDE_STATUS_OFFSET] &
906 (BUSY_STAT | WRERR_STAT | ERR_STAT )) {
907 US_DEBUGP(" Status indicates it is not ready, try again...\n");
908 }
909 /* check for DRDY, ATA devices set DRDY after SRST */
910 else if (regs[IDE_STATUS_OFFSET] & READY_STAT) {
911 US_DEBUGP(" Identified ATA device\n");
912 info->DeviceFlags |= DF_ATA_DEVICE;
913 info->DeviceHead = master_slave;
914 break;
915 }
916 /* check Cylinder High/Low to
917 determine if it is an ATAPI device
918 */
919 else if ((regs[IDE_HCYL_OFFSET] == 0xEB) &&
920 (regs[IDE_LCYL_OFFSET] == 0x14)) {
921 /* It seems that the RICOH
922 MP6200A CD/RW drive will
923 report itself okay as a
924 slave when it is really a
925 master. So this check again
926 as a master device just to
927 make sure it doesn't report
928 itself okay as a master also
929 */
930 if ((master_slave & ATA_ADDRESS_DEVHEAD_SLAVE) &&
931 !recheckAsMaster) {
932 US_DEBUGP(" Identified ATAPI device as slave. Rechecking again as master\n");
933 recheckAsMaster = 1;
934 master_slave = ATA_ADDRESS_DEVHEAD_STD;
935 } else {
936 US_DEBUGP(" Identified ATAPI device\n");
937 info->DeviceHead = master_slave;
938
939 status = isd200_atapi_soft_reset(us);
940 break;
941 }
942 } else {
943 US_DEBUGP(" Not ATA, not ATAPI. Weird.\n");
944 break;
945 }
946
947 /* check for timeout on this request */
948 if (time_after_eq(jiffies, endTime)) {
949 if (!detect)
950 US_DEBUGP(" BSY check timeout, just continue with next operation...\n");
951 else
952 US_DEBUGP(" Device detect timeout!\n");
953 break;
954 }
955 }
956
957 return status;
958 }
959
960 /**************************************************************************
961 * isd200_manual_enum
962 *
963 * Determines if the drive attached is an ATA or ATAPI and if it is a
964 * master or slave.
965 *
966 * RETURNS:
967 * ISD status code
968 */
969 static int isd200_manual_enum(struct us_data *us)
970 {
971 struct isd200_info *info = (struct isd200_info *)us->extra;
972 int retStatus = ISD200_GOOD;
973
974 US_DEBUGP("Entering isd200_manual_enum\n");
975
976 retStatus = isd200_read_config(us);
977 if (retStatus == ISD200_GOOD) {
978 int isslave;
979 /* master or slave? */
980 retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, 0);
981 if (retStatus == ISD200_GOOD)
982 retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_SLAVE, 0);
983
984 if (retStatus == ISD200_GOOD) {
985 retStatus = isd200_srst(us);
986 if (retStatus == ISD200_GOOD)
987 /* ata or atapi? */
988 retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, 1);
989 }
990
991 isslave = (info->DeviceHead & ATA_ADDRESS_DEVHEAD_SLAVE) ? 1 : 0;
992 if (!(info->ConfigData.ATAConfig & ATACFG_MASTER)) {
993 US_DEBUGP(" Setting Master/Slave selection to %d\n", isslave);
994 info->ConfigData.ATAConfig &= 0x3f;
995 info->ConfigData.ATAConfig |= (isslave<<6);
996 retStatus = isd200_write_config(us);
997 }
998 }
999
1000 US_DEBUGP("Leaving isd200_manual_enum %08X\n", retStatus);
1001 return(retStatus);
1002 }
1003
1004 /*
1005 * We are the last non IDE user of the legacy IDE ident structures
1006 * and we thus want to keep a private copy of this function so the
1007 * driver can be used without the obsolete drivers/ide layer
1008 */
1009
1010 static void isd200_fix_driveid (struct hd_driveid *id)
1011 {
1012 #ifndef __LITTLE_ENDIAN
1013 # ifdef __BIG_ENDIAN
1014 int i;
1015 u16 *stringcast;
1016
1017 id->config = __le16_to_cpu(id->config);
1018 id->cyls = __le16_to_cpu(id->cyls);
1019 id->reserved2 = __le16_to_cpu(id->reserved2);
1020 id->heads = __le16_to_cpu(id->heads);
1021 id->track_bytes = __le16_to_cpu(id->track_bytes);
1022 id->sector_bytes = __le16_to_cpu(id->sector_bytes);
1023 id->sectors = __le16_to_cpu(id->sectors);
1024 id->vendor0 = __le16_to_cpu(id->vendor0);
1025 id->vendor1 = __le16_to_cpu(id->vendor1);
1026 id->vendor2 = __le16_to_cpu(id->vendor2);
1027 stringcast = (u16 *)&id->serial_no[0];
1028 for (i = 0; i < (20/2); i++)
1029 stringcast[i] = __le16_to_cpu(stringcast[i]);
1030 id->buf_type = __le16_to_cpu(id->buf_type);
1031 id->buf_size = __le16_to_cpu(id->buf_size);
1032 id->ecc_bytes = __le16_to_cpu(id->ecc_bytes);
1033 stringcast = (u16 *)&id->fw_rev[0];
1034 for (i = 0; i < (8/2); i++)
1035 stringcast[i] = __le16_to_cpu(stringcast[i]);
1036 stringcast = (u16 *)&id->model[0];
1037 for (i = 0; i < (40/2); i++)
1038 stringcast[i] = __le16_to_cpu(stringcast[i]);
1039 id->dword_io = __le16_to_cpu(id->dword_io);
1040 id->reserved50 = __le16_to_cpu(id->reserved50);
1041 id->field_valid = __le16_to_cpu(id->field_valid);
1042 id->cur_cyls = __le16_to_cpu(id->cur_cyls);
1043 id->cur_heads = __le16_to_cpu(id->cur_heads);
1044 id->cur_sectors = __le16_to_cpu(id->cur_sectors);
1045 id->cur_capacity0 = __le16_to_cpu(id->cur_capacity0);
1046 id->cur_capacity1 = __le16_to_cpu(id->cur_capacity1);
1047 id->lba_capacity = __le32_to_cpu(id->lba_capacity);
1048 id->dma_1word = __le16_to_cpu(id->dma_1word);
1049 id->dma_mword = __le16_to_cpu(id->dma_mword);
1050 id->eide_pio_modes = __le16_to_cpu(id->eide_pio_modes);
1051 id->eide_dma_min = __le16_to_cpu(id->eide_dma_min);
1052 id->eide_dma_time = __le16_to_cpu(id->eide_dma_time);
1053 id->eide_pio = __le16_to_cpu(id->eide_pio);
1054 id->eide_pio_iordy = __le16_to_cpu(id->eide_pio_iordy);
1055 for (i = 0; i < 2; ++i)
1056 id->words69_70[i] = __le16_to_cpu(id->words69_70[i]);
1057 for (i = 0; i < 4; ++i)
1058 id->words71_74[i] = __le16_to_cpu(id->words71_74[i]);
1059 id->queue_depth = __le16_to_cpu(id->queue_depth);
1060 for (i = 0; i < 4; ++i)
1061 id->words76_79[i] = __le16_to_cpu(id->words76_79[i]);
1062 id->major_rev_num = __le16_to_cpu(id->major_rev_num);
1063 id->minor_rev_num = __le16_to_cpu(id->minor_rev_num);
1064 id->command_set_1 = __le16_to_cpu(id->command_set_1);
1065 id->command_set_2 = __le16_to_cpu(id->command_set_2);
1066 id->cfsse = __le16_to_cpu(id->cfsse);
1067 id->cfs_enable_1 = __le16_to_cpu(id->cfs_enable_1);
1068 id->cfs_enable_2 = __le16_to_cpu(id->cfs_enable_2);
1069 id->csf_default = __le16_to_cpu(id->csf_default);
1070 id->dma_ultra = __le16_to_cpu(id->dma_ultra);
1071 id->trseuc = __le16_to_cpu(id->trseuc);
1072 id->trsEuc = __le16_to_cpu(id->trsEuc);
1073 id->CurAPMvalues = __le16_to_cpu(id->CurAPMvalues);
1074 id->mprc = __le16_to_cpu(id->mprc);
1075 id->hw_config = __le16_to_cpu(id->hw_config);
1076 id->acoustic = __le16_to_cpu(id->acoustic);
1077 id->msrqs = __le16_to_cpu(id->msrqs);
1078 id->sxfert = __le16_to_cpu(id->sxfert);
1079 id->sal = __le16_to_cpu(id->sal);
1080 id->spg = __le32_to_cpu(id->spg);
1081 id->lba_capacity_2 = __le64_to_cpu(id->lba_capacity_2);
1082 for (i = 0; i < 22; i++)
1083 id->words104_125[i] = __le16_to_cpu(id->words104_125[i]);
1084 id->last_lun = __le16_to_cpu(id->last_lun);
1085 id->word127 = __le16_to_cpu(id->word127);
1086 id->dlf = __le16_to_cpu(id->dlf);
1087 id->csfo = __le16_to_cpu(id->csfo);
1088 for (i = 0; i < 26; i++)
1089 id->words130_155[i] = __le16_to_cpu(id->words130_155[i]);
1090 id->word156 = __le16_to_cpu(id->word156);
1091 for (i = 0; i < 3; i++)
1092 id->words157_159[i] = __le16_to_cpu(id->words157_159[i]);
1093 id->cfa_power = __le16_to_cpu(id->cfa_power);
1094 for (i = 0; i < 14; i++)
1095 id->words161_175[i] = __le16_to_cpu(id->words161_175[i]);
1096 for (i = 0; i < 31; i++)
1097 id->words176_205[i] = __le16_to_cpu(id->words176_205[i]);
1098 for (i = 0; i < 48; i++)
1099 id->words206_254[i] = __le16_to_cpu(id->words206_254[i]);
1100 id->integrity_word = __le16_to_cpu(id->integrity_word);
1101 # else
1102 # error "Please fix <asm/byteorder.h>"
1103 # endif
1104 #endif
1105 }
1106
1107
1108 /**************************************************************************
1109 * isd200_get_inquiry_data
1110 *
1111 * Get inquiry data
1112 *
1113 * RETURNS:
1114 * ISD status code
1115 */
1116 static int isd200_get_inquiry_data( struct us_data *us )
1117 {
1118 struct isd200_info *info = (struct isd200_info *)us->extra;
1119 int retStatus = ISD200_GOOD;
1120 struct hd_driveid *id = info->id;
1121
1122 US_DEBUGP("Entering isd200_get_inquiry_data\n");
1123
1124 /* set default to Master */
1125 info->DeviceHead = ATA_ADDRESS_DEVHEAD_STD;
1126
1127 /* attempt to manually enumerate this device */
1128 retStatus = isd200_manual_enum(us);
1129 if (retStatus == ISD200_GOOD) {
1130 int transferStatus;
1131
1132 /* check for an ATA device */
1133 if (info->DeviceFlags & DF_ATA_DEVICE) {
1134 /* this must be an ATA device */
1135 /* perform an ATA Command Identify */
1136 transferStatus = isd200_action( us, ACTION_IDENTIFY,
1137 id,
1138 sizeof(struct hd_driveid) );
1139 if (transferStatus != ISD200_TRANSPORT_GOOD) {
1140 /* Error issuing ATA Command Identify */
1141 US_DEBUGP(" Error issuing ATA Command Identify\n");
1142 retStatus = ISD200_ERROR;
1143 } else {
1144 /* ATA Command Identify successful */
1145 int i;
1146 __be16 *src;
1147 __u16 *dest;
1148 isd200_fix_driveid(id);
1149
1150 US_DEBUGP(" Identify Data Structure:\n");
1151 US_DEBUGP(" config = 0x%x\n", id->config);
1152 US_DEBUGP(" cyls = 0x%x\n", id->cyls);
1153 US_DEBUGP(" heads = 0x%x\n", id->heads);
1154 US_DEBUGP(" track_bytes = 0x%x\n", id->track_bytes);
1155 US_DEBUGP(" sector_bytes = 0x%x\n", id->sector_bytes);
1156 US_DEBUGP(" sectors = 0x%x\n", id->sectors);
1157 US_DEBUGP(" serial_no[0] = 0x%x\n", id->serial_no[0]);
1158 US_DEBUGP(" buf_type = 0x%x\n", id->buf_type);
1159 US_DEBUGP(" buf_size = 0x%x\n", id->buf_size);
1160 US_DEBUGP(" ecc_bytes = 0x%x\n", id->ecc_bytes);
1161 US_DEBUGP(" fw_rev[0] = 0x%x\n", id->fw_rev[0]);
1162 US_DEBUGP(" model[0] = 0x%x\n", id->model[0]);
1163 US_DEBUGP(" max_multsect = 0x%x\n", id->max_multsect);
1164 US_DEBUGP(" dword_io = 0x%x\n", id->dword_io);
1165 US_DEBUGP(" capability = 0x%x\n", id->capability);
1166 US_DEBUGP(" tPIO = 0x%x\n", id->tPIO);
1167 US_DEBUGP(" tDMA = 0x%x\n", id->tDMA);
1168 US_DEBUGP(" field_valid = 0x%x\n", id->field_valid);
1169 US_DEBUGP(" cur_cyls = 0x%x\n", id->cur_cyls);
1170 US_DEBUGP(" cur_heads = 0x%x\n", id->cur_heads);
1171 US_DEBUGP(" cur_sectors = 0x%x\n", id->cur_sectors);
1172 US_DEBUGP(" cur_capacity = 0x%x\n", (id->cur_capacity1 << 16) + id->cur_capacity0 );
1173 US_DEBUGP(" multsect = 0x%x\n", id->multsect);
1174 US_DEBUGP(" lba_capacity = 0x%x\n", id->lba_capacity);
1175 US_DEBUGP(" command_set_1 = 0x%x\n", id->command_set_1);
1176 US_DEBUGP(" command_set_2 = 0x%x\n", id->command_set_2);
1177
1178 memset(&info->InquiryData, 0, sizeof(info->InquiryData));
1179
1180 /* Standard IDE interface only supports disks */
1181 info->InquiryData.DeviceType = DIRECT_ACCESS_DEVICE;
1182
1183 /* The length must be at least 36 (5 + 31) */
1184 info->InquiryData.AdditionalLength = 0x1F;
1185
1186 if (id->command_set_1 & COMMANDSET_MEDIA_STATUS) {
1187 /* set the removable bit */
1188 info->InquiryData.DeviceTypeModifier = DEVICE_REMOVABLE;
1189 info->DeviceFlags |= DF_REMOVABLE_MEDIA;
1190 }
1191
1192 /* Fill in vendor identification fields */
1193 src = (__be16*)id->model;
1194 dest = (__u16*)info->InquiryData.VendorId;
1195 for (i=0;i<4;i++)
1196 dest[i] = be16_to_cpu(src[i]);
1197
1198 src = (__be16*)(id->model+8);
1199 dest = (__u16*)info->InquiryData.ProductId;
1200 for (i=0;i<8;i++)
1201 dest[i] = be16_to_cpu(src[i]);
1202
1203 src = (__be16*)id->fw_rev;
1204 dest = (__u16*)info->InquiryData.ProductRevisionLevel;
1205 for (i=0;i<2;i++)
1206 dest[i] = be16_to_cpu(src[i]);
1207
1208 /* determine if it supports Media Status Notification */
1209 if (id->command_set_2 & COMMANDSET_MEDIA_STATUS) {
1210 US_DEBUGP(" Device supports Media Status Notification\n");
1211
1212 /* Indicate that it is enabled, even though it is not
1213 * This allows the lock/unlock of the media to work
1214 * correctly.
1215 */
1216 info->DeviceFlags |= DF_MEDIA_STATUS_ENABLED;
1217 }
1218 else
1219 info->DeviceFlags &= ~DF_MEDIA_STATUS_ENABLED;
1220
1221 }
1222 } else {
1223 /*
1224 * this must be an ATAPI device
1225 * use an ATAPI protocol (Transparent SCSI)
1226 */
1227 us->protocol_name = "Transparent SCSI";
1228 us->proto_handler = usb_stor_transparent_scsi_command;
1229
1230 US_DEBUGP("Protocol changed to: %s\n", us->protocol_name);
1231
1232 /* Free driver structure */
1233 us->extra_destructor(info);
1234 us->extra = NULL;
1235 us->extra_destructor = NULL;
1236 }
1237 }
1238
1239 US_DEBUGP("Leaving isd200_get_inquiry_data %08X\n", retStatus);
1240
1241 return(retStatus);
1242 }
1243
1244 /**************************************************************************
1245 * isd200_scsi_to_ata
1246 *
1247 * Translate SCSI commands to ATA commands.
1248 *
1249 * RETURNS:
1250 * 1 if the command needs to be sent to the transport layer
1251 * 0 otherwise
1252 */
1253 static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
1254 union ata_cdb * ataCdb)
1255 {
1256 struct isd200_info *info = (struct isd200_info *)us->extra;
1257 struct hd_driveid *id = info->id;
1258 int sendToTransport = 1;
1259 unsigned char sectnum, head;
1260 unsigned short cylinder;
1261 unsigned long lba;
1262 unsigned long blockCount;
1263 unsigned char senseData[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
1264
1265 memset(ataCdb, 0, sizeof(union ata_cdb));
1266
1267 /* SCSI Command */
1268 switch (srb->cmnd[0]) {
1269 case INQUIRY:
1270 US_DEBUGP(" ATA OUT - INQUIRY\n");
1271
1272 /* copy InquiryData */
1273 usb_stor_set_xfer_buf((unsigned char *) &info->InquiryData,
1274 sizeof(info->InquiryData), srb);
1275 srb->result = SAM_STAT_GOOD;
1276 sendToTransport = 0;
1277 break;
1278
1279 case MODE_SENSE:
1280 US_DEBUGP(" ATA OUT - SCSIOP_MODE_SENSE\n");
1281
1282 /* Initialize the return buffer */
1283 usb_stor_set_xfer_buf(senseData, sizeof(senseData), srb);
1284
1285 if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED)
1286 {
1287 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1288 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1289 ataCdb->generic.TransferBlockSize = 1;
1290 ataCdb->generic.RegisterSelect = REG_COMMAND;
1291 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
1292 isd200_srb_set_bufflen(srb, 0);
1293 } else {
1294 US_DEBUGP(" Media Status not supported, just report okay\n");
1295 srb->result = SAM_STAT_GOOD;
1296 sendToTransport = 0;
1297 }
1298 break;
1299
1300 case TEST_UNIT_READY:
1301 US_DEBUGP(" ATA OUT - SCSIOP_TEST_UNIT_READY\n");
1302
1303 if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED)
1304 {
1305 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1306 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1307 ataCdb->generic.TransferBlockSize = 1;
1308 ataCdb->generic.RegisterSelect = REG_COMMAND;
1309 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
1310 isd200_srb_set_bufflen(srb, 0);
1311 } else {
1312 US_DEBUGP(" Media Status not supported, just report okay\n");
1313 srb->result = SAM_STAT_GOOD;
1314 sendToTransport = 0;
1315 }
1316 break;
1317
1318 case READ_CAPACITY:
1319 {
1320 unsigned long capacity;
1321 struct read_capacity_data readCapacityData;
1322
1323 US_DEBUGP(" ATA OUT - SCSIOP_READ_CAPACITY\n");
1324
1325 if (id->capability & CAPABILITY_LBA ) {
1326 capacity = id->lba_capacity - 1;
1327 } else {
1328 capacity = (id->heads *
1329 id->cyls *
1330 id->sectors) - 1;
1331 }
1332 readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity);
1333 readCapacityData.BytesPerBlock = cpu_to_be32(0x200);
1334
1335 usb_stor_set_xfer_buf((unsigned char *) &readCapacityData,
1336 sizeof(readCapacityData), srb);
1337 srb->result = SAM_STAT_GOOD;
1338 sendToTransport = 0;
1339 }
1340 break;
1341
1342 case READ_10:
1343 US_DEBUGP(" ATA OUT - SCSIOP_READ\n");
1344
1345 lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]);
1346 blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
1347
1348 if (id->capability & CAPABILITY_LBA) {
1349 sectnum = (unsigned char)(lba);
1350 cylinder = (unsigned short)(lba>>8);
1351 head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
1352 } else {
1353 sectnum = (unsigned char)((lba % id->sectors) + 1);
1354 cylinder = (unsigned short)(lba / (id->sectors *
1355 id->heads));
1356 head = (unsigned char)((lba / id->sectors) %
1357 id->heads);
1358 }
1359 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1360 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1361 ataCdb->generic.TransferBlockSize = 1;
1362 ataCdb->generic.RegisterSelect =
1363 REG_SECTOR_COUNT | REG_SECTOR_NUMBER |
1364 REG_CYLINDER_LOW | REG_CYLINDER_HIGH |
1365 REG_DEVICE_HEAD | REG_COMMAND;
1366 ataCdb->write.SectorCountByte = (unsigned char)blockCount;
1367 ataCdb->write.SectorNumberByte = sectnum;
1368 ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
1369 ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
1370 ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
1371 ataCdb->write.CommandByte = WIN_READ;
1372 break;
1373
1374 case WRITE_10:
1375 US_DEBUGP(" ATA OUT - SCSIOP_WRITE\n");
1376
1377 lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]);
1378 blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
1379
1380 if (id->capability & CAPABILITY_LBA) {
1381 sectnum = (unsigned char)(lba);
1382 cylinder = (unsigned short)(lba>>8);
1383 head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
1384 } else {
1385 sectnum = (unsigned char)((lba % id->sectors) + 1);
1386 cylinder = (unsigned short)(lba / (id->sectors * id->heads));
1387 head = (unsigned char)((lba / id->sectors) % id->heads);
1388 }
1389 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1390 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1391 ataCdb->generic.TransferBlockSize = 1;
1392 ataCdb->generic.RegisterSelect =
1393 REG_SECTOR_COUNT | REG_SECTOR_NUMBER |
1394 REG_CYLINDER_LOW | REG_CYLINDER_HIGH |
1395 REG_DEVICE_HEAD | REG_COMMAND;
1396 ataCdb->write.SectorCountByte = (unsigned char)blockCount;
1397 ataCdb->write.SectorNumberByte = sectnum;
1398 ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
1399 ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
1400 ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
1401 ataCdb->write.CommandByte = WIN_WRITE;
1402 break;
1403
1404 case ALLOW_MEDIUM_REMOVAL:
1405 US_DEBUGP(" ATA OUT - SCSIOP_MEDIUM_REMOVAL\n");
1406
1407 if (info->DeviceFlags & DF_REMOVABLE_MEDIA) {
1408 US_DEBUGP(" srb->cmnd[4] = 0x%X\n", srb->cmnd[4]);
1409
1410 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1411 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1412 ataCdb->generic.TransferBlockSize = 1;
1413 ataCdb->generic.RegisterSelect = REG_COMMAND;
1414 ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ?
1415 WIN_DOORLOCK : WIN_DOORUNLOCK;
1416 isd200_srb_set_bufflen(srb, 0);
1417 } else {
1418 US_DEBUGP(" Not removeable media, just report okay\n");
1419 srb->result = SAM_STAT_GOOD;
1420 sendToTransport = 0;
1421 }
1422 break;
1423
1424 case START_STOP:
1425 US_DEBUGP(" ATA OUT - SCSIOP_START_STOP_UNIT\n");
1426 US_DEBUGP(" srb->cmnd[4] = 0x%X\n", srb->cmnd[4]);
1427
1428 if ((srb->cmnd[4] & 0x3) == 0x2) {
1429 US_DEBUGP(" Media Eject\n");
1430 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1431 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1432 ataCdb->generic.TransferBlockSize = 0;
1433 ataCdb->generic.RegisterSelect = REG_COMMAND;
1434 ataCdb->write.CommandByte = ATA_COMMAND_MEDIA_EJECT;
1435 } else if ((srb->cmnd[4] & 0x3) == 0x1) {
1436 US_DEBUGP(" Get Media Status\n");
1437 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
1438 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
1439 ataCdb->generic.TransferBlockSize = 1;
1440 ataCdb->generic.RegisterSelect = REG_COMMAND;
1441 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
1442 isd200_srb_set_bufflen(srb, 0);
1443 } else {
1444 US_DEBUGP(" Nothing to do, just report okay\n");
1445 srb->result = SAM_STAT_GOOD;
1446 sendToTransport = 0;
1447 }
1448 break;
1449
1450 default:
1451 US_DEBUGP("Unsupported SCSI command - 0x%X\n", srb->cmnd[0]);
1452 srb->result = DID_ERROR << 16;
1453 sendToTransport = 0;
1454 break;
1455 }
1456
1457 return(sendToTransport);
1458 }
1459
1460
1461 /**************************************************************************
1462 * isd200_free_info
1463 *
1464 * Frees the driver structure.
1465 */
1466 static void isd200_free_info_ptrs(void *info_)
1467 {
1468 struct isd200_info *info = (struct isd200_info *) info_;
1469
1470 if (info) {
1471 kfree(info->id);
1472 kfree(info->RegsBuf);
1473 }
1474 }
1475
1476 /**************************************************************************
1477 * isd200_init_info
1478 *
1479 * Allocates (if necessary) and initializes the driver structure.
1480 *
1481 * RETURNS:
1482 * ISD status code
1483 */
1484 static int isd200_init_info(struct us_data *us)
1485 {
1486 int retStatus = ISD200_GOOD;
1487 struct isd200_info *info;
1488
1489 info = (struct isd200_info *)
1490 kzalloc(sizeof(struct isd200_info), GFP_KERNEL);
1491 if (!info)
1492 retStatus = ISD200_ERROR;
1493 else {
1494 info->id = (struct hd_driveid *)
1495 kzalloc(sizeof(struct hd_driveid), GFP_KERNEL);
1496 info->RegsBuf = (unsigned char *)
1497 kmalloc(sizeof(info->ATARegs), GFP_KERNEL);
1498 if (!info->id || !info->RegsBuf) {
1499 isd200_free_info_ptrs(info);
1500 kfree(info);
1501 retStatus = ISD200_ERROR;
1502 }
1503 }
1504
1505 if (retStatus == ISD200_GOOD) {
1506 us->extra = info;
1507 us->extra_destructor = isd200_free_info_ptrs;
1508 } else
1509 US_DEBUGP("ERROR - kmalloc failure\n");
1510
1511 return retStatus;
1512 }
1513
1514 /**************************************************************************
1515 * Initialization for the ISD200
1516 */
1517
1518 int isd200_Initialization(struct us_data *us)
1519 {
1520 US_DEBUGP("ISD200 Initialization...\n");
1521
1522 /* Initialize ISD200 info struct */
1523
1524 if (isd200_init_info(us) == ISD200_ERROR) {
1525 US_DEBUGP("ERROR Initializing ISD200 Info struct\n");
1526 } else {
1527 /* Get device specific data */
1528
1529 if (isd200_get_inquiry_data(us) != ISD200_GOOD)
1530 US_DEBUGP("ISD200 Initialization Failure\n");
1531 else
1532 US_DEBUGP("ISD200 Initialization complete\n");
1533 }
1534
1535 return 0;
1536 }
1537
1538
1539 /**************************************************************************
1540 * Protocol and Transport for the ISD200 ASIC
1541 *
1542 * This protocol and transport are for ATA devices connected to an ISD200
1543 * ASIC. An ATAPI device that is conected as a slave device will be
1544 * detected in the driver initialization function and the protocol will
1545 * be changed to an ATAPI protocol (Transparent SCSI).
1546 *
1547 */
1548
1549 void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us)
1550 {
1551 int sendToTransport = 1, orig_bufflen;
1552 union ata_cdb ataCdb;
1553
1554 /* Make sure driver was initialized */
1555
1556 if (us->extra == NULL)
1557 US_DEBUGP("ERROR Driver not initialized\n");
1558
1559 scsi_set_resid(srb, 0);
1560 /* scsi_bufflen might change in protocol translation to ata */
1561 orig_bufflen = scsi_bufflen(srb);
1562 sendToTransport = isd200_scsi_to_ata(srb, us, &ataCdb);
1563
1564 /* send the command to the transport layer */
1565 if (sendToTransport)
1566 isd200_invoke_transport(us, srb, &ataCdb);
1567
1568 isd200_srb_set_bufflen(srb, orig_bufflen);
1569 }
WRT350N Kernel Patches