drivers/ata/pata_hpt37x.c

   1 /*
   2  * Libata driver for the highpoint 37x and 30x UDMA66 ATA controllers.
   3  *
   4  * This driver is heavily based upon:
   5  *
   6  * linux/drivers/ide/pci/hpt366.c               Version 0.36    April 25, 2003
   7  *
   8  * Copyright (C) 1999-2003              Andre Hedrick <andre@linux-ide.org>
   9  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
  10  * Portions Copyright (C) 2003          Red Hat Inc
  11  * Portions Copyright (C) 2005-2009     MontaVista Software, Inc.
  12  *
  13  * TODO
  14  *      Look into engine reset on timeout errors. Should not be required.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/pci.h>
  20 #include <linux/init.h>
  21 #include <linux/blkdev.h>
  22 #include <linux/delay.h>
  23 #include <scsi/scsi_host.h>
  24 #include <linux/libata.h>
  25
  26 #define DRV_NAME        "pata_hpt37x"
  27 #define DRV_VERSION     "0.6.15"
  28
  29 struct hpt_clock {
  30         u8      xfer_speed;
  31         u32     timing;
  32 };
  33
  34 struct hpt_chip {
  35         const char *name;
  36         unsigned int base;
  37         struct hpt_clock const *clocks[4];
  38 };
  39
  40 /* key for bus clock timings
  41  * bit
  42  * 0:3    data_high_time. Inactive time of DIOW_/DIOR_ for PIO and MW DMA.
  43  *        cycles = value + 1
  44  * 4:8    data_low_time. Active time of DIOW_/DIOR_ for PIO and MW DMA.
  45  *        cycles = value + 1
  46  * 9:12   cmd_high_time. Inactive time of DIOW_/DIOR_ during task file
  47  *        register access.
  48  * 13:17  cmd_low_time. Active time of DIOW_/DIOR_ during task file
  49  *        register access.
  50  * 18:20  udma_cycle_time. Clock cycles for UDMA xfer.
  51  * 21     CLK frequency for UDMA: 0=ATA clock, 1=dual ATA clock.
  52  * 22:24  pre_high_time. Time to initialize 1st cycle for PIO and MW DMA xfer.
  53  * 25:27  cmd_pre_high_time. Time to initialize 1st PIO cycle for task file
  54  *        register access.
  55  * 28     UDMA enable.
  56  * 29     DMA  enable.
  57  * 30     PIO_MST enable. If set, the chip is in bus master mode during
  58  *        PIO xfer.
  59  * 31     FIFO enable. Only for PIO.
  60  */
  61
  62 static struct hpt_clock hpt37x_timings_33[] = {
  63         { XFER_UDMA_6,          0x12446231 },   /* 0x12646231 ?? */
  64         { XFER_UDMA_5,          0x12446231 },
  65         { XFER_UDMA_4,          0x12446231 },
  66         { XFER_UDMA_3,          0x126c6231 },
  67         { XFER_UDMA_2,          0x12486231 },
  68         { XFER_UDMA_1,          0x124c6233 },
  69         { XFER_UDMA_0,          0x12506297 },
  70
  71         { XFER_MW_DMA_2,        0x22406c31 },
  72         { XFER_MW_DMA_1,        0x22406c33 },
  73         { XFER_MW_DMA_0,        0x22406c97 },
  74
  75         { XFER_PIO_4,           0x06414e31 },
  76         { XFER_PIO_3,           0x06414e42 },
  77         { XFER_PIO_2,           0x06414e53 },
  78         { XFER_PIO_1,           0x06814e93 },
  79         { XFER_PIO_0,           0x06814ea7 }
  80 };
  81
  82 static struct hpt_clock hpt37x_timings_50[] = {
  83         { XFER_UDMA_6,          0x12848242 },
  84         { XFER_UDMA_5,          0x12848242 },
  85         { XFER_UDMA_4,          0x12ac8242 },
  86         { XFER_UDMA_3,          0x128c8242 },
  87         { XFER_UDMA_2,          0x120c8242 },
  88         { XFER_UDMA_1,          0x12148254 },
  89         { XFER_UDMA_0,          0x121882ea },
  90
  91         { XFER_MW_DMA_2,        0x22808242 },
  92         { XFER_MW_DMA_1,        0x22808254 },
  93         { XFER_MW_DMA_0,        0x228082ea },
  94
  95         { XFER_PIO_4,           0x0a81f442 },
  96         { XFER_PIO_3,           0x0a81f443 },
  97         { XFER_PIO_2,           0x0a81f454 },
  98         { XFER_PIO_1,           0x0ac1f465 },
  99         { XFER_PIO_0,           0x0ac1f48a }
 100 };
 101
 102 static struct hpt_clock hpt37x_timings_66[] = {
 103         { XFER_UDMA_6,          0x1c869c62 },
 104         { XFER_UDMA_5,          0x1cae9c62 },   /* 0x1c8a9c62 */
 105         { XFER_UDMA_4,          0x1c8a9c62 },
 106         { XFER_UDMA_3,          0x1c8e9c62 },
 107         { XFER_UDMA_2,          0x1c929c62 },
 108         { XFER_UDMA_1,          0x1c9a9c62 },
 109         { XFER_UDMA_0,          0x1c829c62 },
 110
 111         { XFER_MW_DMA_2,        0x2c829c62 },
 112         { XFER_MW_DMA_1,        0x2c829c66 },
 113         { XFER_MW_DMA_0,        0x2c829d2e },
 114
 115         { XFER_PIO_4,           0x0c829c62 },
 116         { XFER_PIO_3,           0x0c829c84 },
 117         { XFER_PIO_2,           0x0c829ca6 },
 118         { XFER_PIO_1,           0x0d029d26 },
 119         { XFER_PIO_0,           0x0d029d5e }
 120 };
 121
 122
 123 static const struct hpt_chip hpt370 = {
 124         "HPT370",
 125         48,
 126         {
 127                 hpt37x_timings_33,
 128                 NULL,
 129                 NULL,
 130                 NULL
 131         }
 132 };
 133
 134 static const struct hpt_chip hpt370a = {
 135         "HPT370A",
 136         48,
 137         {
 138                 hpt37x_timings_33,
 139                 NULL,
 140                 hpt37x_timings_50,
 141                 NULL
 142         }
 143 };
 144
 145 static const struct hpt_chip hpt372 = {
 146         "HPT372",
 147         55,
 148         {
 149                 hpt37x_timings_33,
 150                 NULL,
 151                 hpt37x_timings_50,
 152                 hpt37x_timings_66
 153         }
 154 };
 155
 156 static const struct hpt_chip hpt302 = {
 157         "HPT302",
 158         66,
 159         {
 160                 hpt37x_timings_33,
 161                 NULL,
 162                 hpt37x_timings_50,
 163                 hpt37x_timings_66
 164         }
 165 };
 166
 167 static const struct hpt_chip hpt371 = {
 168         "HPT371",
 169         66,
 170         {
 171                 hpt37x_timings_33,
 172                 NULL,
 173                 hpt37x_timings_50,
 174                 hpt37x_timings_66
 175         }
 176 };
 177
 178 static const struct hpt_chip hpt372a = {
 179         "HPT372A",
 180         66,
 181         {
 182                 hpt37x_timings_33,
 183                 NULL,
 184                 hpt37x_timings_50,
 185                 hpt37x_timings_66
 186         }
 187 };
 188
 189 static const struct hpt_chip hpt374 = {
 190         "HPT374",
 191         48,
 192         {
 193                 hpt37x_timings_33,
 194                 NULL,
 195                 NULL,
 196                 NULL
 197         }
 198 };
 199
 200 /**
 201  *      hpt37x_find_mode        -       reset the hpt37x bus
 202  *      @ap: ATA port
 203  *      @speed: transfer mode
 204  *
 205  *      Return the 32bit register programming information for this channel
 206  *      that matches the speed provided.
 207  */
 208
 209 static u32 hpt37x_find_mode(struct ata_port *ap, int speed)
 210 {
 211         struct hpt_clock *clocks = ap->host->private_data;
 212
 213         while(clocks->xfer_speed) {
 214                 if (clocks->xfer_speed == speed)
 215                         return clocks->timing;
 216                 clocks++;
 217         }
 218         BUG();
 219         return 0xffffffffU;     /* silence compiler warning */
 220 }
 221
 222 static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, const char *list[])
 223 {
 224         unsigned char model_num[ATA_ID_PROD_LEN + 1];
 225         int i = 0;
 226
 227         ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
 228
 229         while (list[i] != NULL) {
 230                 if (!strcmp(list[i], model_num)) {
 231                         printk(KERN_WARNING DRV_NAME ": %s is not supported for %s.\n",
 232                                 modestr, list[i]);
 233                         return 1;
 234                 }
 235                 i++;
 236         }
 237         return 0;
 238 }
 239
 240 static const char *bad_ata33[] = {
 241         "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3", "Maxtor 90845U3", "Maxtor 90650U2",
 242         "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5", "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
 243         "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6", "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
 244         "Maxtor 90510D4",
 245         "Maxtor 90432D3", "Maxtor 90288D2", "Maxtor 90256D2",
 246         "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7", "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
 247         "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5", "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
 248         NULL
 249 };
 250
 251 static const char *bad_ata100_5[] = {
 252         "IBM-DTLA-307075",
 253         "IBM-DTLA-307060",
 254         "IBM-DTLA-307045",
 255         "IBM-DTLA-307030",
 256         "IBM-DTLA-307020",
 257         "IBM-DTLA-307015",
 258         "IBM-DTLA-305040",
 259         "IBM-DTLA-305030",
 260         "IBM-DTLA-305020",
 261         "IC35L010AVER07-0",
 262         "IC35L020AVER07-0",
 263         "IC35L030AVER07-0",
 264         "IC35L040AVER07-0",
 265         "IC35L060AVER07-0",
 266         "WDC AC310200R",
 267         NULL
 268 };
 269
 270 /**
 271  *      hpt370_filter   -       mode selection filter
 272  *      @adev: ATA device
 273  *
 274  *      Block UDMA on devices that cause trouble with this controller.
 275  */
 276
 277 static unsigned long hpt370_filter(struct ata_device *adev, unsigned long mask)
 278 {
 279         if (adev->class == ATA_DEV_ATA) {
 280                 if (hpt_dma_blacklisted(adev, "UDMA", bad_ata33))
 281                         mask &= ~ATA_MASK_UDMA;
 282                 if (hpt_dma_blacklisted(adev, "UDMA100", bad_ata100_5))
 283                         mask &= ~(0xE0 << ATA_SHIFT_UDMA);
 284         }
 285         return mask;
 286 }
 287
 288 /**
 289  *      hpt370a_filter  -       mode selection filter
 290  *      @adev: ATA device
 291  *
 292  *      Block UDMA on devices that cause trouble with this controller.
 293  */
 294
 295 static unsigned long hpt370a_filter(struct ata_device *adev, unsigned long mask)
 296 {
 297         if (adev->class == ATA_DEV_ATA) {
 298                 if (hpt_dma_blacklisted(adev, "UDMA100", bad_ata100_5))
 299                         mask &= ~(0xE0 << ATA_SHIFT_UDMA);
 300         }
 301         return mask;
 302 }
 303
 304 /**
 305  *      hpt37x_cable_detect     -       Detect the cable type
 306  *      @ap: ATA port to detect on
 307  *
 308  *      Return the cable type attached to this port
 309  */
 310
 311 static int hpt37x_cable_detect(struct ata_port *ap)
 312 {
 313         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 314         u8 scr2, ata66;
 315
 316         pci_read_config_byte(pdev, 0x5B, &scr2);
 317         pci_write_config_byte(pdev, 0x5B, scr2 & ~0x01);
 318
 319         udelay(10); /* debounce */
 320
 321         /* Cable register now active */
 322         pci_read_config_byte(pdev, 0x5A, &ata66);
 323         /* Restore state */
 324         pci_write_config_byte(pdev, 0x5B, scr2);
 325
 326         if (ata66 & (2 >> ap->port_no))
 327                 return ATA_CBL_PATA40;
 328         else
 329                 return ATA_CBL_PATA80;
 330 }
 331
 332 /**
 333  *      hpt374_fn1_cable_detect -       Detect the cable type
 334  *      @ap: ATA port to detect on
 335  *
 336  *      Return the cable type attached to this port
 337  */
 338
 339 static int hpt374_fn1_cable_detect(struct ata_port *ap)
 340 {
 341         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 342         unsigned int mcrbase = 0x50 + 4 * ap->port_no;
 343         u16 mcr3;
 344         u8 ata66;
 345
 346         /* Do the extra channel work */
 347         pci_read_config_word(pdev, mcrbase + 2, &mcr3);
 348         /* Set bit 15 of 0x52 to enable TCBLID as input */
 349         pci_write_config_word(pdev, mcrbase + 2, mcr3 | 0x8000);
 350         pci_read_config_byte(pdev, 0x5A, &ata66);
 351         /* Reset TCBLID/FCBLID to output */
 352         pci_write_config_word(pdev, mcrbase + 2, mcr3);
 353
 354         if (ata66 & (2 >> ap->port_no))
 355                 return ATA_CBL_PATA40;
 356         else
 357                 return ATA_CBL_PATA80;
 358 }
 359
 360 /**
 361  *      hpt37x_pre_reset        -       reset the hpt37x bus
 362  *      @link: ATA link to reset
 363  *      @deadline: deadline jiffies for the operation
 364  *
 365  *      Perform the initial reset handling for the HPT37x.
 366  */
 367
 368 static int hpt37x_pre_reset(struct ata_link *link, unsigned long deadline)
 369 {
 370         struct ata_port *ap = link->ap;
 371         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 372         static const struct pci_bits hpt37x_enable_bits[] = {
 373                 { 0x50, 1, 0x04, 0x04 },
 374                 { 0x54, 1, 0x04, 0x04 }
 375         };
 376         if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
 377                 return -ENOENT;
 378
 379         /* Reset the state machine */
 380         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
 381         udelay(100);
 382
 383         return ata_sff_prereset(link, deadline);
 384 }
 385
 386 static void hpt370_set_mode(struct ata_port *ap, struct ata_device *adev,
 387                             u8 mode)
 388 {
 389         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 390         u32 addr1, addr2;
 391         u32 reg, timing, mask;
 392         u8 fast;
 393
 394         addr1 = 0x40 + 4 * (adev->devno + 2 * ap->port_no);
 395         addr2 = 0x51 + 4 * ap->port_no;
 396
 397         /* Fast interrupt prediction disable, hold off interrupt disable */
 398         pci_read_config_byte(pdev, addr2, &fast);
 399         fast &= ~0x02;
 400         fast |= 0x01;
 401         pci_write_config_byte(pdev, addr2, fast);
 402
 403         /* Determine timing mask and find matching mode entry */
 404         if (mode < XFER_MW_DMA_0)
 405                 mask = 0xcfc3ffff;
 406         else if (mode < XFER_UDMA_0)
 407                 mask = 0x31c001ff;
 408         else
 409                 mask = 0x303c0000;
 410
 411         timing = hpt37x_find_mode(ap, mode);
 412
 413         pci_read_config_dword(pdev, addr1, &reg);
 414         reg = (reg & ~mask) | (timing & mask);
 415         pci_write_config_dword(pdev, addr1, reg);
 416 }
 417 /**
 418  *      hpt370_set_piomode              -       PIO setup
 419  *      @ap: ATA interface
 420  *      @adev: device on the interface
 421  *
 422  *      Perform PIO mode setup.
 423  */
 424
 425 static void hpt370_set_piomode(struct ata_port *ap, struct ata_device *adev)
 426 {
 427         hpt370_set_mode(ap, adev, adev->pio_mode);
 428 }
 429
 430 /**
 431  *      hpt370_set_dmamode              -       DMA timing setup
 432  *      @ap: ATA interface
 433  *      @adev: Device being configured
 434  *
 435  *      Set up the channel for MWDMA or UDMA modes.
 436  */
 437
 438 static void hpt370_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 439 {
 440         hpt370_set_mode(ap, adev, adev->dma_mode);
 441 }
 442
 443 /**
 444  *      hpt370_bmdma_end                -       DMA engine stop
 445  *      @qc: ATA command
 446  *
 447  *      Work around the HPT370 DMA engine.
 448  */
 449
 450 static void hpt370_bmdma_stop(struct ata_queued_cmd *qc)
 451 {
 452         struct ata_port *ap = qc->ap;
 453         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 454         void __iomem *bmdma = ap->ioaddr.bmdma_addr;
 455         u8 dma_stat = ioread8(bmdma + ATA_DMA_STATUS);
 456         u8 dma_cmd;
 457
 458         if (dma_stat & ATA_DMA_ACTIVE) {
 459                 udelay(20);
 460                 dma_stat = ioread8(bmdma + ATA_DMA_STATUS);
 461         }
 462         if (dma_stat & ATA_DMA_ACTIVE) {
 463                 /* Clear the engine */
 464                 pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
 465                 udelay(10);
 466                 /* Stop DMA */
 467                 dma_cmd = ioread8(bmdma + ATA_DMA_CMD);
 468                 iowrite8(dma_cmd & ~ATA_DMA_START, bmdma + ATA_DMA_CMD);
 469                 /* Clear Error */
 470                 dma_stat = ioread8(bmdma + ATA_DMA_STATUS);
 471                 iowrite8(dma_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 472                          bmdma + ATA_DMA_STATUS);
 473                 /* Clear the engine */
 474                 pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
 475                 udelay(10);
 476         }
 477         ata_bmdma_stop(qc);
 478 }
 479
 480 static void hpt372_set_mode(struct ata_port *ap, struct ata_device *adev,
 481                             u8 mode)
 482 {
 483         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 484         u32 addr1, addr2;
 485         u32 reg, timing, mask;
 486         u8 fast;
 487
 488         addr1 = 0x40 + 4 * (adev->devno + 2 * ap->port_no);
 489         addr2 = 0x51 + 4 * ap->port_no;
 490
 491         /* Fast interrupt prediction disable, hold off interrupt disable */
 492         pci_read_config_byte(pdev, addr2, &fast);
 493         fast &= ~0x07;
 494         pci_write_config_byte(pdev, addr2, fast);
 495
 496         /* Determine timing mask and find matching mode entry */
 497         if (mode < XFER_MW_DMA_0)
 498                 mask = 0xcfc3ffff;
 499         else if (mode < XFER_UDMA_0)
 500                 mask = 0x31c001ff;
 501         else
 502                 mask = 0x303c0000;
 503
 504         timing = hpt37x_find_mode(ap, mode);
 505
 506         pci_read_config_dword(pdev, addr1, &reg);
 507         reg = (reg & ~mask) | (timing & mask);
 508         pci_write_config_dword(pdev, addr1, reg);
 509 }
 510
 511 /**
 512  *      hpt372_set_piomode              -       PIO setup
 513  *      @ap: ATA interface
 514  *      @adev: device on the interface
 515  *
 516  *      Perform PIO mode setup.
 517  */
 518
 519 static void hpt372_set_piomode(struct ata_port *ap, struct ata_device *adev)
 520 {
 521         hpt372_set_mode(ap, adev, adev->pio_mode);
 522 }
 523
 524 /**
 525  *      hpt372_set_dmamode              -       DMA timing setup
 526  *      @ap: ATA interface
 527  *      @adev: Device being configured
 528  *
 529  *      Set up the channel for MWDMA or UDMA modes.
 530  */
 531
 532 static void hpt372_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 533 {
 534         hpt372_set_mode(ap, adev, adev->dma_mode);
 535 }
 536
 537 /**
 538  *      hpt37x_bmdma_end                -       DMA engine stop
 539  *      @qc: ATA command
 540  *
 541  *      Clean up after the HPT372 and later DMA engine
 542  */
 543
 544 static void hpt37x_bmdma_stop(struct ata_queued_cmd *qc)
 545 {
 546         struct ata_port *ap = qc->ap;
 547         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 548         int mscreg = 0x50 + 4 * ap->port_no;
 549         u8 bwsr_stat, msc_stat;
 550
 551         pci_read_config_byte(pdev, 0x6A, &bwsr_stat);
 552         pci_read_config_byte(pdev, mscreg, &msc_stat);
 553         if (bwsr_stat & (1 << ap->port_no))
 554                 pci_write_config_byte(pdev, mscreg, msc_stat | 0x30);
 555         ata_bmdma_stop(qc);
 556 }
 557
 558
 559 static struct scsi_host_template hpt37x_sht = {
 560         ATA_BMDMA_SHT(DRV_NAME),
 561 };
 562
 563 /*
 564  *      Configuration for HPT370
 565  */
 566
 567 static struct ata_port_operations hpt370_port_ops = {
 568         .inherits       = &ata_bmdma_port_ops,
 569
 570         .bmdma_stop     = hpt370_bmdma_stop,
 571
 572         .mode_filter    = hpt370_filter,
 573         .cable_detect   = hpt37x_cable_detect,
 574         .set_piomode    = hpt370_set_piomode,
 575         .set_dmamode    = hpt370_set_dmamode,
 576         .prereset       = hpt37x_pre_reset,
 577 };
 578
 579 /*
 580  *      Configuration for HPT370A. Close to 370 but less filters
 581  */
 582
 583 static struct ata_port_operations hpt370a_port_ops = {
 584         .inherits       = &hpt370_port_ops,
 585         .mode_filter    = hpt370a_filter,
 586 };
 587
 588 /*
 589  *      Configuration for HPT372, HPT371, HPT302. Slightly different PIO
 590  *      and DMA mode setting functionality.
 591  */
 592
 593 static struct ata_port_operations hpt372_port_ops = {
 594         .inherits       = &ata_bmdma_port_ops,
 595
 596         .bmdma_stop     = hpt37x_bmdma_stop,
 597
 598         .cable_detect   = hpt37x_cable_detect,
 599         .set_piomode    = hpt372_set_piomode,
 600         .set_dmamode    = hpt372_set_dmamode,
 601         .prereset       = hpt37x_pre_reset,
 602 };
 603
 604 /*
 605  *      Configuration for HPT374. Mode setting works like 372 and friends
 606  *      but we have a different cable detection procedure for function 1.
 607  */
 608
 609 static struct ata_port_operations hpt374_fn1_port_ops = {
 610         .inherits       = &hpt372_port_ops,
 611         .cable_detect   = hpt374_fn1_cable_detect,
 612         .prereset       = hpt37x_pre_reset,
 613 };
 614
 615 /**
 616  *      hpt37x_clock_slot       -       Turn timing to PC clock entry
 617  *      @freq: Reported frequency timing
 618  *      @base: Base timing
 619  *
 620  *      Turn the timing data intoa clock slot (0 for 33, 1 for 40, 2 for 50
 621  *      and 3 for 66Mhz)
 622  */
 623
 624 static int hpt37x_clock_slot(unsigned int freq, unsigned int base)
 625 {
 626         unsigned int f = (base * freq) / 192;   /* Mhz */
 627         if (f < 40)
 628                 return 0;       /* 33Mhz slot */
 629         if (f < 45)
 630                 return 1;       /* 40Mhz slot */
 631         if (f < 55)
 632                 return 2;       /* 50Mhz slot */
 633         return 3;               /* 60Mhz slot */
 634 }
 635
 636 /**
 637  *      hpt37x_calibrate_dpll           -       Calibrate the DPLL loop
 638  *      @dev: PCI device
 639  *
 640  *      Perform a calibration cycle on the HPT37x DPLL. Returns 1 if this
 641  *      succeeds
 642  */
 643
 644 static int hpt37x_calibrate_dpll(struct pci_dev *dev)
 645 {
 646         u8 reg5b;
 647         u32 reg5c;
 648         int tries;
 649
 650         for(tries = 0; tries < 0x5000; tries++) {
 651                 udelay(50);
 652                 pci_read_config_byte(dev, 0x5b, &reg5b);
 653                 if (reg5b & 0x80) {
 654                         /* See if it stays set */
 655                         for(tries = 0; tries < 0x1000; tries ++) {
 656                                 pci_read_config_byte(dev, 0x5b, &reg5b);
 657                                 /* Failed ? */
 658                                 if ((reg5b & 0x80) == 0)
 659                                         return 0;
 660                         }
 661                         /* Turn off tuning, we have the DPLL set */
 662                         pci_read_config_dword(dev, 0x5c, &reg5c);
 663                         pci_write_config_dword(dev, 0x5c, reg5c & ~ 0x100);
 664                         return 1;
 665                 }
 666         }
 667         /* Never went stable */
 668         return 0;
 669 }
 670
 671 static u32 hpt374_read_freq(struct pci_dev *pdev)
 672 {
 673         u32 freq;
 674         unsigned long io_base = pci_resource_start(pdev, 4);
 675         if (PCI_FUNC(pdev->devfn) & 1) {
 676                 struct pci_dev *pdev_0;
 677
 678                 pdev_0 = pci_get_slot(pdev->bus, pdev->devfn - 1);
 679                 /* Someone hot plugged the controller on us ? */
 680                 if (pdev_0 == NULL)
 681                         return 0;
 682                 io_base = pci_resource_start(pdev_0, 4);
 683                 freq = inl(io_base + 0x90);
 684                 pci_dev_put(pdev_0);
 685         } else
 686                 freq = inl(io_base + 0x90);
 687         return freq;
 688 }
 689
 690 /**
 691  *      hpt37x_init_one         -       Initialise an HPT37X/302
 692  *      @dev: PCI device
 693  *      @id: Entry in match table
 694  *
 695  *      Initialise an HPT37x device. There are some interesting complications
 696  *      here. Firstly the chip may report 366 and be one of several variants.
 697  *      Secondly all the timings depend on the clock for the chip which we must
 698  *      detect and look up
 699  *
 700  *      This is the known chip mappings. It may be missing a couple of later
 701  *      releases.
 702  *
 703  *      Chip version            PCI             Rev     Notes
 704  *      HPT366                  4 (HPT366)      0       Other driver
 705  *      HPT366                  4 (HPT366)      1       Other driver
 706  *      HPT368                  4 (HPT366)      2       Other driver
 707  *      HPT370                  4 (HPT366)      3       UDMA100
 708  *      HPT370A                 4 (HPT366)      4       UDMA100
 709  *      HPT372                  4 (HPT366)      5       UDMA133 (1)
 710  *      HPT372N                 4 (HPT366)      6       Other driver
 711  *      HPT372A                 5 (HPT372)      1       UDMA133 (1)
 712  *      HPT372N                 5 (HPT372)      2       Other driver
 713  *      HPT302                  6 (HPT302)      1       UDMA133
 714  *      HPT302N                 6 (HPT302)      2       Other driver
 715  *      HPT371                  7 (HPT371)      *       UDMA133
 716  *      HPT374                  8 (HPT374)      *       UDMA133 4 channel
 717  *      HPT372N                 9 (HPT372N)     *       Other driver
 718  *
 719  *      (1) UDMA133 support depends on the bus clock
 720  */
 721
 722 static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 723 {
 724         /* HPT370 - UDMA100 */
 725         static const struct ata_port_info info_hpt370 = {
 726                 .flags = ATA_FLAG_SLAVE_POSS,
 727                 .pio_mask = ATA_PIO4,
 728                 .mwdma_mask = ATA_MWDMA2,
 729                 .udma_mask = ATA_UDMA5,
 730                 .port_ops = &hpt370_port_ops
 731         };
 732         /* HPT370A - UDMA100 */
 733         static const struct ata_port_info info_hpt370a = {
 734                 .flags = ATA_FLAG_SLAVE_POSS,
 735                 .pio_mask = ATA_PIO4,
 736                 .mwdma_mask = ATA_MWDMA2,
 737                 .udma_mask = ATA_UDMA5,
 738                 .port_ops = &hpt370a_port_ops
 739         };
 740         /* HPT370 - UDMA100 */
 741         static const struct ata_port_info info_hpt370_33 = {
 742                 .flags = ATA_FLAG_SLAVE_POSS,
 743                 .pio_mask = ATA_PIO4,
 744                 .mwdma_mask = ATA_MWDMA2,
 745                 .udma_mask = ATA_UDMA5,
 746                 .port_ops = &hpt370_port_ops
 747         };
 748         /* HPT370A - UDMA100 */
 749         static const struct ata_port_info info_hpt370a_33 = {
 750                 .flags = ATA_FLAG_SLAVE_POSS,
 751                 .pio_mask = ATA_PIO4,
 752                 .mwdma_mask = ATA_MWDMA2,
 753                 .udma_mask = ATA_UDMA5,
 754                 .port_ops = &hpt370a_port_ops
 755         };
 756         /* HPT371, 372 and friends - UDMA133 */
 757         static const struct ata_port_info info_hpt372 = {
 758                 .flags = ATA_FLAG_SLAVE_POSS,
 759                 .pio_mask = ATA_PIO4,
 760                 .mwdma_mask = ATA_MWDMA2,
 761                 .udma_mask = ATA_UDMA6,
 762                 .port_ops = &hpt372_port_ops
 763         };
 764         /* HPT374 - UDMA100, function 1 uses different prereset method */
 765         static const struct ata_port_info info_hpt374_fn0 = {
 766                 .flags = ATA_FLAG_SLAVE_POSS,
 767                 .pio_mask = ATA_PIO4,
 768                 .mwdma_mask = ATA_MWDMA2,
 769                 .udma_mask = ATA_UDMA5,
 770                 .port_ops = &hpt372_port_ops
 771         };
 772         static const struct ata_port_info info_hpt374_fn1 = {
 773                 .flags = ATA_FLAG_SLAVE_POSS,
 774                 .pio_mask = ATA_PIO4,
 775                 .mwdma_mask = ATA_MWDMA2,
 776                 .udma_mask = ATA_UDMA5,
 777                 .port_ops = &hpt374_fn1_port_ops
 778         };
 779
 780         static const int MHz[4] = { 33, 40, 50, 66 };
 781         void *private_data = NULL;
 782         const struct ata_port_info *ppi[] = { NULL, NULL };
 783         u8 rev = dev->revision;
 784         u8 irqmask;
 785         u8 mcr1;
 786         u32 freq;
 787         int prefer_dpll = 1;
 788
 789         unsigned long iobase = pci_resource_start(dev, 4);
 790
 791         const struct hpt_chip *chip_table;
 792         int clock_slot;
 793         int rc;
 794
 795         rc = pcim_enable_device(dev);
 796         if (rc)
 797                 return rc;
 798
 799         if (dev->device == PCI_DEVICE_ID_TTI_HPT366) {
 800                 /* May be a later chip in disguise. Check */
 801                 /* Older chips are in the HPT366 driver. Ignore them */
 802                 if (rev < 3)
 803                         return -ENODEV;
 804                 /* N series chips have their own driver. Ignore */
 805                 if (rev == 6)
 806                         return -ENODEV;
 807
 808                 switch(rev) {
 809                         case 3:
 810                                 ppi[0] = &info_hpt370;
 811                                 chip_table = &hpt370;
 812                                 prefer_dpll = 0;
 813                                 break;
 814                         case 4:
 815                                 ppi[0] = &info_hpt370a;
 816                                 chip_table = &hpt370a;
 817                                 prefer_dpll = 0;
 818                                 break;
 819                         case 5:
 820                                 ppi[0] = &info_hpt372;
 821                                 chip_table = &hpt372;
 822                                 break;
 823                         default:
 824                                 printk(KERN_ERR "pata_hpt37x: Unknown HPT366 "
 825                                        "subtype, please report (%d).\n", rev);
 826                                 return -ENODEV;
 827                 }
 828         } else {
 829                 switch(dev->device) {
 830                         case PCI_DEVICE_ID_TTI_HPT372:
 831                                 /* 372N if rev >= 2*/
 832                                 if (rev >= 2)
 833                                         return -ENODEV;
 834                                 ppi[0] = &info_hpt372;
 835                                 chip_table = &hpt372a;
 836                                 break;
 837                         case PCI_DEVICE_ID_TTI_HPT302:
 838                                 /* 302N if rev > 1 */
 839                                 if (rev > 1)
 840                                         return -ENODEV;
 841                                 ppi[0] = &info_hpt372;
 842                                 /* Check this */
 843                                 chip_table = &hpt302;
 844                                 break;
 845                         case PCI_DEVICE_ID_TTI_HPT371:
 846                                 if (rev > 1)
 847                                         return -ENODEV;
 848                                 ppi[0] = &info_hpt372;
 849                                 chip_table = &hpt371;
 850                                 /* Single channel device, master is not present
 851                                    but the BIOS (or us for non x86) must mark it
 852                                    absent */
 853                                 pci_read_config_byte(dev, 0x50, &mcr1);
 854                                 mcr1 &= ~0x04;
 855                                 pci_write_config_byte(dev, 0x50, mcr1);
 856                                 break;
 857                         case PCI_DEVICE_ID_TTI_HPT374:
 858                                 chip_table = &hpt374;
 859                                 if (!(PCI_FUNC(dev->devfn) & 1))
 860                                         *ppi = &info_hpt374_fn0;
 861                                 else
 862                                         *ppi = &info_hpt374_fn1;
 863                                 break;
 864                         default:
 865                                 printk(KERN_ERR "pata_hpt37x: PCI table is bogus please report (%d).\n", dev->device);
 866                                 return -ENODEV;
 867                 }
 868         }
 869         /* Ok so this is a chip we support */
 870
 871         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, (L1_CACHE_BYTES / 4));
 872         pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x78);
 873         pci_write_config_byte(dev, PCI_MIN_GNT, 0x08);
 874         pci_write_config_byte(dev, PCI_MAX_LAT, 0x08);
 875
 876         pci_read_config_byte(dev, 0x5A, &irqmask);
 877         irqmask &= ~0x10;
 878         pci_write_config_byte(dev, 0x5a, irqmask);
 879
 880         /*
 881          * default to pci clock. make sure MA15/16 are set to output
 882          * to prevent drives having problems with 40-pin cables. Needed
 883          * for some drives such as IBM-DTLA which will not enter ready
 884          * state on reset when PDIAG is a input.
 885          */
 886
 887         pci_write_config_byte(dev, 0x5b, 0x23);
 888
 889         /*
 890          * HighPoint does this for HPT372A.
 891          * NOTE: This register is only writeable via I/O space.
 892          */
 893         if (chip_table == &hpt372a)
 894                 outb(0x0e, iobase + 0x9c);
 895
 896         /* Some devices do not let this value be accessed via PCI space
 897            according to the old driver. In addition we must use the value
 898            from FN 0 on the HPT374 */
 899
 900         if (chip_table == &hpt374) {
 901                 freq = hpt374_read_freq(dev);
 902                 if (freq == 0)
 903                         return -ENODEV;
 904         } else
 905                 freq = inl(iobase + 0x90);
 906
 907         if ((freq >> 12) != 0xABCDE) {
 908                 int i;
 909                 u8 sr;
 910                 u32 total = 0;
 911
 912                 printk(KERN_WARNING "pata_hpt37x: BIOS has not set timing clocks.\n");
 913
 914                 /* This is the process the HPT371 BIOS is reported to use */
 915                 for(i = 0; i < 128; i++) {
 916                         pci_read_config_byte(dev, 0x78, &sr);
 917                         total += sr & 0x1FF;
 918                         udelay(15);
 919                 }
 920                 freq = total / 128;
 921         }
 922         freq &= 0x1FF;
 923
 924         /*
 925          *      Turn the frequency check into a band and then find a timing
 926          *      table to match it.
 927          */
 928
 929         clock_slot = hpt37x_clock_slot(freq, chip_table->base);
 930         if (chip_table->clocks[clock_slot] == NULL || prefer_dpll) {
 931                 /*
 932                  *      We need to try PLL mode instead
 933                  *
 934                  *      For non UDMA133 capable devices we should
 935                  *      use a 50MHz DPLL by choice
 936                  */
 937                 unsigned int f_low, f_high;
 938                 int dpll, adjust;
 939
 940                 /* Compute DPLL */
 941                 dpll = (ppi[0]->udma_mask & 0xC0) ? 3 : 2;
 942
 943                 f_low = (MHz[clock_slot] * 48) / MHz[dpll];
 944                 f_high = f_low + 2;
 945                 if (clock_slot > 1)
 946                         f_high += 2;
 947
 948                 /* Select the DPLL clock. */
 949                 pci_write_config_byte(dev, 0x5b, 0x21);
 950                 pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low | 0x100);
 951
 952                 for(adjust = 0; adjust < 8; adjust++) {
 953                         if (hpt37x_calibrate_dpll(dev))
 954                                 break;
 955                         /* See if it'll settle at a fractionally different clock */
 956                         if (adjust & 1)
 957                                 f_low -= adjust >> 1;
 958                         else
 959                                 f_high += adjust >> 1;
 960                         pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low | 0x100);
 961                 }
 962                 if (adjust == 8) {
 963                         printk(KERN_ERR "pata_hpt37x: DPLL did not stabilize!\n");
 964                         return -ENODEV;
 965                 }
 966                 if (dpll == 3)
 967                         private_data = (void *)hpt37x_timings_66;
 968                 else
 969                         private_data = (void *)hpt37x_timings_50;
 970
 971                 printk(KERN_INFO "pata_hpt37x: bus clock %dMHz, using %dMHz DPLL.\n",
 972                        MHz[clock_slot], MHz[dpll]);
 973         } else {
 974                 private_data = (void *)chip_table->clocks[clock_slot];
 975                 /*
 976                  *      Perform a final fixup. Note that we will have used the
 977                  *      DPLL on the HPT372 which means we don't have to worry
 978                  *      about lack of UDMA133 support on lower clocks
 979                  */
 980
 981                 if (clock_slot < 2 && ppi[0] == &info_hpt370)
 982                         ppi[0] = &info_hpt370_33;
 983                 if (clock_slot < 2 && ppi[0] == &info_hpt370a)
 984                         ppi[0] = &info_hpt370a_33;
 985                 printk(KERN_INFO "pata_hpt37x: %s using %dMHz bus clock.\n",
 986                        chip_table->name, MHz[clock_slot]);
 987         }
 988
 989         /* Now kick off ATA set up */
 990         return ata_pci_bmdma_init_one(dev, ppi, &hpt37x_sht, private_data, 0);
 991 }
 992
 993 static const struct pci_device_id hpt37x[] = {
 994         { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT366), },
 995         { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT371), },
 996         { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT372), },
 997         { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT374), },
 998         { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT302), },
 999
1000         { },
1001 };
1002
1003 static struct pci_driver hpt37x_pci_driver = {
1004         .name           = DRV_NAME,
1005         .id_table       = hpt37x,
1006         .probe          = hpt37x_init_one,
1007         .remove         = ata_pci_remove_one
1008 };
1009
1010 static int __init hpt37x_init(void)
1011 {
1012         return pci_register_driver(&hpt37x_pci_driver);
1013 }
1014
1015 static void __exit hpt37x_exit(void)
1016 {
1017         pci_unregister_driver(&hpt37x_pci_driver);
1018 }
1019
1020 MODULE_AUTHOR("Alan Cox");
1021 MODULE_DESCRIPTION("low-level driver for the Highpoint HPT37x/30x");
1022 MODULE_LICENSE("GPL");
1023 MODULE_DEVICE_TABLE(pci, hpt37x);
1024 MODULE_VERSION(DRV_VERSION);
1025
1026 module_init(hpt37x_init);
1027 module_exit(hpt37x_exit);