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

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

嵌入式Linux

开发平台：

Unix_Linux

sis5513.c：源码内容
  1. /*
  2.  * linux/drivers/ide/sis5513.c Version 0.11 June 9, 2000
  3.  *
  4.  * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org>
  5.  * May be copied or modified under the terms of the GNU General Public License
  6.  *
  7.  * Thanks to SIS Taiwan for direct support and hardware.
  8.  * Tested and designed on the SiS620/5513 chipset.
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/types.h>
  13. #include <linux/kernel.h>
  14. #include <linux/delay.h>
  15. #include <linux/timer.h>
  16. #include <linux/mm.h>
  17. #include <linux/ioport.h>
  18. #include <linux/blkdev.h>
  19. #include <linux/hdreg.h>
  21. #include <linux/interrupt.h>
  22. #include <linux/pci.h>
  23. #include <linux/init.h>
  24. #include <linux/ide.h>
  26. #include <asm/io.h>
  27. #include <asm/irq.h>
  29. #include "ide_modes.h"
  31. #define DISPLAY_SIS_TIMINGS
  32. #define SIS5513_DEBUG_DRIVE_INFO 0
  34. static struct pci_dev *host_dev = NULL;
  36. #define SIS5513_FLAG_ATA_00 0x00000000
  37. #define SIS5513_FLAG_ATA_16 0x00000001
  38. #define SIS5513_FLAG_ATA_33 0x00000002
  39. #define SIS5513_FLAG_ATA_66 0x00000004
  40. #define SIS5513_FLAG_LATENCY 0x00000010
  42. static const struct {
  43. const char *name;
  44. unsigned short host_id;
  45. unsigned int flags;
  46. } SiSHostChipInfo[] = {
  47. { "SiS530", PCI_DEVICE_ID_SI_530, SIS5513_FLAG_ATA_66, },
  48. { "SiS540", PCI_DEVICE_ID_SI_540, SIS5513_FLAG_ATA_66, },
  49. { "SiS620", PCI_DEVICE_ID_SI_620, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  50. { "SiS630", PCI_DEVICE_ID_SI_630, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  51. { "SiS635", PCI_DEVICE_ID_SI_635, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  52. { "SiS640", PCI_DEVICE_ID_SI_640, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  53. { "SiS645", PCI_DEVICE_ID_SI_645, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  54. { "SiS650", PCI_DEVICE_ID_SI_650, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  55. { "SiS730", PCI_DEVICE_ID_SI_730, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  56. { "SiS735", PCI_DEVICE_ID_SI_735, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  57. { "SiS740", PCI_DEVICE_ID_SI_740, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  58. { "SiS745", PCI_DEVICE_ID_SI_745, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  59. { "SiS750", PCI_DEVICE_ID_SI_750, SIS5513_FLAG_ATA_66|SIS5513_FLAG_LATENCY, },
  60. { "SiS5591", PCI_DEVICE_ID_SI_5591, SIS5513_FLAG_ATA_33, },
  61. { "SiS5597", PCI_DEVICE_ID_SI_5597, SIS5513_FLAG_ATA_33, },
  62. { "SiS5600", PCI_DEVICE_ID_SI_5600, SIS5513_FLAG_ATA_33, },
  63. { "SiS5511", PCI_DEVICE_ID_SI_5511, SIS5513_FLAG_ATA_16, },
  64. };
  66. #if 0
  68. static struct _pio_mode_mapping {
  69. byte data_active;
  70. byte recovery;
  71. byte pio_mode;
  72. } pio_mode_mapping[] = {
  73. { 8, 12, 0 },
  74. { 6,  7, 1 },
  75. { 4,  4, 2 },
  76. { 3,  3, 3 },
  77. { 3,  1, 4 }
  78. };
  80. static struct _dma_mode_mapping {
  81. byte data_active;
  82. byte recovery;
  83. byte dma_mode;
  84. } dma_mode_mapping[] = {
  85. { 8, 8, 0 },
  86. { 3, 2, 1 },
  87. { 3, 1, 2 }
  88. };
  90. static struct _udma_mode_mapping {
  91. byte cycle_time;
  92. char * udma_mode;
  93. } udma_mode_mapping[] = {
  94. { 8, "Mode 0" },
  95. { 6, "Mode 1" },
  96. { 4, "Mode 2" }, 
  97. { 3, "Mode 3" },
  98. { 2, "Mode 4" },
  99. { 0, "Mode 5" }
  100. };
  102. static __inline__ char * find_udma_mode (byte cycle_time)
  103. {
  104. int n;
  106. for (n = 0; n <= 4; n++)
  107. if (udma_mode_mapping[n].cycle_time <= cycle_time)
  108. return udma_mode_mapping[n].udma_mode;
  109. return udma_mode_mapping[4].udma_mode;
  110. }
  111. #endif
  113. #if defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS)
  114. #include <linux/stat.h>
  115. #include <linux/proc_fs.h>
  117. static int sis_get_info(char *, char **, off_t, int);
  118. extern int (*sis_display_info)(char *, char **, off_t, int); /* ide-proc.c */
  119. static struct pci_dev *bmide_dev;
  121. static char *cable_type[] = {
  122. "80 pins",
  123. "40 pins"
  124. };
  126. static char *recovery_time [] ={
  127. "12 PCICLK", "1 PCICLK",
  128. "2 PCICLK", "3 PCICLK",
  129. "4 PCICLK", "5 PCICLCK",
  130. "6 PCICLK", "7 PCICLCK",
  131. "8 PCICLK", "9 PCICLCK",
  132. "10 PCICLK", "11 PCICLK",
  133. "13 PCICLK", "14 PCICLK",
  134. "15 PCICLK", "15 PCICLK"
  135. };
  137. static char * cycle_time [] = {
  138. "2 CLK", "2 CLK",
  139. "3 CLK", "4 CLK",
  140. "5 CLK", "6 CLK",
  141. "7 CLK", "8 CLK"
  142. };
  144. static char * active_time [] = {
  145. "8 PCICLK", "1 PCICLCK",
  146. "2 PCICLK", "2 PCICLK",
  147. "4 PCICLK", "5 PCICLK",
  148. "6 PCICLK", "12 PCICLK"
  149. };
  151. static int sis_get_info (char *buffer, char **addr, off_t offset, int count)
  152. {
  153. int rc;
  154. char *p = buffer;
  155. byte reg,reg1;
  156. u16 reg2, reg3;
  158. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  159. rc = pci_read_config_byte(bmide_dev, 0x4a, &reg);
  160. p += sprintf(p, "Channel Status: %s t t t t %s n",
  161.      (reg & 0x02) ? "On" : "Off",
  162.      (reg & 0x04) ? "On" : "Off");
  163.      
  164. rc = pci_read_config_byte(bmide_dev, 0x09, &reg);
  165. p += sprintf(p, "Operation Mode: %s t t t %s n",
  166.      (reg & 0x01) ? "Native" : "Compatible",
  167.      (reg & 0x04) ? "Native" : "Compatible");
  168.            
  169. rc = pci_read_config_byte(bmide_dev, 0x48, &reg);
  170. p += sprintf(p, "Cable Type:     %s t t t %sn",
  171.      (reg & 0x10) ? cable_type[1] : cable_type[0],
  172.      (reg & 0x20) ? cable_type[1] : cable_type[0]);
  173.      
  174. rc = pci_read_config_word(bmide_dev, 0x4c, &reg2);
  175. rc = pci_read_config_word(bmide_dev, 0x4e, &reg3);
  176. p += sprintf(p, "Prefetch Count: %d t t t t %dn",
  177.      reg2, reg3);
  179. rc = pci_read_config_byte(bmide_dev, 0x4b, &reg);      
  180. p += sprintf(p, "Drive 0:        Postwrite %s t t Postwrite %sn",
  181.      (reg & 0x10) ? "Enabled" : "Disabled",
  182.      (reg & 0x40) ? "Enabled" : "Disabled");
  183. p += sprintf(p, "                Prefetch  %s t t Prefetch  %sn",
  184.      (reg & 0x01) ? "Enabled" : "Disabled",
  185.      (reg & 0x04) ? "Enabled" : "Disabled");
  186.           
  187. rc = pci_read_config_byte(bmide_dev, 0x41, &reg);
  188. rc = pci_read_config_byte(bmide_dev, 0x45, &reg1);
  189. p += sprintf(p, "                UDMA %s t t t UDMA %sn",
  190.      (reg & 0x80)  ? "Enabled" : "Disabled",
  191.      (reg1 & 0x80) ? "Enabled" : "Disabled");
  192. p += sprintf(p, "                UDMA Cycle Time    %s t UDMA Cycle Time    %sn",
  193.      cycle_time[(reg & 0x70) >> 4], cycle_time[(reg1 & 0x70) >> 4]);
  194. p += sprintf(p, "                Data Active Time   %s t Data Active Time   %sn",
  195.      active_time[(reg & 0x07)], active_time[(reg1 &0x07)] ); 
  197. rc = pci_read_config_byte(bmide_dev, 0x40, &reg);
  198. rc = pci_read_config_byte(bmide_dev, 0x44, &reg1);
  199. p += sprintf(p, "                Data Recovery Time %s t Data Recovery Time %sn",
  200.      recovery_time[(reg & 0x0f)], recovery_time[(reg1 & 0x0f)]);
  203. rc = pci_read_config_byte(bmide_dev, 0x4b, &reg);      
  204. p += sprintf(p, "Drive 1:        Postwrite %s t t Postwrite %sn",
  205.      (reg & 0x20) ? "Enabled" : "Disabled",
  206.      (reg & 0x80) ? "Enabled" : "Disabled");
  207. p += sprintf(p, "                Prefetch  %s t t Prefetch  %sn",
  208.      (reg & 0x02) ? "Enabled" : "Disabled",
  209.      (reg & 0x08) ? "Enabled" : "Disabled");
  211. rc = pci_read_config_byte(bmide_dev, 0x43, &reg);
  212. rc = pci_read_config_byte(bmide_dev, 0x47, &reg1);
  213. p += sprintf(p, "                UDMA %s t t t UDMA %sn",
  214.      (reg & 0x80)  ? "Enabled" : "Disabled",
  215.      (reg1 & 0x80) ? "Enabled" : "Disabled");
  216. p += sprintf(p, "                UDMA Cycle Time    %s t UDMA Cycle Time    %sn",
  217.      cycle_time[(reg & 0x70) >> 4], cycle_time[(reg1 & 0x70) >> 4]);
  218. p += sprintf(p, "                Data Active Time   %s t Data Active Time   %sn",
  219.      active_time[(reg & 0x07)], active_time[(reg1 &0x07)] ); 
  221. rc = pci_read_config_byte(bmide_dev, 0x42, &reg);
  222. rc = pci_read_config_byte(bmide_dev, 0x46, &reg1);
  223. p += sprintf(p, "                Data Recovery Time %s t Data Recovery Time %sn",
  224.      recovery_time[(reg & 0x0f)], recovery_time[(reg1 & 0x0f)]);
  225. return p-buffer;
  226. }
  227. #endif /* defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS) */
  229. byte sis_proc = 0;
  230. extern char *ide_xfer_verbose (byte xfer_rate);
  232. static void config_drive_art_rwp (ide_drive_t *drive)
  233. {
  234. ide_hwif_t *hwif = HWIF(drive);
  235. struct pci_dev *dev = hwif->pci_dev;
  237. byte reg4bh = 0;
  238. byte rw_prefetch = (0x11 << drive->dn);
  240. pci_read_config_byte(dev, 0x4b, &reg4bh);
  241. if (drive->media != ide_disk)
  242. return;
  244. if ((reg4bh & rw_prefetch) != rw_prefetch)
  245. pci_write_config_byte(dev, 0x4b, reg4bh|rw_prefetch);
  246. }
  248. static void config_art_rwp_pio (ide_drive_t *drive, byte pio)
  249. {
  250. ide_hwif_t *hwif = HWIF(drive);
  251. struct pci_dev *dev = hwif->pci_dev;
  253. byte timing, drive_pci, test1, test2;
  255. unsigned short eide_pio_timing[6] = {600, 390, 240, 180, 120, 90};
  256. unsigned short xfer_pio = drive->id->eide_pio_modes;
  258. config_drive_art_rwp(drive);
  259. pio = ide_get_best_pio_mode(drive, 255, pio, NULL);
  261. if (xfer_pio> 4)
  262. xfer_pio = 0;
  264. if (drive->id->eide_pio_iordy > 0) {
  265. for (xfer_pio = 5;
  266. xfer_pio>0 &&
  267. drive->id->eide_pio_iordy>eide_pio_timing[xfer_pio];
  268. xfer_pio--);
  269. } else {
  270. xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
  271.    (drive->id->eide_pio_modes & 2) ? 0x04 :
  272.    (drive->id->eide_pio_modes & 1) ? 0x03 : xfer_pio;
  273. }
  275. timing = (xfer_pio >= pio) ? xfer_pio : pio;
  277. /*
  278.  *               Mode 0       Mode 1     Mode 2     Mode 3     Mode 4
  279.  * Active time    8T (240ns)  6T (180ns) 4T (120ns) 3T  (90ns) 3T  (90ns)
  280.  * 0x41 2:0 bits  000          110        100        011        011
  281.  * Recovery time 12T (360ns)  7T (210ns) 4T (120ns) 3T  (90ns) 1T  (30ns)
  282.  * 0x40 3:0 bits 0000         0111       0100       0011       0001
  283.  * Cycle time    20T (600ns) 13T (390ns) 8T (240ns) 6T (180ns) 4T (120ns)
  284.  */
  286. switch(drive->dn) {
  287. case 0: drive_pci = 0x40; break;
  288. case 1: drive_pci = 0x42; break;
  289. case 2: drive_pci = 0x44; break;
  290. case 3: drive_pci = 0x46; break;
  291. default: return;
  292. }
  294. pci_read_config_byte(dev, drive_pci, &test1);
  295. pci_read_config_byte(dev, drive_pci|0x01, &test2);
  297. /*
  298.  * Do a blanket clear of active and recovery timings.
  299.  */
  301. test1 &= ~0x07;
  302. test2 &= ~0x0F;
  304. switch(timing) {
  305. case 4: test1 |= 0x01; test2 |= 0x03; break;
  306. case 3: test1 |= 0x03; test2 |= 0x03; break;
  307. case 2: test1 |= 0x04; test2 |= 0x04; break;
  308. case 1: test1 |= 0x07; test2 |= 0x06; break;
  309. default: break;
  310. }
  312. pci_write_config_byte(dev, drive_pci, test1);
  313. pci_write_config_byte(dev, drive_pci|0x01, test2);
  314. }
  316. static int config_chipset_for_pio (ide_drive_t *drive, byte pio)
  317. {
  318. int err;
  319. byte speed;
  321. switch(pio) {
  322. case 4: speed = XFER_PIO_4; break;
  323. case 3: speed = XFER_PIO_3; break;
  324. case 2: speed = XFER_PIO_2; break;
  325. case 1: speed = XFER_PIO_1; break;
  326. default: speed = XFER_PIO_0; break;
  327. }
  329. config_art_rwp_pio(drive, pio);
  330. drive->current_speed = speed;
  331. err = ide_config_drive_speed(drive, speed);
  332. return err;
  333. }
  335. static int sis5513_tune_chipset (ide_drive_t *drive, byte speed)
  336. {
  337. ide_hwif_t *hwif = HWIF(drive);
  338. struct pci_dev *dev = hwif->pci_dev;
  340. byte drive_pci, test1, test2;
  341. byte unmask, four_two, mask = 0;
  343. if (host_dev) {
  344. switch(host_dev->device) {
  345. case PCI_DEVICE_ID_SI_530:
  346. case PCI_DEVICE_ID_SI_540:
  347. case PCI_DEVICE_ID_SI_620:
  348. case PCI_DEVICE_ID_SI_630:
  349. case PCI_DEVICE_ID_SI_635:
  350. case PCI_DEVICE_ID_SI_640:
  351. case PCI_DEVICE_ID_SI_645:
  352. case PCI_DEVICE_ID_SI_650:
  353. case PCI_DEVICE_ID_SI_730:
  354. case PCI_DEVICE_ID_SI_735:
  355. case PCI_DEVICE_ID_SI_740:
  356. case PCI_DEVICE_ID_SI_745:
  357. case PCI_DEVICE_ID_SI_750:
  358. unmask   = 0xF0;
  359. four_two = 0x01;
  360. break;
  361. default:
  362. unmask   = 0xE0;
  363. four_two = 0x00;
  364. break;
  365. }
  366. } else {
  367. unmask   = 0xE0;
  368. four_two = 0x00;
  369. }
  371. switch(drive->dn) {
  372. case 0: drive_pci = 0x40;break;
  373. case 1: drive_pci = 0x42;break;
  374. case 2: drive_pci = 0x44;break;
  375. case 3: drive_pci = 0x46;break;
  376. default: return ide_dma_off;
  377. }
  379. pci_read_config_byte(dev, drive_pci, &test1);
  380. pci_read_config_byte(dev, drive_pci|0x01, &test2);
  382. if ((speed <= XFER_MW_DMA_2) && (test2 & 0x80)) {
  383. pci_write_config_byte(dev, drive_pci|0x01, test2 & ~0x80);
  384. pci_read_config_byte(dev, drive_pci|0x01, &test2);
  385. } else {
  386. pci_write_config_byte(dev, drive_pci|0x01, test2 & ~unmask);
  387. }
  389. switch(speed) {
  390. #ifdef CONFIG_BLK_DEV_IDEDMA
  391. case XFER_UDMA_5: mask = 0x80; break;
  392. case XFER_UDMA_4: mask = 0x90; break;
  393. case XFER_UDMA_3: mask = 0xA0; break;
  394. case XFER_UDMA_2: mask = (four_two) ? 0xB0 : 0xA0; break;
  395. case XFER_UDMA_1: mask = (four_two) ? 0xD0 : 0xC0; break;
  396. case XFER_UDMA_0: mask = unmask; break;
  397. case XFER_MW_DMA_2:
  398. case XFER_MW_DMA_1:
  399. case XFER_MW_DMA_0:
  400. case XFER_SW_DMA_2:
  401. case XFER_SW_DMA_1:
  402. case XFER_SW_DMA_0: break;
  403. #endif /* CONFIG_BLK_DEV_IDEDMA */
  404. case XFER_PIO_4: return((int) config_chipset_for_pio(drive, 4));
  405. case XFER_PIO_3: return((int) config_chipset_for_pio(drive, 3));
  406. case XFER_PIO_2: return((int) config_chipset_for_pio(drive, 2));
  407. case XFER_PIO_1: return((int) config_chipset_for_pio(drive, 1));
  408. case XFER_PIO_0:
  409. default:  return((int) config_chipset_for_pio(drive, 0));
  410. }
  412. if (speed > XFER_MW_DMA_2)
  413. pci_write_config_byte(dev, drive_pci|0x01, test2|mask);
  415. drive->current_speed = speed;
  416. return ((int) ide_config_drive_speed(drive, speed));
  417. }
  419. static void sis5513_tune_drive (ide_drive_t *drive, byte pio)
  420. {
  421. (void) config_chipset_for_pio(drive, pio);
  422. }
  424. #ifdef CONFIG_BLK_DEV_IDEDMA
  425. /*
  426.  * ((id->hw_config & 0x4000|0x2000) && (HWIF(drive)->udma_four))
  427.  */
  428. static int config_chipset_for_dma (ide_drive_t *drive, byte ultra)
  429. {
  430. struct hd_driveid *id = drive->id;
  431. ide_hwif_t *hwif = HWIF(drive);
  433. byte four_two = 0, speed = 0;
  434. int err;
  436. byte unit = (drive->select.b.unit & 0x01);
  437. byte udma_66 = eighty_ninty_three(drive);
  438. byte ultra_100 = 0;
  440. if (host_dev) {
  441. switch(host_dev->device) {
  442. case PCI_DEVICE_ID_SI_635:
  443. case PCI_DEVICE_ID_SI_640:
  444. case PCI_DEVICE_ID_SI_645:
  445. case PCI_DEVICE_ID_SI_650:
  446. case PCI_DEVICE_ID_SI_730:
  447. case PCI_DEVICE_ID_SI_735:
  448. case PCI_DEVICE_ID_SI_740:
  449. case PCI_DEVICE_ID_SI_745:
  450. case PCI_DEVICE_ID_SI_750:
  451. ultra_100 = 1;
  452. case PCI_DEVICE_ID_SI_530:
  453. case PCI_DEVICE_ID_SI_540:
  454. case PCI_DEVICE_ID_SI_620:
  455. case PCI_DEVICE_ID_SI_630:
  456. four_two = 0x01;
  457. break;
  458. default:
  459. four_two = 0x00; break;
  460. }
  461. }
  463. if ((id->dma_ultra & 0x0020) && (ultra) && (udma_66) && (four_two) && (ultra_100))
  464. speed = XFER_UDMA_5;
  465. else if ((id->dma_ultra & 0x0010) && (ultra) && (udma_66) && (four_two))
  466. speed = XFER_UDMA_4;
  467. else if ((id->dma_ultra & 0x0008) && (ultra) && (udma_66) && (four_two))
  468. speed = XFER_UDMA_3;
  469. else if ((id->dma_ultra & 0x0004) && (ultra))
  470. speed = XFER_UDMA_2;
  471. else if ((id->dma_ultra & 0x0002) && (ultra))
  472. speed = XFER_UDMA_1;
  473. else if ((id->dma_ultra & 0x0001) && (ultra))
  474. speed = XFER_UDMA_0;
  475. else if (id->dma_mword & 0x0004)
  476. speed = XFER_MW_DMA_2;
  477. else if (id->dma_mword & 0x0002)
  478. speed = XFER_MW_DMA_1;
  479. else if (id->dma_mword & 0x0001)
  480. speed = XFER_MW_DMA_0;
  481. else if (id->dma_1word & 0x0004)
  482. speed = XFER_SW_DMA_2;
  483. else if (id->dma_1word & 0x0002)
  484. speed = XFER_SW_DMA_1;
  485. else if (id->dma_1word & 0x0001)
  486. speed = XFER_SW_DMA_0;
  487. else
  488. return ((int) ide_dma_off_quietly);
  490. outb(inb(hwif->dma_base+2)|(1<<(5+unit)), hwif->dma_base+2);
  492. err = sis5513_tune_chipset(drive, speed);
  494. #if SIS5513_DEBUG_DRIVE_INFO
  495. printk("%s: %s drive%dn", drive->name, ide_xfer_verbose(speed), drive->dn);
  496. #endif /* SIS5513_DEBUG_DRIVE_INFO */
  498. return ((int) ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  499. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  500. ((id->dma_mword >> 8) & 7) ? ide_dma_on :
  501. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  502.      ide_dma_off_quietly);
  503. }
  505. static int config_drive_xfer_rate (ide_drive_t *drive)
  506. {
  507. struct hd_driveid *id = drive->id;
  508. ide_dma_action_t dma_func = ide_dma_off_quietly;
  510. if (id && (id->capability & 1) && HWIF(drive)->autodma) {
  511. /* Consult the list of known "bad" drives */
  512. if (ide_dmaproc(ide_dma_bad_drive, drive)) {
  513. dma_func = ide_dma_off;
  514. goto fast_ata_pio;
  515. }
  516. dma_func = ide_dma_off_quietly;
  517. if (id->field_valid & 4) {
  518. if (id->dma_ultra & 0x003F) {
  519. /* Force if Capable UltraDMA */
  520. dma_func = config_chipset_for_dma(drive, 1);
  521. if ((id->field_valid & 2) &&
  522.     (dma_func != ide_dma_on))
  523. goto try_dma_modes;
  524. }
  525. } else if (id->field_valid & 2) {
  526. try_dma_modes:
  527. if ((id->dma_mword & 0x0007) ||
  528.     (id->dma_1word & 0x0007)) {
  529. /* Force if Capable regular DMA modes */
  530. dma_func = config_chipset_for_dma(drive, 0);
  531. if (dma_func != ide_dma_on)
  532. goto no_dma_set;
  533. }
  534. } else if ((ide_dmaproc(ide_dma_good_drive, drive)) &&
  535.    (id->eide_dma_time > 150)) {
  536. /* Consult the list of known "good" drives */
  537. dma_func = config_chipset_for_dma(drive, 0);
  538. if (dma_func != ide_dma_on)
  539. goto no_dma_set;
  540. } else {
  541. goto fast_ata_pio;
  542. }
  543. } else if ((id->capability & 8) || (id->field_valid & 2)) {
  544. fast_ata_pio:
  545. dma_func = ide_dma_off_quietly;
  546. no_dma_set:
  547. (void) config_chipset_for_pio(drive, 5);
  548. }
  550. return HWIF(drive)->dmaproc(dma_func, drive);
  551. }
  553. /*
  554.  * sis5513_dmaproc() initiates/aborts (U)DMA read/write operations on a drive.
  555.  */
  556. int sis5513_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  557. {
  558. switch (func) {
  559. case ide_dma_check:
  560. config_drive_art_rwp(drive);
  561. config_art_rwp_pio(drive, 5);
  562. return config_drive_xfer_rate(drive);
  563. default:
  564. break;
  565. }
  566. return ide_dmaproc(func, drive); /* use standard DMA stuff */
  567. }
  568. #endif /* CONFIG_BLK_DEV_IDEDMA */
  570. unsigned int __init pci_init_sis5513 (struct pci_dev *dev, const char *name)
  571. {
  572. struct pci_dev *host;
  573. int i = 0;
  574. byte latency = 0;
  576. pci_read_config_byte(dev, PCI_LATENCY_TIMER, &latency);
  578. for (i = 0; i < ARRAY_SIZE (SiSHostChipInfo) && !host_dev; i++) {
  579. host = pci_find_device (PCI_VENDOR_ID_SI,
  580. SiSHostChipInfo[i].host_id,
  581. NULL);
  582. if (!host)
  583. continue;
  585. host_dev = host;
  586. printk(SiSHostChipInfo[i].name);
  587. printk("n");
  588. if (SiSHostChipInfo[i].flags & SIS5513_FLAG_LATENCY) {
  589. if (latency != 0x10)
  590. pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x10);
  591. }
  592. }
  594. if (host_dev) {
  595. byte reg52h = 0;
  597. pci_read_config_byte(dev, 0x52, &reg52h);
  598. if (!(reg52h & 0x04)) {
  599. /* set IDE controller to operate in Compabitility mode only */
  600. pci_write_config_byte(dev, 0x52, reg52h|0x04);
  601. }
  602. #if defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS)
  603. if (!sis_proc) {
  604. sis_proc = 1;
  605. bmide_dev = dev;
  606. sis_display_info = &sis_get_info;
  607. }
  608. #endif /* defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS) */
  609. }
  610. return 0;
  611. }
  613. unsigned int __init ata66_sis5513 (ide_hwif_t *hwif)
  614. {
  615. byte reg48h = 0, ata66 = 0;
  616. byte mask = hwif->channel ? 0x20 : 0x10;
  617. pci_read_config_byte(hwif->pci_dev, 0x48, &reg48h);
  619. if (host_dev) {
  620. switch(host_dev->device) {
  621. case PCI_DEVICE_ID_SI_530:
  622. case PCI_DEVICE_ID_SI_540:
  623. case PCI_DEVICE_ID_SI_620:
  624. case PCI_DEVICE_ID_SI_630:
  625. case PCI_DEVICE_ID_SI_635:
  626. case PCI_DEVICE_ID_SI_640:
  627. case PCI_DEVICE_ID_SI_645:
  628. case PCI_DEVICE_ID_SI_650:
  629. case PCI_DEVICE_ID_SI_730:
  630. case PCI_DEVICE_ID_SI_735:
  631. case PCI_DEVICE_ID_SI_740:
  632. case PCI_DEVICE_ID_SI_745:
  633. case PCI_DEVICE_ID_SI_750:
  634. ata66 = (reg48h & mask) ? 0 : 1;
  635. default:
  636. break;
  637. }
  638. }
  639.         return (ata66);
  640. }
  642. void __init ide_init_sis5513 (ide_hwif_t *hwif)
  643. {
  645. hwif->irq = hwif->channel ? 15 : 14;
  647. hwif->tuneproc = &sis5513_tune_drive;
  648. hwif->speedproc = &sis5513_tune_chipset;
  650. if (!(hwif->dma_base))
  651. return;
  653. if (host_dev) {
  654. switch(host_dev->device) {
  655. #ifdef CONFIG_BLK_DEV_IDEDMA
  656. case PCI_DEVICE_ID_SI_530:
  657. case PCI_DEVICE_ID_SI_540:
  658. case PCI_DEVICE_ID_SI_620:
  659. case PCI_DEVICE_ID_SI_630:
  660. case PCI_DEVICE_ID_SI_635:
  661. case PCI_DEVICE_ID_SI_640:
  662. case PCI_DEVICE_ID_SI_645:
  663. case PCI_DEVICE_ID_SI_650:
  664. case PCI_DEVICE_ID_SI_730:
  665. case PCI_DEVICE_ID_SI_735:
  666. case PCI_DEVICE_ID_SI_740:
  667. case PCI_DEVICE_ID_SI_745:
  668. case PCI_DEVICE_ID_SI_750:
  669. case PCI_DEVICE_ID_SI_5600:
  670. case PCI_DEVICE_ID_SI_5597:
  671. case PCI_DEVICE_ID_SI_5591:
  672. if (!noautodma)
  673. hwif->autodma = 1;
  674. hwif->dmaproc = &sis5513_dmaproc;
  675. break;
  676. #endif /* CONFIG_BLK_DEV_IDEDMA */
  677. default:
  678. hwif->autodma = 0;
  679. break;
  680. }
  681. }
  682. return;
  683. }