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

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

Linux/Unix编程

开发平台：

Unix_Linux

cmd64x.c：源码内容
  1. /* $Id: cmd64x.c,v 1.21 2000/01/30 23:23:16
  2.  *
  3.  * linux/drivers/ide/cmd64x.c Version 1.22 June 9, 2000
  4.  *
  5.  * cmd64x.c: Enable interrupts at initialization time on Ultra/PCI machines.
  6.  *           Note, this driver is not used at all on other systems because
  7.  *           there the "BIOS" has done all of the following already.
  8.  *           Due to massive hardware bugs, UltraDMA is only supported
  9.  *           on the 646U2 and not on the 646U.
  10.  *
  11.  * Copyright (C) 1998       Eddie C. Dost  (ecd@skynet.be)
  12.  * Copyright (C) 1998       David S. Miller (davem@redhat.com)
  13.  * Copyright (C) 1999-2000  Andre Hedrick <andre@linux-ide.org>
  14.  */
  16. #include <linux/config.h>
  17. #include <linux/types.h>
  18. #include <linux/pci.h>
  19. #include <linux/delay.h>
  20. #include <linux/hdreg.h>
  21. #include <linux/ide.h>
  22. #include <linux/init.h>
  24. #include <asm/io.h>
  26. #include "ide_modes.h"
  28. #ifndef SPLIT_BYTE
  29. #define SPLIT_BYTE(B,H,L) ((H)=(B>>4), (L)=(B-((B>>4)<<4)))
  30. #endif
  32. #define CMD_DEBUG 0
  34. #if CMD_DEBUG
  35. #define cmdprintk(x...) printk(##x)
  36. #else
  37. #define cmdprintk(x...)
  38. #endif
  40. /*
  41.  * CMD64x specific registers definition.
  42.  */
  44. #define CFR 0x50
  45. #define   CFR_INTR_CH0 0x02
  46. #define CNTRL 0x51
  47. #define   CNTRL_DIS_RA0 0x40
  48. #define   CNTRL_DIS_RA1 0x80
  49. #define   CNTRL_ENA_2ND 0x08
  51. #define CMDTIM 0x52
  52. #define ARTTIM0 0x53
  53. #define DRWTIM0 0x54
  54. #define ARTTIM1  0x55
  55. #define DRWTIM1 0x56
  56. #define ARTTIM23 0x57
  57. #define   ARTTIM23_DIS_RA2 0x04
  58. #define   ARTTIM23_DIS_RA3 0x08
  59. #define   ARTTIM23_INTR_CH1 0x10
  60. #define ARTTIM2 0x57
  61. #define ARTTIM3 0x57
  62. #define DRWTIM23 0x58
  63. #define DRWTIM2 0x58
  64. #define BRST 0x59
  65. #define DRWTIM3 0x5b
  67. #define BMIDECR0 0x70
  68. #define MRDMODE 0x71
  69. #define   MRDMODE_INTR_CH0 0x04
  70. #define   MRDMODE_INTR_CH1 0x08
  71. #define   MRDMODE_BLK_CH0 0x10
  72. #define   MRDMODE_BLK_CH1 0x20
  73. #define BMIDESR0 0x72
  74. #define UDIDETCR0 0x73
  75. #define DTPR0 0x74
  76. #define BMIDECR1 0x78
  77. #define BMIDECSR 0x79
  78. #define BMIDESR1 0x7A
  79. #define UDIDETCR1 0x7B
  80. #define DTPR1 0x7C
  82. #define DISPLAY_CMD64X_TIMINGS
  84. #if defined(DISPLAY_CMD64X_TIMINGS) && defined(CONFIG_PROC_FS)
  85. #include <linux/stat.h>
  86. #include <linux/proc_fs.h>
  88. static int cmd64x_get_info(char *, char **, off_t, int);
  89. static int cmd680_get_info(char *, char **, off_t, int);
  90. extern int (*cmd64x_display_info)(char *, char **, off_t, int); /* ide-proc.c */
  91. extern char *ide_media_verbose(ide_drive_t *);
  92. static struct pci_dev *bmide_dev;
  94. static int cmd64x_get_info (char *buffer, char **addr, off_t offset, int count)
  95. {
  96. char *p = buffer;
  97. u8 reg53 = 0, reg54 = 0, reg55 = 0, reg56 = 0; /* primary */
  98. u8 reg57 = 0, reg58 = 0, reg5b; /* secondary */
  99. u8 reg72 = 0, reg73 = 0; /* primary */
  100. u8 reg7a = 0, reg7b = 0; /* secondary */
  101. u8 reg50 = 0, reg71 = 0; /* extra */
  102. u8 hi_byte = 0, lo_byte = 0;
  104. switch(bmide_dev->device) {
  105. case PCI_DEVICE_ID_CMD_649:
  106. p += sprintf(p, "n                                CMD649 Chipset.n");
  107. break;
  108. case PCI_DEVICE_ID_CMD_648:
  109. p += sprintf(p, "n                                CMD648 Chipset.n");
  110. break;
  111. case PCI_DEVICE_ID_CMD_646:
  112. p += sprintf(p, "n                                CMD646 Chipset.n");
  113. break;
  114. case PCI_DEVICE_ID_CMD_643:
  115. p += sprintf(p, "n                                CMD643 Chipset.n");
  116. break;
  117. default:
  118. p += sprintf(p, "n                                CMD64? Chipse.n");
  119. break;
  120. }
  121. (void) pci_read_config_byte(bmide_dev, CFR,       &reg50);
  122. (void) pci_read_config_byte(bmide_dev, ARTTIM0,   &reg53);
  123. (void) pci_read_config_byte(bmide_dev, DRWTIM0,   &reg54);
  124. (void) pci_read_config_byte(bmide_dev, ARTTIM1,   &reg55);
  125. (void) pci_read_config_byte(bmide_dev, DRWTIM1,   &reg56);
  126. (void) pci_read_config_byte(bmide_dev, ARTTIM2,   &reg57);
  127. (void) pci_read_config_byte(bmide_dev, DRWTIM2,   &reg58);
  128. (void) pci_read_config_byte(bmide_dev, DRWTIM3,   &reg5b);
  129. (void) pci_read_config_byte(bmide_dev, MRDMODE,   &reg71);
  130. (void) pci_read_config_byte(bmide_dev, BMIDESR0,  &reg72);
  131. (void) pci_read_config_byte(bmide_dev, UDIDETCR0, &reg73);
  132. (void) pci_read_config_byte(bmide_dev, BMIDESR1,  &reg7a);
  133. (void) pci_read_config_byte(bmide_dev, UDIDETCR1, &reg7b);
  135. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  136. p += sprintf(p, "                %sabled                         %sabledn",
  137. (reg72&0x80)?"dis":" en",(reg7a&0x80)?"dis":" en");
  138. p += sprintf(p, "--------------- drive0 --------- drive1 -------- drive0 ---------- drive1 ------n");
  139. p += sprintf(p, "DMA enabled:    %s              %s             %s               %sn",
  140. (reg72&0x20)?"yes":"no ",(reg72&0x40)?"yes":"no ",(reg7a&0x20)?"yes":"no ",(reg7a&0x40)?"yes":"no ");
  141. p += sprintf(p, "DMA Mode:       %s(%s)          %s(%s)         %s(%s)           %s(%s)n",
  142. (reg72&0x20)?((reg73&0x01)?"UDMA":" DMA"):" PIO",
  143. (reg72&0x20)?(  ((reg73&0x30)==0x30)?(((reg73&0x35)==0x35)?"3":"0"):
  144. ((reg73&0x20)==0x20)?(((reg73&0x25)==0x25)?"3":"1"):
  145. ((reg73&0x10)==0x10)?(((reg73&0x15)==0x15)?"4":"2"):
  146. ((reg73&0x00)==0x00)?(((reg73&0x05)==0x05)?"5":"2"):"X"):"?",
  147. (reg72&0x40)?((reg73&0x02)?"UDMA":" DMA"):" PIO",
  148. (reg72&0x40)?( ((reg73&0xC0)==0xC0)?(((reg73&0xC5)==0xC5)?"3":"0"):
  149. ((reg73&0x80)==0x80)?(((reg73&0x85)==0x85)?"3":"1"):
  150. ((reg73&0x40)==0x40)?(((reg73&0x4A)==0x4A)?"4":"2"):
  151. ((reg73&0x00)==0x00)?(((reg73&0x0A)==0x0A)?"5":"2"):"X"):"?",
  152. (reg7a&0x20)?((reg7b&0x01)?"UDMA":" DMA"):" PIO",
  153. (reg7a&0x20)?( ((reg7b&0x30)==0x30)?(((reg7b&0x35)==0x35)?"3":"0"):
  154. ((reg7b&0x20)==0x20)?(((reg7b&0x25)==0x25)?"3":"1"):
  155. ((reg7b&0x10)==0x10)?(((reg7b&0x15)==0x15)?"4":"2"):
  156. ((reg7b&0x00)==0x00)?(((reg7b&0x05)==0x05)?"5":"2"):"X"):"?",
  157. (reg7a&0x40)?((reg7b&0x02)?"UDMA":" DMA"):" PIO",
  158. (reg7a&0x40)?( ((reg7b&0xC0)==0xC0)?(((reg7b&0xC5)==0xC5)?"3":"0"):
  159. ((reg7b&0x80)==0x80)?(((reg7b&0x85)==0x85)?"3":"1"):
  160. ((reg7b&0x40)==0x40)?(((reg7b&0x4A)==0x4A)?"4":"2"):
  161. ((reg7b&0x00)==0x00)?(((reg7b&0x0A)==0x0A)?"5":"2"):"X"):"?" );
  162. p += sprintf(p, "PIO Mode:       %s                %s               %s                 %sn",
  163. "?", "?", "?", "?");
  164. p += sprintf(p, "                %s                     %sn",
  165. (reg50 & CFR_INTR_CH0) ? "interrupting" : "polling     ",
  166. (reg57 & ARTTIM23_INTR_CH1) ? "interrupting" : "polling");
  167. p += sprintf(p, "                %s                          %sn",
  168. (reg71 & MRDMODE_INTR_CH0) ? "pending" : "clear  ",
  169. (reg71 & MRDMODE_INTR_CH1) ? "pending" : "clear");
  170. p += sprintf(p, "                %s                          %sn",
  171. (reg71 & MRDMODE_BLK_CH0) ? "blocked" : "enabled",
  172. (reg71 & MRDMODE_BLK_CH1) ? "blocked" : "enabled");
  174. SPLIT_BYTE(reg50, hi_byte, lo_byte);
  175. p += sprintf(p, "CFR       = 0x%02x, HI = 0x%02x, LOW = 0x%02xn", reg50, hi_byte, lo_byte);
  176. SPLIT_BYTE(reg57, hi_byte, lo_byte);
  177. p += sprintf(p, "ARTTIM23  = 0x%02x, HI = 0x%02x, LOW = 0x%02xn", reg57, hi_byte, lo_byte);
  178. SPLIT_BYTE(reg71, hi_byte, lo_byte);
  179. p += sprintf(p, "MRDMODE   = 0x%02x, HI = 0x%02x, LOW = 0x%02xn", reg71, hi_byte, lo_byte);
  181. return p-buffer; /* => must be less than 4k! */
  182. }
  184. static int cmd680_get_info (char *buffer, char **addr, off_t offset, int count)
  185. {
  186. char *p = buffer;
  187. p += sprintf(p, "n                                CMD680 Chipset.n");
  188. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  189. p += sprintf(p, "--------------- drive0 --------- drive1 -------- drive0 ---------- drive1 ------n");
  190. p += sprintf(p, "PIO Mode:       %s                %s               %s                 %sn",
  191. "?", "?", "?", "?");
  192. return p-buffer; /* => must be less than 4k! */
  193. }
  195. #endif /* defined(DISPLAY_CMD64X_TIMINGS) && defined(CONFIG_PROC_FS) */
  197. byte cmd64x_proc = 0;
  198. byte cmd680_proc = 0;
  200. /*
  201.  * Registers and masks for easy access by drive index:
  202.  */
  203. #if 0
  204. static byte prefetch_regs[4]  = {CNTRL, CNTRL, ARTTIM23, ARTTIM23};
  205. static byte prefetch_masks[4] = {CNTRL_DIS_RA0, CNTRL_DIS_RA1, ARTTIM23_DIS_RA2, ARTTIM23_DIS_RA3};
  206. #endif
  208. /*
  209.  * This routine writes the prepared setup/active/recovery counts
  210.  * for a drive into the cmd646 chipset registers to active them.
  211.  */
  212. static void program_drive_counts (ide_drive_t *drive, int setup_count, int active_count, int recovery_count)
  213. {
  214. unsigned long flags;
  215. ide_drive_t *drives = HWIF(drive)->drives;
  216. byte temp_b;
  217. static const byte setup_counts[] = {0x40, 0x40, 0x40, 0x80, 0, 0xc0};
  218. static const byte recovery_counts[] =
  219. {15, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0};
  220. static const byte arttim_regs[2][2] = {
  221. { ARTTIM0, ARTTIM1 },
  222. { ARTTIM23, ARTTIM23 }
  223. };
  224. static const byte drwtim_regs[2][2] = {
  225. { DRWTIM0, DRWTIM1 },
  226. { DRWTIM2, DRWTIM3 }
  227. };
  228. int channel = (int) HWIF(drive)->channel;
  229. int slave = (drives != drive);  /* Is this really the best way to determine this?? */
  231. cmdprintk("program_drive_count parameters = s(%d),a(%d),r(%d),p(%d)n", setup_count,
  232. active_count, recovery_count, drive->present);
  233. /*
  234.  * Set up address setup count registers.
  235.  * Primary interface has individual count/timing registers for
  236.  * each drive.  Secondary interface has one common set of registers,
  237.  * for address setup so we merge these timings, using the slowest
  238.  * value.
  239.  */
  240. if (channel) {
  241. drive->drive_data = setup_count;
  242. setup_count = IDE_MAX(drives[0].drive_data, drives[1].drive_data);
  243. cmdprintk("Secondary interface, setup_count = %dn", setup_count);
  244. }
  246. /*
  247.  * Convert values to internal chipset representation
  248.  */
  249. setup_count = (setup_count > 5) ? 0xc0 : (int) setup_counts[setup_count];
  250. active_count &= 0xf; /* Remember, max value is 16 */
  251. recovery_count = (int) recovery_counts[recovery_count];
  253. cmdprintk("Final values = %d,%d,%dn", setup_count, active_count, recovery_count);
  255. /*
  256.  * Now that everything is ready, program the new timings
  257.  */
  258. __save_flags (flags);
  259. __cli();
  260. /*
  261.  * Program the address_setup clocks into ARTTIM reg,
  262.  * and then the active/recovery counts into the DRWTIM reg
  263.  */
  264. (void) pci_read_config_byte(HWIF(drive)->pci_dev, arttim_regs[channel][slave], &temp_b);
  265. (void) pci_write_config_byte(HWIF(drive)->pci_dev, arttim_regs[channel][slave],
  266. ((byte) setup_count) | (temp_b & 0x3f));
  267. (void) pci_write_config_byte(HWIF(drive)->pci_dev, drwtim_regs[channel][slave],
  268. (byte) ((active_count << 4) | recovery_count));
  269. cmdprintk ("Write %x to %xn", ((byte) setup_count) | (temp_b & 0x3f), arttim_regs[channel][slave]);
  270. cmdprintk ("Write %x to %xn", (byte) ((active_count << 4) | recovery_count), drwtim_regs[channel][slave]);
  271. __restore_flags(flags);
  272. }
  274. /*
  275.  * Attempts to set the interface PIO mode.
  276.  * The preferred method of selecting PIO modes (e.g. mode 4) is 
  277.  * "echo 'piomode:4' > /proc/ide/hdx/settings".  Special cases are
  278.  * 8: prefetch off, 9: prefetch on, 255: auto-select best mode.
  279.  * Called with 255 at boot time.
  280.  */
  281. static void cmd64x_tuneproc (ide_drive_t *drive, byte mode_wanted)
  282. {
  283. int setup_time, active_time, recovery_time, clock_time, pio_mode, cycle_time;
  284. byte recovery_count2, cycle_count;
  285. int setup_count, active_count, recovery_count;
  286. int bus_speed = system_bus_clock();
  287. /*byte b;*/
  288. ide_pio_data_t  d;
  290. switch (mode_wanted) {
  291. case 8: /* set prefetch off */
  292. case 9: /* set prefetch on */
  293. mode_wanted &= 1;
  294. /*set_prefetch_mode(index, mode_wanted);*/
  295. cmdprintk("%s: %sabled cmd640 prefetchn", drive->name, mode_wanted ? "en" : "dis");
  296. return;
  297. }
  299. mode_wanted = ide_get_best_pio_mode (drive, mode_wanted, 5, &d);
  300. pio_mode = d.pio_mode;
  301. cycle_time = d.cycle_time;
  303. /*
  304.  * I copied all this complicated stuff from cmd640.c and made a few minor changes.
  305.  * For now I am just going to pray that it is correct.
  306.  */
  307. if (pio_mode > 5)
  308. pio_mode = 5;
  309. setup_time  = ide_pio_timings[pio_mode].setup_time;
  310. active_time = ide_pio_timings[pio_mode].active_time;
  311. recovery_time = cycle_time - (setup_time + active_time);
  312. clock_time = 1000 / bus_speed;
  313. cycle_count = (cycle_time + clock_time - 1) / clock_time;
  315. setup_count = (setup_time + clock_time - 1) / clock_time;
  317. active_count = (active_time + clock_time - 1) / clock_time;
  319. recovery_count = (recovery_time + clock_time - 1) / clock_time;
  320. recovery_count2 = cycle_count - (setup_count + active_count);
  321. if (recovery_count2 > recovery_count)
  322. recovery_count = recovery_count2;
  323. if (recovery_count > 16) {
  324. active_count += recovery_count - 16;
  325. recovery_count = 16;
  326. }
  327. if (active_count > 16)
  328. active_count = 16; /* maximum allowed by cmd646 */
  330. /*
  331.  * In a perfect world, we might set the drive pio mode here
  332.  * (using WIN_SETFEATURE) before continuing.
  333.  *
  334.  * But we do not, because:
  335.  * 1) this is the wrong place to do it (proper is do_special() in ide.c)
  336.  *  2) in practice this is rarely, if ever, necessary
  337.  */
  338. program_drive_counts (drive, setup_count, active_count, recovery_count);
  340. cmdprintk("%s: selected cmd646 PIO mode%d : %d (%dns)%s, clocks=%d/%d/%dn",
  341. drive->name, pio_mode, mode_wanted, cycle_time,
  342. d.overridden ? " (overriding vendor mode)" : "",
  343. setup_count, active_count, recovery_count);
  344. }
  346. static byte cmd680_taskfile_timing (ide_hwif_t *hwif)
  347. {
  348. struct pci_dev *dev = hwif->pci_dev;
  349. byte addr_mask = (hwif->channel) ? 0xB2 : 0xA2;
  350. unsigned short timing;
  352. pci_read_config_word(dev, addr_mask, &timing);
  354. switch (timing) {
  355. case 0x10c1: return 4;
  356. case 0x10c3: return 3;
  357. case 0x1281: return 2;
  358. case 0x2283: return 1;
  359. case 0x328a:
  360. default: return 0;
  361. }
  362. }
  364. static void cmd680_tuneproc (ide_drive_t *drive, byte mode_wanted)
  365. {
  366. ide_hwif_t *hwif = HWIF(drive);
  367. struct pci_dev *dev = hwif->pci_dev;
  368. byte drive_pci;
  369. unsigned short speedt;
  371. switch (drive->dn) {
  372. case 0: drive_pci = 0xA4; break;
  373. case 1: drive_pci = 0xA6; break;
  374. case 2: drive_pci = 0xB4; break;
  375. case 3: drive_pci = 0xB6; break;
  376. default: return;
  377.         }
  379. pci_read_config_word(dev, drive_pci, &speedt);
  381. /* cheat for now and use the docs */
  382. // switch(cmd680_taskfile_timing(hwif)) {
  383. switch(mode_wanted) {
  384. case 4: speedt = 0x10c1; break;
  385. case 3: speedt = 0x10C3; break;
  386. case 2: speedt = 0x1104; break;
  387. case 1: speedt = 0x2283; break;
  388. case 0:
  389. default: speedt = 0x328A; break;
  390. }
  391. pci_write_config_word(dev, drive_pci, speedt);
  392. }
  394. static void config_cmd64x_chipset_for_pio (ide_drive_t *drive, byte set_speed)
  395. {
  396. byte speed = 0x00;
  397. byte set_pio = ide_get_best_pio_mode(drive, 4, 5, NULL);
  399. cmd64x_tuneproc(drive, set_pio);
  400. speed = XFER_PIO_0 + set_pio;
  401. if (set_speed)
  402. (void) ide_config_drive_speed(drive, speed);
  403. }
  405. static void config_cmd680_chipset_for_pio (ide_drive_t *drive, byte set_speed)
  406. {
  407. ide_hwif_t *hwif = HWIF(drive);
  408. struct pci_dev *dev = hwif->pci_dev;
  409. u8 unit = (drive->select.b.unit & 0x01);
  410. u8 addr_mask = (hwif->channel) ? 0x84 : 0x80;
  411. u8 speed = 0x00;
  412. u8 mode_pci = 0x00;
  413. u8 channel_timings = cmd680_taskfile_timing(hwif);
  414. u8 set_pio = ide_get_best_pio_mode(drive, 4, 5, NULL);
  416. pci_read_config_byte(dev, addr_mask, &mode_pci);
  417. mode_pci &= ~((unit) ? 0x30 : 0x03);
  419. /* WARNING PIO timing mess is going to happen b/w devices, argh */
  420. if ((channel_timings != set_pio) && (set_pio > channel_timings))
  421. set_pio = channel_timings;
  423. cmd680_tuneproc(drive, set_pio);
  424. speed = XFER_PIO_0 + set_pio;
  425. if (set_speed) {
  426. (void) ide_config_drive_speed(drive, speed);
  427. drive->current_speed = speed;
  428. }
  429. }
  431. static void config_chipset_for_pio (ide_drive_t *drive, byte set_speed)
  432. {
  433.         if (HWIF(drive)->pci_dev->device == PCI_DEVICE_ID_CMD_680) {
  434. config_cmd680_chipset_for_pio(drive, set_speed);
  435. } else {
  436. config_cmd64x_chipset_for_pio(drive, set_speed);
  437. }
  438. }
  440. static int cmd64x_tune_chipset (ide_drive_t *drive, byte speed)
  441. {
  442. #ifdef CONFIG_BLK_DEV_IDEDMA
  443. ide_hwif_t *hwif = HWIF(drive);
  444. struct pci_dev *dev = hwif->pci_dev;
  445. int err = 0;
  447. u8 unit = (drive->select.b.unit & 0x01);
  448. u8 pciU = (hwif->channel) ? UDIDETCR1 : UDIDETCR0;
  449. u8 pciD = (hwif->channel) ? BMIDESR1 : BMIDESR0;
  450. u8 regU = 0;
  451. u8 regD = 0;
  453. if ((drive->media != ide_disk) && (speed < XFER_SW_DMA_0)) return 1;
  455. (void) pci_read_config_byte(dev, pciD, &regD);
  456. (void) pci_read_config_byte(dev, pciU, &regU);
  457. regD &= ~(unit ? 0x40 : 0x20);
  458. regU &= ~(unit ? 0xCA : 0x35);
  459. (void) pci_write_config_byte(dev, pciD, regD);
  460. (void) pci_write_config_byte(dev, pciU, regU);
  462. (void) pci_read_config_byte(dev, pciD, &regD);
  463. (void) pci_read_config_byte(dev, pciU, &regU);
  464. switch(speed) {
  465. case XFER_UDMA_5: regU |= (unit ? 0x0A : 0x05); break;
  466. case XFER_UDMA_4: regU |= (unit ? 0x4A : 0x15); break;
  467. case XFER_UDMA_3: regU |= (unit ? 0x8A : 0x25); break;
  468. case XFER_UDMA_2: regU |= (unit ? 0x42 : 0x11); break;
  469. case XFER_UDMA_1: regU |= (unit ? 0x82 : 0x21); break;
  470. case XFER_UDMA_0: regU |= (unit ? 0xC2 : 0x31); break;
  471. case XFER_MW_DMA_2: regD |= (unit ? 0x40 : 0x10); break;
  472. case XFER_MW_DMA_1: regD |= (unit ? 0x80 : 0x20); break;
  473. case XFER_MW_DMA_0: regD |= (unit ? 0xC0 : 0x30); break;
  474. case XFER_SW_DMA_2: regD |= (unit ? 0x40 : 0x10); break;
  475. case XFER_SW_DMA_1: regD |= (unit ? 0x80 : 0x20); break;
  476. case XFER_SW_DMA_0: regD |= (unit ? 0xC0 : 0x30); break;
  477. #else
  478. int err = 0;
  480. switch(speed) {
  481. #endif /* CONFIG_BLK_DEV_IDEDMA */
  482. case XFER_PIO_4: cmd64x_tuneproc(drive, 4); break;
  483. case XFER_PIO_3: cmd64x_tuneproc(drive, 3); break;
  484. case XFER_PIO_2: cmd64x_tuneproc(drive, 2); break;
  485. case XFER_PIO_1: cmd64x_tuneproc(drive, 1); break;
  486. case XFER_PIO_0: cmd64x_tuneproc(drive, 0); break;
  488. default:
  489. return 1;
  490. }
  492. #ifdef CONFIG_BLK_DEV_IDEDMA
  493. (void) pci_write_config_byte(dev, pciU, regU);
  494. #endif /* CONFIG_BLK_DEV_IDEDMA */
  496. err = ide_config_drive_speed(drive, speed);
  498. drive->current_speed = speed;
  500. #ifdef CONFIG_BLK_DEV_IDEDMA
  501. regD |= (unit ? 0x40 : 0x20);
  502. (void) pci_write_config_byte(dev, pciD, regD);
  503. #endif /* CONFIG_BLK_DEV_IDEDMA */
  505. return err;
  506. }
  508. static int cmd680_tune_chipset (ide_drive_t *drive, byte speed)
  509. {
  510. ide_hwif_t *hwif = HWIF(drive);
  511. struct pci_dev *dev = hwif->pci_dev;
  512. u8 addr_mask = (hwif->channel) ? 0x84 : 0x80;
  513. u8 unit = (drive->select.b.unit & 0x01);
  514. u8 dma_pci = 0;
  515. u8 udma_pci = 0;
  516. u8 mode_pci = 0;
  517. u8 scsc = 0;
  518. u16 ultra = 0;
  519. u16 multi = 0;
  520. int err = 0;
  522.         pci_read_config_byte(dev, addr_mask, &mode_pci);
  523. pci_read_config_byte(dev, 0x8A, &scsc);
  525.         switch (drive->dn) {
  526. case 0: dma_pci = 0xA8; udma_pci = 0xAC; break;
  527. case 1: dma_pci = 0xAA; udma_pci = 0xAE; break;
  528. case 2: dma_pci = 0xB8; udma_pci = 0xBC; break;
  529. case 3: dma_pci = 0xBA; udma_pci = 0xBE; break;
  530. default: return 1;
  531. }
  533. pci_read_config_byte(dev, addr_mask, &mode_pci);
  534. mode_pci &= ~((unit) ? 0x30 : 0x03);
  535. pci_read_config_word(dev, dma_pci, &multi);
  536. pci_read_config_word(dev, udma_pci, &ultra);
  538. if ((speed == XFER_UDMA_6) && (scsc & 0x30) == 0x00) {
  539. pci_write_config_byte(dev, 0x8A, scsc|0x01);
  540. pci_read_config_byte(dev, 0x8A, &scsc);
  541. }
  543. switch(speed) {
  544. #ifdef CONFIG_BLK_DEV_IDEDMA
  545. case XFER_UDMA_6:
  546. if ((scsc & 0x30) == 0x00)
  547. goto speed_break;
  548. multi = 0x10C1;
  549. ultra &= ~0x3F;
  550. ultra |= 0x01;
  551. break;
  552. speed_break :
  553. speed = XFER_UDMA_5;
  554. case XFER_UDMA_5:
  555. multi = 0x10C1;
  556. ultra &= ~0x3F;
  557. ultra |= (((scsc & 0x30) == 0x00) ? 0x01 : 0x02);
  558. break;
  559. case XFER_UDMA_4:
  560. multi = 0x10C1;
  561. ultra &= ~0x3F;
  562. ultra |= (((scsc & 0x30) == 0x00) ? 0x02 : 0x03);
  563. break;
  564. case XFER_UDMA_3:
  565. multi = 0x10C1;
  566. ultra &= ~0x3F;
  567. ultra |= (((scsc & 0x30) == 0x00) ? 0x04 : 0x05);
  568. break;
  569. case XFER_UDMA_2:
  570. multi = 0x10C1;
  571. ultra &= ~0x3F;
  572. ultra |= (((scsc & 0x30) == 0x00) ? 0x05 : 0x07);
  573. break;
  574. case XFER_UDMA_1:
  575. multi = 0x10C1;
  576. ultra &= ~0x3F;
  577. ultra |= (((scsc & 0x30) == 0x00) ? 0x07 : 0x0B);
  578. break;
  579. case XFER_UDMA_0:
  580. multi = 0x10C1;
  581. ultra &= ~0x3F;
  582. ultra |= (((scsc & 0x30) == 0x00) ? 0x0C : 0x0F);
  583. break;
  584. case XFER_MW_DMA_2:
  585. multi = 0x10C1;
  586. break;
  587. case XFER_MW_DMA_1:
  588. multi = 0x10C2;
  589. break;
  590. case XFER_MW_DMA_0:
  591. multi = 0x2208;
  592. break;
  593. #endif /* CONFIG_BLK_DEV_IDEDMA */
  594. case XFER_PIO_4: cmd680_tuneproc(drive, 4); break;
  595. case XFER_PIO_3: cmd680_tuneproc(drive, 3); break;
  596. case XFER_PIO_2: cmd680_tuneproc(drive, 2); break;
  597. case XFER_PIO_1: cmd680_tuneproc(drive, 1); break;
  598. case XFER_PIO_0: cmd680_tuneproc(drive, 0); break;
  599. default:
  600. return 1;
  601. }
  604. if (speed >= XFER_MW_DMA_0) 
  605. config_cmd680_chipset_for_pio(drive, 0);
  607. if (speed >= XFER_UDMA_0)
  608. mode_pci |= ((unit) ? 0x30 : 0x03);
  609. else if (speed >= XFER_MW_DMA_0)
  610. mode_pci |= ((unit) ? 0x20 : 0x02);
  611. else
  612. mode_pci |= ((unit) ? 0x10 : 0x01);
  614. pci_write_config_byte(dev, addr_mask, mode_pci);
  615. pci_write_config_word(dev, dma_pci, multi);
  616. pci_write_config_word(dev, udma_pci, ultra);
  618. err = ide_config_drive_speed(drive, speed);
  619. drive->current_speed = speed;
  620. return err;
  621. }
  623. #ifdef CONFIG_BLK_DEV_IDEDMA
  624. static int config_cmd64x_chipset_for_dma (ide_drive_t *drive, unsigned int rev, byte ultra_66)
  625. {
  626. struct hd_driveid *id = drive->id;
  627. ide_hwif_t *hwif = HWIF(drive);
  628. struct pci_dev *dev = hwif->pci_dev;
  630. byte speed = 0x00;
  631. byte set_pio = 0x00;
  632. byte udma_33 = ((rev >= 0x05) || (ultra_66)) ? 1 : 0;
  633. byte udma_66 = eighty_ninty_three(drive);
  634. byte udma_100 = 0;
  635. int rval;
  637. switch(dev->device) {
  638. case PCI_DEVICE_ID_CMD_649: udma_100 = 1; break;
  639. case PCI_DEVICE_ID_CMD_648:
  640. case PCI_DEVICE_ID_CMD_646:
  641. case PCI_DEVICE_ID_CMD_643:
  642. default:
  643. break;
  644. }
  646. if (drive->media != ide_disk) {
  647. cmdprintk("CMD64X: drive->media != ide_disk at double check, inital check failed!!n");
  648. return ((int) ide_dma_off);
  649. }
  651. /* UltraDMA only supported on PCI646U and PCI646U2,
  652.  * which correspond to revisions 0x03, 0x05 and 0x07 respectively.
  653.  * Actually, although the CMD tech support people won't
  654.  * tell me the details, the 0x03 revision cannot support
  655.  * UDMA correctly without hardware modifications, and even
  656.  * then it only works with Quantum disks due to some
  657.  * hold time assumptions in the 646U part which are fixed
  658.  * in the 646U2.
  659.  * So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
  660.  */
  661. if ((id->dma_ultra & 0x0020) && (udma_100) && (udma_66) && (udma_33)) {
  662. speed = XFER_UDMA_5;
  663. } else if ((id->dma_ultra & 0x0010) && (udma_66) && (udma_33)) {
  664. speed = XFER_UDMA_4;
  665. } else if ((id->dma_ultra & 0x0008) && (udma_66) && (udma_33)) {
  666. speed = XFER_UDMA_3;
  667. } else if ((id->dma_ultra & 0x0004) && (udma_33)) {
  668. speed = XFER_UDMA_2;
  669. } else if ((id->dma_ultra & 0x0002) && (udma_33)) {
  670. speed = XFER_UDMA_1;
  671. } else if ((id->dma_ultra & 0x0001) && (udma_33)) {
  672. speed = XFER_UDMA_0;
  673. } else if (id->dma_mword & 0x0004) {
  674. speed = XFER_MW_DMA_2;
  675. } else if (id->dma_mword & 0x0002) {
  676. speed = XFER_MW_DMA_1;
  677. } else if (id->dma_mword & 0x0001) {
  678. speed = XFER_MW_DMA_0;
  679. } else if (id->dma_1word & 0x0004) {
  680. speed = XFER_SW_DMA_2;
  681. } else if (id->dma_1word & 0x0002) {
  682. speed = XFER_SW_DMA_1;
  683. } else if (id->dma_1word & 0x0001) {
  684. speed = XFER_SW_DMA_0;
  685. } else {
  686. set_pio = 1;
  687. }
  689. if (!drive->init_speed)
  690. drive->init_speed = speed;
  692. config_chipset_for_pio(drive, set_pio);
  694. if (set_pio)
  695. return ((int) ide_dma_off_quietly);
  697. if (cmd64x_tune_chipset(drive, speed))
  698. return ((int) ide_dma_off);
  700. rval = (int)( ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  701. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  702. ((id->dma_mword >> 8) & 7) ? ide_dma_on :
  703. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  704.      ide_dma_off_quietly);
  706. return rval;
  707. }
  709. static int config_cmd680_chipset_for_dma (ide_drive_t *drive)
  710. {
  711. struct hd_driveid *id = drive->id;
  712. byte udma_66 = eighty_ninty_three(drive);
  713. byte speed = 0x00;
  714. byte set_pio = 0x00;
  715. int rval;
  717. if ((id->dma_ultra & 0x0040) && (udma_66)) speed = XFER_UDMA_6;
  718. else if ((id->dma_ultra & 0x0020) && (udma_66)) speed = XFER_UDMA_5;
  719. else if ((id->dma_ultra & 0x0010) && (udma_66)) speed = XFER_UDMA_4;
  720. else if ((id->dma_ultra & 0x0008) && (udma_66)) speed = XFER_UDMA_3;
  721. else if (id->dma_ultra & 0x0004) speed = XFER_UDMA_2;
  722. else if (id->dma_ultra & 0x0002) speed = XFER_UDMA_1;
  723. else if (id->dma_ultra & 0x0001) speed = XFER_UDMA_0;
  724. else if (id->dma_mword & 0x0004) speed = XFER_MW_DMA_2;
  725. else if (id->dma_mword & 0x0002) speed = XFER_MW_DMA_1;
  726. else if (id->dma_mword & 0x0001) speed = XFER_MW_DMA_0;
  727. else {
  728. set_pio = 1;
  729. }
  731. if (!drive->init_speed)
  732. drive->init_speed = speed;
  734. config_chipset_for_pio(drive, set_pio);
  736. if (set_pio)
  737. return ((int) ide_dma_off_quietly);
  739. if (cmd680_tune_chipset(drive, speed))
  740. return ((int) ide_dma_off);
  742. rval = (int)( ((id->dma_ultra >> 14) & 3) ? ide_dma_on :
  743. ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  744. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  745. ((id->dma_mword >> 8) & 7) ? ide_dma_on :
  746. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  747.      ide_dma_off_quietly);
  748. return rval;
  749. }
  751. static int config_chipset_for_dma (ide_drive_t *drive, unsigned int rev, byte ultra_66)
  752. {
  753. if (HWIF(drive)->pci_dev->device == PCI_DEVICE_ID_CMD_680)
  754. return (config_cmd680_chipset_for_dma(drive));
  755. return (config_cmd64x_chipset_for_dma(drive, rev, ultra_66));
  756. }
  758. static int cmd64x_config_drive_for_dma (ide_drive_t *drive)
  759. {
  760. struct hd_driveid *id = drive->id;
  761. ide_hwif_t *hwif = HWIF(drive);
  762. struct pci_dev *dev = hwif->pci_dev;
  763. unsigned int class_rev = 0;
  764. byte can_ultra_33 = 0;
  765. byte can_ultra_66 = 0;
  766. byte can_ultra_100 = 0;
  767. byte can_ultra_133 = 0;
  768. ide_dma_action_t dma_func = ide_dma_on;
  770. pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
  771. class_rev &= 0xff;
  773. switch(dev->device) {
  774. case PCI_DEVICE_ID_CMD_680:
  775. can_ultra_133 = 1;
  776. case PCI_DEVICE_ID_CMD_649:
  777. can_ultra_100 = 1;
  778. case PCI_DEVICE_ID_CMD_648:
  779. can_ultra_66  = 1;
  780. case PCI_DEVICE_ID_CMD_643:
  781. can_ultra_33  = 1;
  782. break;
  783. case PCI_DEVICE_ID_CMD_646:
  784. can_ultra_33  = (class_rev >= 0x05) ? 1 : 0;
  785. can_ultra_66  = 0;
  786. can_ultra_100 = 0;
  787. break;
  788. default:
  789. return hwif->dmaproc(ide_dma_off, drive);
  790. }
  792. if ((id != NULL) && ((id->capability & 1) != 0) &&
  793.     hwif->autodma && (drive->media == ide_disk)) {
  794. /* Consult the list of known "bad" drives */
  795. if (ide_dmaproc(ide_dma_bad_drive, drive)) {
  796. dma_func = ide_dma_off;
  797. goto fast_ata_pio;
  798. }
  799. dma_func = ide_dma_off_quietly;
  800. if ((id->field_valid & 4) && (can_ultra_33)) {
  801. if (id->dma_ultra & 0x007F) {
  802. /* Force if Capable UltraDMA */
  803. dma_func = config_chipset_for_dma(drive, class_rev, can_ultra_66);
  804. if ((id->field_valid & 2) &&
  805.     (dma_func != ide_dma_on))
  806. goto try_dma_modes;
  807. }
  808. } else if (id->field_valid & 2) {
  809. try_dma_modes:
  810. if ((id->dma_mword & 0x0007) ||
  811.     (id->dma_1word & 0x0007)) {
  812. /* Force if Capable regular DMA modes */
  813. dma_func = config_chipset_for_dma(drive, class_rev, 0);
  814. if (dma_func != ide_dma_on)
  815. goto no_dma_set;
  816. }
  817. } else if (ide_dmaproc(ide_dma_good_drive, drive)) {
  818. if (id->eide_dma_time > 150) {
  819. goto no_dma_set;
  820. }
  821. /* Consult the list of known "good" drives */
  822. dma_func = config_chipset_for_dma(drive, class_rev, 0);
  823. if (dma_func != ide_dma_on)
  824. goto no_dma_set;
  825. } else {
  826. goto fast_ata_pio;
  827. }
  828. } else if ((id->capability & 8) || (id->field_valid & 2)) {
  829. fast_ata_pio:
  830. dma_func = ide_dma_off_quietly;
  831. no_dma_set:
  832. config_chipset_for_pio(drive, 1);
  833. }
  834. return HWIF(drive)->dmaproc(dma_func, drive);
  835. }
  837. static int cmd680_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  838. {
  839. switch (func) {
  840. case ide_dma_check:
  841. return cmd64x_config_drive_for_dma(drive);
  842. default:
  843. break;
  844. }
  845. /* Other cases are done by generic IDE-DMA code. */
  846.         return ide_dmaproc(func, drive);
  847. }
  849. static int cmd64x_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  850. {
  851. byte dma_stat = 0;
  852. byte dma_alt_stat = 0;
  853. byte mask = (HWIF(drive)->channel) ? MRDMODE_INTR_CH1 : MRDMODE_INTR_CH0;
  854. unsigned long dma_base = HWIF(drive)->dma_base;
  855. struct pci_dev *dev = HWIF(drive)->pci_dev;
  856. byte jack_slap = ((dev->device == PCI_DEVICE_ID_CMD_648) || (dev->device == PCI_DEVICE_ID_CMD_649)) ? 1 : 0;
  858. switch (func) {
  859. case ide_dma_check:
  860. return cmd64x_config_drive_for_dma(drive);
  861. case ide_dma_end: /* returns 1 on error, 0 otherwise */
  862. drive->waiting_for_dma = 0;
  863. outb(inb(dma_base)&~1, dma_base); /* stop DMA */
  864. dma_stat = inb(dma_base+2); /* get DMA status */
  865. outb(dma_stat|6, dma_base+2); /* clear the INTR & ERROR bits */
  866. if (jack_slap) {
  867. byte dma_intr = 0;
  868. byte dma_mask = (HWIF(drive)->channel) ? ARTTIM23_INTR_CH1 : CFR_INTR_CH0;
  869. byte dma_reg = (HWIF(drive)->channel) ? ARTTIM2 : CFR;
  870. (void) pci_read_config_byte(dev, dma_reg, &dma_intr);
  871. /*
  872.  * DAMN BMIDE is not connected to PCI space!
  873.  * Have to manually jack-slap that bitch!
  874.  * To allow the PCI side to read incoming interrupts.
  875.  */
  876. (void) pci_write_config_byte(dev, dma_reg, dma_intr|dma_mask); /* clear the INTR bit */
  877. }
  878. ide_destroy_dmatable(drive); /* purge DMA mappings */
  879. return (dma_stat & 7) != 4; /* verify good DMA status */
  880. case ide_dma_test_irq: /* returns 1 if dma irq issued, 0 otherwise */
  881. dma_stat = inb(dma_base+2);
  882. (void) pci_read_config_byte(dev, MRDMODE, &dma_alt_stat);
  883. #ifdef DEBUG
  884. printk("%s: dma_stat: 0x%02x dma_alt_stat: 0x%02x mask: 0x%02xn", drive->name, dma_stat, dma_alt_stat, mask);
  885. #endif
  886. if (!(dma_alt_stat & mask)) {
  887. return 0;
  888. }
  889. return (dma_stat & 4) == 4; /* return 1 if INTR asserted */
  890. default:
  891. break;
  892. }
  893. /* Other cases are done by generic IDE-DMA code. */
  894. return ide_dmaproc(func, drive);
  895. }
  897. /*
  898.  * ASUS P55T2P4D with CMD646 chipset revision 0x01 requires the old
  899.  * event order for DMA transfers.
  900.  */
  901. static int cmd646_1_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  902. {
  903. ide_hwif_t *hwif = HWIF(drive);
  904. unsigned long dma_base = hwif->dma_base;
  905. byte dma_stat;
  907. switch (func) {
  908. case ide_dma_check:
  909. return cmd64x_config_drive_for_dma(drive);
  910. case ide_dma_end:
  911. drive->waiting_for_dma = 0;
  912. dma_stat = inb(dma_base+2); /* get DMA status */
  913. outb(inb(dma_base)&~1, dma_base); /* stop DMA */
  914. outb(dma_stat|6, dma_base+2); /* clear the INTR & ERROR bits */
  915. ide_destroy_dmatable(drive); /* and free any DMA resources */
  916. return (dma_stat & 7) != 4; /* verify good DMA status */
  917. default:
  918. break;
  919. }
  921. /* Other cases are done by generic IDE-DMA code. */
  922. return ide_dmaproc(func, drive);
  923. }
  924. #endif /* CONFIG_BLK_DEV_IDEDMA */
  926. static int cmd680_busproc (ide_drive_t * drive, int state)
  927. {
  928. #if 0
  929. ide_hwif_t *hwif = HWIF(drive);
  930. u8 addr_mask = (hwif->channel) ? 0xB0 : 0xA0;
  931. u32 stat_config = 0;
  933.         pci_read_config_dword(hwif->pci_dev, addr_mask, &stat_config);
  935. if (!hwif)
  936. return -EINVAL;
  938. switch (state) {
  939. case BUSSTATE_ON:
  940. hwif->drives[0].failures = 0;
  941. hwif->drives[1].failures = 0;
  942. break;
  943. case BUSSTATE_OFF:
  944. hwif->drives[0].failures = hwif->drives[0].max_failures + 1;
  945. hwif->drives[1].failures = hwif->drives[1].max_failures + 1;
  946. break;
  947. case BUSSTATE_TRISTATE:
  948. hwif->drives[0].failures = hwif->drives[0].max_failures + 1;
  949. hwif->drives[1].failures = hwif->drives[1].max_failures + 1;
  950. break;
  951. default:
  952. return 0;
  953. }
  954. hwif->bus_state = state;
  955. #endif
  956. return 0;
  957. }
  959. void cmd680_reset (ide_drive_t *drive)
  960. {
  961. #if 0
  962. ide_hwif_t *hwif = HWIF(drive);
  963. u8 addr_mask = (hwif->channel) ? 0xB0 : 0xA0;
  964. byte reset = 0;
  966. pci_read_config_byte(hwif->pci_dev, addr_mask, &reset);
  967. pci_write_config_byte(hwif->pci_dev, addr_mask, reset|0x03);
  968. #endif
  969. }
  971. unsigned int cmd680_pci_init (struct pci_dev *dev, const char *name)
  972. {
  973. u8 tmpbyte = 0;
  974. pci_write_config_byte(dev, 0x80, 0x00);
  975. pci_write_config_byte(dev, 0x84, 0x00);
  976. pci_read_config_byte(dev, 0x8A, &tmpbyte);
  977. pci_write_config_byte(dev, 0x8A, tmpbyte|0x01);
  978. pci_write_config_word(dev, 0xA2, 0x328A);
  979. pci_write_config_dword(dev, 0xA4, 0x328A);
  980. pci_write_config_dword(dev, 0xA8, 0x4392);
  981. pci_write_config_dword(dev, 0xAC, 0x4009);
  982. pci_write_config_word(dev, 0xB2, 0x328A);
  983. pci_write_config_dword(dev, 0xB4, 0x328A);
  984. pci_write_config_dword(dev, 0xB8, 0x4392);
  985. pci_write_config_dword(dev, 0xBC, 0x4009);
  987. #if defined(DISPLAY_CMD64X_TIMINGS) && defined(CONFIG_PROC_FS)
  988. if (!cmd64x_proc) {
  989. cmd64x_proc = 1;
  990. bmide_dev = dev;
  991. cmd64x_display_info = &cmd680_get_info;
  992. }
  993. #endif /* DISPLAY_CMD64X_TIMINGS && CONFIG_PROC_FS */
  994. return 0;
  995. }
  997. unsigned int cmd64x_pci_init (struct pci_dev *dev, const char *name)
  998. {
  999. unsigned char mrdmode;
  1000. unsigned int class_rev;
  1002. pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
  1003. class_rev &= 0xff;
  1005. #ifdef __i386__
  1006. if (dev->resource[PCI_ROM_RESOURCE].start) {
  1007. pci_write_config_byte(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
  1008. printk("%s: ROM enabled at 0x%08lxn", name, dev->resource[PCI_ROM_RESOURCE].start);
  1009. }
  1010. #endif
  1012. switch(dev->device) {
  1013. case PCI_DEVICE_ID_CMD_643:
  1014. break;
  1015. case PCI_DEVICE_ID_CMD_646:
  1016. printk("%s: chipset revision 0x%02X, ", name, class_rev);
  1017. switch(class_rev) {
  1018. case 0x07:
  1019. case 0x05:
  1020. printk("UltraDMA Capable");
  1021. break;
  1022. case 0x03:
  1023. printk("MultiWord DMA Force Limited");
  1024. break;
  1025. case 0x01:
  1026. default:
  1027. printk("MultiWord DMA Limited, IRQ workaround enabled");
  1028. break;
  1029. }
  1030. printk("n");
  1031.                         break;
  1032. case PCI_DEVICE_ID_CMD_648:
  1033. case PCI_DEVICE_ID_CMD_649:
  1034. break;
  1035. default:
  1036. break;
  1037. }
  1039. /* Set a good latency timer and cache line size value. */
  1040. (void) pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
  1041. #ifdef __sparc_v9__
  1042. (void) pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 0x10);
  1043. #endif
  1046. /* Setup interrupts. */
  1047. (void) pci_read_config_byte(dev, MRDMODE, &mrdmode);
  1048. mrdmode &= ~(0x30);
  1049. (void) pci_write_config_byte(dev, MRDMODE, mrdmode);
  1051. /* Use MEMORY READ LINE for reads.
  1052.  * NOTE: Although not mentioned in the PCI0646U specs,
  1053.  *       these bits are write only and won't be read
  1054.  *       back as set or not.  The PCI0646U2 specs clarify
  1055.  *       this point.
  1056.  */
  1057. (void) pci_write_config_byte(dev, MRDMODE, mrdmode | 0x02);
  1059. /* Set reasonable active/recovery/address-setup values. */
  1060. (void) pci_write_config_byte(dev, ARTTIM0,  0x40);
  1061. (void) pci_write_config_byte(dev, DRWTIM0,  0x3f);
  1062. (void) pci_write_config_byte(dev, ARTTIM1,  0x40);
  1063. (void) pci_write_config_byte(dev, DRWTIM1,  0x3f);
  1064. #ifdef __i386__
  1065. (void) pci_write_config_byte(dev, ARTTIM23, 0x1c);
  1066. #else
  1067. (void) pci_write_config_byte(dev, ARTTIM23, 0x5c);
  1068. #endif
  1069. (void) pci_write_config_byte(dev, DRWTIM23, 0x3f);
  1070. (void) pci_write_config_byte(dev, DRWTIM3,  0x3f);
  1071. #ifdef CONFIG_PPC
  1072. (void) pci_write_config_byte(dev, UDIDETCR0, 0xf0);
  1073. #endif /* CONFIG_PPC */
  1075. #if defined(DISPLAY_CMD64X_TIMINGS) && defined(CONFIG_PROC_FS)
  1076. if (!cmd64x_proc) {
  1077. cmd64x_proc = 1;
  1078. bmide_dev = dev;
  1079. cmd64x_display_info = &cmd64x_get_info;
  1080. }
  1081. #endif /* DISPLAY_CMD64X_TIMINGS && CONFIG_PROC_FS */
  1083. return 0;
  1084. }
  1086. unsigned int __init pci_init_cmd64x (struct pci_dev *dev, const char *name)
  1087. {
  1088. if (dev->device == PCI_DEVICE_ID_CMD_680)
  1089. return cmd680_pci_init (dev, name);
  1090. return cmd64x_pci_init (dev, name);
  1091. }
  1093. unsigned int cmd680_ata66 (ide_hwif_t *hwif)
  1094. {
  1095. byte ata66 = 0;
  1096. byte addr_mask = (hwif->channel) ? 0xB0 : 0xA0;
  1098. pci_read_config_byte(hwif->pci_dev, addr_mask, &ata66);
  1099. return (ata66 & 0x01) ? 1 : 0;
  1100. }
  1102. unsigned int cmd64x_ata66 (ide_hwif_t *hwif)
  1103. {
  1104. byte ata66 = 0;
  1105. byte mask = (hwif->channel) ? 0x02 : 0x01;
  1107. pci_read_config_byte(hwif->pci_dev, BMIDECSR, &ata66);
  1108. return (ata66 & mask) ? 1 : 0;
  1109. }
  1111. unsigned int __init ata66_cmd64x (ide_hwif_t *hwif)
  1112. {
  1113. struct pci_dev *dev = hwif->pci_dev;
  1114. if (dev->device == PCI_DEVICE_ID_CMD_680)
  1115. return cmd680_ata66(hwif);
  1116. return cmd64x_ata66(hwif);
  1117. }
  1119. void __init ide_init_cmd64x (ide_hwif_t *hwif)
  1120. {
  1121. struct pci_dev *dev = hwif->pci_dev;
  1122. unsigned int class_rev;
  1124. pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
  1125. class_rev &= 0xff;
  1127. hwif->drives[0].autotune = 1;
  1128. hwif->drives[1].autotune = 1;
  1130. if (!hwif->dma_base)
  1131. return;
  1133. #ifdef CONFIG_BLK_DEV_IDEDMA
  1134. switch(dev->device) {
  1135. case PCI_DEVICE_ID_CMD_680:
  1136. hwif->busproc = &cmd680_busproc;
  1137. hwif->dmaproc = &cmd680_dmaproc;
  1138. hwif->resetproc = &cmd680_reset;
  1139. hwif->speedproc = &cmd680_tune_chipset;
  1140. hwif->tuneproc = &cmd680_tuneproc;
  1141. break;
  1142. case PCI_DEVICE_ID_CMD_649:
  1143. case PCI_DEVICE_ID_CMD_648:
  1144. case PCI_DEVICE_ID_CMD_643:
  1145. hwif->dmaproc = &cmd64x_dmaproc;
  1146. hwif->tuneproc = &cmd64x_tuneproc;
  1147. hwif->speedproc = &cmd64x_tune_chipset;
  1148. break;
  1149. case PCI_DEVICE_ID_CMD_646:
  1150. hwif->chipset = ide_cmd646;
  1151. if (class_rev == 0x01) {
  1152. hwif->dmaproc = &cmd646_1_dmaproc;
  1153. } else {
  1154. hwif->dmaproc = &cmd64x_dmaproc;
  1155. }
  1156. hwif->tuneproc = &cmd64x_tuneproc;
  1157. hwif->speedproc = &cmd64x_tune_chipset;
  1158. break;
  1159. default:
  1160. break;
  1161. }
  1162. #endif /* CONFIG_BLK_DEV_IDEDMA */
  1163. }