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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
piix.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

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. p += sprintf(p, "n                                Intel PIIX4 Ultra 100 Chipset.n");
  96. break;
  97. case PCI_DEVICE_ID_INTEL_82372FB_1:
  98. case PCI_DEVICE_ID_INTEL_82801AA_1:
  99. p += sprintf(p, "n                                Intel PIIX4 Ultra 66 Chipset.n");
  100. break;
  101. case PCI_DEVICE_ID_INTEL_82451NX:
  102. case PCI_DEVICE_ID_INTEL_82801AB_1:
  103. case PCI_DEVICE_ID_INTEL_82443MX_1:
  104. case PCI_DEVICE_ID_INTEL_82371AB:
  105. p += sprintf(p, "n                                Intel PIIX4 Ultra 33 Chipset.n");
  106. break;
  107. case PCI_DEVICE_ID_INTEL_82371SB_1:
  108. p += sprintf(p, "n                                Intel PIIX3 Chipset.n");
  109. break;
  110. case PCI_DEVICE_ID_INTEL_82371MX:
  111. p += sprintf(p, "n                                Intel MPIIX Chipset.n");
  112. return p-buffer; /* => must be less than 4k! */
  113. case PCI_DEVICE_ID_INTEL_82371FB_1:
  114. case PCI_DEVICE_ID_INTEL_82371FB_0:
  115. default:
  116. p += sprintf(p, "n                                Intel PIIX Chipset.n");
  117. break;
  118. }
  120. pci_read_config_word(bmide_dev, 0x40, &reg40);
  121. pci_read_config_word(bmide_dev, 0x42, &reg42);
  122. pci_read_config_byte(bmide_dev, 0x44, &reg44);
  123. pci_read_config_byte(bmide_dev, 0x48, &reg48);
  124. pci_read_config_byte(bmide_dev, 0x4a, &reg4a);
  125. pci_read_config_byte(bmide_dev, 0x4b, &reg4b);
  126. pci_read_config_byte(bmide_dev, 0x54, &reg54);
  127. pci_read_config_byte(bmide_dev, 0x55, &reg55);
  129. psitre = (reg40 & 0x4000) ? 1 : 0;
  130. ssitre = (reg42 & 0x4000) ? 1 : 0;
  132. /*
  133.  * at that point bibma+0x2 et bibma+0xa are byte registers
  134.  * to investigate:
  135.  */
  136. c0 = inb_p((unsigned short)bibma + 0x02);
  137. c1 = inb_p((unsigned short)bibma + 0x0a);
  139. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  140. p += sprintf(p, "                %sabled                         %sabledn",
  141. (c0&0x80) ? "dis" : " en",
  142. (c1&0x80) ? "dis" : " en");
  143. p += sprintf(p, "--------------- drive0 --------- drive1 -------- drive0 ---------- drive1 ------n");
  144. p += sprintf(p, "DMA enabled:    %s              %s             %s               %sn",
  145. (c0&0x20) ? "yes" : "no ",
  146. (c0&0x40) ? "yes" : "no ",
  147. (c1&0x20) ? "yes" : "no ",
  148. (c1&0x40) ? "yes" : "no " );
  149. p += sprintf(p, "UDMA enabled:   %s              %s             %s               %sn",
  150. (reg48&0x01) ? "yes" : "no ",
  151. (reg48&0x02) ? "yes" : "no ",
  152. (reg48&0x04) ? "yes" : "no ",
  153. (reg48&0x08) ? "yes" : "no " );
  154. p += sprintf(p, "UDMA enabled:   %s                %s               %s                 %sn",
  155. ((reg54&0x11) && (reg55&0x10) && (reg4a&0x01)) ? "5" :
  156. ((reg54&0x11) && (reg4a&0x02)) ? "4" :
  157. ((reg54&0x11) && (reg4a&0x01)) ? "3" :
  158. (reg4a&0x02) ? "2" :
  159. (reg4a&0x01) ? "1" :
  160. (reg4a&0x00) ? "0" : "X",
  161. ((reg54&0x22) && (reg55&0x20) && (reg4a&0x10)) ? "5" :
  162. ((reg54&0x22) && (reg4a&0x20)) ? "4" :
  163. ((reg54&0x22) && (reg4a&0x10)) ? "3" :
  164. (reg4a&0x20) ? "2" :
  165. (reg4a&0x10) ? "1" :
  166. (reg4a&0x00) ? "0" : "X",
  167. ((reg54&0x44) && (reg55&0x40) && (reg4b&0x03)) ? "5" :
  168. ((reg54&0x44) && (reg4b&0x02)) ? "4" :
  169. ((reg54&0x44) && (reg4b&0x01)) ? "3" :
  170. (reg4b&0x02) ? "2" :
  171. (reg4b&0x01) ? "1" :
  172. (reg4b&0x00) ? "0" : "X",
  173. ((reg54&0x88) && (reg55&0x80) && (reg4b&0x30)) ? "5" :
  174. ((reg54&0x88) && (reg4b&0x20)) ? "4" :
  175. ((reg54&0x88) && (reg4b&0x10)) ? "3" :
  176. (reg4b&0x20) ? "2" :
  177. (reg4b&0x10) ? "1" :
  178. (reg4b&0x00) ? "0" : "X");
  180. p += sprintf(p, "UDMAn");
  181. p += sprintf(p, "DMAn");
  182. p += sprintf(p, "PIOn");
  184. /*
  185.  * FIXME.... Add configuration junk data....blah blah......
  186.  */
  188. return p-buffer;  /* => must be less than 4k! */
  189. }
  190. #endif  /* defined(DISPLAY_PIIX_TIMINGS) && defined(CONFIG_PROC_FS) */
  192. /*
  193.  *  Used to set Fifo configuration via kernel command line:
  194.  */
  196. byte piix_proc = 0;
  198. extern char *ide_xfer_verbose (byte xfer_rate);
  200. #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_PIIX_TUNING)
  201. /*
  202.  *
  203.  */
  204. static byte piix_dma_2_pio (byte xfer_rate) {
  205. switch(xfer_rate) {
  206. case XFER_UDMA_5:
  207. case XFER_UDMA_4:
  208. case XFER_UDMA_3:
  209. case XFER_UDMA_2:
  210. case XFER_UDMA_1:
  211. case XFER_UDMA_0:
  212. case XFER_MW_DMA_2:
  213. case XFER_PIO_4:
  214. return 4;
  215. case XFER_MW_DMA_1:
  216. case XFER_PIO_3:
  217. return 3;
  218. case XFER_SW_DMA_2:
  219. case XFER_PIO_2:
  220. return 2;
  221. case XFER_MW_DMA_0:
  222. case XFER_SW_DMA_1:
  223. case XFER_SW_DMA_0:
  224. case XFER_PIO_1:
  225. case XFER_PIO_0:
  226. case XFER_PIO_SLOW:
  227. default:
  228. return 0;
  229. }
  230. }
  231. #endif /* defined(CONFIG_BLK_DEV_IDEDMA) && (CONFIG_PIIX_TUNING) */
  233. /*
  234.  *  Based on settings done by AMI BIOS
  235.  *  (might be useful if drive is not registered in CMOS for any reason).
  236.  */
  237. static void piix_tune_drive (ide_drive_t *drive, byte pio)
  238. {
  239. unsigned long flags;
  240. u16 master_data;
  241. byte slave_data;
  242. int is_slave = (&HWIF(drive)->drives[1] == drive);
  243. int master_port = HWIF(drive)->index ? 0x42 : 0x40;
  244. int slave_port = 0x44;
  245.  /* ISP  RTC */
  246. byte timings[][2] = { { 0, 0 },
  247.     { 0, 0 },
  248.     { 1, 0 },
  249.     { 2, 1 },
  250.     { 2, 3 }, };
  252. pio = ide_get_best_pio_mode(drive, pio, 5, NULL);
  253. pci_read_config_word(HWIF(drive)->pci_dev, master_port, &master_data);
  254. if (is_slave) {
  255. master_data = master_data | 0x4000;
  256. if (pio > 1)
  257. /* enable PPE, IE and TIME */
  258. master_data = master_data | 0x0070;
  259. pci_read_config_byte(HWIF(drive)->pci_dev, slave_port, &slave_data);
  260. slave_data = slave_data & (HWIF(drive)->index ? 0x0f : 0xf0);
  261. slave_data = slave_data | ((timings[pio][0] << 2) | (timings[pio][1]
  262.    << (HWIF(drive)->index ? 4 : 0)));
  263. } else {
  264. master_data = master_data & 0xccf8;
  265. if (pio > 1)
  266. /* enable PPE, IE and TIME */
  267. master_data = master_data | 0x0007;
  268. master_data = master_data | (timings[pio][0] << 12) |
  269.       (timings[pio][1] << 8);
  270. }
  271. save_flags(flags);
  272. cli();
  273. pci_write_config_word(HWIF(drive)->pci_dev, master_port, master_data);
  274. if (is_slave)
  275. pci_write_config_byte(HWIF(drive)->pci_dev, slave_port, slave_data);
  276. restore_flags(flags);
  277. }
  279. #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_PIIX_TUNING)
  280. static int piix_tune_chipset (ide_drive_t *drive, byte speed)
  281. {
  282. ide_hwif_t *hwif = HWIF(drive);
  283. struct pci_dev *dev = hwif->pci_dev;
  284. byte maslave = hwif->channel ? 0x42 : 0x40;
  285. int a_speed = 3 << (drive->dn * 4);
  286. int u_flag = 1 << drive->dn;
  287. int v_flag = 0x01 << drive->dn;
  288. int w_flag = 0x10 << drive->dn;
  289. int u_speed = 0;
  290. int err = 0;
  291. int sitre;
  292. short reg4042, reg44, reg48, reg4a, reg54;
  293. byte reg55;
  295. pci_read_config_word(dev, maslave, &reg4042);
  296. sitre = (reg4042 & 0x4000) ? 1 : 0;
  297. pci_read_config_word(dev, 0x44, &reg44);
  298. pci_read_config_word(dev, 0x48, &reg48);
  299. pci_read_config_word(dev, 0x4a, &reg4a);
  300. pci_read_config_word(dev, 0x54, &reg54);
  301. pci_read_config_byte(dev, 0x55, &reg55);
  303. switch(speed) {
  304. case XFER_UDMA_4:
  305. case XFER_UDMA_2: u_speed = 2 << (drive->dn * 4); break;
  306. case XFER_UDMA_5:
  307. case XFER_UDMA_3:
  308. case XFER_UDMA_1: u_speed = 1 << (drive->dn * 4); break;
  309. case XFER_UDMA_0: u_speed = 0 << (drive->dn * 4); break;
  310. case XFER_MW_DMA_2:
  311. case XFER_MW_DMA_1:
  312. case XFER_SW_DMA_2: break;
  313. default: return -1;
  314. }
  316. if (speed >= XFER_UDMA_0) {
  317. if (!(reg48 & u_flag))
  318. pci_write_config_word(dev, 0x48, reg48|u_flag);
  319. if (speed == XFER_UDMA_5) {
  320. pci_write_config_byte(dev, 0x55, (byte) reg55|w_flag);
  321. } else {
  322. pci_write_config_byte(dev, 0x55, (byte) reg55 & ~w_flag);
  323. }
  324. if (!(reg4a & u_speed)) {
  325. pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
  326. pci_write_config_word(dev, 0x4a, reg4a|u_speed);
  327. }
  328. if (speed > XFER_UDMA_2) {
  329. if (!(reg54 & v_flag)) {
  330. pci_write_config_word(dev, 0x54, reg54|v_flag);
  331. }
  332. } else {
  333. pci_write_config_word(dev, 0x54, reg54 & ~v_flag);
  334. }
  335. }
  336. if (speed < XFER_UDMA_0) {
  337. if (reg48 & u_flag)
  338. pci_write_config_word(dev, 0x48, reg48 & ~u_flag);
  339. if (reg4a & a_speed)
  340. pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
  341. if (reg54 & v_flag)
  342. pci_write_config_word(dev, 0x54, reg54 & ~v_flag);
  343. if (reg55 & w_flag)
  344. pci_write_config_byte(dev, 0x55, (byte) reg55 & ~w_flag);
  345. }
  347. piix_tune_drive(drive, piix_dma_2_pio(speed));
  349. #if PIIX_DEBUG_DRIVE_INFO
  350. printk("%s: %s drive%dn", drive->name, ide_xfer_verbose(speed), drive->dn);
  351. #endif /* PIIX_DEBUG_DRIVE_INFO */
  352. if (!drive->init_speed)
  353. drive->init_speed = speed;
  354. err = ide_config_drive_speed(drive, speed);
  355. drive->current_speed = speed;
  356. return err;
  357. }
  359. static int piix_config_drive_for_dma (ide_drive_t *drive)
  360. {
  361. struct hd_driveid *id = drive->id;
  362. ide_hwif_t *hwif = HWIF(drive);
  363. struct pci_dev *dev = hwif->pci_dev;
  364. byte speed;
  366. byte udma_66 = eighty_ninty_three(drive);
  367. int ultra100 = ((dev->device == PCI_DEVICE_ID_INTEL_82801BA_8) ||
  368.    (dev->device == PCI_DEVICE_ID_INTEL_82801BA_9) ||
  369.    (dev->device == PCI_DEVICE_ID_INTEL_82801CA_10)) ? 1 : 0;
  370. int ultra66 = ((ultra100) ||
  371.    (dev->device == PCI_DEVICE_ID_INTEL_82801AA_1) ||
  372.    (dev->device == PCI_DEVICE_ID_INTEL_82372FB_1)) ? 1 : 0;
  373. int ultra = ((ultra66) ||
  374.    (dev->device == PCI_DEVICE_ID_INTEL_82371AB) ||
  375.    (dev->device == PCI_DEVICE_ID_INTEL_82443MX_1) ||
  376.    (dev->device == PCI_DEVICE_ID_INTEL_82451NX) ||
  377.    (dev->device == PCI_DEVICE_ID_INTEL_82801AB_1)) ? 1 : 0;
  379. if ((id->dma_ultra & 0x0020) && (udma_66) && (ultra100)) {
  380. speed = XFER_UDMA_5;
  381. } else if ((id->dma_ultra & 0x0010) && (ultra)) {
  382. speed = ((udma_66) && (ultra66)) ? XFER_UDMA_4 : XFER_UDMA_2;
  383. } else if ((id->dma_ultra & 0x0008) && (ultra)) {
  384. speed = ((udma_66) && (ultra66)) ? XFER_UDMA_3 : XFER_UDMA_1;
  385. } else if ((id->dma_ultra & 0x0004) && (ultra)) {
  386. speed = XFER_UDMA_2;
  387. } else if ((id->dma_ultra & 0x0002) && (ultra)) {
  388. speed = XFER_UDMA_1;
  389. } else if ((id->dma_ultra & 0x0001) && (ultra)) {
  390. speed = XFER_UDMA_0;
  391. } else if (id->dma_mword & 0x0004) {
  392. speed = XFER_MW_DMA_2;
  393. } else if (id->dma_mword & 0x0002) {
  394. speed = XFER_MW_DMA_1;
  395. } else if (id->dma_1word & 0x0004) {
  396. speed = XFER_SW_DMA_2;
  397.         } else {
  398. speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5, NULL);
  399. }
  401. (void) piix_tune_chipset(drive, speed);
  403. return ((int) ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  404. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  405. ((id->dma_mword >> 8) & 7) ? ide_dma_on :
  406. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  407.      ide_dma_off_quietly);
  408. }
  410. static void config_chipset_for_pio (ide_drive_t *drive)
  411. {
  412. piix_tune_drive(drive, ide_get_best_pio_mode(drive, 255, 5, NULL));
  413. }
  415. static int config_drive_xfer_rate (ide_drive_t *drive)
  416. {
  417. struct hd_driveid *id = drive->id;
  418. ide_dma_action_t dma_func = ide_dma_on;
  420. if (id && (id->capability & 1) && HWIF(drive)->autodma) {
  421. /* Consult the list of known "bad" drives */
  422. if (ide_dmaproc(ide_dma_bad_drive, drive)) {
  423. dma_func = ide_dma_off;
  424. goto fast_ata_pio;
  425. }
  426. dma_func = ide_dma_off_quietly;
  427. if (id->field_valid & 4) {
  428. if (id->dma_ultra & 0x002F) {
  429. /* Force if Capable UltraDMA */
  430. dma_func = piix_config_drive_for_dma(drive);
  431. if ((id->field_valid & 2) &&
  432.     (dma_func != ide_dma_on))
  433. goto try_dma_modes;
  434. }
  435. } else if (id->field_valid & 2) {
  436. try_dma_modes:
  437. if ((id->dma_mword & 0x0007) ||
  438.     (id->dma_1word & 0x007)) {
  439. /* Force if Capable regular DMA modes */
  440. dma_func = piix_config_drive_for_dma(drive);
  441. if (dma_func != ide_dma_on)
  442. goto no_dma_set;
  443. }
  444. } else if (ide_dmaproc(ide_dma_good_drive, drive)) {
  445. if (id->eide_dma_time > 150) {
  446. goto no_dma_set;
  447. }
  448. /* Consult the list of known "good" drives */
  449. dma_func = piix_config_drive_for_dma(drive);
  450. if (dma_func != ide_dma_on)
  451. goto no_dma_set;
  452. } else {
  453. goto fast_ata_pio;
  454. }
  455. } else if ((id->capability & 8) || (id->field_valid & 2)) {
  456. fast_ata_pio:
  457. dma_func = ide_dma_off_quietly;
  458. no_dma_set:
  459. config_chipset_for_pio(drive);
  460. }
  461. return HWIF(drive)->dmaproc(dma_func, drive);
  462. }
  464. static int piix_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
  465. {
  466. switch (func) {
  467. case ide_dma_check:
  468. return config_drive_xfer_rate(drive);
  469. default :
  470. break;
  471. }
  472. /* Other cases are done by generic IDE-DMA code. */
  473. return ide_dmaproc(func, drive);
  474. }
  475. #endif /* defined(CONFIG_BLK_DEV_IDEDMA) && (CONFIG_PIIX_TUNING) */
  477. unsigned int __init pci_init_piix (struct pci_dev *dev, const char *name)
  478. {
  479. #if defined(DISPLAY_PIIX_TIMINGS) && defined(CONFIG_PROC_FS)
  480. if (!piix_proc) {
  481. piix_proc = 1;
  482. bmide_dev = dev;
  483. piix_display_info = &piix_get_info;
  484. }
  485. #endif /* DISPLAY_PIIX_TIMINGS && CONFIG_PROC_FS */
  486. return 0;
  487. }
  489. /*
  490.  * Sheesh, someone at Intel needs to go read the ATA-4/5 T13 standards.
  491.  * It does not specify device detection, but channel!!!
  492.  * You determine later if bit 13 of word93 is set...
  493.  */
  494. unsigned int __init ata66_piix (ide_hwif_t *hwif)
  495. {
  496. byte reg54h = 0, reg55h = 0, ata66 = 0;
  497. byte mask = hwif->channel ? 0xc0 : 0x30;
  499. pci_read_config_byte(hwif->pci_dev, 0x54, &reg54h);
  500. pci_read_config_byte(hwif->pci_dev, 0x55, &reg55h);
  502. ata66 = (reg54h & mask) ? 1 : 0;
  504. return ata66;
  505. }
  507. void __init ide_init_piix (ide_hwif_t *hwif)
  508. {
  509. #ifndef CONFIG_IA64
  510. if (!hwif->irq)
  511. hwif->irq = hwif->channel ? 15 : 14;
  512. #endif /* CONFIG_IA64 */
  514. if (hwif->pci_dev->device == PCI_DEVICE_ID_INTEL_82371MX) {
  515. /* This is a painful system best to let it self tune for now */
  516. return;
  517. }
  519. hwif->tuneproc = &piix_tune_drive;
  520. hwif->drives[0].autotune = 1;
  521. hwif->drives[1].autotune = 1;
  523. if (!hwif->dma_base)
  524. return;
  526. #ifndef CONFIG_BLK_DEV_IDEDMA
  527. hwif->autodma = 0;
  528. #else /* CONFIG_BLK_DEV_IDEDMA */
  529. #ifdef CONFIG_PIIX_TUNING
  530. if (!noautodma)
  531. hwif->autodma = 1;
  532. hwif->dmaproc = &piix_dmaproc;
  533. hwif->speedproc = &piix_tune_chipset;
  534. #endif /* CONFIG_PIIX_TUNING */
  535. #endif /* !CONFIG_BLK_DEV_IDEDMA */
  536. }