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

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

Linux/Unix编程

开发平台：

Unix_Linux

sis5513.c：源码内容
  1. /*
  2.  * linux/drivers/ide/sis5513.c Version 0.13 March 6, 2002
  3.  *
  4.  * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org>
  5.  * Copyright (C) 2002 Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer
  6.  * May be copied or modified under the terms of the GNU General Public License
  7.  *
  8.  *
  9.  * Thanks :
  10.  *
  11.  * SiS Taiwan : for direct support and hardware.
  12.  * Daniela Engert : for initial ATA100 advices and numerous others.
  13.  * John Fremlin, Manfred Spraul :
  14.  *   for checking code correctness, providing patches.
  15.  *
  16.  *
  17.  * Original tests and design on the SiS620/5513 chipset.
  18.  * ATA100 tests and design on the SiS735/5513 chipset.
  19.  * ATA16/33 design from specs
  20.  */
  22. /*
  23.  * TODO:
  24.  * - Get ridden of SisHostChipInfo[] completness dependancy.
  25.  * - Get ATA-133 datasheets, implement ATA-133 init code.
  26.  * - Study drivers/ide/ide-timing.h.
  27.  * - Are there pre-ATA_16 SiS5513 chips ? -> tune init code for them
  28.  *   or remove ATA_00 define
  29.  * - More checks in the config registers (force values instead of
  30.  *   relying on the BIOS setting them correctly).
  31.  * - Further optimisations ?
  32.  *   . for example ATA66+ regs 0x48 & 0x4A
  33.  */
  35. #include <linux/config.h>
  36. #include <linux/types.h>
  37. #include <linux/kernel.h>
  38. #include <linux/delay.h>
  39. #include <linux/timer.h>
  40. #include <linux/mm.h>
  41. #include <linux/ioport.h>
  42. #include <linux/blkdev.h>
  43. #include <linux/hdreg.h>
  45. #include <linux/interrupt.h>
  46. #include <linux/pci.h>
  47. #include <linux/init.h>
  48. #include <linux/ide.h>
  50. #include <asm/io.h>
  51. #include <asm/irq.h>
  53. #include "ide_modes.h"
  55. /* When DEBUG is defined it outputs initial PCI config register
  56.    values and changes made to them by the driver */   
  57. // #define DEBUG
  58. /* When BROKEN_LEVEL is defined it limits the DMA mode
  59.    at boot time to its value */
  60. // #define BROKEN_LEVEL XFER_SW_DMA_0
  61. #define DISPLAY_SIS_TIMINGS
  63. /* Miscellaneaous flags */
  64. #define SIS5513_LATENCY 0x01
  66. /* registers layout and init values are chipset family dependant */
  67. /* 1/ define families */
  68. #define ATA_00 0x00
  69. #define ATA_16 0x01
  70. #define ATA_33 0x02
  71. #define ATA_66 0x03
  72. #define ATA_100a 0x04 // SiS730 is ATA100 with ATA66 layout
  73. #define ATA_100 0x05
  74. #define ATA_133 0x06
  75. /* 2/ variable holding the controller chipset family value */
  76. static unsigned char chipset_family;
  79. /*
  80.  * Debug code: following IDE config registers' changes
  81.  */
  82. #ifdef DEBUG
  83. /* Copy of IDE Config registers 0x00 -> 0x57
  84.    Fewer might be used depending on the actual chipset */
  85. static unsigned char ide_regs_copy[0x58];
  87. static byte sis5513_max_config_register(void) {
  88. switch(chipset_family) {
  89. case ATA_00:
  90. case ATA_16: return 0x4f;
  91. case ATA_33: return 0x52;
  92. case ATA_66:
  93. case ATA_100a:
  94. case ATA_100:
  95. case ATA_133:
  96. default: return 0x57;
  97. }
  98. }
  100. /* Read config registers, print differences from previous read */
  101. static void sis5513_load_verify_registers(struct pci_dev* dev, char* info) {
  102. int i;
  103. byte reg_val;
  104. byte changed=0;
  105. byte max = sis5513_max_config_register();
  107. printk("SIS5513: %s, changed registers:n", info);
  108. for(i=0; i<=max; i++) {
  109. pci_read_config_byte(dev, i, &reg_val);
  110. if (reg_val != ide_regs_copy[i]) {
  111. printk("%0#x: %0#x -> %0#xn",
  112.        i, ide_regs_copy[i], reg_val);
  113. ide_regs_copy[i]=reg_val;
  114. changed=1;
  115. }
  116. }
  118. if (!changed) {
  119. printk("nonen");
  120. }
  121. }
  123. /* Load config registers, no printing */
  124. static void sis5513_load_registers(struct pci_dev* dev) {
  125. int i;
  126. byte max = sis5513_max_config_register();
  128. for(i=0; i<=max; i++) {
  129. pci_read_config_byte(dev, i, &(ide_regs_copy[i]));
  130. }
  131. }
  133. /* Print a register */
  134. static void sis5513_print_register(int reg) {
  135. printk(" %0#x:%0#x", reg, ide_regs_copy[reg]);
  136. }
  138. /* Print valuable registers */
  139. static void sis5513_print_registers(struct pci_dev* dev, char* marker) {
  140. int i;
  141. byte max = sis5513_max_config_register();
  143. sis5513_load_registers(dev);
  144. printk("SIS5513 %sn", marker);
  145. printk("SIS5513 dump:");
  146. for(i=0x00; i<0x40; i++) {
  147. if ((i % 0x10)==0) printk("n             ");
  148. sis5513_print_register(i);
  149. }
  150. for(; i<49; i++) {
  151. sis5513_print_register(i);
  152. }
  153. printk("n             ");
  155. for(; i<=max; i++) {
  156. sis5513_print_register(i);
  157. }
  158. printk("n");
  159. }
  160. #endif
  163. /*
  164.  * Devices supported
  165.  */
  166. static const struct {
  167. const char *name;
  168. unsigned short host_id;
  169. unsigned char chipset_family;
  170. unsigned char flags;
  171. } SiSHostChipInfo[] = {
  172. // { "SiS750", PCI_DEVICE_ID_SI_750, ATA_100, SIS5513_LATENCY },
  173. // { "SiS745", PCI_DEVICE_ID_SI_745, ATA_100, SIS5513_LATENCY },
  174. { "SiS740", PCI_DEVICE_ID_SI_740, ATA_100, SIS5513_LATENCY },
  175. { "SiS735", PCI_DEVICE_ID_SI_735, ATA_100, SIS5513_LATENCY },
  176. { "SiS730", PCI_DEVICE_ID_SI_730, ATA_100a, SIS5513_LATENCY },
  177. // { "SiS650", PCI_DEVICE_ID_SI_650, ATA_100, SIS5513_LATENCY },
  178. // { "SiS645", PCI_DEVICE_ID_SI_645, ATA_100, SIS5513_LATENCY },
  179. { "SiS635", PCI_DEVICE_ID_SI_635, ATA_100, SIS5513_LATENCY },
  180. { "SiS640", PCI_DEVICE_ID_SI_640, ATA_66, SIS5513_LATENCY },
  181. { "SiS630", PCI_DEVICE_ID_SI_630, ATA_66, SIS5513_LATENCY },
  182. { "SiS620", PCI_DEVICE_ID_SI_620, ATA_66, SIS5513_LATENCY },
  183. { "SiS540", PCI_DEVICE_ID_SI_540, ATA_66, 0},
  184. { "SiS530", PCI_DEVICE_ID_SI_530, ATA_66, 0},
  185. { "SiS5600", PCI_DEVICE_ID_SI_5600, ATA_33, 0},
  186. { "SiS5598", PCI_DEVICE_ID_SI_5598, ATA_33, 0},
  187. { "SiS5597", PCI_DEVICE_ID_SI_5597, ATA_33, 0},
  188. { "SiS5591", PCI_DEVICE_ID_SI_5591, ATA_33, 0},
  189. { "SiS5513", PCI_DEVICE_ID_SI_5513, ATA_16, 0},
  190. { "SiS5511", PCI_DEVICE_ID_SI_5511, ATA_16, 0},
  191. };
  193. /* Cycle time bits and values vary accross chip dma capabilities
  194.    These three arrays hold the register layout and the values to set.
  195.    Indexed by chipset_family and (dma_mode - XFER_UDMA_0) */
  196. static byte cycle_time_offset[] = {0,0,5,4,4,0,0};
  197. static byte cycle_time_range[] = {0,0,2,3,3,4,4};
  198. static byte cycle_time_value[][XFER_UDMA_5 - XFER_UDMA_0 + 1] = {
  199. {0,0,0,0,0,0}, /* no udma */
  200. {0,0,0,0,0,0}, /* no udma */
  201. {3,2,1,0,0,0},
  202. {7,5,3,2,1,0},
  203. {7,5,3,2,1,0},
  204. {11,7,5,4,2,1},
  205. {0,0,0,0,0,0} /* not yet known, ask SiS */
  206. };
  208. static struct pci_dev *host_dev = NULL;
  211. /*
  212.  * Printing configuration
  213.  */
  214. #if defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS)
  215. #include <linux/stat.h>
  216. #include <linux/proc_fs.h>
  218. static int sis_get_info(char *, char **, off_t, int);
  219. extern int (*sis_display_info)(char *, char **, off_t, int); /* ide-proc.c */
  220. static struct pci_dev *bmide_dev;
  222. static char* cable_type[] = {
  223. "80 pins",
  224. "40 pins"
  225. };
  227. static char* recovery_time[] ={
  228. "12 PCICLK", "1 PCICLK",
  229. "2 PCICLK", "3 PCICLK",
  230. "4 PCICLK", "5 PCICLCK",
  231. "6 PCICLK", "7 PCICLCK",
  232. "8 PCICLK", "9 PCICLCK",
  233. "10 PCICLK", "11 PCICLK",
  234. "13 PCICLK", "14 PCICLK",
  235. "15 PCICLK", "15 PCICLK"
  236. };
  238. static char* active_time[] = {
  239. "8 PCICLK", "1 PCICLCK",
  240. "2 PCICLK", "3 PCICLK",
  241. "4 PCICLK", "5 PCICLK",
  242. "6 PCICLK", "12 PCICLK"
  243. };
  245. static char* cycle_time[] = {
  246. "Reserved", "2 CLK",
  247. "3 CLK", "4 CLK",
  248. "5 CLK", "6 CLK",
  249. "7 CLK", "8 CLK",
  250. "9 CLK", "10 CLK",
  251. "11 CLK", "12 CLK",
  252. "Reserved", "Reserved",
  253. "Reserved", "Reserved"
  254. };
  256. /* Generic add master or slave info function */
  257. static char* get_drives_info (char *buffer, byte pos)
  258. {
  259. byte reg00, reg01, reg10, reg11; /* timing registers */
  260. char* p = buffer;
  262. /* Postwrite/Prefetch */
  263. pci_read_config_byte(bmide_dev, 0x4b, &reg00);
  264. p += sprintf(p, "Drive %d:        Postwrite %s t t Postwrite %sn",
  265.      pos, (reg00 & (0x10 << pos)) ? "Enabled" : "Disabled",
  266.      (reg00 & (0x40 << pos)) ? "Enabled" : "Disabled");
  267. p += sprintf(p, "                Prefetch  %s t t Prefetch  %sn",
  268.      (reg00 & (0x01 << pos)) ? "Enabled" : "Disabled",
  269.      (reg00 & (0x04 << pos)) ? "Enabled" : "Disabled");
  271. pci_read_config_byte(bmide_dev, 0x40+2*pos, &reg00);
  272. pci_read_config_byte(bmide_dev, 0x41+2*pos, &reg01);
  273. pci_read_config_byte(bmide_dev, 0x44+2*pos, &reg10);
  274. pci_read_config_byte(bmide_dev, 0x45+2*pos, &reg11);
  276. /* UDMA */
  277. if (chipset_family >= ATA_33) {
  278. p += sprintf(p, "                UDMA %s t t t UDMA %sn",
  279.      (reg01 & 0x80)  ? "Enabled" : "Disabled",
  280.      (reg11 & 0x80) ? "Enabled" : "Disabled");
  282. p += sprintf(p, "                UDMA Cycle Time    ");
  283. switch(chipset_family) {
  284. case ATA_33: p += sprintf(p, cycle_time[(reg01 & 0x60) >> 5]); break;
  285. case ATA_66:
  286. case ATA_100a: p += sprintf(p, cycle_time[(reg01 & 0x70) >> 4]); break;
  287. case ATA_100: p += sprintf(p, cycle_time[reg01 & 0x0F]); break;
  288. case ATA_133:
  289. default: p += sprintf(p, "133+ ?"); break;
  290. }
  291. p += sprintf(p, " t UDMA Cycle Time    ");
  292. switch(chipset_family) {
  293. case ATA_33: p += sprintf(p, cycle_time[(reg11 & 0x60) >> 5]); break;
  294. case ATA_66:
  295. case ATA_100a: p += sprintf(p, cycle_time[(reg11 & 0x70) >> 4]); break;
  296. case ATA_100: p += sprintf(p, cycle_time[reg11 & 0x0F]); break;
  297. case ATA_133:
  298. default: p += sprintf(p, "133+ ?"); break;
  299. }
  300. p += sprintf(p, "n");
  301. }
  303. /* Data Active */
  304. p += sprintf(p, "                Data Active Time   ");
  305. switch(chipset_family) {
  306. case ATA_00:
  307. case ATA_16: /* confirmed */
  308. case ATA_33:
  309. case ATA_66:
  310. case ATA_100a: p += sprintf(p, active_time[reg01 & 0x07]); break;
  311. case ATA_100: p += sprintf(p, active_time[(reg00 & 0x70) >> 4]); break;
  312. case ATA_133:
  313. default: p += sprintf(p, "133+ ?"); break;
  314. }
  315. p += sprintf(p, " t Data Active Time   ");
  316. switch(chipset_family) {
  317. case ATA_00:
  318. case ATA_16:
  319. case ATA_33:
  320. case ATA_66:
  321. case ATA_100a: p += sprintf(p, active_time[reg11 & 0x07]); break;
  322. case ATA_100: p += sprintf(p, active_time[(reg10 & 0x70) >> 4]); break;
  323. case ATA_133:
  324. default: p += sprintf(p, "133+ ?"); break;
  325. }
  326. p += sprintf(p, "n");
  328. /* Data Recovery */
  329. /* warning: may need (reg&0x07) for pre ATA66 chips */
  330. p += sprintf(p, "                Data Recovery Time %s t Data Recovery Time %sn",
  331.      recovery_time[reg00 & 0x0f], recovery_time[reg10 & 0x0f]);
  333. return p;
  334. }
  336. static char* get_masters_info(char* buffer)
  337. {
  338. return get_drives_info(buffer, 0);
  339. }
  341. static char* get_slaves_info(char* buffer)
  342. {
  343. return get_drives_info(buffer, 1);
  344. }
  346. /* Main get_info, called on /proc/ide/sis reads */
  347. static int sis_get_info (char *buffer, char **addr, off_t offset, int count)
  348. {
  349. char *p = buffer;
  350. byte reg;
  351. u16 reg2, reg3;
  353. p += sprintf(p, "nSiS 5513 ");
  354. switch(chipset_family) {
  355. case ATA_00: p += sprintf(p, "Unknown???"); break;
  356. case ATA_16: p += sprintf(p, "DMA 16"); break;
  357. case ATA_33: p += sprintf(p, "Ultra 33"); break;
  358. case ATA_66: p += sprintf(p, "Ultra 66"); break;
  359. case ATA_100a:
  360. case ATA_100: p += sprintf(p, "Ultra 100"); break;
  361. case ATA_133:
  362. default: p+= sprintf(p, "Ultra 133+"); break;
  363. }
  364. p += sprintf(p, " chipsetn");
  365. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  367. /* Status */
  368. pci_read_config_byte(bmide_dev, 0x4a, &reg);
  369. p += sprintf(p, "Channel Status: ");
  370. if (chipset_family < ATA_66) {
  371. p += sprintf(p, "%s t t t t %sn",
  372.      (reg & 0x04) ? "On" : "Off",
  373.      (reg & 0x02) ? "On" : "Off");
  374. } else {
  375. p += sprintf(p, "%s t t t t %s n",
  376.      (reg & 0x02) ? "On" : "Off",
  377.      (reg & 0x04) ? "On" : "Off");
  378. }
  380. /* Operation Mode */
  381. pci_read_config_byte(bmide_dev, 0x09, &reg);
  382. p += sprintf(p, "Operation Mode: %s t t t %s n",
  383.      (reg & 0x01) ? "Native" : "Compatible",
  384.      (reg & 0x04) ? "Native" : "Compatible");
  386. /* 80-pin cable ? */
  387. if (chipset_family > ATA_33) {
  388. pci_read_config_byte(bmide_dev, 0x48, &reg);
  389. p += sprintf(p, "Cable Type:     %s t t t %sn",
  390.      (reg & 0x10) ? cable_type[1] : cable_type[0],
  391.      (reg & 0x20) ? cable_type[1] : cable_type[0]);
  392. }
  394. /* Prefetch Count */
  395. pci_read_config_word(bmide_dev, 0x4c, &reg2);
  396. pci_read_config_word(bmide_dev, 0x4e, &reg3);
  397. p += sprintf(p, "Prefetch Count: %d t t t t %dn",
  398.      reg2, reg3);
  400. p = get_masters_info(p);
  401. p = get_slaves_info(p);
  403. return p-buffer;
  404. }
  405. #endif /* defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS) */
  408. byte sis_proc = 0;
  409. extern char *ide_xfer_verbose (byte xfer_rate);
  412. /*
  413.  * Configuration functions
  414.  */
  415. /* Enables per-drive prefetch and postwrite */
  416. static void config_drive_art_rwp (ide_drive_t *drive)
  417. {
  418. ide_hwif_t *hwif = HWIF(drive);
  419. struct pci_dev *dev = hwif->pci_dev;
  421. byte reg4bh = 0;
  422. byte rw_prefetch = (0x11 << drive->dn);
  424. #ifdef DEBUG
  425. printk("SIS5513: config_drive_art_rwp, drive %dn", drive->dn);
  426. sis5513_load_verify_registers(dev, "config_drive_art_rwp start");
  427. #endif
  429. if (drive->media != ide_disk)
  430. return;
  431. pci_read_config_byte(dev, 0x4b, &reg4bh);
  433. if ((reg4bh & rw_prefetch) != rw_prefetch)
  434. pci_write_config_byte(dev, 0x4b, reg4bh|rw_prefetch);
  435. #ifdef DEBUG
  436. sis5513_load_verify_registers(dev, "config_drive_art_rwp end");
  437. #endif
  438. }
  441. /* Set per-drive active and recovery time */
  442. static void config_art_rwp_pio (ide_drive_t *drive, byte pio)
  443. {
  444. ide_hwif_t *hwif = HWIF(drive);
  445. struct pci_dev *dev = hwif->pci_dev;
  447. byte timing, drive_pci, test1, test2;
  449. unsigned short eide_pio_timing[6] = {600, 390, 240, 180, 120, 90};
  450. unsigned short xfer_pio = drive->id->eide_pio_modes;
  452. #ifdef DEBUG
  453. sis5513_load_verify_registers(dev, "config_drive_art_rwp_pio start");
  454. #endif
  456. config_drive_art_rwp(drive);
  457. pio = ide_get_best_pio_mode(drive, 255, pio, NULL);
  459. if (xfer_pio> 4)
  460. xfer_pio = 0;
  462. if (drive->id->eide_pio_iordy > 0) {
  463. for (xfer_pio = 5;
  464. (xfer_pio > 0) &&
  465. (drive->id->eide_pio_iordy > eide_pio_timing[xfer_pio]);
  466. xfer_pio--);
  467. } else {
  468. xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
  469.    (drive->id->eide_pio_modes & 2) ? 0x04 :
  470.    (drive->id->eide_pio_modes & 1) ? 0x03 : xfer_pio;
  471. }
  473. timing = (xfer_pio >= pio) ? xfer_pio : pio;
  475. #ifdef DEBUG
  476. printk("SIS5513: config_drive_art_rwp_pio, drive %d, pio %d, timing %dn",
  477.        drive->dn, pio, timing);
  478. #endif
  480. switch(drive->dn) {
  481. case 0: drive_pci = 0x40; break;
  482. case 1: drive_pci = 0x42; break;
  483. case 2: drive_pci = 0x44; break;
  484. case 3: drive_pci = 0x46; break;
  485. default: return;
  486. }
  488. /* register layout changed with newer ATA100 chips */
  489. if (chipset_family < ATA_100) {
  490. pci_read_config_byte(dev, drive_pci, &test1);
  491. pci_read_config_byte(dev, drive_pci+1, &test2);
  493. /* Clear active and recovery timings */
  494. test1 &= ~0x0F;
  495. test2 &= ~0x07;
  497. switch(timing) {
  498. case 4: test1 |= 0x01; test2 |= 0x03; break;
  499. case 3: test1 |= 0x03; test2 |= 0x03; break;
  500. case 2: test1 |= 0x04; test2 |= 0x04; break;
  501. case 1: test1 |= 0x07; test2 |= 0x06; break;
  502. default: break;
  503. }
  504. pci_write_config_byte(dev, drive_pci, test1);
  505. pci_write_config_byte(dev, drive_pci+1, test2);
  506. } else {
  507. switch(timing) { /*   active  recovery
  508.   v     v */
  509. case 4: test1 = 0x30|0x01; break;
  510. case 3: test1 = 0x30|0x03; break;
  511. case 2: test1 = 0x40|0x04; break;
  512. case 1: test1 = 0x60|0x07; break;
  513. default: break;
  514. }
  515. pci_write_config_byte(dev, drive_pci, test1);
  516. }
  518. #ifdef DEBUG
  519. sis5513_load_verify_registers(dev, "config_drive_art_rwp_pio start");
  520. #endif
  521. }
  523. static int config_chipset_for_pio (ide_drive_t *drive, byte pio)
  524. {
  525. byte speed;
  527. switch(pio) {
  528. case 4: speed = XFER_PIO_4; break;
  529. case 3: speed = XFER_PIO_3; break;
  530. case 2: speed = XFER_PIO_2; break;
  531. case 1: speed = XFER_PIO_1; break;
  532. default: speed = XFER_PIO_0; break;
  533. }
  535. config_art_rwp_pio(drive, pio);
  536. drive->current_speed = speed;
  537. return ide_config_drive_speed(drive, speed);
  538. }
  540. static int sis5513_tune_chipset (ide_drive_t *drive, byte speed)
  541. {
  542. ide_hwif_t *hwif = HWIF(drive);
  543. struct pci_dev *dev = hwif->pci_dev;
  545. byte drive_pci, reg;
  547. #ifdef DEBUG
  548. sis5513_load_verify_registers(dev, "sis5513_tune_chipset start");
  549. printk("SIS5513: sis5513_tune_chipset, drive %d, speed %dn",
  550.        drive->dn, speed);
  551. #endif
  552. switch(drive->dn) {
  553. case 0: drive_pci = 0x40; break;
  554. case 1: drive_pci = 0x42; break;
  555. case 2: drive_pci = 0x44; break;
  556. case 3: drive_pci = 0x46; break;
  557. default: return ide_dma_off;
  558. }
  560. #ifdef BROKEN_LEVEL
  561. #ifdef DEBUG
  562. printk("SIS5513: BROKEN_LEVEL activated, speed=%d -> speed=%dn", speed, BROKEN_LEVEL);
  563. #endif
  564. if (speed > BROKEN_LEVEL) speed = BROKEN_LEVEL;
  565. #endif
  567. pci_read_config_byte(dev, drive_pci+1, &reg);
  568. /* Disable UDMA bit for non UDMA modes on UDMA chips */
  569. if ((speed < XFER_UDMA_0) && (chipset_family > ATA_16)) {
  570. reg &= 0x7F;
  571. pci_write_config_byte(dev, drive_pci+1, reg);
  572. }
  574. /* Config chip for mode */
  575. switch(speed) {
  576. #ifdef CONFIG_BLK_DEV_IDEDMA
  577. case XFER_UDMA_5:
  578. case XFER_UDMA_4:
  579. case XFER_UDMA_3:
  580. case XFER_UDMA_2:
  581. case XFER_UDMA_1:
  582. case XFER_UDMA_0:
  583. /* Force the UDMA bit on if we want to use UDMA */
  584. reg |= 0x80;
  585. /* clean reg cycle time bits */
  586. reg &= ~((0xFF >> (8 - cycle_time_range[chipset_family]))
  587.  << cycle_time_offset[chipset_family]);
  588. /* set reg cycle time bits */
  589. reg |= cycle_time_value[chipset_family-ATA_00][speed-XFER_UDMA_0]
  590. << cycle_time_offset[chipset_family];
  591. pci_write_config_byte(dev, drive_pci+1, reg);
  592. break;
  593. case XFER_MW_DMA_2:
  594. case XFER_MW_DMA_1:
  595. case XFER_MW_DMA_0:
  596. case XFER_SW_DMA_2:
  597. case XFER_SW_DMA_1:
  598. case XFER_SW_DMA_0:
  599. break;
  600. #endif /* CONFIG_BLK_DEV_IDEDMA */
  601. case XFER_PIO_4: return((int) config_chipset_for_pio(drive, 4));
  602. case XFER_PIO_3: return((int) config_chipset_for_pio(drive, 3));
  603. case XFER_PIO_2: return((int) config_chipset_for_pio(drive, 2));
  604. case XFER_PIO_1: return((int) config_chipset_for_pio(drive, 1));
  605. case XFER_PIO_0:
  606. default:  return((int) config_chipset_for_pio(drive, 0));
  607. }
  608. drive->current_speed = speed;
  609. #ifdef DEBUG
  610. sis5513_load_verify_registers(dev, "sis5513_tune_chipset end");
  611. #endif
  612. return ((int) ide_config_drive_speed(drive, speed));
  613. }
  615. static void sis5513_tune_drive (ide_drive_t *drive, byte pio)
  616. {
  617. (void) config_chipset_for_pio(drive, pio);
  618. }
  620. #ifdef CONFIG_BLK_DEV_IDEDMA
  621. /*
  622.  * ((id->hw_config & 0x4000|0x2000) && (HWIF(drive)->udma_four))
  623.  */
  624. static int config_chipset_for_dma (ide_drive_t *drive, byte ultra)
  625. {
  626. struct hd_driveid *id = drive->id;
  627. ide_hwif_t *hwif = HWIF(drive);
  629. byte speed = 0;
  631. byte unit = (drive->select.b.unit & 0x01);
  632. byte udma_66 = eighty_ninty_three(drive);
  634. #ifdef DEBUG
  635. printk("SIS5513: config_chipset_for_dma, drive %d, ultra %dn",
  636.        drive->dn, ultra);
  637. #endif
  639. if ((id->dma_ultra & 0x0020) && ultra && udma_66 && (chipset_family >= ATA_100a))
  640. speed = XFER_UDMA_5;
  641. else if ((id->dma_ultra & 0x0010) && ultra && udma_66 && (chipset_family >= ATA_66))
  642. speed = XFER_UDMA_4;
  643. else if ((id->dma_ultra & 0x0008) && ultra && udma_66 && (chipset_family >= ATA_66))
  644. speed = XFER_UDMA_3;
  645. else if ((id->dma_ultra & 0x0004) && ultra && (chipset_family >= ATA_33))
  646. speed = XFER_UDMA_2;
  647. else if ((id->dma_ultra & 0x0002) && ultra && (chipset_family >= ATA_33))
  648. speed = XFER_UDMA_1;
  649. else if ((id->dma_ultra & 0x0001) && ultra && (chipset_family >= ATA_33))
  650. speed = XFER_UDMA_0;
  651. else if (id->dma_mword & 0x0004)
  652. speed = XFER_MW_DMA_2;
  653. else if (id->dma_mword & 0x0002)
  654. speed = XFER_MW_DMA_1;
  655. else if (id->dma_mword & 0x0001)
  656. speed = XFER_MW_DMA_0;
  657. else if (id->dma_1word & 0x0004)
  658. speed = XFER_SW_DMA_2;
  659. else if (id->dma_1word & 0x0002)
  660. speed = XFER_SW_DMA_1;
  661. else if (id->dma_1word & 0x0001)
  662. speed = XFER_SW_DMA_0;
  663. else
  664. return ((int) ide_dma_off_quietly);
  666. outb(inb(hwif->dma_base+2)|(1<<(5+unit)), hwif->dma_base+2);
  668. sis5513_tune_chipset(drive, speed);
  670. return ((int) ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  671. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  672. ((id->dma_mword >> 8) & 7) ? ide_dma_on :
  673. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  674.      ide_dma_off_quietly);
  675. }
  677. static int config_drive_xfer_rate (ide_drive_t *drive)
  678. {
  679. struct hd_driveid *id = drive->id;
  680. ide_dma_action_t dma_func = ide_dma_off_quietly;
  682. (void) config_chipset_for_pio(drive, 5);
  684. if (id && (id->capability & 1) && HWIF(drive)->autodma) {
  685. /* Consult the list of known "bad" drives */
  686. if (ide_dmaproc(ide_dma_bad_drive, drive)) {
  687. dma_func = ide_dma_off;
  688. goto fast_ata_pio;
  689. }
  690. dma_func = ide_dma_off_quietly;
  691. if (id->field_valid & 4) {
  692. if (id->dma_ultra & 0x003F) {
  693. /* Force if Capable UltraDMA */
  694. dma_func = config_chipset_for_dma(drive, 1);
  695. if ((id->field_valid & 2) &&
  696.     (dma_func != ide_dma_on))
  697. goto try_dma_modes;
  698. }
  699. } else if (id->field_valid & 2) {
  700. try_dma_modes:
  701. if ((id->dma_mword & 0x0007) ||
  702.     (id->dma_1word & 0x0007)) {
  703. /* Force if Capable regular DMA modes */
  704. dma_func = config_chipset_for_dma(drive, 0);
  705. if (dma_func != ide_dma_on)
  706. goto no_dma_set;
  707. }
  708. } else if ((ide_dmaproc(ide_dma_good_drive, drive)) &&
  709.    (id->eide_dma_time > 150)) {
  710. /* Consult the list of known "good" drives */
  711. dma_func = config_chipset_for_dma(drive, 0);
  712. if (dma_func != ide_dma_on)
  713. goto no_dma_set;
  714. } else {
  715. goto fast_ata_pio;
  716. }
  717. } else if ((id->capability & 8) || (id->field_valid & 2)) {
  718. fast_ata_pio:
  719. dma_func = ide_dma_off_quietly;
  720. no_dma_set:
  721. (void) config_chipset_for_pio(drive, 5);
  722. }
  724. return HWIF(drive)->dmaproc(dma_func, drive);
  725. }
  727. /* initiates/aborts (U)DMA read/write operations on a drive. */
  728. int sis5513_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  729. {
  730. switch (func) {
  731. case ide_dma_check:
  732. config_drive_art_rwp(drive);
  733. config_art_rwp_pio(drive, 5);
  734. return config_drive_xfer_rate(drive);
  735. default:
  736. break;
  737. }
  738. return ide_dmaproc(func, drive); /* use standard DMA stuff */
  739. }
  740. #endif /* CONFIG_BLK_DEV_IDEDMA */
  742. /* Chip detection and general config */
  743. unsigned int __init pci_init_sis5513 (struct pci_dev *dev, const char *name)
  744. {
  745. struct pci_dev *host;
  746. int i = 0;
  748. /* Find the chip */
  749. for (i = 0; i < ARRAY_SIZE(SiSHostChipInfo) && !host_dev; i++) {
  750. host = pci_find_device (PCI_VENDOR_ID_SI,
  751. SiSHostChipInfo[i].host_id,
  752. NULL);
  753. if (!host)
  754. continue;
  756. host_dev = host;
  757. chipset_family = SiSHostChipInfo[i].chipset_family;
  758. printk(SiSHostChipInfo[i].name);
  759. printk("n");
  761. #ifdef DEBUG
  762. sis5513_print_registers(dev, "pci_init_sis5513 start");
  763. #endif
  765. if (SiSHostChipInfo[i].flags & SIS5513_LATENCY) {
  766. byte latency = (chipset_family == ATA_100)? 0x80 : 0x10; /* Lacking specs */
  767. pci_write_config_byte(dev, PCI_LATENCY_TIMER, latency);
  768. }
  769. }
  771. /* Make general config ops here
  772.    1/ tell IDE channels to operate in Compabitility mode only
  773.    2/ tell old chips to allow per drive IDE timings */
  774. if (host_dev) {
  775. byte reg;
  776. switch(chipset_family) {
  777. case ATA_133:
  778. case ATA_100:
  779. /* Set compatibility bit */
  780. pci_read_config_byte(dev, 0x49, &reg);
  781. if (!(reg & 0x01)) {
  782. pci_write_config_byte(dev, 0x49, reg|0x01);
  783. }
  784. break;
  785. case ATA_100a:
  786. case ATA_66:
  787. /* On ATA_66 chips the bit was elsewhere */
  788. pci_read_config_byte(dev, 0x52, &reg);
  789. if (!(reg & 0x04)) {
  790. pci_write_config_byte(dev, 0x52, reg|0x04);
  791. }
  792. break;
  793. case ATA_33:
  794. /* On ATA_33 we didn't have a single bit to set */
  795. pci_read_config_byte(dev, 0x09, &reg);
  796. if ((reg & 0x0f) != 0x00) {
  797. pci_write_config_byte(dev, 0x09, reg&0xf0);
  798. }
  799. case ATA_16:
  800. /* force per drive recovery and active timings
  801.    needed on ATA_33 and below chips */
  802. pci_read_config_byte(dev, 0x52, &reg);
  803. if (!(reg & 0x08)) {
  804. pci_write_config_byte(dev, 0x52, reg|0x08);
  805. }
  806. break;
  807. case ATA_00:
  808. default: break;
  809. }
  811. #if defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS)
  812. if (!sis_proc) {
  813. sis_proc = 1;
  814. bmide_dev = dev;
  815. sis_display_info = &sis_get_info;
  816. }
  817. #endif
  818. }
  819. #ifdef DEBUG
  820. sis5513_load_verify_registers(dev, "pci_init_sis5513 end");
  821. #endif
  822. return 0;
  823. }
  825. unsigned int __init ata66_sis5513 (ide_hwif_t *hwif)
  826. {
  827. byte reg48h = 0, ata66 = 0;
  828. byte mask = hwif->channel ? 0x20 : 0x10;
  829. pci_read_config_byte(hwif->pci_dev, 0x48, &reg48h);
  831. if (chipset_family >= ATA_66) {
  832. ata66 = (reg48h & mask) ? 0 : 1;
  833. }
  834.         return ata66;
  835. }
  837. void __init ide_init_sis5513 (ide_hwif_t *hwif)
  838. {
  840. hwif->irq = hwif->channel ? 15 : 14;
  842. hwif->tuneproc = &sis5513_tune_drive;
  843. hwif->speedproc = &sis5513_tune_chipset;
  845. if (!(hwif->dma_base))
  846. return;
  848. if (host_dev) {
  849. #ifdef CONFIG_BLK_DEV_IDEDMA
  850. if (chipset_family > ATA_16) {
  851. hwif->autodma = noautodma ? 0 : 1;
  852. hwif->dmaproc = &sis5513_dmaproc;
  853. } else {
  854. #endif
  855. hwif->autodma = 0;
  856. #ifdef CONFIG_BLK_DEV_IDEDMA
  857. }
  858. #endif
  859. }
  860. return;
  861. }