drivers/ata/libata.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2008 Freescale Semiconductor, Inc.
   4  *              Dave Liu <daveliu@freescale.com>
   5  *              port from the libata of linux kernel
   6  */
   7
   8 #include <libata.h>
   9
  10 u64 ata_id_n_sectors(u16 *id)
  11 {
  12         if (ata_id_has_lba(id)) {
  13                 if (ata_id_has_lba48(id))
  14                         return ata_id_u64(id, ATA_ID_LBA48_SECTORS);
  15                 else
  16                         return ata_id_u32(id, ATA_ID_LBA_SECTORS);
  17         } else {
  18                 return 0;
  19         }
  20 }
  21
  22 u32 ata_dev_classify(u32 sig)
  23 {
  24         u8 lbam, lbah;
  25
  26         lbam = (sig >> 16) & 0xff;
  27         lbah = (sig >> 24) & 0xff;
  28
  29         if (((lbam == 0) && (lbah == 0)) ||
  30                 ((lbam == 0x3c) && (lbah == 0xc3)))
  31                 return ATA_DEV_ATA;
  32
  33         if ((lbam == 0x14) && (lbah == 0xeb))
  34                 return ATA_DEV_ATAPI;
  35
  36         if ((lbam == 0x69) && (lbah == 0x96))
  37                 return ATA_DEV_PMP;
  38
  39         return ATA_DEV_UNKNOWN;
  40 }
  41
  42 static void ata_id_string(const u16 *id, unsigned char *s,
  43                          unsigned int ofs, unsigned int len)
  44 {
  45         unsigned int c;
  46
  47         while (len > 0) {
  48                 c = id[ofs] >> 8;
  49                 *s = c;
  50                 s++;
  51
  52                 c = id[ofs] & 0xff;
  53                 *s = c;
  54                 s++;
  55
  56                 ofs++;
  57                 len -= 2;
  58         }
  59 }
  60
  61 void ata_id_c_string(const u16 *id, unsigned char *s,
  62                          unsigned int ofs, unsigned int len)
  63 {
  64         unsigned char *p;
  65
  66         ata_id_string(id, s, ofs, len - 1);
  67
  68         p = s + strnlen((char *)s, len - 1);
  69         while (p > s && p[-1] == ' ')
  70                 p--;
  71         *p = '\0';
  72 }
  73
  74 void ata_dump_id(u16 *id)
  75 {
  76         unsigned char serial[ATA_ID_SERNO_LEN + 1];
  77         unsigned char firmware[ATA_ID_FW_REV_LEN + 1];
  78         unsigned char product[ATA_ID_PROD_LEN + 1];
  79         u64 n_sectors;
  80
  81         /* Serial number */
  82         ata_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
  83         printf("S/N: %s\n\r", serial);
  84
  85         /* Firmware version */
  86         ata_id_c_string(id, firmware, ATA_ID_FW_REV, sizeof(firmware));
  87         printf("Firmware version: %s\n\r", firmware);
  88
  89         /* Product model */
  90         ata_id_c_string(id, product, ATA_ID_PROD, sizeof(product));
  91         printf("Product model number: %s\n\r", product);
  92
  93         /* Total sectors of device  */
  94         n_sectors = ata_id_n_sectors(id);
  95         printf("Capablity: %lld sectors\n\r", n_sectors);
  96
  97         printf ("id[49]: capabilities = 0x%04x\n"
  98                 "id[53]: field valid = 0x%04x\n"
  99                 "id[63]: mwdma = 0x%04x\n"
 100                 "id[64]: pio = 0x%04x\n"
 101                 "id[75]: queue depth = 0x%04x\n",
 102                 id[49],
 103                 id[53],
 104                 id[63],
 105                 id[64],
 106                 id[75]);
 107
 108         printf ("id[76]: sata capablity = 0x%04x\n"
 109                 "id[78]: sata features supported = 0x%04x\n"
 110                 "id[79]: sata features enable = 0x%04x\n",
 111                 id[76],
 112                 id[78],
 113                 id[79]);
 114
 115         printf ("id[80]: major version = 0x%04x\n"
 116                 "id[81]: minor version = 0x%04x\n"
 117                 "id[82]: command set supported 1 = 0x%04x\n"
 118                 "id[83]: command set supported 2 = 0x%04x\n"
 119                 "id[84]: command set extension = 0x%04x\n",
 120                 id[80],
 121                 id[81],
 122                 id[82],
 123                 id[83],
 124                 id[84]);
 125         printf ("id[85]: command set enable 1 = 0x%04x\n"
 126                 "id[86]: command set enable 2 = 0x%04x\n"
 127                 "id[87]: command set default = 0x%04x\n"
 128                 "id[88]: udma = 0x%04x\n"
 129                 "id[93]: hardware reset result = 0x%04x\n",
 130                 id[85],
 131                 id[86],
 132                 id[87],
 133                 id[88],
 134                 id[93]);
 135 }
 136
 137 void ata_swap_buf_le16(u16 *buf, unsigned int buf_words)
 138 {
 139         unsigned int i;
 140
 141         for (i = 0; i < buf_words; i++)
 142                 buf[i] = le16_to_cpu(buf[i]);
 143 }