Annotation of embedaddon/smartmontools/scsiata.cpp, revision 1.1.1.1
1.1 misho 1: /*
2: * scsiata.cpp
3: *
4: * Home page of code is: http://smartmontools.sourceforge.net
5: *
6: * Copyright (C) 2006-10 Douglas Gilbert <dgilbert@interlog.com>
7: * Copyright (C) 2009-10 Christian Franke <smartmontools-support@lists.sourceforge.net>
8: *
9: * This program is free software; you can redistribute it and/or modify
10: * it under the terms of the GNU General Public License as published by
11: * the Free Software Foundation; either version 2, or (at your option)
12: * any later version.
13: *
14: * You should have received a copy of the GNU General Public License
15: * (for example COPYING); if not, write to the Free
16: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: *
18: * The code in this file is based on the SCSI to ATA Translation (SAT)
19: * draft found at http://www.t10.org . The original draft used for this
20: * code is sat-r08.pdf which is not too far away from becoming a
21: * standard. The SAT commands of interest to smartmontools are the
22: * ATA PASS THROUGH SCSI (16) and ATA PASS THROUGH SCSI (12) defined in
23: * section 12 of that document.
24: *
25: * sat-r09.pdf is the most recent, easily accessible draft prior to the
26: * original SAT standard (ANSI INCITS 431-2007). By mid-2009 the second
27: * version of the SAT standard (SAT-2) is nearing standardization. In
28: * their wisdom an incompatible change has been introduced in draft
29: * sat2r08a.pdf in the area of the ATA RETURN DESCRIPTOR. A new "fixed
30: * format" ATA RETURN buffer has been defined (sat2r08b.pdf section
31: * 12.2.7) for the case when DSENSE=0 in the Control mode page.
32: * Unfortunately this is the normal case. If the change stands our
33: * code will need to be extended for this case.
34: *
35: * With more transports "hiding" SATA disks (and other S-ATAPI devices)
36: * behind a SCSI command set, accessing special features like SMART
37: * information becomes a challenge. The SAT standard offers ATA PASS
38: * THROUGH commands for special usages. Note that the SAT layer may
39: * be inside a generic OS layer (e.g. libata in linux), in a host
40: * adapter (HA or HBA) firmware, or somewhere on the interconnect
41: * between the host computer and the SATA devices (e.g. a RAID made
42: * of SATA disks and the RAID talks "SCSI" to the host computer).
43: * Note that in the latter case, this code does not solve the
44: * addressing issue (i.e. which SATA disk to address behind the logical
45: * SCSI (RAID) interface).
46: *
47: */
48:
49: #include <stdio.h>
50: #include <string.h>
51: #include <stdlib.h>
52: #include <ctype.h>
53: #include <errno.h>
54:
55: #include "config.h"
56: #include "int64.h"
57: #include "scsicmds.h"
58: #include "atacmds.h" // ataReadHDIdentity()
59: #include "knowndrives.h" // lookup_usb_device()
60: #include "utility.h"
61: #include "dev_interface.h"
62: #include "dev_ata_cmd_set.h" // ata_device_with_command_set
63: #include "dev_tunnelled.h" // tunnelled_device<>
64:
65: const char * scsiata_cpp_cvsid = "$Id: scsiata.cpp 3441 2011-10-12 17:22:15Z chrfranke $";
66:
67: /* This is a slightly stretched SCSI sense "descriptor" format header.
68: The addition is to allow the 0x70 and 0x71 response codes. The idea
69: is to place the salient data of both "fixed" and "descriptor" sense
70: format into one structure to ease application processing.
71: The original sense buffer should be kept around for those cases
72: in which more information is required (e.g. the LBA of a MEDIUM ERROR). */
73: /// Abridged SCSI sense data
74: struct sg_scsi_sense_hdr {
75: unsigned char response_code; /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
76: unsigned char sense_key;
77: unsigned char asc;
78: unsigned char ascq;
79: unsigned char byte4;
80: unsigned char byte5;
81: unsigned char byte6;
82: unsigned char additional_length;
83: };
84:
85: /* Maps the salient data from a sense buffer which is in either fixed or
86: descriptor format into a structure mimicking a descriptor format
87: header (i.e. the first 8 bytes of sense descriptor format).
88: If zero response code returns 0. Otherwise returns 1 and if 'sshp' is
89: non-NULL then zero all fields and then set the appropriate fields in
90: that structure. sshp::additional_length is always 0 for response
91: codes 0x70 and 0x71 (fixed format). */
92: static int sg_scsi_normalize_sense(const unsigned char * sensep, int sb_len,
93: struct sg_scsi_sense_hdr * sshp);
94:
95: /* Attempt to find the first SCSI sense data descriptor that matches the
96: given 'desc_type'. If found return pointer to start of sense data
97: descriptor; otherwise (including fixed format sense data) returns NULL. */
98: static const unsigned char * sg_scsi_sense_desc_find(const unsigned char * sensep,
99: int sense_len, int desc_type);
100:
101: #define SAT_ATA_PASSTHROUGH_12LEN 12
102: #define SAT_ATA_PASSTHROUGH_16LEN 16
103:
104: #define DEF_SAT_ATA_PASSTHRU_SIZE 16
105: #define ATA_RETURN_DESCRIPTOR 9
106:
107:
108: namespace sat { // no need to publish anything, name provided for Doxygen
109:
110: /// SAT support.
111: /// Implements ATA by tunnelling through SCSI.
112:
113: class sat_device
114: : public tunnelled_device<
115: /*implements*/ ata_device
116: /*by tunnelling through a*/, scsi_device
117: >
118: {
119: public:
120: sat_device(smart_interface * intf, scsi_device * scsidev,
121: const char * req_type, int passthrulen = 0);
122:
123: virtual ~sat_device() throw();
124:
125: virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
126:
127: private:
128: int m_passthrulen;
129: };
130:
131:
132: sat_device::sat_device(smart_interface * intf, scsi_device * scsidev,
133: const char * req_type, int passthrulen /*= 0*/)
134: : smart_device(intf, scsidev->get_dev_name(), "sat", req_type),
135: tunnelled_device<ata_device, scsi_device>(scsidev),
136: m_passthrulen(passthrulen)
137: {
138: set_info().info_name = strprintf("%s [SAT]", scsidev->get_info_name());
139: }
140:
141: sat_device::~sat_device() throw()
142: {
143: }
144:
145:
146: // cdb[0]: ATA PASS THROUGH (16) SCSI command opcode byte (0x85)
147: // cdb[1]: multiple_count, protocol + extend
148: // cdb[2]: offline, ck_cond, t_dir, byte_block + t_length
149: // cdb[3]: features (15:8)
150: // cdb[4]: features (7:0)
151: // cdb[5]: sector_count (15:8)
152: // cdb[6]: sector_count (7:0)
153: // cdb[7]: lba_low (15:8)
154: // cdb[8]: lba_low (7:0)
155: // cdb[9]: lba_mid (15:8)
156: // cdb[10]: lba_mid (7:0)
157: // cdb[11]: lba_high (15:8)
158: // cdb[12]: lba_high (7:0)
159: // cdb[13]: device
160: // cdb[14]: (ata) command
161: // cdb[15]: control (SCSI, leave as zero)
162: //
163: // 24 bit lba (from MSB): cdb[12] cdb[10] cdb[8]
164: // 48 bit lba (from MSB): cdb[11] cdb[9] cdb[7] cdb[12] cdb[10] cdb[8]
165: //
166: //
167: // cdb[0]: ATA PASS THROUGH (12) SCSI command opcode byte (0xa1)
168: // cdb[1]: multiple_count, protocol + extend
169: // cdb[2]: offline, ck_cond, t_dir, byte_block + t_length
170: // cdb[3]: features (7:0)
171: // cdb[4]: sector_count (7:0)
172: // cdb[5]: lba_low (7:0)
173: // cdb[6]: lba_mid (7:0)
174: // cdb[7]: lba_high (7:0)
175: // cdb[8]: device
176: // cdb[9]: (ata) command
177: // cdb[10]: reserved
178: // cdb[11]: control (SCSI, leave as zero)
179: //
180: //
181: // ATA Return Descriptor (component of descriptor sense data)
182: // des[0]: descriptor code (0x9)
183: // des[1]: additional descriptor length (0xc)
184: // des[2]: extend (bit 0)
185: // des[3]: error
186: // des[4]: sector_count (15:8)
187: // des[5]: sector_count (7:0)
188: // des[6]: lba_low (15:8)
189: // des[7]: lba_low (7:0)
190: // des[8]: lba_mid (15:8)
191: // des[9]: lba_mid (7:0)
192: // des[10]: lba_high (15:8)
193: // des[11]: lba_high (7:0)
194: // des[12]: device
195: // des[13]: status
196:
197:
198:
199: // PURPOSE
200: // This interface routine takes ATA SMART commands and packages
201: // them in the SAT-defined ATA PASS THROUGH SCSI commands. There are
202: // two available SCSI commands: a 12 byte and 16 byte variant; the
203: // one used is chosen via this->m_passthrulen .
204: // DETAILED DESCRIPTION OF ARGUMENTS
205: // device: is the file descriptor provided by (a SCSI dvice type) open()
206: // command: defines the different ATA operations.
207: // select: additional input data if needed (which log, which type of
208: // self-test).
209: // data: location to write output data, if needed (512 bytes).
210: // Note: not all commands use all arguments.
211: // RETURN VALUES
212: // -1 if the command failed
213: // 0 if the command succeeded,
214: // STATUS_CHECK routine:
215: // -1 if the command failed
216: // 0 if the command succeeded and disk SMART status is "OK"
217: // 1 if the command succeeded and disk SMART status is "FAILING"
218:
219: bool sat_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out)
220: {
221: if (!ata_cmd_is_ok(in,
222: true, // data_out_support
223: true, // multi_sector_support
224: true) // ata_48bit_support
225: )
226: return false;
227:
228: struct scsi_cmnd_io io_hdr;
229: struct scsi_sense_disect sinfo;
230: struct sg_scsi_sense_hdr ssh;
231: unsigned char cdb[SAT_ATA_PASSTHROUGH_16LEN];
232: unsigned char sense[32];
233: const unsigned char * ardp;
234: int status, ard_len, have_sense;
235: int extend = 0;
236: int ck_cond = 0; /* set to 1 to read register(s) back */
237: int protocol = 3; /* non-data */
238: int t_dir = 1; /* 0 -> to device, 1 -> from device */
239: int byte_block = 1; /* 0 -> bytes, 1 -> 512 byte blocks */
240: int t_length = 0; /* 0 -> no data transferred */
241: int passthru_size = DEF_SAT_ATA_PASSTHRU_SIZE;
242:
243: memset(cdb, 0, sizeof(cdb));
244: memset(sense, 0, sizeof(sense));
245:
246: // Set data direction
247: // TODO: This works only for commands where sector_count holds count!
248: switch (in.direction) {
249: case ata_cmd_in::no_data:
250: break;
251: case ata_cmd_in::data_in:
252: protocol = 4; // PIO data-in
253: t_length = 2; // sector_count holds count
254: break;
255: case ata_cmd_in::data_out:
256: protocol = 5; // PIO data-out
257: t_length = 2; // sector_count holds count
258: t_dir = 0; // to device
259: break;
260: default:
261: return set_err(EINVAL, "sat_device::ata_pass_through: invalid direction=%d",
262: (int)in.direction);
263: }
264:
265: // Check condition if any output register needed
266: if (in.out_needed.is_set())
267: ck_cond = 1;
268:
269: if ((SAT_ATA_PASSTHROUGH_12LEN == m_passthrulen) ||
270: (SAT_ATA_PASSTHROUGH_16LEN == m_passthrulen))
271: passthru_size = m_passthrulen;
272:
273: // Set extend bit on 48-bit ATA command
274: if (in.in_regs.is_48bit_cmd()) {
275: if (passthru_size != SAT_ATA_PASSTHROUGH_16LEN)
276: return set_err(ENOSYS, "48-bit ATA commands require SAT ATA PASS-THROUGH (16)");
277: extend = 1;
278: }
279:
280: cdb[0] = (SAT_ATA_PASSTHROUGH_12LEN == passthru_size) ?
281: SAT_ATA_PASSTHROUGH_12 : SAT_ATA_PASSTHROUGH_16;
282:
283: cdb[1] = (protocol << 1) | extend;
284: cdb[2] = (ck_cond << 5) | (t_dir << 3) |
285: (byte_block << 2) | t_length;
286:
287: if (passthru_size == SAT_ATA_PASSTHROUGH_12LEN) {
288: // ATA PASS-THROUGH (12)
289: const ata_in_regs & lo = in.in_regs;
290: cdb[3] = lo.features;
291: cdb[4] = lo.sector_count;
292: cdb[5] = lo.lba_low;
293: cdb[6] = lo.lba_mid;
294: cdb[7] = lo.lba_high;
295: cdb[8] = lo.device;
296: cdb[9] = lo.command;
297: }
298: else {
299: // ATA PASS-THROUGH (16)
300: const ata_in_regs & lo = in.in_regs;
301: const ata_in_regs & hi = in.in_regs.prev;
302: // Note: all 'in.in_regs.prev.*' are always zero for 28-bit commands
303: cdb[ 3] = hi.features;
304: cdb[ 4] = lo.features;
305: cdb[ 5] = hi.sector_count;
306: cdb[ 6] = lo.sector_count;
307: cdb[ 7] = hi.lba_low;
308: cdb[ 8] = lo.lba_low;
309: cdb[ 9] = hi.lba_mid;
310: cdb[10] = lo.lba_mid;
311: cdb[11] = hi.lba_high;
312: cdb[12] = lo.lba_high;
313: cdb[13] = lo.device;
314: cdb[14] = lo.command;
315: }
316:
317: memset(&io_hdr, 0, sizeof(io_hdr));
318: if (0 == t_length) {
319: io_hdr.dxfer_dir = DXFER_NONE;
320: io_hdr.dxfer_len = 0;
321: } else if (t_dir) { /* from device */
322: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
323: io_hdr.dxfer_len = in.size;
324: io_hdr.dxferp = (unsigned char *)in.buffer;
325: memset(in.buffer, 0, in.size); // prefill with zeroes
326: } else { /* to device */
327: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
328: io_hdr.dxfer_len = in.size;
329: io_hdr.dxferp = (unsigned char *)in.buffer;
330: }
331: io_hdr.cmnd = cdb;
332: io_hdr.cmnd_len = passthru_size;
333: io_hdr.sensep = sense;
334: io_hdr.max_sense_len = sizeof(sense);
335: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
336:
337: scsi_device * scsidev = get_tunnel_dev();
338: if (!scsidev->scsi_pass_through(&io_hdr)) {
339: if (scsi_debugmode > 0)
340: pout("sat_device::ata_pass_through: scsi_pass_through() failed, "
341: "errno=%d [%s]\n", scsidev->get_errno(), scsidev->get_errmsg());
342: return set_err(scsidev->get_err());
343: }
344: ardp = NULL;
345: ard_len = 0;
346: have_sense = sg_scsi_normalize_sense(io_hdr.sensep, io_hdr.resp_sense_len,
347: &ssh);
348: if (have_sense) {
349: /* look for SAT ATA Return Descriptor */
350: ardp = sg_scsi_sense_desc_find(io_hdr.sensep,
351: io_hdr.resp_sense_len,
352: ATA_RETURN_DESCRIPTOR);
353: if (ardp) {
354: ard_len = ardp[1] + 2;
355: if (ard_len < 12)
356: ard_len = 12;
357: else if (ard_len > 14)
358: ard_len = 14;
359: }
360: scsi_do_sense_disect(&io_hdr, &sinfo);
361: status = scsiSimpleSenseFilter(&sinfo);
362: if (0 != status) {
363: if (scsi_debugmode > 0) {
364: pout("sat_device::ata_pass_through: scsi error: %s\n",
365: scsiErrString(status));
366: if (ardp && (scsi_debugmode > 1)) {
367: pout("Values from ATA Return Descriptor are:\n");
368: dStrHex((const char *)ardp, ard_len, 1);
369: }
370: }
371: if (t_dir && (t_length > 0) && (in.direction == ata_cmd_in::data_in))
372: memset(in.buffer, 0, in.size);
373: return set_err(EIO, "scsi error %s", scsiErrString(status));
374: }
375: }
376: if (ck_cond) { /* expecting SAT specific sense data */
377: if (have_sense) {
378: if (ardp) {
379: if (scsi_debugmode > 1) {
380: pout("Values from ATA Return Descriptor are:\n");
381: dStrHex((const char *)ardp, ard_len, 1);
382: }
383: // Set output registers
384: ata_out_regs & lo = out.out_regs;
385: lo.error = ardp[ 3];
386: lo.sector_count = ardp[ 5];
387: lo.lba_low = ardp[ 7];
388: lo.lba_mid = ardp[ 9];
389: lo.lba_high = ardp[11];
390: lo.device = ardp[12];
391: lo.status = ardp[13];
392: if (in.in_regs.is_48bit_cmd()) {
393: ata_out_regs & hi = out.out_regs.prev;
394: hi.sector_count = ardp[ 4];
395: hi.lba_low = ardp[ 6];
396: hi.lba_mid = ardp[ 8];
397: hi.lba_high = ardp[10];
398: }
399: }
400: }
401: if (ardp == NULL)
402: ck_cond = 0; /* not the type of sense data expected */
403: }
404: if (0 == ck_cond) {
405: if (have_sense) {
406: if ((ssh.response_code >= 0x72) &&
407: ((SCSI_SK_NO_SENSE == ssh.sense_key) ||
408: (SCSI_SK_RECOVERED_ERR == ssh.sense_key)) &&
409: (0 == ssh.asc) &&
410: (SCSI_ASCQ_ATA_PASS_THROUGH == ssh.ascq)) {
411: if (ardp) {
412: if (scsi_debugmode > 0) {
413: pout("Values from ATA Return Descriptor are:\n");
414: dStrHex((const char *)ardp, ard_len, 1);
415: }
416: return set_err(EIO, "SAT command failed");
417: }
418: }
419: }
420: }
421: return true;
422: }
423:
424: } // namespace
425:
426: /////////////////////////////////////////////////////////////////////////////
427:
428: /* Attempt an IDENTIFY DEVICE ATA command via SATL when packet_interface
429: is false otherwise attempt IDENTIFY PACKET DEVICE. If successful
430: return true, else false */
431:
432: static bool has_sat_pass_through(ata_device * dev, bool packet_interface = false)
433: {
434: /* Note: malloc() ensures the read buffer lands on a single
435: page. This avoids some bugs seen on LSI controlers under
436: FreeBSD */
437: char *data = (char *)malloc(512);
438: ata_cmd_in in;
439: in.in_regs.command = (packet_interface ? ATA_IDENTIFY_PACKET_DEVICE : ATA_IDENTIFY_DEVICE);
440: in.set_data_in(data, 1);
441: bool ret = dev->ata_pass_through(in);
442: free(data);
443: return ret;
444: }
445:
446: /////////////////////////////////////////////////////////////////////////////
447:
448: /* Next two functions are borrowed from sg_lib.c in the sg3_utils
449: package. Same copyrght owner, same license as this file. */
450: static int sg_scsi_normalize_sense(const unsigned char * sensep, int sb_len,
451: struct sg_scsi_sense_hdr * sshp)
452: {
453: if (sshp)
454: memset(sshp, 0, sizeof(struct sg_scsi_sense_hdr));
455: if ((NULL == sensep) || (0 == sb_len) || (0x70 != (0x70 & sensep[0])))
456: return 0;
457: if (sshp) {
458: sshp->response_code = (0x7f & sensep[0]);
459: if (sshp->response_code >= 0x72) { /* descriptor format */
460: if (sb_len > 1)
461: sshp->sense_key = (0xf & sensep[1]);
462: if (sb_len > 2)
463: sshp->asc = sensep[2];
464: if (sb_len > 3)
465: sshp->ascq = sensep[3];
466: if (sb_len > 7)
467: sshp->additional_length = sensep[7];
468: } else { /* fixed format */
469: if (sb_len > 2)
470: sshp->sense_key = (0xf & sensep[2]);
471: if (sb_len > 7) {
472: sb_len = (sb_len < (sensep[7] + 8)) ? sb_len :
473: (sensep[7] + 8);
474: if (sb_len > 12)
475: sshp->asc = sensep[12];
476: if (sb_len > 13)
477: sshp->ascq = sensep[13];
478: }
479: }
480: }
481: return 1;
482: }
483:
484:
485: static const unsigned char * sg_scsi_sense_desc_find(const unsigned char * sensep,
486: int sense_len, int desc_type)
487: {
488: int add_sen_len, add_len, desc_len, k;
489: const unsigned char * descp;
490:
491: if ((sense_len < 8) || (0 == (add_sen_len = sensep[7])))
492: return NULL;
493: if ((sensep[0] < 0x72) || (sensep[0] > 0x73))
494: return NULL;
495: add_sen_len = (add_sen_len < (sense_len - 8)) ?
496: add_sen_len : (sense_len - 8);
497: descp = &sensep[8];
498: for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) {
499: descp += desc_len;
500: add_len = (k < (add_sen_len - 1)) ? descp[1]: -1;
501: desc_len = add_len + 2;
502: if (descp[0] == desc_type)
503: return descp;
504: if (add_len < 0) /* short descriptor ?? */
505: break;
506: }
507: return NULL;
508: }
509:
510:
511: // Call scsi_pass_through and check sense.
512: // TODO: Provide as member function of class scsi_device (?)
513: static bool scsi_pass_through_and_check(scsi_device * scsidev, scsi_cmnd_io * iop,
514: const char * msg = "")
515: {
516: // Provide sense buffer
517: unsigned char sense[32] = {0, };
518: iop->sensep = sense;
519: iop->max_sense_len = sizeof(sense);
520: iop->timeout = SCSI_TIMEOUT_DEFAULT;
521:
522: // Run cmd
523: if (!scsidev->scsi_pass_through(iop)) {
524: if (scsi_debugmode > 0)
525: pout("%sscsi_pass_through() failed, errno=%d [%s]\n",
526: msg, scsidev->get_errno(), scsidev->get_errmsg());
527: return false;
528: }
529:
530: // Check sense
531: scsi_sense_disect sinfo;
532: scsi_do_sense_disect(iop, &sinfo);
533: int err = scsiSimpleSenseFilter(&sinfo);
534: if (err) {
535: if (scsi_debugmode > 0)
536: pout("%sscsi error: %s\n", msg, scsiErrString(err));
537: return scsidev->set_err(EIO, "scsi error %s", scsiErrString(err));
538: }
539:
540: return true;
541: }
542:
543:
544: /////////////////////////////////////////////////////////////////////////////
545:
546: namespace sat {
547:
548: /// Cypress USB Brigde support.
549:
550: class usbcypress_device
551: : public tunnelled_device<
552: /*implements*/ ata_device_with_command_set
553: /*by tunnelling through a*/, scsi_device
554: >
555: {
556: public:
557: usbcypress_device(smart_interface * intf, scsi_device * scsidev,
558: const char * req_type, unsigned char signature);
559:
560: virtual ~usbcypress_device() throw();
561:
562: protected:
563: virtual int ata_command_interface(smart_command_set command, int select, char * data);
564:
565: unsigned char m_signature;
566: };
567:
568:
569: usbcypress_device::usbcypress_device(smart_interface * intf, scsi_device * scsidev,
570: const char * req_type, unsigned char signature)
571: : smart_device(intf, scsidev->get_dev_name(), "sat", req_type),
572: tunnelled_device<ata_device_with_command_set, scsi_device>(scsidev),
573: m_signature(signature)
574: {
575: set_info().info_name = strprintf("%s [USB Cypress]", scsidev->get_info_name());
576: }
577:
578: usbcypress_device::~usbcypress_device() throw()
579: {
580: }
581:
582:
583: /* see cy7c68300c_8.pdf for more information */
584: #define USBCYPRESS_PASSTHROUGH_LEN 16
585: int usbcypress_device::ata_command_interface(smart_command_set command, int select, char *data)
586: {
587: struct scsi_cmnd_io io_hdr;
588: unsigned char cdb[USBCYPRESS_PASSTHROUGH_LEN];
589: unsigned char sense[32];
590: int copydata = 0;
591: int outlen = 0;
592: int ck_cond = 0; /* set to 1 to read register(s) back */
593: int t_dir = 1; /* 0 -> to device, 1 -> from device */
594: int byte_block = 1; /* 0 -> bytes, 1 -> 512 byte blocks */
595: int t_length = 0; /* 0 -> no data transferred */
596: int feature = 0;
597: int ata_command = 0;
598: int sector_count = 0;
599: int lba_low = 0;
600: int lba_mid = 0;
601: int lba_high = 0;
602: int passthru_size = USBCYPRESS_PASSTHROUGH_LEN;
603:
604: memset(cdb, 0, sizeof(cdb));
605: memset(sense, 0, sizeof(sense));
606:
607: ata_command = ATA_SMART_CMD;
608: switch (command) {
609: case CHECK_POWER_MODE:
610: ata_command = ATA_CHECK_POWER_MODE;
611: ck_cond = 1;
612: copydata = 1;
613: break;
614: case READ_VALUES: /* READ DATA */
615: feature = ATA_SMART_READ_VALUES;
616: sector_count = 1; /* one (512 byte) block */
617: t_length = 2; /* sector count holds count */
618: copydata = 512;
619: break;
620: case READ_THRESHOLDS: /* obsolete */
621: feature = ATA_SMART_READ_THRESHOLDS;
622: sector_count = 1; /* one (512 byte) block */
623: lba_low = 1;
624: t_length = 2; /* sector count holds count */
625: copydata=512;
626: break;
627: case READ_LOG:
628: feature = ATA_SMART_READ_LOG_SECTOR;
629: sector_count = 1; /* one (512 byte) block */
630: lba_low = select;
631: t_length = 2; /* sector count holds count */
632: copydata = 512;
633: break;
634: case WRITE_LOG:
635: feature = ATA_SMART_WRITE_LOG_SECTOR;
636: sector_count = 1; /* one (512 byte) block */
637: lba_low = select;
638: t_length = 2; /* sector count holds count */
639: t_dir = 0; /* to device */
640: outlen = 512;
641: break;
642: case IDENTIFY:
643: ata_command = ATA_IDENTIFY_DEVICE;
644: sector_count = 1; /* one (512 byte) block */
645: t_length = 2; /* sector count holds count */
646: copydata = 512;
647: break;
648: case PIDENTIFY:
649: ata_command = ATA_IDENTIFY_PACKET_DEVICE;
650: sector_count = 1; /* one (512 byte) block */
651: t_length = 2; /* sector count (7:0) holds count */
652: copydata = 512;
653: break;
654: case ENABLE:
655: feature = ATA_SMART_ENABLE;
656: lba_low = 1;
657: break;
658: case DISABLE:
659: feature = ATA_SMART_DISABLE;
660: lba_low = 1;
661: break;
662: case STATUS:
663: // this command only says if SMART is working. It could be
664: // replaced with STATUS_CHECK below.
665: feature = ATA_SMART_STATUS;
666: ck_cond = 1;
667: break;
668: case AUTO_OFFLINE:
669: feature = ATA_SMART_AUTO_OFFLINE;
670: sector_count = select; // YET NOTE - THIS IS A NON-DATA COMMAND!!
671: break;
672: case AUTOSAVE:
673: feature = ATA_SMART_AUTOSAVE;
674: sector_count = select; // YET NOTE - THIS IS A NON-DATA COMMAND!!
675: break;
676: case IMMEDIATE_OFFLINE:
677: feature = ATA_SMART_IMMEDIATE_OFFLINE;
678: lba_low = select;
679: break;
680: case STATUS_CHECK:
681: // This command uses HDIO_DRIVE_TASK and has different syntax than
682: // the other commands.
683: feature = ATA_SMART_STATUS; /* SMART RETURN STATUS */
684: ck_cond = 1;
685: break;
686: default:
687: pout("Unrecognized command %d in usbcypress_device::ata_command_interface()\n"
688: "Please contact " PACKAGE_BUGREPORT "\n", command);
689: errno=ENOSYS;
690: return -1;
691: }
692: if (ATA_SMART_CMD == ata_command) {
693: lba_mid = 0x4f;
694: lba_high = 0xc2;
695: }
696:
697: cdb[0] = m_signature; // bVSCBSignature : vendor-specific command
698: cdb[1] = 0x24; // bVSCBSubCommand : 0x24 for ATACB
699: cdb[2] = 0x0;
700: if (ata_command == ATA_IDENTIFY_DEVICE || ata_command == ATA_IDENTIFY_PACKET_DEVICE)
701: cdb[2] |= (1<<7); //set IdentifyPacketDevice for these cmds
702: cdb[3] = 0xff - (1<<0) - (1<<6); //features, sector count, lba low, lba med
703: // lba high, command are valid
704: cdb[4] = byte_block; //TransferBlockCount : 512
705:
706:
707: cdb[6] = feature;
708: cdb[7] = sector_count;
709: cdb[8] = lba_low;
710: cdb[9] = lba_mid;
711: cdb[10] = lba_high;
712: cdb[12] = ata_command;
713:
714: memset(&io_hdr, 0, sizeof(io_hdr));
715: if (0 == t_length) {
716: io_hdr.dxfer_dir = DXFER_NONE;
717: io_hdr.dxfer_len = 0;
718: } else if (t_dir) { /* from device */
719: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
720: io_hdr.dxfer_len = copydata;
721: io_hdr.dxferp = (unsigned char *)data;
722: memset(data, 0, copydata); /* prefill with zeroes */
723: } else { /* to device */
724: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
725: io_hdr.dxfer_len = outlen;
726: io_hdr.dxferp = (unsigned char *)data;
727: }
728: io_hdr.cmnd = cdb;
729: io_hdr.cmnd_len = passthru_size;
730: io_hdr.sensep = sense;
731: io_hdr.max_sense_len = sizeof(sense);
732: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
733:
734: scsi_device * scsidev = get_tunnel_dev();
735: if (!scsidev->scsi_pass_through(&io_hdr)) {
736: if (scsi_debugmode > 0)
737: pout("usbcypress_device::ata_command_interface: scsi_pass_through() failed, "
738: "errno=%d [%s]\n", scsidev->get_errno(), scsidev->get_errmsg());
739: set_err(scsidev->get_err());
740: return -1;
741: }
742:
743: // if there is a sense the command failed or the
744: // device doesn't support usbcypress
745: if (io_hdr.scsi_status == SCSI_STATUS_CHECK_CONDITION &&
746: sg_scsi_normalize_sense(io_hdr.sensep, io_hdr.resp_sense_len, NULL)) {
747: return -1;
748: }
749: if (ck_cond) {
750: unsigned char ardp[8];
751: int ard_len = 8;
752: /* XXX this is racy if there other scsi command between
753: * the first usbcypress command and this one
754: */
755: //pout("If you got strange result, please retry without traffic on the disc\n");
756: /* we use the same command as before, but we set
757: * * the read taskfile bit, for not executing usbcypress command,
758: * * but reading register selected in srb->cmnd[4]
759: */
760: cdb[2] = (1<<0); /* ask read taskfile */
761: memset(sense, 0, sizeof(sense));
762:
763: /* transfert 8 bytes */
764: memset(&io_hdr, 0, sizeof(io_hdr));
765: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
766: io_hdr.dxfer_len = ard_len;
767: io_hdr.dxferp = (unsigned char *)ardp;
768: memset(ardp, 0, ard_len); /* prefill with zeroes */
769:
770: io_hdr.cmnd = cdb;
771: io_hdr.cmnd_len = passthru_size;
772: io_hdr.sensep = sense;
773: io_hdr.max_sense_len = sizeof(sense);
774: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
775:
776:
777: if (!scsidev->scsi_pass_through(&io_hdr)) {
778: if (scsi_debugmode > 0)
779: pout("usbcypress_device::ata_command_interface: scsi_pass_through() failed, "
780: "errno=%d [%s]\n", scsidev->get_errno(), scsidev->get_errmsg());
781: set_err(scsidev->get_err());
782: return -1;
783: }
784: // if there is a sense the command failed or the
785: // device doesn't support usbcypress
786: if (io_hdr.scsi_status == SCSI_STATUS_CHECK_CONDITION &&
787: sg_scsi_normalize_sense(io_hdr.sensep, io_hdr.resp_sense_len, NULL)) {
788: return -1;
789: }
790:
791:
792: if (scsi_debugmode > 1) {
793: pout("Values from ATA Return Descriptor are:\n");
794: dStrHex((const char *)ardp, ard_len, 1);
795: }
796:
797: if (ATA_CHECK_POWER_MODE == ata_command)
798: data[0] = ardp[2]; /* sector count (0:7) */
799: else if (STATUS_CHECK == command) {
800: if ((ardp[4] == 0x4f) && (ardp[5] == 0xc2))
801: return 0; /* GOOD smart status */
802: if ((ardp[4] == 0xf4) && (ardp[5] == 0x2c))
803: return 1; // smart predicting failure, "bad" status
804: // We haven't gotten output that makes sense so
805: // print out some debugging info
806: syserror("Error SMART Status command failed");
807: pout("This may be due to a race in usbcypress\n");
808: pout("Retry without other disc access\n");
809: pout("Please get assistance from " PACKAGE_HOMEPAGE "\n");
810: pout("Values from ATA Return Descriptor are:\n");
811: dStrHex((const char *)ardp, ard_len, 1);
812: return -1;
813: }
814: }
815: return 0;
816: }
817:
818: #if 0 // Not used, see autodetect_sat_device() below.
819: static int isprint_string(const char *s)
820: {
821: while (*s) {
822: if (isprint(*s) == 0)
823: return 0;
824: s++;
825: }
826: return 1;
827: }
828:
829: /* Attempt an IDENTIFY DEVICE ATA or IDENTIFY PACKET DEVICE command
830: If successful return 1, else 0 */
831: // TODO: Combine with has_sat_pass_through above
832: static int has_usbcypress_pass_through(ata_device * atadev, const char *manufacturer, const char *product)
833: {
834: struct ata_identify_device drive;
835: char model[40], serial[20], firm[8];
836:
837: /* issue the command and do a checksum if possible */
838: if (ataReadHDIdentity(atadev, &drive) < 0)
839: return 0;
840:
841: /* check if model string match, revision doesn't work for me */
842: format_ata_string(model, drive.model, 40);
843: if (*model == 0 || isprint_string(model) == 0)
844: return 0;
845:
846: if (manufacturer && strncmp(manufacturer, model, 8))
847: pout("manufacturer doesn't match in pass_through test\n");
848: if (product &&
849: strlen(model) > 8 && strncmp(product, model+8, strlen(model)-8))
850: pout("product doesn't match in pass_through test\n");
851:
852: /* check serial */
853: format_ata_string(serial, drive.serial_no, 20);
854: if (isprint_string(serial) == 0)
855: return 0;
856: format_ata_string(firm, drive.fw_rev, 8);
857: if (isprint_string(firm) == 0)
858: return 0;
859: return 1;
860: }
861: #endif
862:
863: /////////////////////////////////////////////////////////////////////////////
864:
865: /// JMicron USB Bridge support.
866:
867: class usbjmicron_device
868: : public tunnelled_device<
869: /*implements*/ ata_device,
870: /*by tunnelling through a*/ scsi_device
871: >
872: {
873: public:
874: usbjmicron_device(smart_interface * intf, scsi_device * scsidev,
875: const char * req_type, bool ata_48bit_support, int port);
876:
877: virtual ~usbjmicron_device() throw();
878:
879: virtual bool open();
880:
881: virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
882:
883: private:
884: bool get_registers(unsigned short addr, unsigned char * buf, unsigned short size);
885:
886: bool m_ata_48bit_support;
887: int m_port;
888: };
889:
890:
891: usbjmicron_device::usbjmicron_device(smart_interface * intf, scsi_device * scsidev,
892: const char * req_type, bool ata_48bit_support, int port)
893: : smart_device(intf, scsidev->get_dev_name(), "usbjmicron", req_type),
894: tunnelled_device<ata_device, scsi_device>(scsidev),
895: m_ata_48bit_support(ata_48bit_support), m_port(port)
896: {
897: set_info().info_name = strprintf("%s [USB JMicron]", scsidev->get_info_name());
898: }
899:
900: usbjmicron_device::~usbjmicron_device() throw()
901: {
902: }
903:
904:
905: bool usbjmicron_device::open()
906: {
907: // Open USB first
908: if (!tunnelled_device<ata_device, scsi_device>::open())
909: return false;
910:
911: // Detect port if not specified
912: if (m_port < 0) {
913: unsigned char regbuf[1] = {0};
914: if (!get_registers(0x720f, regbuf, sizeof(regbuf))) {
915: close();
916: return false;
917: }
918:
919: switch (regbuf[0] & 0x44) {
920: case 0x04:
921: m_port = 0; break;
922: case 0x40:
923: m_port = 1; break;
924: case 0x44:
925: close();
926: return set_err(EINVAL, "Two devices connected, try '-d usbjmicron,[01]'");
927: default:
928: close();
929: return set_err(ENODEV, "No device connected");
930: }
931: }
932:
933: return true;
934: }
935:
936:
937: bool usbjmicron_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out)
938: {
939: if (!ata_cmd_is_ok(in,
940: true, // data_out_support
941: false, // !multi_sector_support
942: m_ata_48bit_support) // limited, see below
943: )
944: return false;
945:
946: bool is_smart_status = ( in.in_regs.command == ATA_SMART_CMD
947: && in.in_regs.features == ATA_SMART_STATUS);
948:
949: // Support output registers for SMART STATUS
950: if (in.out_needed.is_set() && !is_smart_status)
951: return set_err(ENOSYS, "ATA output registers not supported");
952:
953: // Support 48-bit commands with zero high bytes
954: if (in.in_regs.is_real_48bit_cmd())
955: return set_err(ENOSYS, "48-bit ATA commands not fully supported");
956:
957: if (m_port < 0)
958: return set_err(EIO, "Unknown JMicron port");
959:
960: scsi_cmnd_io io_hdr;
961: memset(&io_hdr, 0, sizeof(io_hdr));
962:
963: bool rwbit = true;
964: unsigned char smart_status = 0;
965:
966: if (is_smart_status && in.out_needed.is_set()) {
967: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
968: io_hdr.dxfer_len = 1;
969: io_hdr.dxferp = &smart_status;
970: }
971: else switch (in.direction) {
972: case ata_cmd_in::no_data:
973: io_hdr.dxfer_dir = DXFER_NONE;
974: break;
975: case ata_cmd_in::data_in:
976: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
977: io_hdr.dxfer_len = in.size;
978: io_hdr.dxferp = (unsigned char *)in.buffer;
979: memset(in.buffer, 0, in.size);
980: break;
981: case ata_cmd_in::data_out:
982: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
983: io_hdr.dxfer_len = in.size;
984: io_hdr.dxferp = (unsigned char *)in.buffer;
985: rwbit = false;
986: break;
987: default:
988: return set_err(EINVAL);
989: }
990:
991: // Build pass through command
992: unsigned char cdb[12];
993: cdb[ 0] = 0xdf;
994: cdb[ 1] = (rwbit ? 0x10 : 0x00);
995: cdb[ 2] = 0x00;
996: cdb[ 3] = (unsigned char)(io_hdr.dxfer_len >> 8);
997: cdb[ 4] = (unsigned char)(io_hdr.dxfer_len );
998: cdb[ 5] = in.in_regs.features;
999: cdb[ 6] = in.in_regs.sector_count;
1000: cdb[ 7] = in.in_regs.lba_low;
1001: cdb[ 8] = in.in_regs.lba_mid;
1002: cdb[ 9] = in.in_regs.lba_high;
1003: cdb[10] = in.in_regs.device | (m_port == 0 ? 0xa0 : 0xb0);
1004: cdb[11] = in.in_regs.command;
1005:
1006: io_hdr.cmnd = cdb;
1007: io_hdr.cmnd_len = sizeof(cdb);
1008:
1009: scsi_device * scsidev = get_tunnel_dev();
1010: if (!scsi_pass_through_and_check(scsidev, &io_hdr,
1011: "usbjmicron_device::ata_pass_through: "))
1012: return set_err(scsidev->get_err());
1013:
1014: if (in.out_needed.is_set()) {
1015: if (is_smart_status) {
1016: switch (smart_status) {
1017: case 0x01: case 0xc2:
1018: out.out_regs.lba_high = 0xc2;
1019: out.out_regs.lba_mid = 0x4f;
1020: break;
1021: case 0x00: case 0x2c:
1022: out.out_regs.lba_high = 0x2c;
1023: out.out_regs.lba_mid = 0xf4;
1024: break;
1025: }
1026: }
1027:
1028: #if 0 // Not needed for SMART STATUS, see also notes below
1029: else {
1030: // Read ATA output registers
1031: // NOTE: The register addresses are not valid for some older chip revisions
1032: // NOTE: There is a small race condition here!
1033: unsigned char regbuf[16] = {0, };
1034: if (!get_registers((m_port == 0 ? 0x8000 : 0x9000), regbuf, sizeof(regbuf)))
1035: return false;
1036:
1037: out.out_regs.sector_count = regbuf[ 0];
1038: out.out_regs.lba_mid = regbuf[ 4];
1039: out.out_regs.lba_low = regbuf[ 6];
1040: out.out_regs.device = regbuf[ 9];
1041: out.out_regs.lba_high = regbuf[10];
1042: out.out_regs.error = regbuf[13];
1043: out.out_regs.status = regbuf[14];
1044: }
1045: #endif
1046: }
1047:
1048: return true;
1049: }
1050:
1051: bool usbjmicron_device::get_registers(unsigned short addr,
1052: unsigned char * buf, unsigned short size)
1053: {
1054: unsigned char cdb[12];
1055: cdb[ 0] = 0xdf;
1056: cdb[ 1] = 0x10;
1057: cdb[ 2] = 0x00;
1058: cdb[ 3] = (unsigned char)(size >> 8);
1059: cdb[ 4] = (unsigned char)(size );
1060: cdb[ 5] = 0x00;
1061: cdb[ 6] = (unsigned char)(addr >> 8);
1062: cdb[ 7] = (unsigned char)(addr );
1063: cdb[ 8] = 0x00;
1064: cdb[ 9] = 0x00;
1065: cdb[10] = 0x00;
1066: cdb[11] = 0xfd;
1067:
1068: scsi_cmnd_io io_hdr;
1069: memset(&io_hdr, 0, sizeof(io_hdr));
1070: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
1071: io_hdr.dxfer_len = size;
1072: io_hdr.dxferp = buf;
1073: io_hdr.cmnd = cdb;
1074: io_hdr.cmnd_len = sizeof(cdb);
1075:
1076: scsi_device * scsidev = get_tunnel_dev();
1077: if (!scsi_pass_through_and_check(scsidev, &io_hdr,
1078: "usbjmicron_device::get_registers: "))
1079: return set_err(scsidev->get_err());
1080:
1081: return true;
1082: }
1083:
1084:
1085: /////////////////////////////////////////////////////////////////////////////
1086:
1087: /// SunplusIT USB Bridge support.
1088:
1089: class usbsunplus_device
1090: : public tunnelled_device<
1091: /*implements*/ ata_device,
1092: /*by tunnelling through a*/ scsi_device
1093: >
1094: {
1095: public:
1096: usbsunplus_device(smart_interface * intf, scsi_device * scsidev,
1097: const char * req_type);
1098:
1099: virtual ~usbsunplus_device() throw();
1100:
1101: virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
1102: };
1103:
1104:
1105: usbsunplus_device::usbsunplus_device(smart_interface * intf, scsi_device * scsidev,
1106: const char * req_type)
1107: : smart_device(intf, scsidev->get_dev_name(), "usbsunplus", req_type),
1108: tunnelled_device<ata_device, scsi_device>(scsidev)
1109: {
1110: set_info().info_name = strprintf("%s [USB Sunplus]", scsidev->get_info_name());
1111: }
1112:
1113: usbsunplus_device::~usbsunplus_device() throw()
1114: {
1115: }
1116:
1117: bool usbsunplus_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out)
1118: {
1119: if (!ata_cmd_is_ok(in,
1120: true, // data_out_support
1121: false, // !multi_sector_support
1122: true) // ata_48bit_support
1123: )
1124: return false;
1125:
1126: scsi_cmnd_io io_hdr;
1127: unsigned char cdb[12];
1128:
1129: if (in.in_regs.is_48bit_cmd()) {
1130: // Set "previous" registers
1131: memset(&io_hdr, 0, sizeof(io_hdr));
1132: io_hdr.dxfer_dir = DXFER_NONE;
1133:
1134: cdb[ 0] = 0xf8;
1135: cdb[ 1] = 0x00;
1136: cdb[ 2] = 0x23; // Subcommand: Pass through presetting
1137: cdb[ 3] = 0x00;
1138: cdb[ 4] = 0x00;
1139: cdb[ 5] = in.in_regs.prev.features;
1140: cdb[ 6] = in.in_regs.prev.sector_count;
1141: cdb[ 7] = in.in_regs.prev.lba_low;
1142: cdb[ 8] = in.in_regs.prev.lba_mid;
1143: cdb[ 9] = in.in_regs.prev.lba_high;
1144: cdb[10] = 0x00;
1145: cdb[11] = 0x00;
1146:
1147: io_hdr.cmnd = cdb;
1148: io_hdr.cmnd_len = sizeof(cdb);
1149:
1150: scsi_device * scsidev = get_tunnel_dev();
1151: if (!scsi_pass_through_and_check(scsidev, &io_hdr,
1152: "usbsunplus_device::scsi_pass_through (presetting): "))
1153: return set_err(scsidev->get_err());
1154: }
1155:
1156: // Run Pass through command
1157: memset(&io_hdr, 0, sizeof(io_hdr));
1158: unsigned char protocol;
1159: switch (in.direction) {
1160: case ata_cmd_in::no_data:
1161: io_hdr.dxfer_dir = DXFER_NONE;
1162: protocol = 0x00;
1163: break;
1164: case ata_cmd_in::data_in:
1165: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
1166: io_hdr.dxfer_len = in.size;
1167: io_hdr.dxferp = (unsigned char *)in.buffer;
1168: memset(in.buffer, 0, in.size);
1169: protocol = 0x10;
1170: break;
1171: case ata_cmd_in::data_out:
1172: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
1173: io_hdr.dxfer_len = in.size;
1174: io_hdr.dxferp = (unsigned char *)in.buffer;
1175: protocol = 0x11;
1176: break;
1177: default:
1178: return set_err(EINVAL);
1179: }
1180:
1181: cdb[ 0] = 0xf8;
1182: cdb[ 1] = 0x00;
1183: cdb[ 2] = 0x22; // Subcommand: Pass through
1184: cdb[ 3] = protocol;
1185: cdb[ 4] = (unsigned char)(io_hdr.dxfer_len >> 9);
1186: cdb[ 5] = in.in_regs.features;
1187: cdb[ 6] = in.in_regs.sector_count;
1188: cdb[ 7] = in.in_regs.lba_low;
1189: cdb[ 8] = in.in_regs.lba_mid;
1190: cdb[ 9] = in.in_regs.lba_high;
1191: cdb[10] = in.in_regs.device | 0xa0;
1192: cdb[11] = in.in_regs.command;
1193:
1194: io_hdr.cmnd = cdb;
1195: io_hdr.cmnd_len = sizeof(cdb);
1196:
1197: scsi_device * scsidev = get_tunnel_dev();
1198: if (!scsi_pass_through_and_check(scsidev, &io_hdr,
1199: "usbsunplus_device::scsi_pass_through: "))
1200: // Returns sense key 0x03 (medium error) on ATA command error
1201: return set_err(scsidev->get_err());
1202:
1203: if (in.out_needed.is_set()) {
1204: // Read ATA output registers
1205: unsigned char regbuf[8] = {0, };
1206: memset(&io_hdr, 0, sizeof(io_hdr));
1207: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
1208: io_hdr.dxfer_len = sizeof(regbuf);
1209: io_hdr.dxferp = regbuf;
1210:
1211: cdb[ 0] = 0xf8;
1212: cdb[ 1] = 0x00;
1213: cdb[ 2] = 0x21; // Subcommand: Get status
1214: memset(cdb+3, 0, sizeof(cdb)-3);
1215: io_hdr.cmnd = cdb;
1216: io_hdr.cmnd_len = sizeof(cdb);
1217:
1218: if (!scsi_pass_through_and_check(scsidev, &io_hdr,
1219: "usbsunplus_device::scsi_pass_through (get registers): "))
1220: return set_err(scsidev->get_err());
1221:
1222: out.out_regs.error = regbuf[1];
1223: out.out_regs.sector_count = regbuf[2];
1224: out.out_regs.lba_low = regbuf[3];
1225: out.out_regs.lba_mid = regbuf[4];
1226: out.out_regs.lba_high = regbuf[5];
1227: out.out_regs.device = regbuf[6];
1228: out.out_regs.status = regbuf[7];
1229: }
1230:
1231: return true;
1232: }
1233:
1234:
1235: } // namespace
1236:
1237: using namespace sat;
1238:
1239:
1240: /////////////////////////////////////////////////////////////////////////////
1241:
1242: // Return ATA->SCSI filter for SAT or USB.
1243:
1244: ata_device * smart_interface::get_sat_device(const char * type, scsi_device * scsidev)
1245: {
1246: if (!strncmp(type, "sat", 3)) {
1247: int ptlen = 0, n1 = -1, n2 = -1;
1248: if (!(((sscanf(type, "sat%n,%d%n", &n1, &ptlen, &n2) == 1 && n2 == (int)strlen(type)) || n1 == (int)strlen(type))
1249: && (ptlen == 0 || ptlen == 12 || ptlen == 16))) {
1250: set_err(EINVAL, "Option '-d sat,<n>' requires <n> to be 0, 12 or 16");
1251: return 0;
1252: }
1253: return new sat_device(this, scsidev, type, ptlen);
1254: }
1255:
1256: else if (!strncmp(type, "usbcypress", 10)) {
1257: unsigned signature = 0x24; int n1 = -1, n2 = -1;
1258: if (!(((sscanf(type, "usbcypress%n,0x%x%n", &n1, &signature, &n2) == 1 && n2 == (int)strlen(type)) || n1 == (int)strlen(type))
1259: && signature <= 0xff)) {
1260: set_err(EINVAL, "Option '-d usbcypress,<n>' requires <n> to be "
1261: "an hexadecimal number between 0x0 and 0xff");
1262: return 0;
1263: }
1264: return new usbcypress_device(this, scsidev, type, signature);
1265: }
1266:
1267: else if (!strncmp(type, "usbjmicron", 10)) {
1268: const char * t = type + 10;
1269: bool ata_48bit_support = false;
1270: if (!strncmp(t, ",x", 2)) {
1271: t += 2;
1272: ata_48bit_support = true;
1273: }
1274: int port = -1, n = -1;
1275: if (*t && !( (sscanf(t, ",%d%n", &port, &n) == 1
1276: && n == (int)strlen(t) && 0 <= port && port <= 1))) {
1277: set_err(EINVAL, "Option '-d usbmicron[,x],<n>' requires <n> to be 0 or 1");
1278: return 0;
1279: }
1280: return new usbjmicron_device(this, scsidev, type, ata_48bit_support, port);
1281: }
1282:
1283: else if (!strcmp(type, "usbsunplus")) {
1284: return new usbsunplus_device(this, scsidev, type);
1285: }
1286:
1287: else {
1288: set_err(EINVAL, "Unknown USB device type '%s'", type);
1289: return 0;
1290: }
1291: }
1292:
1293: // Try to detect a SAT device behind a SCSI interface.
1294:
1295: ata_device * smart_interface::autodetect_sat_device(scsi_device * scsidev,
1296: const unsigned char * inqdata, unsigned inqsize)
1297: {
1298: if (!scsidev->is_open())
1299: return 0;
1300:
1301: // SAT ?
1302: if (inqdata && inqsize >= 36 && !memcmp(inqdata + 8, "ATA ", 8)) { // TODO: Linux-specific?
1303: ata_device_auto_ptr atadev( new sat_device(this, scsidev, "") , scsidev);
1304: if (has_sat_pass_through(atadev.get()))
1305: return atadev.release(); // Detected SAT
1306: }
1307:
1308: return 0;
1309: }
1310:
1311:
1312: /////////////////////////////////////////////////////////////////////////////
1313: // USB device type detection
1314:
1315: // Format USB ID for error messages
1316: static std::string format_usb_id(int vendor_id, int product_id, int version)
1317: {
1318: if (version >= 0)
1319: return strprintf("[0x%04x:0x%04x (0x%03x)]", vendor_id, product_id, version);
1320: else
1321: return strprintf("[0x%04x:0x%04x]", vendor_id, product_id);
1322: }
1323:
1324: // Get type name for USB device with known VENDOR:PRODUCT ID.
1325: const char * smart_interface::get_usb_dev_type_by_id(int vendor_id, int product_id,
1326: int version /*= -1*/)
1327: {
1328: usb_dev_info info, info2;
1329: int n = lookup_usb_device(vendor_id, product_id, version, info, info2);
1330:
1331: if (n <= 0) {
1332: set_err(EINVAL, "Unknown USB bridge %s",
1333: format_usb_id(vendor_id, product_id, version).c_str());
1334: return 0;
1335: }
1336:
1337: if (n > 1) {
1338: set_err(EINVAL, "USB bridge %s type is ambiguous: '%s' or '%s'",
1339: format_usb_id(vendor_id, product_id, version).c_str(),
1340: (!info.usb_type.empty() ? info.usb_type.c_str() : "[unsupported]"),
1341: (!info2.usb_type.empty() ? info2.usb_type.c_str() : "[unsupported]"));
1342: return 0;
1343: }
1344:
1345: if (info.usb_type.empty()) {
1346: set_err(ENOSYS, "Unsupported USB bridge %s",
1347: format_usb_id(vendor_id, product_id, version).c_str());
1348: return 0;
1349: }
1350:
1351: // TODO: change return type to std::string
1352: static std::string type;
1353: type = info.usb_type;
1354: return type.c_str();
1355: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to scsiata.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools