开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
piix.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

piix.c：源码内容
  1. /*
  2.  *  linux/drivers/ide/piix.c Version 0.32 June 9, 2000
  3.  *
  4.  *  Copyright (C) 1998-1999 Andrzej Krzysztofowicz, Author and Maintainer
  5.  *  Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
  6.  *  May be copied or modified under the terms of the GNU General Public License
  7.  *
  8.  *  PIO mode setting function for Intel chipsets.  
  9.  *  For use instead of BIOS settings.
  10.  *
  11.  * 40-41
  12.  * 42-43
  13.  * 
  14.  *                 41
  15.  *                 43
  16.  *
  17.  * | PIO 0       | c0 | 80 | 0 |  piix_tune_drive(drive, 0);
  18.  * | PIO 2 | SW2 | d0 | 90 | 4 |  piix_tune_drive(drive, 2);
  19.  * | PIO 3 | MW1 | e1 | a1 | 9 |  piix_tune_drive(drive, 3);
  20.  * | PIO 4 | MW2 | e3 | a3 | b |  piix_tune_drive(drive, 4);
  21.  * 
  22.  * sitre = word40 & 0x4000; primary
  23.  * sitre = word42 & 0x4000; secondary
  24.  *
  25.  * 44 8421|8421    hdd|hdb
  26.  * 
  27.  * 48 8421         hdd|hdc|hdb|hda udma enabled
  28.  *
  29.  *    0001         hda
  30.  *    0010         hdb
  31.  *    0100         hdc
  32.  *    1000         hdd
  33.  *
  34.  * 4a 84|21        hdb|hda
  35.  * 4b 84|21        hdd|hdc
  36.  *
  37.  *    ata-33/82371AB
  38.  *    ata-33/82371EB
  39.  *    ata-33/82801AB            ata-66/82801AA
  40.  *    00|00 udma 0              00|00 reserved
  41.  *    01|01 udma 1              01|01 udma 3
  42.  *    10|10 udma 2              10|10 udma 4
  43.  *    11|11 reserved            11|11 reserved
  44.  *
  45.  * 54 8421|8421    ata66 drive|ata66 enable
  46.  *
  47.  * pci_read_config_word(HWIF(drive)->pci_dev, 0x40, &reg40);
  48.  * pci_read_config_word(HWIF(drive)->pci_dev, 0x42, &reg42);
  49.  * pci_read_config_word(HWIF(drive)->pci_dev, 0x44, &reg44);
  50.  * pci_read_config_word(HWIF(drive)->pci_dev, 0x48, &reg48);
  51.  * pci_read_config_word(HWIF(drive)->pci_dev, 0x4a, &reg4a);
  52.  * pci_read_config_word(HWIF(drive)->pci_dev, 0x54, &reg54);
  53.  *
  54.  */
  56. #include <linux/config.h>
  57. #include <linux/types.h>
  58. #include <linux/kernel.h>
  59. #include <linux/ioport.h>
  60. #include <linux/pci.h>
  61. #include <linux/hdreg.h>
  62. #include <linux/ide.h>
  63. #include <linux/delay.h>
  64. #include <linux/init.h>
  66. #include <asm/io.h>
  68. #include "ide_modes.h"
  70. #define PIIX_DEBUG_DRIVE_INFO 0
  72. #define DISPLAY_PIIX_TIMINGS
  74. #if defined(DISPLAY_PIIX_TIMINGS) && defined(CONFIG_PROC_FS)
  75. #include <linux/stat.h>
  76. #include <linux/proc_fs.h>
  78. static int piix_get_info(char *, char **, off_t, int);
  79. extern int (*piix_display_info)(char *, char **, off_t, int); /* ide-proc.c */
  80. extern char *ide_media_verbose(ide_drive_t *);
  81. static struct pci_dev *bmide_dev;
  83. static int piix_get_info (char *buffer, char **addr, off_t offset, int count)
  84. {
  85. char *p = buffer;
  86. u32 bibma = pci_resource_start(bmide_dev, 4);
  87.         u16 reg40 = 0, psitre = 0, reg42 = 0, ssitre = 0;
  88. u8  c0 = 0, c1 = 0;
  89. u8  reg44 = 0, reg48 = 0, reg4a = 0, reg4b = 0, reg54 = 0, reg55 = 0;
  91. switch(bmide_dev->device) {
  92. case PCI_DEVICE_ID_INTEL_82801BA_8:
  93. case PCI_DEVICE_ID_INTEL_82801BA_9:
  94.         case PCI_DEVICE_ID_INTEL_82801CA_10:
  95.         case PCI_DEVICE_ID_INTEL_82801CA_11:
  96.         case PCI_DEVICE_ID_INTEL_82801DB_11:
  97.         case PCI_DEVICE_ID_INTEL_82801E_11:
  98. p += sprintf(p, "n                                Intel PIIX4 Ultra 100 Chipset.n");
  99. break;
  100. case PCI_DEVICE_ID_INTEL_82372FB_1:
  101. case PCI_DEVICE_ID_INTEL_82801AA_1:
  102. p += sprintf(p, "n                                Intel PIIX4 Ultra 66 Chipset.n");
  103. break;
  104. case PCI_DEVICE_ID_INTEL_82451NX:
  105. case PCI_DEVICE_ID_INTEL_82801AB_1:
  106. case PCI_DEVICE_ID_INTEL_82443MX_1:
  107. case PCI_DEVICE_ID_INTEL_82371AB:
  108. p += sprintf(p, "n                                Intel PIIX4 Ultra 33 Chipset.n");
  109. break;
  110. case PCI_DEVICE_ID_INTEL_82371SB_1:
  111. p += sprintf(p, "n                                Intel PIIX3 Chipset.n");
  112. break;
  113. case PCI_DEVICE_ID_INTEL_82371MX:
  114. p += sprintf(p, "n                                Intel MPIIX Chipset.n");
  115. return p-buffer; /* => must be less than 4k! */
  116. case PCI_DEVICE_ID_INTEL_82371FB_1:
  117. case PCI_DEVICE_ID_INTEL_82371FB_0:
  118. default:
  119. p += sprintf(p, "n                                Intel PIIX Chipset.n");
  120. break;
  121. }
  123. pci_read_config_word(bmide_dev, 0x40, &reg40);
  124. pci_read_config_word(bmide_dev, 0x42, &reg42);
  125. pci_read_config_byte(bmide_dev, 0x44, &reg44);
  126. pci_read_config_byte(bmide_dev, 0x48, &reg48);
  127. pci_read_config_byte(bmide_dev, 0x4a, &reg4a);
  128. pci_read_config_byte(bmide_dev, 0x4b, &reg4b);
  129. pci_read_config_byte(bmide_dev, 0x54, &reg54);
  130. pci_read_config_byte(bmide_dev, 0x55, &reg55);
  132. psitre = (reg40 & 0x4000) ? 1 : 0;
  133. ssitre = (reg42 & 0x4000) ? 1 : 0;
  135. /*
  136.  * at that point bibma+0x2 et bibma+0xa are byte registers
  137.  * to investigate:
  138.  */
  139. c0 = inb_p((unsigned short)bibma + 0x02);
  140. c1 = inb_p((unsigned short)bibma + 0x0a);
  142. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  143. p += sprintf(p, "                %sabled                         %sabledn",
  144. (c0&0x80) ? "dis" : " en",
  145. (c1&0x80) ? "dis" : " en");
  146. p += sprintf(p, "--------------- drive0 --------- drive1 -------- drive0 ---------- drive1 ------n");
  147. p += sprintf(p, "DMA enabled:    %s              %s             %s               %sn",
  148. (c0&0x20) ? "yes" : "no ",
  149. (c0&0x40) ? "yes" : "no ",
  150. (c1&0x20) ? "yes" : "no ",
  151. (c1&0x40) ? "yes" : "no " );
  152. p += sprintf(p, "UDMA enabled:   %s              %s             %s               %sn",
  153. (reg48&0x01) ? "yes" : "no ",
  154. (reg48&0x02) ? "yes" : "no ",
  155. (reg48&0x04) ? "yes" : "no ",
  156. (reg48&0x08) ? "yes" : "no " );
  157. p += sprintf(p, "UDMA enabled:   %s                %s               %s                 %sn",
  158. ((reg54&0x11) && (reg55&0x10) && (reg4a&0x01)) ? "5" :
  159. ((reg54&0x11) && (reg4a&0x02)) ? "4" :
  160. ((reg54&0x11) && (reg4a&0x01)) ? "3" :
  161. (reg4a&0x02) ? "2" :
  162. (reg4a&0x01) ? "1" :
  163. (reg4a&0x00) ? "0" : "X",
  164. ((reg54&0x22) && (reg55&0x20) && (reg4a&0x10)) ? "5" :
  165. ((reg54&0x22) && (reg4a&0x20)) ? "4" :
  166. ((reg54&0x22) && (reg4a&0x10)) ? "3" :
  167. (reg4a&0x20) ? "2" :
  168. (reg4a&0x10) ? "1" :
  169. (reg4a&0x00) ? "0" : "X",
  170. ((reg54&0x44) && (reg55&0x40) && (reg4b&0x03)) ? "5" :
  171. ((reg54&0x44) && (reg4b&0x02)) ? "4" :
  172. ((reg54&0x44) && (reg4b&0x01)) ? "3" :
  173. (reg4b&0x02) ? "2" :
  174. (reg4b&0x01) ? "1" :
  175. (reg4b&0x00) ? "0" : "X",
  176. ((reg54&0x88) && (reg55&0x80) && (reg4b&0x30)) ? "5" :
  177. ((reg54&0x88) && (reg4b&0x20)) ? "4" :
  178. ((reg54&0x88) && (reg4b&0x10)) ? "3" :
  179. (reg4b&0x20) ? "2" :
  180. (reg4b&0x10) ? "1" :
  181. (reg4b&0x00) ? "0" : "X");
  183. p += sprintf(p, "UDMAn");
  184. p += sprintf(p, "DMAn");
  185. p += sprintf(p, "PIOn");
  187. /*
  188.  * FIXME.... Add configuration junk data....blah blah......
  189.  */
  191. return p-buffer;  /* => must be less than 4k! */
  192. }
  193. #endif  /* defined(DISPLAY_PIIX_TIMINGS) && defined(CONFIG_PROC_FS) */
  195. /*
  196.  *  Used to set Fifo configuration via kernel command line:
  197.  */
  199. byte piix_proc = 0;
  201. extern char *ide_xfer_verbose (byte xfer_rate);
  203. #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_PIIX_TUNING)
  204. /*
  205.  *
  206.  */
  207. static byte piix_dma_2_pio (byte xfer_rate) {
  208. switch(xfer_rate) {
  209. case XFER_UDMA_5:
  210. case XFER_UDMA_4:
  211. case XFER_UDMA_3:
  212. case XFER_UDMA_2:
  213. case XFER_UDMA_1:
  214. case XFER_UDMA_0:
  215. case XFER_MW_DMA_2:
  216. case XFER_PIO_4:
  217. return 4;
  218. case XFER_MW_DMA_1:
  219. case XFER_PIO_3:
  220. return 3;
  221. case XFER_SW_DMA_2:
  222. case XFER_PIO_2:
  223. return 2;
  224. case XFER_MW_DMA_0:
  225. case XFER_SW_DMA_1:
  226. case XFER_SW_DMA_0:
  227. case XFER_PIO_1:
  228. case XFER_PIO_0:
  229. case XFER_PIO_SLOW:
  230. default:
  231. return 0;
  232. }
  233. }
  234. #endif /* defined(CONFIG_BLK_DEV_IDEDMA) && (CONFIG_PIIX_TUNING) */
  236. /*
  237.  *  Based on settings done by AMI BIOS
  238.  *  (might be useful if drive is not registered in CMOS for any reason).
  239.  */
  240. static void piix_tune_drive (ide_drive_t *drive, byte pio)
  241. {
  242. unsigned long flags;
  243. u16 master_data;
  244. byte slave_data;
  245. int is_slave = (&HWIF(drive)->drives[1] == drive);
  246. int master_port = HWIF(drive)->index ? 0x42 : 0x40;
  247. int slave_port = 0x44;
  248.  /* ISP  RTC */
  249. byte timings[][2] = { { 0, 0 },
  250.     { 0, 0 },
  251.     { 1, 0 },
  252.     { 2, 1 },
  253.     { 2, 3 }, };
  255. pio = ide_get_best_pio_mode(drive, pio, 5, NULL);
  256. pci_read_config_word(HWIF(drive)->pci_dev, master_port, &master_data);
  257. if (is_slave) {
  258. master_data = master_data | 0x4000;
  259. if (pio > 1)
  260. /* enable PPE, IE and TIME */
  261. master_data = master_data | 0x0070;
  262. pci_read_config_byte(HWIF(drive)->pci_dev, slave_port, &slave_data);
  263. slave_data = slave_data & (HWIF(drive)->index ? 0x0f : 0xf0);
  264. slave_data = slave_data | (((timings[pio][0] << 2) | timings[pio][1])
  265.    << (HWIF(drive)->index ? 4 : 0));
  266. } else {
  267. master_data = master_data & 0xccf8;
  268. if (pio > 1)
  269. /* enable PPE, IE and TIME */
  270. master_data = master_data | 0x0007;
  271. master_data = master_data | (timings[pio][0] << 12) |
  272.       (timings[pio][1] << 8);
  273. }
  274. save_flags(flags);
  275. cli();
  276. pci_write_config_word(HWIF(drive)->pci_dev, master_port, master_data);
  277. if (is_slave)
  278. pci_write_config_byte(HWIF(drive)->pci_dev, slave_port, slave_data);
  279. restore_flags(flags);
  280. }
  282. #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_PIIX_TUNING)
  283. static int piix_tune_chipset (ide_drive_t *drive, byte speed)
  284. {
  285. ide_hwif_t *hwif = HWIF(drive);
  286. struct pci_dev *dev = hwif->pci_dev;
  287. byte maslave = hwif->channel ? 0x42 : 0x40;
  288. int a_speed = 3 << (drive->dn * 4);
  289. int u_flag = 1 << drive->dn;
  290. int v_flag = 0x01 << drive->dn;
  291. int w_flag = 0x10 << drive->dn;
  292. int u_speed = 0;
  293. int err = 0;
  294. int sitre;
  295. short reg4042, reg44, reg48, reg4a, reg54;
  296. byte reg55;
  298. pci_read_config_word(dev, maslave, &reg4042);
  299. sitre = (reg4042 & 0x4000) ? 1 : 0;
  300. pci_read_config_word(dev, 0x44, &reg44);
  301. pci_read_config_word(dev, 0x48, &reg48);
  302. pci_read_config_word(dev, 0x4a, &reg4a);
  303. pci_read_config_word(dev, 0x54, &reg54);
  304. pci_read_config_byte(dev, 0x55, &reg55);
  306. switch(speed) {
  307. case XFER_UDMA_4:
  308. case XFER_UDMA_2: u_speed = 2 << (drive->dn * 4); break;
  309. case XFER_UDMA_5:
  310. case XFER_UDMA_3:
  311. case XFER_UDMA_1: u_speed = 1 << (drive->dn * 4); break;
  312. case XFER_UDMA_0: u_speed = 0 << (drive->dn * 4); break;
  313. case XFER_MW_DMA_2:
  314. case XFER_MW_DMA_1:
  315. case XFER_SW_DMA_2: break;
  316. default: return -1;
  317. }
  319. if (speed >= XFER_UDMA_0) {
  320. if (!(reg48 & u_flag))
  321. pci_write_config_word(dev, 0x48, reg48|u_flag);
  322. if (speed == XFER_UDMA_5) {
  323. pci_write_config_byte(dev, 0x55, (byte) reg55|w_flag);
  324. } else {
  325. pci_write_config_byte(dev, 0x55, (byte) reg55 & ~w_flag);
  326. }
  327. if (!(reg4a & u_speed)) {
  328. pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
  329. pci_write_config_word(dev, 0x4a, reg4a|u_speed);
  330. }
  331. if (speed > XFER_UDMA_2) {
  332. if (!(reg54 & v_flag)) {
  333. pci_write_config_word(dev, 0x54, reg54|v_flag);
  334. }
  335. } else {
  336. pci_write_config_word(dev, 0x54, reg54 & ~v_flag);
  337. }
  338. }
  339. if (speed < XFER_UDMA_0) {
  340. if (reg48 & u_flag)
  341. pci_write_config_word(dev, 0x48, reg48 & ~u_flag);
  342. if (reg4a & a_speed)
  343. pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
  344. if (reg54 & v_flag)
  345. pci_write_config_word(dev, 0x54, reg54 & ~v_flag);
  346. if (reg55 & w_flag)
  347. pci_write_config_byte(dev, 0x55, (byte) reg55 & ~w_flag);
  348. }
  350. piix_tune_drive(drive, piix_dma_2_pio(speed));
  352. #if PIIX_DEBUG_DRIVE_INFO
  353. printk("%s: %s drive%dn", drive->name, ide_xfer_verbose(speed), drive->dn);
  354. #endif /* PIIX_DEBUG_DRIVE_INFO */
  355. if (!drive->init_speed)
  356. drive->init_speed = speed;
  357. err = ide_config_drive_speed(drive, speed);
  358. drive->current_speed = speed;
  359. return err;
  360. }
  362. static int piix_config_drive_for_dma (ide_drive_t *drive)
  363. {
  364. struct hd_driveid *id = drive->id;
  365. ide_hwif_t *hwif = HWIF(drive);
  366. struct pci_dev *dev = hwif->pci_dev;
  367. byte speed;
  369. byte udma_66 = eighty_ninty_three(drive);
  370. int ultra100 = ((dev->device == PCI_DEVICE_ID_INTEL_82801BA_8) ||
  371.    (dev->device == PCI_DEVICE_ID_INTEL_82801BA_9) ||
  372.    (dev->device == PCI_DEVICE_ID_INTEL_82801CA_10) ||
  373.    (dev->device == PCI_DEVICE_ID_INTEL_82801CA_11) ||
  374.    (dev->device == PCI_DEVICE_ID_INTEL_82801DB_11) ||
  375.    (dev->device == PCI_DEVICE_ID_INTEL_82801E_11)) ? 1 : 0;
  376. int ultra66 = ((ultra100) ||
  377.    (dev->device == PCI_DEVICE_ID_INTEL_82801AA_1) ||
  378.    (dev->device == PCI_DEVICE_ID_INTEL_82372FB_1)) ? 1 : 0;
  379. int ultra = ((ultra66) ||
  380.    (dev->device == PCI_DEVICE_ID_INTEL_82371AB) ||
  381.    (dev->device == PCI_DEVICE_ID_INTEL_82443MX_1) ||
  382.    (dev->device == PCI_DEVICE_ID_INTEL_82451NX) ||
  383.    (dev->device == PCI_DEVICE_ID_INTEL_82801AB_1)) ? 1 : 0;
  385. if ((id->dma_ultra & 0x0020) && (udma_66) && (ultra100)) {
  386. speed = XFER_UDMA_5;
  387. } else if ((id->dma_ultra & 0x0010) && (ultra)) {
  388. speed = ((udma_66) && (ultra66)) ? XFER_UDMA_4 : XFER_UDMA_2;
  389. } else if ((id->dma_ultra & 0x0008) && (ultra)) {
  390. speed = ((udma_66) && (ultra66)) ? XFER_UDMA_3 : XFER_UDMA_1;
  391. } else if ((id->dma_ultra & 0x0004) && (ultra)) {
  392. speed = XFER_UDMA_2;
  393. } else if ((id->dma_ultra & 0x0002) && (ultra)) {
  394. speed = XFER_UDMA_1;
  395. } else if ((id->dma_ultra & 0x0001) && (ultra)) {
  396. speed = XFER_UDMA_0;
  397. } else if (id->dma_mword & 0x0004) {
  398. speed = XFER_MW_DMA_2;
  399. } else if (id->dma_mword & 0x0002) {
  400. speed = XFER_MW_DMA_1;
  401. } else if (id->dma_1word & 0x0004) {
  402. speed = XFER_SW_DMA_2;
  403.         } else {
  404. speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5, NULL);
  405. }
  407. (void) piix_tune_chipset(drive, speed);
  409. return ((int) ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  410. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  411. ((id->dma_mword >> 8) & 7) ? ide_dma_on :
  412. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  413.      ide_dma_off_quietly);
  414. }
  416. static void config_chipset_for_pio (ide_drive_t *drive)
  417. {
  418. piix_tune_drive(drive, ide_get_best_pio_mode(drive, 255, 5, NULL));
  419. }
  421. static int config_drive_xfer_rate (ide_drive_t *drive)
  422. {
  423. struct hd_driveid *id = drive->id;
  424. ide_dma_action_t dma_func = ide_dma_on;
  426. if (id && (id->capability & 1) && HWIF(drive)->autodma) {
  427. /* Consult the list of known "bad" drives */
  428. if (ide_dmaproc(ide_dma_bad_drive, drive)) {
  429. dma_func = ide_dma_off;
  430. goto fast_ata_pio;
  431. }
  432. dma_func = ide_dma_off_quietly;
  433. if (id->field_valid & 4) {
  434. if (id->dma_ultra & 0x003F) {
  435. /* Force if Capable UltraDMA */
  436. dma_func = piix_config_drive_for_dma(drive);
  437. if ((id->field_valid & 2) &&
  438.     (dma_func != ide_dma_on))
  439. goto try_dma_modes;
  440. }
  441. } else if (id->field_valid & 2) {
  442. try_dma_modes:
  443. if ((id->dma_mword & 0x0007) ||
  444.     (id->dma_1word & 0x007)) {
  445. /* Force if Capable regular DMA modes */
  446. dma_func = piix_config_drive_for_dma(drive);
  447. if (dma_func != ide_dma_on)
  448. goto no_dma_set;
  449. }
  450. } else if (ide_dmaproc(ide_dma_good_drive, drive)) {
  451. if (id->eide_dma_time > 150) {
  452. goto no_dma_set;
  453. }
  454. /* Consult the list of known "good" drives */
  455. dma_func = piix_config_drive_for_dma(drive);
  456. if (dma_func != ide_dma_on)
  457. goto no_dma_set;
  458. } else {
  459. goto fast_ata_pio;
  460. }
  461. } else if ((id->capability & 8) || (id->field_valid & 2)) {
  462. fast_ata_pio:
  463. dma_func = ide_dma_off_quietly;
  464. no_dma_set:
  465. config_chipset_for_pio(drive);
  466. }
  467. return HWIF(drive)->dmaproc(dma_func, drive);
  468. }
  470. static int piix_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
  471. {
  472. switch (func) {
  473. case ide_dma_check:
  474. return config_drive_xfer_rate(drive);
  475. default :
  476. break;
  477. }
  478. /* Other cases are done by generic IDE-DMA code. */
  479. return ide_dmaproc(func, drive);
  480. }
  481. #endif /* defined(CONFIG_BLK_DEV_IDEDMA) && (CONFIG_PIIX_TUNING) */
  483. unsigned int __init pci_init_piix (struct pci_dev *dev, const char *name)
  484. {
  485. #if defined(DISPLAY_PIIX_TIMINGS) && defined(CONFIG_PROC_FS)
  486. if (!piix_proc) {
  487. piix_proc = 1;
  488. bmide_dev = dev;
  489. piix_display_info = &piix_get_info;
  490. }
  491. #endif /* DISPLAY_PIIX_TIMINGS && CONFIG_PROC_FS */
  492. return 0;
  493. }
  495. /*
  496.  * Sheesh, someone at Intel needs to go read the ATA-4/5 T13 standards.
  497.  * It does not specify device detection, but channel!!!
  498.  * You determine later if bit 13 of word93 is set...
  499.  */
  500. unsigned int __init ata66_piix (ide_hwif_t *hwif)
  501. {
  502. byte reg54h = 0, reg55h = 0, ata66 = 0;
  503. byte mask = hwif->channel ? 0xc0 : 0x30;
  505. pci_read_config_byte(hwif->pci_dev, 0x54, &reg54h);
  506. pci_read_config_byte(hwif->pci_dev, 0x55, &reg55h);
  508. ata66 = (reg54h & mask) ? 1 : 0;
  510. return ata66;
  511. }
  513. void __init ide_init_piix (ide_hwif_t *hwif)
  514. {
  515. #ifndef CONFIG_IA64
  516. if (!hwif->irq)
  517. hwif->irq = hwif->channel ? 15 : 14;
  518. #endif /* CONFIG_IA64 */
  520. if (hwif->pci_dev->device == PCI_DEVICE_ID_INTEL_82371MX) {
  521. /* This is a painful system best to let it self tune for now */
  522. return;
  523. }
  525. hwif->tuneproc = &piix_tune_drive;
  526. hwif->drives[0].autotune = 1;
  527. hwif->drives[1].autotune = 1;
  529. if (!hwif->dma_base)
  530. return;
  532. #ifndef CONFIG_BLK_DEV_IDEDMA
  533. hwif->autodma = 0;
  534. #else /* CONFIG_BLK_DEV_IDEDMA */
  535. #ifdef CONFIG_PIIX_TUNING
  536. if (!noautodma)
  537. hwif->autodma = 1;
  538. hwif->dmaproc = &piix_dmaproc;
  539. hwif->speedproc = &piix_tune_chipset;
  540. #endif /* CONFIG_PIIX_TUNING */
  541. #endif /* !CONFIG_BLK_DEV_IDEDMA */
  542. }