initial commit
[freebsd-arm:freebsd-arm.git] / cam / ata / ata_all.c
1 /*-
2  * Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification, immediately at the beginning of the file.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <sys/param.h>
31
32 #ifdef _KERNEL
33 #include <opt_scsi.h>
34
35 #include <sys/systm.h>
36 #include <sys/libkern.h>
37 #include <sys/kernel.h>
38 #include <sys/sysctl.h>
39 #else
40 #include <errno.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #ifndef min
45 #define min(a,b) (((a)<(b))?(a):(b))
46 #endif
47 #endif
48
49 #include <cam/cam.h>
50 #include <cam/cam_ccb.h>
51 #include <cam/cam_queue.h>
52 #include <cam/cam_xpt.h>
53 #include <sys/ata.h>
54 #include <cam/ata/ata_all.h>
55 #include <sys/sbuf.h>
56 #include <sys/endian.h>
57
58 int
59 ata_version(int ver)
60 {
61         int bit;
62
63         if (ver == 0xffff)
64                 return 0;
65         for (bit = 15; bit >= 0; bit--)
66                 if (ver & (1<<bit))
67                         return bit;
68         return 0;
69 }
70
71 char *
72 ata_op_string(struct ata_cmd *cmd)
73 {
74
75         switch (cmd->command) {
76         case 0x00: return ("NOP");
77         case 0x03: return ("CFA_REQUEST_EXTENDED_ERROR");
78         case 0x06:
79                 switch (cmd->features) {
80                 case 0x01: return ("DSM TRIM");
81                 }
82                 return "DSM";
83         case 0x08: return ("DEVICE_RESET");
84         case 0x20: return ("READ");
85         case 0x24: return ("READ48");
86         case 0x25: return ("READ_DMA48");
87         case 0x26: return ("READ_DMA_QUEUED48");
88         case 0x27: return ("READ_NATIVE_MAX_ADDRESS48");
89         case 0x29: return ("READ_MUL48");
90         case 0x2a: return ("READ_STREAM_DMA48");
91         case 0x2b: return ("READ_STREAM48");
92         case 0x2f: return ("READ_LOG_EXT");
93         case 0x30: return ("WRITE");
94         case 0x34: return ("WRITE48");
95         case 0x35: return ("WRITE_DMA48");
96         case 0x36: return ("WRITE_DMA_QUEUED48");
97         case 0x37: return ("SET_MAX_ADDRESS48");
98         case 0x39: return ("WRITE_MUL48");
99         case 0x3a: return ("WRITE_STREAM_DMA48");
100         case 0x3b: return ("WRITE_STREAM48");
101         case 0x3d: return ("WRITE_DMA_FUA48");
102         case 0x3e: return ("WRITE_DMA_QUEUED_FUA48");
103         case 0x3f: return ("WRITE_LOG_EXT");
104         case 0x40: return ("READ_VERIFY");
105         case 0x42: return ("READ_VERIFY48");
106         case 0x51: return ("CONFIGURE_STREAM");
107         case 0x60: return ("READ_FPDMA_QUEUED");
108         case 0x61: return ("WRITE_FPDMA_QUEUED");
109         case 0x70: return ("SEEK");
110         case 0x87: return ("CFA_TRANSLATE_SECTOR");
111         case 0x90: return ("EXECUTE_DEVICE_DIAGNOSTIC");
112         case 0x92: return ("DOWNLOAD_MICROCODE");
113         case 0xa0: return ("PACKET");
114         case 0xa1: return ("ATAPI_IDENTIFY");
115         case 0xa2: return ("SERVICE");
116         case 0xb0: return ("SMART");
117         case 0xb1: return ("DEVICE CONFIGURATION");
118         case 0xc0: return ("CFA_ERASE");
119         case 0xc4: return ("READ_MUL");
120         case 0xc5: return ("WRITE_MUL");
121         case 0xc6: return ("SET_MULTI");
122         case 0xc7: return ("READ_DMA_QUEUED");
123         case 0xc8: return ("READ_DMA");
124         case 0xca: return ("WRITE_DMA");
125         case 0xcc: return ("WRITE_DMA_QUEUED");
126         case 0xcd: return ("CFA_WRITE_MULTIPLE_WITHOUT_ERASE");
127         case 0xce: return ("WRITE_MUL_FUA48");
128         case 0xd1: return ("CHECK_MEDIA_CARD_TYPE");
129         case 0xda: return ("GET_MEDIA_STATUS");
130         case 0xde: return ("MEDIA_LOCK");
131         case 0xdf: return ("MEDIA_UNLOCK");
132         case 0xe0: return ("STANDBY_IMMEDIATE");
133         case 0xe1: return ("IDLE_IMMEDIATE");
134         case 0xe2: return ("STANDBY");
135         case 0xe3: return ("IDLE");
136         case 0xe4: return ("READ_BUFFER/PM");
137         case 0xe5: return ("CHECK_POWER_MODE");
138         case 0xe6: return ("SLEEP");
139         case 0xe7: return ("FLUSHCACHE");
140         case 0xe8: return ("WRITE_PM");
141         case 0xea: return ("FLUSHCACHE48");
142         case 0xec: return ("ATA_IDENTIFY");
143         case 0xed: return ("MEDIA_EJECT");
144         case 0xef:
145                 switch (cmd->features) {
146                 case 0x03: return ("SETFEATURES SET TRANSFER MODE");
147                 case 0x02: return ("SETFEATURES ENABLE WCACHE");
148                 case 0x82: return ("SETFEATURES DISABLE WCACHE");
149                 case 0xaa: return ("SETFEATURES ENABLE RCACHE");
150                 case 0x55: return ("SETFEATURES DISABLE RCACHE");
151                 }
152                 return "SETFEATURES";
153         case 0xf1: return ("SECURITY_SET_PASSWORD");
154         case 0xf2: return ("SECURITY_UNLOCK");
155         case 0xf3: return ("SECURITY_ERASE_PREPARE");
156         case 0xf4: return ("SECURITY_ERASE_UNIT");
157         case 0xf5: return ("SECURITY_FREE_LOCK");
158         case 0xf6: return ("SECURITY DISABLE PASSWORD");
159         case 0xf8: return ("READ_NATIVE_MAX_ADDRESS");
160         case 0xf9: return ("SET_MAX_ADDRESS");
161         }
162         return "UNKNOWN";
163 }
164
165 char *
166 ata_cmd_string(struct ata_cmd *cmd, char *cmd_string, size_t len)
167 {
168
169         snprintf(cmd_string, len, "%02x %02x %02x %02x "
170             "%02x %02x %02x %02x %02x %02x %02x %02x",
171             cmd->command, cmd->features,
172             cmd->lba_low, cmd->lba_mid, cmd->lba_high, cmd->device,
173             cmd->lba_low_exp, cmd->lba_mid_exp, cmd->lba_high_exp,
174             cmd->features_exp, cmd->sector_count, cmd->sector_count_exp);
175
176         return(cmd_string);
177 }
178
179 char *
180 ata_res_string(struct ata_res *res, char *res_string, size_t len)
181 {
182
183         snprintf(res_string, len, "%02x %02x %02x %02x "
184             "%02x %02x %02x %02x %02x %02x %02x",
185             res->status, res->error,
186             res->lba_low, res->lba_mid, res->lba_high, res->device,
187             res->lba_low_exp, res->lba_mid_exp, res->lba_high_exp,
188             res->sector_count, res->sector_count_exp);
189
190         return(res_string);
191 }
192
193 /*
194  * ata_command_sbuf() returns 0 for success and -1 for failure.
195  */
196 int
197 ata_command_sbuf(struct ccb_ataio *ataio, struct sbuf *sb)
198 {
199         char cmd_str[(12 * 3) + 1];
200
201         sbuf_printf(sb, "%s. ACB: %s",
202             ata_op_string(&ataio->cmd),
203             ata_cmd_string(&ataio->cmd, cmd_str, sizeof(cmd_str)));
204
205         return(0);
206 }
207
208 /*
209  * ata_status_abuf() returns 0 for success and -1 for failure.
210  */
211 int
212 ata_status_sbuf(struct ccb_ataio *ataio, struct sbuf *sb)
213 {
214
215         sbuf_printf(sb, "ATA status: %02x (%s%s%s%s%s%s%s%s)",
216             ataio->res.status,
217             (ataio->res.status & 0x80) ? "BSY " : "",
218             (ataio->res.status & 0x40) ? "DRDY " : "",
219             (ataio->res.status & 0x20) ? "DF " : "",
220             (ataio->res.status & 0x10) ? "SERV " : "",
221             (ataio->res.status & 0x08) ? "DRQ " : "",
222             (ataio->res.status & 0x04) ? "CORR " : "",
223             (ataio->res.status & 0x02) ? "IDX " : "",
224             (ataio->res.status & 0x01) ? "ERR" : "");
225         if (ataio->res.status & 1) {
226             sbuf_printf(sb, ", error: %02x (%s%s%s%s%s%s%s%s)",
227                 ataio->res.error,
228                 (ataio->res.error & 0x80) ? "ICRC " : "",
229                 (ataio->res.error & 0x40) ? "UNC " : "",
230                 (ataio->res.error & 0x20) ? "MC " : "",
231                 (ataio->res.error & 0x10) ? "IDNF " : "",
232                 (ataio->res.error & 0x08) ? "MCR " : "",
233                 (ataio->res.error & 0x04) ? "ABRT " : "",
234                 (ataio->res.error & 0x02) ? "NM " : "",
235                 (ataio->res.error & 0x01) ? "ILI" : "");
236         }
237
238         return(0);
239 }
240
241 /*
242  * ata_res_sbuf() returns 0 for success and -1 for failure.
243  */
244 int
245 ata_res_sbuf(struct ccb_ataio *ataio, struct sbuf *sb)
246 {
247         char res_str[(11 * 3) + 1];
248
249         sbuf_printf(sb, "RES: %s",
250             ata_res_string(&ataio->res, res_str, sizeof(res_str)));
251
252         return(0);
253 }
254
255 void
256 ata_print_ident(struct ata_params *ident_data)
257 {
258         char product[48], revision[16];
259
260         cam_strvis(product, ident_data->model, sizeof(ident_data->model),
261                    sizeof(product));
262         cam_strvis(revision, ident_data->revision, sizeof(ident_data->revision),
263                    sizeof(revision));
264         printf("<%s %s> %s-%d",
265             product, revision,
266             (ident_data->config & ATA_PROTO_ATAPI) ? "ATAPI" : "ATA",
267             ata_version(ident_data->version_major));
268         if (ident_data->satacapabilities && ident_data->satacapabilities != 0xffff) {
269                 if (ident_data->satacapabilities & ATA_SATA_GEN3)
270                         printf(" SATA 3.x");
271                 else if (ident_data->satacapabilities & ATA_SATA_GEN2)
272                         printf(" SATA 2.x");
273                 else if (ident_data->satacapabilities & ATA_SATA_GEN1)
274                         printf(" SATA 1.x");
275                 else
276                         printf(" SATA");
277         }
278         printf(" device\n");
279 }
280
281 uint32_t
282 ata_logical_sector_size(struct ata_params *ident_data)
283 {
284         if ((ident_data->pss & 0xc000) == 0x4000 &&
285             (ident_data->pss & ATA_PSS_LSSABOVE512)) {
286                 return ((u_int32_t)ident_data->lss_1 |
287                     ((u_int32_t)ident_data->lss_2 << 16));
288         }
289         return (512);
290 }
291
292 uint64_t
293 ata_physical_sector_size(struct ata_params *ident_data)
294 {
295         if ((ident_data->pss & 0xc000) == 0x4000 &&
296             (ident_data->pss & ATA_PSS_MULTLS)) {
297                 return ((uint64_t)ata_logical_sector_size(ident_data) *
298                     (1 << (ident_data->pss & ATA_PSS_LSPPS)));
299         }
300         return (512);
301 }
302
303 uint64_t
304 ata_logical_sector_offset(struct ata_params *ident_data)
305 {
306         if ((ident_data->lsalign & 0xc000) == 0x4000) {
307                 return ((uint64_t)ata_logical_sector_size(ident_data) *
308                     (ident_data->lsalign & 0x3fff));
309         }
310         return (0);
311 }
312
313 void
314 ata_28bit_cmd(struct ccb_ataio *ataio, uint8_t cmd, uint8_t features,
315     uint32_t lba, uint8_t sector_count)
316 {
317         bzero(&ataio->cmd, sizeof(ataio->cmd));
318         ataio->cmd.flags = 0;
319         if (cmd == ATA_READ_DMA ||
320             cmd == ATA_READ_DMA_QUEUED ||
321             cmd == ATA_WRITE_DMA ||
322             cmd == ATA_WRITE_DMA_QUEUED)
323                 ataio->cmd.flags |= CAM_ATAIO_DMA;
324         ataio->cmd.command = cmd;
325         ataio->cmd.features = features;
326         ataio->cmd.lba_low = lba;
327         ataio->cmd.lba_mid = lba >> 8;
328         ataio->cmd.lba_high = lba >> 16;
329         ataio->cmd.device = 0x40 | ((lba >> 24) & 0x0f);
330         ataio->cmd.sector_count = sector_count;
331 }
332
333 void
334 ata_48bit_cmd(struct ccb_ataio *ataio, uint8_t cmd, uint16_t features,
335     uint64_t lba, uint16_t sector_count)
336 {
337         bzero(&ataio->cmd, sizeof(ataio->cmd));
338         ataio->cmd.flags = CAM_ATAIO_48BIT;
339         if (cmd == ATA_READ_DMA48 ||
340             cmd == ATA_READ_DMA_QUEUED48 ||
341             cmd == ATA_READ_STREAM_DMA48 ||
342             cmd == ATA_WRITE_DMA48 ||
343             cmd == ATA_WRITE_DMA_FUA48 ||
344             cmd == ATA_WRITE_DMA_QUEUED48 ||
345             cmd == ATA_WRITE_DMA_QUEUED_FUA48 ||
346             cmd == ATA_WRITE_STREAM_DMA48 ||
347             cmd == ATA_DATA_SET_MANAGEMENT)
348                 ataio->cmd.flags |= CAM_ATAIO_DMA;
349         ataio->cmd.command = cmd;
350         ataio->cmd.features = features;
351         ataio->cmd.lba_low = lba;
352         ataio->cmd.lba_mid = lba >> 8;
353         ataio->cmd.lba_high = lba >> 16;
354         ataio->cmd.device = 0x40;
355         ataio->cmd.lba_low_exp = lba >> 24;
356         ataio->cmd.lba_mid_exp = lba >> 32;
357         ataio->cmd.lba_high_exp = lba >> 40;
358         ataio->cmd.features_exp = features >> 8;
359         ataio->cmd.sector_count = sector_count;
360         ataio->cmd.sector_count_exp = sector_count >> 8;
361 }
362
363 void
364 ata_ncq_cmd(struct ccb_ataio *ataio, uint8_t cmd,
365     uint64_t lba, uint16_t sector_count)
366 {
367         bzero(&ataio->cmd, sizeof(ataio->cmd));
368         ataio->cmd.flags = CAM_ATAIO_48BIT | CAM_ATAIO_FPDMA;
369         ataio->cmd.command = cmd;
370         ataio->cmd.features = sector_count;
371         ataio->cmd.lba_low = lba;
372         ataio->cmd.lba_mid = lba >> 8;
373         ataio->cmd.lba_high = lba >> 16;
374         ataio->cmd.device = 0x40;
375         ataio->cmd.lba_low_exp = lba >> 24;
376         ataio->cmd.lba_mid_exp = lba >> 32;
377         ataio->cmd.lba_high_exp = lba >> 40;
378         ataio->cmd.features_exp = sector_count >> 8;
379 }
380
381 void
382 ata_reset_cmd(struct ccb_ataio *ataio)
383 {
384         bzero(&ataio->cmd, sizeof(ataio->cmd));
385         ataio->cmd.flags = CAM_ATAIO_CONTROL | CAM_ATAIO_NEEDRESULT;
386         ataio->cmd.control = 0x04;
387 }
388
389 void
390 ata_pm_read_cmd(struct ccb_ataio *ataio, int reg, int port)
391 {
392         bzero(&ataio->cmd, sizeof(ataio->cmd));
393         ataio->cmd.flags = CAM_ATAIO_NEEDRESULT;
394         ataio->cmd.command = ATA_READ_PM;
395         ataio->cmd.features = reg;
396         ataio->cmd.device = port & 0x0f;
397 }
398
399 void
400 ata_pm_write_cmd(struct ccb_ataio *ataio, int reg, int port, uint32_t val)
401 {
402         bzero(&ataio->cmd, sizeof(ataio->cmd));
403         ataio->cmd.flags = 0;
404         ataio->cmd.command = ATA_WRITE_PM;
405         ataio->cmd.features = reg;
406         ataio->cmd.sector_count = val;
407         ataio->cmd.lba_low = val >> 8;
408         ataio->cmd.lba_mid = val >> 16;
409         ataio->cmd.lba_high = val >> 24;
410         ataio->cmd.device = port & 0x0f;
411 }
412
413 void
414 ata_bswap(int8_t *buf, int len)
415 {
416         u_int16_t *ptr = (u_int16_t*)(buf + len);
417
418         while (--ptr >= (u_int16_t*)buf)
419                 *ptr = be16toh(*ptr);
420 }
421
422 void
423 ata_btrim(int8_t *buf, int len)
424 {
425         int8_t *ptr;
426
427         for (ptr = buf; ptr < buf+len; ++ptr)
428                 if (!*ptr || *ptr == '_')
429                         *ptr = ' ';
430         for (ptr = buf + len - 1; ptr >= buf && *ptr == ' '; --ptr)
431                 *ptr = 0;
432 }
433
434 void
435 ata_bpack(int8_t *src, int8_t *dst, int len)
436 {
437         int i, j, blank;
438
439         for (i = j = blank = 0 ; i < len; i++) {
440                 if (blank && src[i] == ' ') continue;
441                 if (blank && src[i] != ' ') {
442                         dst[j++] = src[i];
443                         blank = 0;
444                         continue;
445                 }
446                 if (src[i] == ' ') {
447                         blank = 1;
448                         if (i == 0)
449                         continue;
450                 }
451                 dst[j++] = src[i];
452         }
453         while (j < len)
454                 dst[j++] = 0x00;
455 }
456
457 int
458 ata_max_pmode(struct ata_params *ap)
459 {
460     if (ap->atavalid & ATA_FLAG_64_70) {
461         if (ap->apiomodes & 0x02)
462             return ATA_PIO4;
463         if (ap->apiomodes & 0x01)
464             return ATA_PIO3;
465     }
466     if (ap->mwdmamodes & 0x04)
467         return ATA_PIO4;
468     if (ap->mwdmamodes & 0x02)
469         return ATA_PIO3;
470     if (ap->mwdmamodes & 0x01)
471         return ATA_PIO2;
472     if ((ap->retired_piomode & ATA_RETIRED_PIO_MASK) == 0x200)
473         return ATA_PIO2;
474     if ((ap->retired_piomode & ATA_RETIRED_PIO_MASK) == 0x100)
475         return ATA_PIO1;
476     if ((ap->retired_piomode & ATA_RETIRED_PIO_MASK) == 0x000)
477         return ATA_PIO0;
478     return ATA_PIO0;
479 }
480
481 int
482 ata_max_wmode(struct ata_params *ap)
483 {
484     if (ap->mwdmamodes & 0x04)
485         return ATA_WDMA2;
486     if (ap->mwdmamodes & 0x02)
487         return ATA_WDMA1;
488     if (ap->mwdmamodes & 0x01)
489         return ATA_WDMA0;
490     return -1;
491 }
492
493 int
494 ata_max_umode(struct ata_params *ap)
495 {
496     if (ap->atavalid & ATA_FLAG_88) {
497         if (ap->udmamodes & 0x40)
498             return ATA_UDMA6;
499         if (ap->udmamodes & 0x20)
500             return ATA_UDMA5;
501         if (ap->udmamodes & 0x10)
502             return ATA_UDMA4;
503         if (ap->udmamodes & 0x08)
504             return ATA_UDMA3;
505         if (ap->udmamodes & 0x04)
506             return ATA_UDMA2;
507         if (ap->udmamodes & 0x02)
508             return ATA_UDMA1;
509         if (ap->udmamodes & 0x01)
510             return ATA_UDMA0;
511     }
512     return -1;
513 }
514
515 int
516 ata_max_mode(struct ata_params *ap, int maxmode)
517 {
518
519         if (maxmode == 0)
520                 maxmode = ATA_DMA_MAX;
521         if (maxmode >= ATA_UDMA0 && ata_max_umode(ap) > 0)
522                 return (min(maxmode, ata_max_umode(ap)));
523         if (maxmode >= ATA_WDMA0 && ata_max_wmode(ap) > 0)
524                 return (min(maxmode, ata_max_wmode(ap)));
525         return (min(maxmode, ata_max_pmode(ap)));
526 }
527
528 char *
529 ata_mode2string(int mode)
530 {
531     switch (mode) {
532     case -1: return "UNSUPPORTED";
533     case 0: return "NONE";
534     case ATA_PIO0: return "PIO0";
535     case ATA_PIO1: return "PIO1";
536     case ATA_PIO2: return "PIO2";
537     case ATA_PIO3: return "PIO3";
538     case ATA_PIO4: return "PIO4";
539     case ATA_WDMA0: return "WDMA0";
540     case ATA_WDMA1: return "WDMA1";
541     case ATA_WDMA2: return "WDMA2";
542     case ATA_UDMA0: return "UDMA0";
543     case ATA_UDMA1: return "UDMA1";
544     case ATA_UDMA2: return "UDMA2";
545     case ATA_UDMA3: return "UDMA3";
546     case ATA_UDMA4: return "UDMA4";
547     case ATA_UDMA5: return "UDMA5";
548     case ATA_UDMA6: return "UDMA6";
549     default:
550         if (mode & ATA_DMA_MASK)
551             return "BIOSDMA";
552         else
553             return "BIOSPIO";
554     }
555 }
556
557 int
558 ata_string2mode(char *str)
559 {
560         if (!strcasecmp(str, "PIO0")) return (ATA_PIO0);
561         if (!strcasecmp(str, "PIO1")) return (ATA_PIO1);
562         if (!strcasecmp(str, "PIO2")) return (ATA_PIO2);
563         if (!strcasecmp(str, "PIO3")) return (ATA_PIO3);
564         if (!strcasecmp(str, "PIO4")) return (ATA_PIO4);
565         if (!strcasecmp(str, "WDMA0")) return (ATA_WDMA0);
566         if (!strcasecmp(str, "WDMA1")) return (ATA_WDMA1);
567         if (!strcasecmp(str, "WDMA2")) return (ATA_WDMA2);
568         if (!strcasecmp(str, "UDMA0")) return (ATA_UDMA0);
569         if (!strcasecmp(str, "UDMA16")) return (ATA_UDMA0);
570         if (!strcasecmp(str, "UDMA1")) return (ATA_UDMA1);
571         if (!strcasecmp(str, "UDMA25")) return (ATA_UDMA1);
572         if (!strcasecmp(str, "UDMA2")) return (ATA_UDMA2);
573         if (!strcasecmp(str, "UDMA33")) return (ATA_UDMA2);
574         if (!strcasecmp(str, "UDMA3")) return (ATA_UDMA3);
575         if (!strcasecmp(str, "UDMA44")) return (ATA_UDMA3);
576         if (!strcasecmp(str, "UDMA4")) return (ATA_UDMA4);
577         if (!strcasecmp(str, "UDMA66")) return (ATA_UDMA4);
578         if (!strcasecmp(str, "UDMA5")) return (ATA_UDMA5);
579         if (!strcasecmp(str, "UDMA100")) return (ATA_UDMA5);
580         if (!strcasecmp(str, "UDMA6")) return (ATA_UDMA6);
581         if (!strcasecmp(str, "UDMA133")) return (ATA_UDMA6);
582         return (-1);
583 }
584
585
586 u_int
587 ata_mode2speed(int mode)
588 {
589         switch (mode) {
590         case ATA_PIO0:
591         default:
592                 return (3300);
593         case ATA_PIO1:
594                 return (5200);
595         case ATA_PIO2:
596                 return (8300);
597         case ATA_PIO3:
598                 return (11100);
599         case ATA_PIO4:
600                 return (16700);
601         case ATA_WDMA0:
602                 return (4200);
603         case ATA_WDMA1:
604                 return (13300);
605         case ATA_WDMA2:
606                 return (16700);
607         case ATA_UDMA0:
608                 return (16700);
609         case ATA_UDMA1:
610                 return (25000);
611         case ATA_UDMA2:
612                 return (33300);
613         case ATA_UDMA3:
614                 return (44400);
615         case ATA_UDMA4:
616                 return (66700);
617         case ATA_UDMA5:
618                 return (100000);
619         case ATA_UDMA6:
620                 return (133000);
621         }
622 }
623
624 u_int
625 ata_revision2speed(int revision)
626 {
627         switch (revision) {
628         case 1:
629         default:
630                 return (150000);
631         case 2:
632                 return (300000);
633         case 3:
634                 return (600000);
635         }
636 }
637
638 int
639 ata_speed2revision(u_int speed)
640 {
641         switch (speed) {
642         case 0:
643                 return (0);
644         case 150000:
645                 return (1);
646         case 300000:
647                 return (2);
648         case 600000:
649                 return (3);
650         default:
651                 return (-1);
652         }
653 }
654
655 int
656 ata_identify_match(caddr_t identbuffer, caddr_t table_entry)
657 {
658         struct scsi_inquiry_pattern *entry;
659         struct ata_params *ident;
660  
661         entry = (struct scsi_inquiry_pattern *)table_entry;
662         ident = (struct ata_params *)identbuffer;
663
664         if ((cam_strmatch(ident->model, entry->product,
665                           sizeof(ident->model)) == 0)
666          && (cam_strmatch(ident->revision, entry->revision,
667                           sizeof(ident->revision)) == 0)) {
668                 return (0);
669         }
670         return (-1);
671 }
672
673 int
674 ata_static_identify_match(caddr_t identbuffer, caddr_t table_entry)
675 {
676         struct scsi_static_inquiry_pattern *entry;
677         struct ata_params *ident;
678  
679         entry = (struct scsi_static_inquiry_pattern *)table_entry;
680         ident = (struct ata_params *)identbuffer;
681
682         if ((cam_strmatch(ident->model, entry->product,
683                           sizeof(ident->model)) == 0)
684          && (cam_strmatch(ident->revision, entry->revision,
685                           sizeof(ident->revision)) == 0)) {
686                 return (0);
687         }
688         return (-1);
689 }