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

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

Linux/Unix编程

开发平台：

Unix_Linux

pdc202xx.c：源码内容
  1. /*
  2.  *  linux/drivers/ide/pdc202xx.c Version 0.32 Feb. 27, 2002
  3.  *
  4.  *  Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
  5.  *  May be copied or modified under the terms of the GNU General Public License
  6.  *
  7.  *  Promise Ultra66 cards with BIOS v1.11 this
  8.  *  compiled into the kernel if you have more than one card installed.
  9.  *
  10.  *  Promise Ultra100 cards with BIOS v2.01 this
  11.  *  compiled into the kernel if you have more than one card installed.
  12.  *
  13.  *  Promise Ultra100TX2 with BIOS v2.10 & Ultra133TX2 with BIOS v2.20
  14.  *  support 8 hard drives on UDMA mode.
  15.  *
  16.  *  Linux kernel will misunderstand FastTrak ATA-RAID series as Ultra
  17.  *  IDE Controller, UNLESS you enable "CONFIG_PDC202XX_FORCE"
  18.  *  That's you can use FastTrak ATA-RAID controllers as IDE controllers.
  19.  *
  20.  *  History :
  21.  *  05/22/01    v1.20 b1
  22.  *           (1) support PDC20268
  23.  *           (2) fix cable judge function
  24.  *  08/22/01    v1.20 b2
  25.  *           (1) support ATA-133 PDC20269/75
  26.  *           (2) support UDMA Mode 6
  27.  *           (3) fix proc report information
  28.  *           (4) set ATA133 timing
  29.  *           (5) fix ultra dma bit 14 selectable
  30.  *           (6) support 32bit LBA
  31.  *  09/11/01    v1.20 b3 
  32.  *           (1) fix eighty_ninty_three()
  33.  *           (2) fix offset address 0x1c~0x1f
  34.  *  10/30/01    v1.20 b4
  35.  *           (1) fix 48bit LBA HOB bit
  36.  *           (2) force rescan drive under PIO modes if need
  37.  *  11/02/01    v1.20.0.5
  38.  *           (1) could be patched with ext3 filesystem code
  39.  *  11/06/01    v1.20.0.6
  40.  *           (1) fix LBA48 drive running without Promise controllers
  41.  *           (2) fix LBA48 drive running under PIO modes
  42.  *  01/28/02    v1.20.0.6
  43.  *           (1) release for linux IDE Group kernel 2.4.18
  44.  *           (2) add version and controller info to proc
  45.  *  05/23/02    v1.20.0.7
  46.  *           (1) disable PDC20262 running with 48bit
  47.  *           (2) Add quirk drive lists for PDC20265/67
  48.  *
  49.  *  Copyright (C) 1999-2002 Promise Technology, Inc.
  50.  *  Author: Frank Tiernan <frankt@promise.com>
  51.  *          PROMISE pdc202xx IDE Controller driver MAINTAINERS
  52.  *  Released under terms of General Public License
  53.  */
  54.  
  55. #define VERSION "1.20.0.7"
  56. #define VERDATE "2002-05-23"
  57. #include <linux/config.h>
  58. #include <linux/types.h>
  59. #include <linux/kernel.h>
  60. #include <linux/delay.h>
  61. #include <linux/timer.h>
  62. #include <linux/mm.h>
  63. #include <linux/ioport.h>
  64. #include <linux/blkdev.h>
  65. #include <linux/hdreg.h>
  66. #include <linux/interrupt.h>
  67. #include <linux/pci.h>
  68. #include <linux/init.h>
  69. #include <linux/ide.h>
  71. #include <asm/io.h>
  72. #include <asm/irq.h>
  74. #include "ide_modes.h"
  76. #define PDC202XX_DEBUG_DRIVE_INFO 0
  77. #define PDC202XX_DECODE_REGISTER_INFO 0
  79. #define DISPLAY_PDC202XX_TIMINGS
  81. #ifndef SPLIT_BYTE
  82. #define SPLIT_BYTE(B,H,L) ((H)=(B>>4), (L)=(B-((B>>4)<<4)))
  83. #endif
  85. #if defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS)
  86. #include <linux/stat.h>
  87. #include <linux/proc_fs.h>
  89. static int pdc202xx_get_info(char *, char **, off_t, int);
  90. extern int (*pdc202xx_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;
  93. static struct hd_driveid *id[4];
  94. static int speed_rate[4];
  96. static char * pdc202xx_info (char *buf, struct pci_dev *dev)
  97. {
  98. char *p = buf;
  100. u32 bibma  = pci_resource_start(dev, 4);
  101. u32 reg60h = 0, reg64h = 0, reg68h = 0, reg6ch = 0;
  102. u16 reg50h = 0;
  103. u16 word88 = 0;
  104. int udmasel[4] = {0,0,0,0}, piosel[4] = {0,0,0,0};
  105. int i = 0, hd = 0;
  107.         /*
  108.          * at that point bibma+0x2 et bibma+0xa are byte registers
  109.          * to investigate:
  110.          */
  111. u8 c0 = inb_p((unsigned short)bibma + 0x02);
  112. u8 c1 = inb_p((unsigned short)bibma + 0x0a);
  114. u8 sc11 = inb_p((unsigned short)bibma + 0x11);
  115. u8 sc1a = inb_p((unsigned short)bibma + 0x1a);
  116. u8 sc1b = inb_p((unsigned short)bibma + 0x1b);
  117. /* u8 sc1c = inb_p((unsigned short)bibma + 0x1c); 
  118. u8 sc1d = inb_p((unsigned short)bibma + 0x1d);
  119. u8 sc1e = inb_p((unsigned short)bibma + 0x1e);
  120. u8 sc1f = inb_p((unsigned short)bibma + 0x1f); */
  122. pci_read_config_word(dev, 0x50, &reg50h);
  123. pci_read_config_dword(dev, 0x60, &reg60h);
  124. pci_read_config_dword(dev, 0x64, &reg64h);
  125. pci_read_config_dword(dev, 0x68, &reg68h);
  126. pci_read_config_dword(dev, 0x6c, &reg6ch);
  128. p+=sprintf(p, "nPROMISE Ultra series driver Ver %s %s Adapter: ", VERSION, VERDATE);
  129. switch(dev->device) {
  130. case PCI_DEVICE_ID_PROMISE_20275:
  131. p += sprintf(p, "MBUltra133n");
  132. break;
  133. case PCI_DEVICE_ID_PROMISE_20269:
  134. p += sprintf(p, "Ultra133 TX2n");
  135. break;
  136. case PCI_DEVICE_ID_PROMISE_20268:
  137. p += sprintf(p, "Ultra100 TX2n");
  138. break;
  139. case PCI_DEVICE_ID_PROMISE_20267:
  140. p += sprintf(p, "Ultra100n");
  141. break;
  142. case PCI_DEVICE_ID_PROMISE_20265:
  143. p += sprintf(p, "Ultra100 on M/Bn");
  144. break;
  145. case PCI_DEVICE_ID_PROMISE_20262:
  146. p += sprintf(p, "Ultra66n");
  147. break;
  148. case PCI_DEVICE_ID_PROMISE_20246:
  149. p += sprintf(p, "Ultra33n");
  150. reg50h |= 0x0c00;
  151. break;
  152. default:
  153. p += sprintf(p, "Ultra Seriesn");
  154. break;
  155. }
  157. p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------n");
  158. p += sprintf(p, "                %s                         %sn",
  159. (c0&0x80)?"disabled":"enabled ",
  160. (c1&0x80)?"disabled":"enabled ");
  161. p += sprintf(p, "66 Clocking     %s                         %sn",
  162. (sc11&0x02)?"enabled ":"disabled",
  163. (sc11&0x08)?"enabled ":"disabled");
  164. p += sprintf(p, "Mode            %s                           %sn",
  165. (sc1a & 0x01) ? "MASTER" : "PCI   ",
  166. (sc1b & 0x01) ? "MASTER" : "PCI   ");
  167. p += sprintf(p, "--------------- drive0 --------- drive1 -------- drive0 ---------- drive1 ------n");
  168. p += sprintf(p, "DMA enabled:    %s              %s             %s               %sn",
  169. (id[0]!=NULL && (c0&0x20))?"yes":"no ",(id[1]!=NULL && (c0&0x40))?"yes":"no ",
  170. (id[2]!=NULL && (c1&0x20))?"yes":"no ",(id[3]!=NULL && (c1&0x40))?"yes":"no ");
  171. for( hd = 0; hd < 4 ; hd++) {
  172. if (id[hd] == NULL)
  173. continue;
  174. word88 = id[hd]->dma_ultra;
  175. for ( i = 7 ; i >= 0 ; i--)
  176. if (word88 >> (i+8)) {
  177. udmasel[hd] = i; /* get select UDMA mode */
  178. break;
  179. }
  180. piosel[hd] = (id[hd]->eide_pio_modes >= 0x02) ? 4 : 3;
  181.         }
  182. p += sprintf(p, "UDMA Mode:      %d                %d               %d                 %dn",
  183. udmasel[0], udmasel[1], udmasel[2], udmasel[3]);
  184. p += sprintf(p, "PIO Mode:       %d                %d               %d                 %dn",
  185. piosel[0], piosel[1], piosel[2], piosel[3]);
  186. #if 0
  187. p += sprintf(p, "--------------- Can ATAPI DMA ---------------n");
  188. #endif
  189. return (char *)p;
  190. }
  192. static int pdc202xx_get_info (char *buffer, char **addr, off_t offset, int count)
  193. {
  194. char *p = buffer;
  196. p = pdc202xx_info(buffer, bmide_dev);
  197. return p-buffer; /* => must be less than 4k! */
  198. }
  199. #endif  /* defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS) */
  201. byte pdc202xx_proc = 0;
  203. const char *pdc_quirk_drives[] = {
  204. "QUANTUM FIREBALLlct08 08",
  205. "QUANTUM FIREBALLP KA6.4",
  206. "QUANTUM FIREBALLP KA9.1",
  207. "QUANTUM FIREBALLP LM20.4",
  208. "QUANTUM FIREBALLP KX13.6",
  209. "QUANTUM FIREBALLP KX20.5",
  210. "QUANTUM FIREBALLP KX27.3",
  211. "QUANTUM FIREBALLP LM20.5",
  212. NULL
  213. };
  215. extern char *ide_xfer_verbose (byte xfer_rate);
  217. /* A Register */
  218. #define SYNC_ERRDY_EN 0xC0
  220. #define SYNC_IN 0x80 /* control bit, different for master vs. slave drives */
  221. #define ERRDY_EN 0x40 /* control bit, different for master vs. slave drives */
  222. #define IORDY_EN 0x20 /* PIO: IOREADY */
  223. #define PREFETCH_EN 0x10 /* PIO: PREFETCH */
  225. #define PA3 0x08 /* PIO"A" timing */
  226. #define PA2 0x04 /* PIO"A" timing */
  227. #define PA1 0x02 /* PIO"A" timing */
  228. #define PA0 0x01 /* PIO"A" timing */
  230. /* B Register */
  232. #define MB2 0x80 /* DMA"B" timing */
  233. #define MB1 0x40 /* DMA"B" timing */
  234. #define MB0 0x20 /* DMA"B" timing */
  236. #define PB4 0x10 /* PIO_FORCE 1:0 */
  238. #define PB3 0x08 /* PIO"B" timing */ /* PIO flow Control mode */
  239. #define PB2 0x04 /* PIO"B" timing */ /* PIO 4 */
  240. #define PB1 0x02 /* PIO"B" timing */ /* PIO 3 half */
  241. #define PB0 0x01 /* PIO"B" timing */ /* PIO 3 other half */
  243. /* C Register */
  244. #define IORDYp_NO_SPEED 0x4F
  245. #define SPEED_DIS 0x0F
  247. #define DMARQp 0x80
  248. #define IORDYp 0x40
  249. #define DMAR_EN 0x20
  250. #define DMAW_EN 0x10
  252. #define MC3 0x08 /* DMA"C" timing */
  253. #define MC2 0x04 /* DMA"C" timing */
  254. #define MC1 0x02 /* DMA"C" timing */
  255. #define MC0 0x01 /* DMA"C" timing */
  257. #if PDC202XX_DECODE_REGISTER_INFO
  259. #define REG_A 0x01
  260. #define REG_B 0x02
  261. #define REG_C 0x04
  262. #define REG_D 0x08
  264. static void decode_registers (byte registers, byte value)
  265. {
  266. byte bit = 0, bit1 = 0, bit2 = 0;
  268. switch(registers) {
  269. case REG_A:
  270. bit2 = 0;
  271. printk("A Register ");
  272. if (value & 0x80) printk("SYNC_IN ");
  273. if (value & 0x40) printk("ERRDY_EN ");
  274. if (value & 0x20) printk("IORDY_EN ");
  275. if (value & 0x10) printk("PREFETCH_EN ");
  276. if (value & 0x08) { printk("PA3 ");bit2 |= 0x08; }
  277. if (value & 0x04) { printk("PA2 ");bit2 |= 0x04; }
  278. if (value & 0x02) { printk("PA1 ");bit2 |= 0x02; }
  279. if (value & 0x01) { printk("PA0 ");bit2 |= 0x01; }
  280. printk("PIO(A) = %d ", bit2);
  281. break;
  282. case REG_B:
  283. bit1 = 0;bit2 = 0;
  284. printk("B Register ");
  285. if (value & 0x80) { printk("MB2 ");bit1 |= 0x80; }
  286. if (value & 0x40) { printk("MB1 ");bit1 |= 0x40; }
  287. if (value & 0x20) { printk("MB0 ");bit1 |= 0x20; }
  288. printk("DMA(B) = %d ", bit1 >> 5);
  289. if (value & 0x10) printk("PIO_FORCED/PB4 ");
  290. if (value & 0x08) { printk("PB3 ");bit2 |= 0x08; }
  291. if (value & 0x04) { printk("PB2 ");bit2 |= 0x04; }
  292. if (value & 0x02) { printk("PB1 ");bit2 |= 0x02; }
  293. if (value & 0x01) { printk("PB0 ");bit2 |= 0x01; }
  294. printk("PIO(B) = %d ", bit2);
  295. break;
  296. case REG_C:
  297. bit2 = 0;
  298. printk("C Register ");
  299. if (value & 0x80) printk("DMARQp ");
  300. if (value & 0x40) printk("IORDYp ");
  301. if (value & 0x20) printk("DMAR_EN ");
  302. if (value & 0x10) printk("DMAW_EN ");
  304. if (value & 0x08) { printk("MC3 ");bit2 |= 0x08; }
  305. if (value & 0x04) { printk("MC2 ");bit2 |= 0x04; }
  306. if (value & 0x02) { printk("MC1 ");bit2 |= 0x02; }
  307. if (value & 0x01) { printk("MC0 ");bit2 |= 0x01; }
  308. printk("DMA(C) = %d ", bit2);
  309. break;
  310. case REG_D:
  311. printk("D Register ");
  312. break;
  313. default:
  314. return;
  315. }
  316. printk("n        %s ", (registers & REG_D) ? "DP" :
  317. (registers & REG_C) ? "CP" :
  318. (registers & REG_B) ? "BP" :
  319. (registers & REG_A) ? "AP" : "ERROR");
  320. for (bit=128;bit>0;bit/=2)
  321. printk("%s", (value & bit) ? "1" : "0");
  322. printk("n");
  323. }
  325. #endif /* PDC202XX_DECODE_REGISTER_INFO */
  327. static int check_in_drive_lists (ide_drive_t *drive, const char **list)
  328. {
  329. struct hd_driveid *id = drive->id;
  331. if (pdc_quirk_drives == list) {
  332. while (*list) {
  333. if (strstr(id->model, *list++)) {
  334. return 2;
  335. }
  336. }
  337. } else {
  338. while (*list) {
  339. if (!strcmp(*list++,id->model)) {
  340. return 1;
  341. }
  342. }
  343. }
  344. return 0;
  345. }
  347. static int pdc202xx_tune_chipset (ide_drive_t *drive, byte speed)
  348. {
  349. ide_hwif_t *hwif = HWIF(drive);
  350. struct pci_dev *dev = hwif->pci_dev;
  352. unsigned int drive_conf;
  353. int err = 0, i = 0, j = hwif->channel ? 2 : 0 ;
  354. byte drive_pci, AP, BP, CP, DP;
  355. byte TA = 0, TB = 0, TC = 0;
  357. switch (drive->dn) {
  358. case 0: drive_pci = 0x60; break;
  359. case 1: drive_pci = 0x64; break;
  360. case 2: drive_pci = 0x68; break;
  361. case 3: drive_pci = 0x6c; break;
  362. default: return -1;
  363. }
  365. if ((drive->media != ide_disk) && (speed < XFER_SW_DMA_0)) return -1;
  367. pci_read_config_dword(dev, drive_pci, &drive_conf);
  368. pci_read_config_byte(dev, (drive_pci), &AP);
  369. pci_read_config_byte(dev, (drive_pci)|0x01, &BP);
  370. pci_read_config_byte(dev, (drive_pci)|0x02, &CP);
  371. pci_read_config_byte(dev, (drive_pci)|0x03, &DP);
  373. #ifdef CONFIG_BLK_DEV_IDEDMA
  374. if (speed >= XFER_SW_DMA_0) {
  375. if ((BP & 0xF0) && (CP & 0x0F)) {
  376. /* clear DMA modes of upper 842 bits of B Register */
  377. /* clear PIO forced mode upper 1 bit of B Register */
  378. pci_write_config_byte(dev, (drive_pci)|0x01, BP & ~0xF0);
  379. pci_read_config_byte(dev, (drive_pci)|0x01, &BP);
  381. /* clear DMA modes of lower 8421 bits of C Register */
  382. pci_write_config_byte(dev, (drive_pci)|0x02, CP & ~0x0F);
  383. pci_read_config_byte(dev, (drive_pci)|0x02, &CP);
  384. }
  385. } else {
  386. #else
  387. {
  388. #endif /* CONFIG_BLK_DEV_IDEDMA */
  389. if ((AP & 0x0F) || (BP & 0x07)) {
  390. /* clear PIO modes of lower 8421 bits of A Register */
  391. pci_write_config_byte(dev, (drive_pci), AP & ~0x0F);
  392. pci_read_config_byte(dev, (drive_pci), &AP);
  394. /* clear PIO modes of lower 421 bits of B Register */
  395. pci_write_config_byte(dev, (drive_pci)|0x01, BP & ~0x07);
  396. pci_read_config_byte(dev, (drive_pci)|0x01, &BP);
  398. pci_read_config_byte(dev, (drive_pci), &AP);
  399. pci_read_config_byte(dev, (drive_pci)|0x01, &BP);
  400. }
  401. }
  403. pci_read_config_byte(dev, (drive_pci), &AP);
  404. pci_read_config_byte(dev, (drive_pci)|0x01, &BP);
  405. pci_read_config_byte(dev, (drive_pci)|0x02, &CP);
  407. for ( i = 0; i < 2; i++)
  408. if (hwif->drives[i].present)
  409.    id[i+j] = hwif->drives[i].id; /* get identify structs */
  411. switch(speed) {
  412. #ifdef CONFIG_BLK_DEV_IDEDMA
  413. /* case XFER_UDMA_6: */
  414. case XFER_UDMA_5:
  415. case XFER_UDMA_4: TB = 0x20; TC = 0x01; break; /* speed 8 == UDMA mode 4 */
  416. case XFER_UDMA_3: TB = 0x40; TC = 0x02; break; /* speed 7 == UDMA mode 3 */
  417. case XFER_UDMA_2: TB = 0x20; TC = 0x01; break; /* speed 6 == UDMA mode 2 */
  418. case XFER_UDMA_1: TB = 0x40; TC = 0x02; break; /* speed 5 == UDMA mode 1 */
  419. case XFER_UDMA_0: TB = 0x60; TC = 0x03; break; /* speed 4 == UDMA mode 0 */
  420. case XFER_MW_DMA_2: TB = 0x60; TC = 0x03; break; /* speed 4 == MDMA mode 2 */
  421. case XFER_MW_DMA_1: TB = 0x60; TC = 0x04; break; /* speed 3 == MDMA mode 1 */
  422. case XFER_MW_DMA_0: TB = 0x60; TC = 0x05; break; /* speed 2 == MDMA mode 0 */
  423. case XFER_SW_DMA_2: TB = 0x60; TC = 0x05; break; /* speed 0 == SDMA mode 2 */
  424. case XFER_SW_DMA_1: TB = 0x80; TC = 0x06; break; /* speed 1 == SDMA mode 1 */
  425. case XFER_SW_DMA_0: TB = 0xC0; TC = 0x0B; break; /* speed 0 == SDMA mode 0 */
  426. #endif /* CONFIG_BLK_DEV_IDEDMA */
  427. case XFER_PIO_4: TA = 0x01; TB = 0x04; break;
  428. case XFER_PIO_3: TA = 0x02; TB = 0x06; break;
  429. case XFER_PIO_2: TA = 0x03; TB = 0x08; break;
  430. case XFER_PIO_1: TA = 0x05; TB = 0x0C; break;
  431. case XFER_PIO_0:
  432. default: TA = 0x09; TB = 0x13; break;
  433. }
  435. #ifdef CONFIG_BLK_DEV_IDEDMA
  436.         if (speed >= XFER_SW_DMA_0) {
  437. pci_write_config_byte(dev, (drive_pci)|0x01, BP|TB);
  438. pci_write_config_byte(dev, (drive_pci)|0x02, CP|TC);
  439. } else {
  440. #else
  441. {
  442. #endif /* CONFIG_BLK_DEV_IDEDMA */
  443. pci_write_config_byte(dev, (drive_pci), AP|TA);
  444. pci_write_config_byte(dev, (drive_pci)|0x01, BP|TB);
  445. }
  447. #if PDC202XX_DECODE_REGISTER_INFO
  448. pci_read_config_byte(dev, (drive_pci), &AP);
  449. pci_read_config_byte(dev, (drive_pci)|0x01, &BP);
  450. pci_read_config_byte(dev, (drive_pci)|0x02, &CP);
  451. pci_read_config_byte(dev, (drive_pci)|0x03, &DP);
  453. decode_registers(REG_A, AP);
  454. decode_registers(REG_B, BP);
  455. decode_registers(REG_C, CP);
  456. decode_registers(REG_D, DP);
  457. #endif /* PDC202XX_DECODE_REGISTER_INFO */
  459. if (!drive->init_speed)
  460. drive->init_speed = speed;
  461. err = ide_config_drive_speed(drive, speed);
  462. drive->current_speed = speed;
  464. #if PDC202XX_DEBUG_DRIVE_INFO
  465. printk("%s: %s drive%d 0x%08x ",
  466. drive->name, ide_xfer_verbose(speed),
  467. drive->dn, drive_conf);
  468. pci_read_config_dword(dev, drive_pci, &drive_conf);
  469. printk("0x%08xn", drive_conf);
  470. #endif /* PDC202XX_DEBUG_DRIVE_INFO */
  471. return err;
  472. }
  474. static int pdc202xx_new_tune_chipset (ide_drive_t *drive, byte speed)
  475. {
  476. ide_hwif_t *hwif = HWIF(drive);
  477. #ifdef CONFIG_BLK_DEV_IDEDMA
  478. unsigned long indexreg = (hwif->dma_base + 1);
  479. unsigned long datareg = (hwif->dma_base + 3);
  480. #else
  481. struct pci_dev *dev = hwif->pci_dev;
  482. unsigned long high_16 = pci_resource_start(dev, 4);
  483. unsigned long indexreg = high_16 + (hwif->channel ? 0x09 : 0x01);
  484. unsigned long datareg = (indexreg + 2);
  485. #endif /* CONFIG_BLK_DEV_IDEDMA */
  486. byte thold = 0x10;
  487. byte adj = (drive->dn%2) ? 0x08 : 0x00;
  488. int set_speed = 0, i=0, j=hwif->channel ? 2:0;
  489. int                     err;
  491. /* Setting tHOLD bit to 0 if using UDMA mode 2 */
  492. if (speed == XFER_UDMA_2) {
  493. OUT_BYTE((thold + adj), indexreg);
  494. OUT_BYTE((IN_BYTE(datareg) & 0x7f), datareg);
  495. }
  497. /* We need to set ATA133 timing if ATA133 drives exist */
  498. if (speed>=XFER_UDMA_6)
  499. set_speed=1;
  501. if (!drive->init_speed)
  502. drive->init_speed = speed;
  503. #if PDC202XX_DEBUG_DRIVE_INFO
  504. printk("%s: Before set_feature = %s, word88 = %#xn",
  505. drive->name, ide_xfer_verbose(speed), drive->id->dma_ultra );
  506. #endif /* PDC202XX_DEBUG_DRIVE_INFO */
  507. err = ide_config_drive_speed(drive, speed);
  508. drive->current_speed = speed;
  509. for ( i = 0 ; i < 2 ; i++)
  510. if (hwif->drives[i].present) {
  511.    id[i+j] = hwif->drives[i].id; /* get identify structs */
  512.   speed_rate[i+j] = speed; /* get current speed */
  513.   }
  514. if (set_speed) {
  515. for (i=0; i<4; i++) {
  516. if (id[i]==NULL)
  517. continue;
  518. switch(speed_rate[i]) {
  519. #ifdef CONFIG_BLK_DEV_IDEDMA
  520. case XFER_UDMA_6:
  521. OUT_BYTE((0x10 + adj), indexreg);
  522. OUT_BYTE(0x1a, datareg);
  523. OUT_BYTE((0x11 + adj), indexreg);
  524. OUT_BYTE(0x01, datareg);
  525. OUT_BYTE((0x12 + adj), indexreg);
  526. OUT_BYTE(0xcb, datareg);
  527. break;
  528. case XFER_UDMA_5:
  529. OUT_BYTE((0x10 + adj), indexreg);
  530. OUT_BYTE(0x1a, datareg);
  531. OUT_BYTE((0x11 + adj), indexreg);
  532. OUT_BYTE(0x02, datareg);
  533. OUT_BYTE((0x12 + adj), indexreg);
  534. OUT_BYTE(0xcb, datareg);
  535. break;
  536. case XFER_UDMA_4:
  537. OUT_BYTE((0x10 + adj), indexreg);
  538. OUT_BYTE(0x1a, datareg);
  539. OUT_BYTE((0x11 + adj), indexreg);
  540. OUT_BYTE(0x03, datareg);
  541. OUT_BYTE((0x12 + adj), indexreg);
  542. OUT_BYTE(0xcd, datareg);
  543. break;
  544. case XFER_UDMA_3:
  545. OUT_BYTE((0x10 + adj), indexreg);
  546. OUT_BYTE(0x1a, datareg);
  547. OUT_BYTE((0x11 + adj), indexreg);
  548. OUT_BYTE(0x05, datareg);
  549. OUT_BYTE((0x12 + adj), indexreg);
  550. OUT_BYTE(0xcd, datareg);
  551. break;
  552. case XFER_UDMA_2:
  553. OUT_BYTE((0x10 + adj), indexreg);
  554. OUT_BYTE(0x2a, datareg);
  555. OUT_BYTE((0x11 + adj), indexreg);
  556. OUT_BYTE(0x07, datareg);
  557. OUT_BYTE((0x12 + adj), indexreg);
  558. OUT_BYTE(0xcd, datareg);
  559. break;
  560. case XFER_UDMA_1:
  561. OUT_BYTE((0x10 + adj), indexreg);
  562. OUT_BYTE(0x3a, datareg);
  563. OUT_BYTE((0x11 + adj), indexreg);
  564. OUT_BYTE(0x0a, datareg);
  565. OUT_BYTE((0x12 + adj), indexreg);
  566. OUT_BYTE(0xd0, datareg);
  567. break;
  568. case XFER_UDMA_0:
  569. OUT_BYTE((0x10 + adj), indexreg);
  570. OUT_BYTE(0x4a, datareg);
  571. OUT_BYTE((0x11 + adj), indexreg);
  572. OUT_BYTE(0x0f, datareg);
  573. OUT_BYTE((0x12 + adj), indexreg);
  574. OUT_BYTE(0xd5, datareg);
  575. break;
  576. case XFER_MW_DMA_2:
  577. OUT_BYTE((0x0e + adj), indexreg);
  578. OUT_BYTE(0x69, datareg);
  579. OUT_BYTE((0x0f + adj), indexreg);
  580. OUT_BYTE(0x25, datareg);
  581. break;
  582. case XFER_MW_DMA_1:
  583. OUT_BYTE((0x0e + adj), indexreg);
  584. OUT_BYTE(0x6b, datareg);
  585. OUT_BYTE((0x0f+ adj), indexreg);
  586. OUT_BYTE(0x27, datareg);
  587. break;
  588. case XFER_MW_DMA_0:
  589. OUT_BYTE((0x0e + adj), indexreg);
  590. OUT_BYTE(0xdf, datareg);
  591. OUT_BYTE((0x0f + adj), indexreg);
  592. OUT_BYTE(0x5f, datareg);
  593. break;
  594. #endif /* CONFIG_BLK_DEV_IDEDMA */
  595. case XFER_PIO_4:
  596. OUT_BYTE((0x0c + adj), indexreg);
  597. OUT_BYTE(0x23, datareg);
  598. OUT_BYTE((0x0d + adj), indexreg);
  599. OUT_BYTE(0x09, datareg);
  600. OUT_BYTE((0x13 + adj), indexreg);
  601. OUT_BYTE(0x25, datareg);
  602. break;
  603. case XFER_PIO_3:
  604. OUT_BYTE((0x0c + adj), indexreg);
  605. OUT_BYTE(0x27, datareg);
  606. OUT_BYTE((0x0d + adj), indexreg);
  607. OUT_BYTE(0x0d, datareg);
  608. OUT_BYTE((0x13 + adj), indexreg);
  609. OUT_BYTE(0x35, datareg);
  610. break;
  611. case XFER_PIO_2:
  612. OUT_BYTE((0x0c + adj), indexreg);
  613. OUT_BYTE(0x23, datareg);
  614. OUT_BYTE((0x0d + adj), indexreg);
  615. OUT_BYTE(0x26, datareg);
  616. OUT_BYTE((0x13 + adj), indexreg);
  617. OUT_BYTE(0x64, datareg);
  618. break;
  619. case XFER_PIO_1:
  620. OUT_BYTE((0x0c + adj), indexreg);
  621. OUT_BYTE(0x46, datareg);
  622. OUT_BYTE((0x0d + adj), indexreg);
  623. OUT_BYTE(0x29, datareg);
  624. OUT_BYTE((0x13 + adj), indexreg);
  625. OUT_BYTE(0xa4, datareg);
  626. break;
  627. case XFER_PIO_0:
  628. OUT_BYTE((0x0c + adj), indexreg);
  629. OUT_BYTE(0xfb, datareg);
  630. OUT_BYTE((0x0d + adj), indexreg);
  631. OUT_BYTE(0x2b, datareg);
  632. OUT_BYTE((0x13 + adj), indexreg);
  633. OUT_BYTE(0xac, datareg);
  634. break;
  635. default:
  636. }
  637. }
  638. }
  639. return err;
  640. }
  642. /*   0    1    2    3    4    5    6   7   8
  643.  * 960, 480, 390, 300, 240, 180, 120, 90, 60
  644.  *           180, 150, 120,  90,  60
  645.  * DMA_Speed
  646.  * 180, 120,  90,  90,  90,  60,  30
  647.  *  11,   5,   4,   3,   2,   1,   0
  648.  */
  649. static int config_chipset_for_pio (ide_drive_t *drive, byte pio)
  650. {
  651. byte speed = 0x00;
  653. pio = (pio == 5) ? 4 : pio;
  654. speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, pio, NULL);
  655.         
  656. return ((int) pdc202xx_tune_chipset(drive, speed));
  657. }
  659. static void pdc202xx_tune_drive (ide_drive_t *drive, byte pio)
  660. {
  661. (void) config_chipset_for_pio(drive, pio);
  662. }
  664. #ifdef CONFIG_BLK_DEV_IDEDMA
  665. static int config_chipset_for_dma (ide_drive_t *drive, byte ultra)
  666. {
  667. struct hd_driveid *id = drive->id;
  668. ide_hwif_t *hwif = HWIF(drive);
  669. struct pci_dev *dev = hwif->pci_dev;
  670. unsigned long high_16   = pci_resource_start(dev, 4);
  671. unsigned long dma_base  = hwif->dma_base;
  672. unsigned long indexreg = dma_base + 1;
  673. unsigned long datareg = dma_base + 3;
  674. byte iordy = 0x13;
  675. byte adj = (drive->dn%2) ? 0x08 : 0x00;
  676. byte cable = 0;
  677. byte new_chip = 0;
  678. byte unit = (drive->select.b.unit & 0x01);
  679. unsigned int drive_conf;
  680. byte drive_pci = 0;
  681. byte test1, test2, speed = -1;
  682. byte AP;
  683. unsigned short EP;
  684. byte CLKSPD = 0;
  685. byte clockreg = high_16 + 0x11;
  686. byte udma_33 = ultra;
  687. byte udma_66 = ((eighty_ninty_three(drive)) && udma_33) ? 1 : 0;
  688. byte udma_100 = 0;
  689. byte udma_133 = 0;
  690. byte mask = hwif->channel ? 0x08 : 0x02;
  691. unsigned short c_mask = hwif->channel ? (1<<11) : (1<<10);
  693. byte ultra_66 = ((id->dma_ultra & 0x0010) ||
  694.    (id->dma_ultra & 0x0008)) ? 1 : 0;
  695. byte ultra_100 = ((id->dma_ultra & 0x0020) ||
  696.    (ultra_66)) ? 1 : 0;
  697. byte ultra_133 = ((id->dma_ultra & 0x0040) ||
  698.    (ultra_100)) ? 1 : 0;
  700. switch(dev->device) {
  701. case PCI_DEVICE_ID_PROMISE_20276:
  702. case PCI_DEVICE_ID_PROMISE_20275:
  703. case PCI_DEVICE_ID_PROMISE_20269:
  704. udma_133 = (udma_66) ? 1 : 0;
  705. udma_100 = (udma_66) ? 1 : 0;
  706. OUT_BYTE(0x0b, (hwif->dma_base + 1));
  707. cable = ((IN_BYTE((hwif->dma_base + 3)) & 0x04));
  708. new_chip = 1;
  709. break;
  710. case PCI_DEVICE_ID_PROMISE_20268:
  711. case PCI_DEVICE_ID_PROMISE_20270:
  712. udma_100 = (udma_66) ? 1 : 0;
  713. OUT_BYTE(0x0b, (hwif->dma_base + 1));
  714. cable = ((IN_BYTE((hwif->dma_base + 3)) & 0x04));
  715. new_chip = 1;
  716. break;
  717. case PCI_DEVICE_ID_PROMISE_20267:
  718. case PCI_DEVICE_ID_PROMISE_20265:
  719. udma_100 = (udma_66) ? 1 : 0;
  720. pci_read_config_word(dev, 0x50, &EP);
  721. cable = (EP & c_mask);
  722. new_chip = 0;
  723. CLKSPD = IN_BYTE(clockreg);
  724. break;
  725. case PCI_DEVICE_ID_PROMISE_20262:
  726. pci_read_config_word(dev, 0x50, &EP);
  727. cable = (EP & c_mask);
  728. new_chip = 0;
  729. CLKSPD = IN_BYTE(clockreg);
  730. break;
  731. default:
  732. udma_100 = 0; udma_133 = 0; cable = 0; new_chip = 1;
  733. break;
  734. }
  736. /*
  737.  * Set the control register to use the 66Mhz system
  738.  * clock for UDMA 3/4 mode operation. If one drive on
  739.  * a channel is U66 capable but the other isn't we
  740.  * fall back to U33 mode. The BIOS INT 13 hooks turn
  741.  * the clock on then off for each read/write issued. I don't
  742.  * do that here because it would require modifying the
  743.  * kernel, seperating the fop routines from the kernel or
  744.  * somehow hooking the fops calls. It may also be possible to
  745.  * leave the 66Mhz clock on and readjust the timing
  746.  * parameters.
  747.  */
  749. if (((ultra_66) || (ultra_100) || (ultra_133)) && (cable)) {
  750. #ifdef DEBUG
  751. printk("ULTRA66: %s channel of Ultra 66 requires an 80-pin cable for Ultra66 operation.n", hwif->channel ? "Secondary" : "Primary");
  752. printk("         Switching to Ultra33 mode.n");
  753. #endif /* DEBUG */
  754. /* Primary   : zero out second bit */
  755. /* Secondary : zero out fourth bit */
  756. //if (!new_chip)
  757. OUT_BYTE(CLKSPD & ~mask, clockreg);
  758. printk("Warning: %s channel requires an 80-pin cable for operation.n", hwif->channel ? "Secondary":"Primary");
  759. printk("%s reduced to Ultra33 mode.n", drive->name);
  760. udma_66 = 0; udma_100 = 0; udma_133 = 0;
  761. } else {
  762. if ((ultra_66) || (ultra_100) || (ultra_133)) {
  763. /*
  764.  * check to make sure drive on same channel
  765.  * is u66 capable
  766.  */
  767. if (hwif->drives[!(drive->dn%2)].id) {
  768. if ((hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0040) ||
  769.     (hwif->drives[!(drive->dn%2)].id->dma_ultra
  770. & 0x0020) ||
  771.     (hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0010) ||
  772.     (hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0008)) {
  773. OUT_BYTE(CLKSPD | mask, clockreg);
  774. } else {
  775. OUT_BYTE(CLKSPD & ~mask, clockreg);
  776. }
  777. } else { /* udma4 drive by itself */
  778. OUT_BYTE(CLKSPD | mask, clockreg);
  779. }
  780. }
  781. }
  783. if (new_chip) goto chipset_is_set;
  785. switch(drive->dn) {
  786. case 0: drive_pci = 0x60;
  787. pci_read_config_dword(dev, drive_pci, &drive_conf);
  788. if ((drive_conf != 0x004ff304) && (drive_conf != 0x004ff3c4))
  789. goto chipset_is_set;
  790. pci_read_config_byte(dev, (drive_pci), &test1);
  791. if (!(test1 & SYNC_ERRDY_EN))
  792. pci_write_config_byte(dev, (drive_pci), test1|SYNC_ERRDY_EN);
  793. break;
  794. case 1: drive_pci = 0x64;
  795. pci_read_config_dword(dev, drive_pci, &drive_conf);
  796. if ((drive_conf != 0x004ff304) && (drive_conf != 0x004ff3c4))
  797. goto chipset_is_set;
  798. pci_read_config_byte(dev, 0x60, &test1);
  799. pci_read_config_byte(dev, (drive_pci), &test2);
  800. if ((test1 & SYNC_ERRDY_EN) && !(test2 & SYNC_ERRDY_EN))
  801. pci_write_config_byte(dev, (drive_pci), test2|SYNC_ERRDY_EN);
  802. break;
  803. case 2: drive_pci = 0x68;
  804. pci_read_config_dword(dev, drive_pci, &drive_conf);
  805. if ((drive_conf != 0x004ff304) && (drive_conf != 0x004ff3c4))
  806. goto chipset_is_set;
  807. pci_read_config_byte(dev, (drive_pci), &test1);
  808. if (!(test1 & SYNC_ERRDY_EN))
  809. pci_write_config_byte(dev, (drive_pci), test1|SYNC_ERRDY_EN);
  810. break;
  811. case 3: drive_pci = 0x6c;
  812. pci_read_config_dword(dev, drive_pci, &drive_conf);
  813. if ((drive_conf != 0x004ff304) && (drive_conf != 0x004ff3c4))
  814. goto chipset_is_set;
  815. pci_read_config_byte(dev, 0x68, &test1);
  816. pci_read_config_byte(dev, (drive_pci), &test2);
  817. if ((test1 & SYNC_ERRDY_EN) && !(test2 & SYNC_ERRDY_EN))
  818. pci_write_config_byte(dev, (drive_pci), test2|SYNC_ERRDY_EN);
  819. break;
  820. default:
  821. return ide_dma_off;
  822. }
  824. chipset_is_set:
  826. if (drive->media != ide_disk)
  827. return ide_dma_off_quietly;
  829. if (new_chip) {
  830. if (id->capability & 4) { /* IORDY_EN & PREFETCH_EN */
  831. OUT_BYTE((iordy + adj), indexreg);
  832. OUT_BYTE((IN_BYTE(datareg)|0x03), datareg);
  833. }
  834. }
  835. else {
  836. pci_read_config_byte(dev, (drive_pci), &AP);
  837. if (id->capability & 4) /* IORDY_EN */
  838. pci_write_config_byte(dev, (drive_pci), AP|IORDY_EN);
  839. pci_read_config_byte(dev, (drive_pci), &AP);
  840. if (drive->media == ide_disk) /* PREFETCH_EN */
  841. pci_write_config_byte(dev, (drive_pci), AP|PREFETCH_EN);
  842. }
  844. if ((id->dma_ultra & 0x0040)&&(udma_133)) speed = XFER_UDMA_6;
  845. else if ((id->dma_ultra & 0x0020)&&(udma_100)) speed = XFER_UDMA_5;
  846. else if ((id->dma_ultra & 0x0010)&&(udma_66)) speed = XFER_UDMA_4;
  847. else if ((id->dma_ultra & 0x0008)&&(udma_66)) speed = XFER_UDMA_3;
  848. else if ((id->dma_ultra & 0x0004)&&(udma_33)) speed = XFER_UDMA_2;
  849. else if ((id->dma_ultra & 0x0002)&&(udma_33)) speed = XFER_UDMA_1;
  850. else if ((id->dma_ultra & 0x0001)&&(udma_33)) speed = XFER_UDMA_0;
  851. else if (id->dma_mword & 0x0004) speed = XFER_MW_DMA_2;
  852. else if (id->dma_mword & 0x0002) speed = XFER_MW_DMA_1;
  853. else if (id->dma_mword & 0x0001) speed = XFER_MW_DMA_0;
  854. else if ((id->dma_1word & 0x0004)&&(!new_chip)) speed = XFER_SW_DMA_2;
  855. else if ((id->dma_1word & 0x0002)&&(!new_chip)) speed = XFER_SW_DMA_1;
  856. else if ((id->dma_1word & 0x0001)&&(!new_chip)) speed = XFER_SW_DMA_0;
  857. else {
  858. /* restore original pci-config space */
  859. if (!new_chip)
  860. pci_write_config_dword(dev, drive_pci, drive_conf);
  861. return ide_dma_off_quietly;
  862. }
  864. outb(inb(dma_base+2) & ~(1<<(5+unit)), dma_base+2);
  865. (void) hwif->speedproc(drive, speed);
  867. return ((int) ((id->dma_ultra >> 14) & 3) ? ide_dma_on :
  868. ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
  869. ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
  870. ((id->dma_mword >> 8) & 7) ? ide_dma_on : 
  871. ((id->dma_1word >> 8) & 7) ? ide_dma_on :
  872.      ide_dma_off_quietly);
  873. }
  875. static int config_drive_xfer_rate (ide_drive_t *drive)
  876. {
  877. struct hd_driveid *id = drive->id;
  878. ide_hwif_t *hwif = HWIF(drive);
  879. ide_dma_action_t dma_func = ide_dma_off_quietly;
  881. if (id && (id->capability & 1) && hwif->autodma) {
  882. /* Consult the list of known "bad" drives */
  883. if (ide_dmaproc(ide_dma_bad_drive, drive)) {
  884. dma_func = ide_dma_off;
  885. goto fast_ata_pio;
  886. }
  887. dma_func = ide_dma_off_quietly;
  888. if (id->field_valid & 4) {
  889. if (id->dma_ultra & 0x007F) {
  890. /* Force if Capable UltraDMA */
  891. dma_func = config_chipset_for_dma(drive, 1);
  892. if ((id->field_valid & 2) &&
  893.     (dma_func != ide_dma_on))
  894. goto try_dma_modes;
  895. }
  896. } else if (id->field_valid & 2) {
  897. try_dma_modes:
  898. if ((id->dma_mword & 0x0007) ||
  899.     (id->dma_1word & 0x0007)) {
  900. /* Force if Capable regular DMA modes */
  901. dma_func = config_chipset_for_dma(drive, 0);
  902. if (dma_func != ide_dma_on)
  903. goto no_dma_set;
  904. }
  905. } else if (ide_dmaproc(ide_dma_good_drive, drive)) {
  906. if (id->eide_dma_time > 150) {
  907. goto no_dma_set;
  908. }
  909. /* Consult the list of known "good" drives */
  910. dma_func = config_chipset_for_dma(drive, 0);
  911. if (dma_func != ide_dma_on)
  912. goto no_dma_set;
  913. } else {
  914. goto fast_ata_pio;
  915. }
  916. } else if ((id->capability & 8) || (id->field_valid & 2)) {
  917. fast_ata_pio:
  918. dma_func = ide_dma_off_quietly;
  919. no_dma_set:
  920. (void) config_chipset_for_pio(drive, 5);
  921. }
  923. return HWIF(drive)->dmaproc(dma_func, drive);
  924. }
  926. int pdc202xx_quirkproc (ide_drive_t *drive)
  927. {
  928. return ((int) check_in_drive_lists(drive, pdc_quirk_drives));
  929. }
  931. /*
  932.  * pdc202xx_dmaproc() initiates/aborts (U)DMA read/write operations on a drive.
  933.  */
  934. int pdc202xx_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  935. {
  936. byte dma_stat = 0;
  937. byte sc1d = 0;
  938. byte newchip = 0;
  939. byte clock = 0;
  940. byte hardware48fix = 0;
  941. ide_hwif_t *hwif = HWIF(drive);
  942. struct pci_dev *dev = hwif->pci_dev;
  943. unsigned long high_16 = pci_resource_start(dev, 4);
  944. unsigned long dma_base = hwif->dma_base;
  945. unsigned long atapi_port= hwif->channel ? high_16+0x24 : high_16+0x20;
  947. switch (dev->device) {
  948. case PCI_DEVICE_ID_PROMISE_20276:
  949. case PCI_DEVICE_ID_PROMISE_20275:
  950. case PCI_DEVICE_ID_PROMISE_20269:
  951. case PCI_DEVICE_ID_PROMISE_20268:
  952. case PCI_DEVICE_ID_PROMISE_20270:
  953. newchip = 1;
  954. break;
  955. case PCI_DEVICE_ID_PROMISE_20267:
  956. case PCI_DEVICE_ID_PROMISE_20265:
  957. hardware48fix = 1;
  958. clock = IN_BYTE(high_16 + 0x11);
  959. default:
  960. break;
  961. }
  963. switch (func) {
  964. case ide_dma_check:
  965. return config_drive_xfer_rate(drive);
  966. case ide_dma_begin:
  967. /* Note that this is done *after* the cmd has
  968.  * been issued to the drive, as per the BM-IDE spec.
  969.  * The Promise Ultra33 doesn't work correctly when
  970.  * we do this part before issuing the drive cmd.
  971.  */
  972. /* Enable ATAPI UDMA port for 48bit data on PDC20267 */
  973. if ((drive->addressing) && (hardware48fix)) {
  974. struct request *rq = HWGROUP(drive)->rq;
  975. unsigned long word_count = 0;
  976. unsigned long hankval = 0;
  977. byte clockreg = high_16 + 0x11;
  979. OUT_BYTE(clock|(hwif->channel ? 0x08:0x02), clockreg);
  980. word_count = (rq->nr_sectors << 8);
  981. hankval = (rq->cmd == READ) ? 0x05<<24 : 0x06<<24;
  982. hankval = hankval | word_count ;
  983. outl(hankval, atapi_port);
  984. }  
  985. break;
  986. case ide_dma_end:
  987. /* Disable ATAPI UDMA port for 48bit data on PDC20267 */
  988. if ((drive->addressing) && (hardware48fix)) {
  989. unsigned long hankval = 0;
  990. byte clockreg = high_16 + 0x11;
  992.      outl(hankval, atapi_port); /* zero out extra */
  993. clock = IN_BYTE(clockreg);
  994. OUT_BYTE(clock & ~(hwif->channel ? 0x08:0x02), clockreg);
  995. }
  996. break;
  997. case ide_dma_test_irq: /* returns 1 if dma irq issued, 0 otherwise */
  998. dma_stat = IN_BYTE(dma_base+2);
  999. if (newchip)
  1000. return (dma_stat & 4) == 4;
  1002. sc1d = IN_BYTE(high_16 + 0x001d);
  1003. if (HWIF(drive)->channel) {
  1004. if ((sc1d & 0x50) == 0x50) goto somebody_else;
  1005. else if ((sc1d & 0x40) == 0x40)
  1006. return (dma_stat & 4) == 4;
  1007. } else {
  1008. if ((sc1d & 0x05) == 0x05) goto somebody_else;
  1009. else if ((sc1d & 0x04) == 0x04)
  1010. return (dma_stat & 4) == 4;
  1011. }
  1012. somebody_else:
  1013. return (dma_stat & 4) == 4; /* return 1 if INTR asserted */
  1014. case ide_dma_lostirq:
  1015. case ide_dma_timeout:
  1016. if (HWIF(drive)->resetproc != NULL)
  1017. HWIF(drive)->resetproc(drive);
  1018. default:
  1019. break;
  1020. }
  1021. return ide_dmaproc(func, drive); /* use standard DMA stuff */
  1022. }
  1023. #endif /* CONFIG_BLK_DEV_IDEDMA */
  1025. void pdc202xx_reset (ide_drive_t *drive)
  1026. {
  1027. OUT_BYTE(0x04,IDE_CONTROL_REG);
  1028. mdelay(1000);
  1029. OUT_BYTE(0x00,IDE_CONTROL_REG);
  1030. mdelay(1000);
  1031. printk("PDC202XX: %s channel reset.n",
  1032. HWIF(drive)->channel ? "Secondary" : "Primary");
  1033. }
  1035. /*
  1036.  * Since SUN Cobalt is attempting to do this operation, I should disclose
  1037.  * this has been a long time ago Thu Jul 27 16:40:57 2000 was the patch date
  1038.  * HOTSWAP ATA Infrastructure.
  1039.  */
  1040. static int pdc202xx_tristate (ide_drive_t * drive, int state)
  1041. {
  1042. #if 0
  1043. ide_hwif_t *hwif = HWIF(drive);
  1044. unsigned long high_16 = pci_resource_start(hwif->pci_dev, 4);
  1045. byte sc1f = inb(high_16 + 0x001f);
  1047. if (!hwif)
  1048. return -EINVAL;
  1050. // hwif->bus_state = state;
  1052. if (state) {
  1053. outb(sc1f | 0x08, high_16 + 0x001f);
  1054. } else {
  1055. outb(sc1f & ~0x08, high_16 + 0x001f);
  1056. }
  1057. #endif
  1058. return 0;
  1059. }
  1061. unsigned int __init pci_init_pdc202xx (struct pci_dev *dev, const char *name)
  1062. {
  1063. unsigned long high_16 = pci_resource_start(dev, 4);
  1064. byte udma_speed_flag = IN_BYTE(high_16 + 0x001f);
  1065. byte primary_mode = IN_BYTE(high_16 + 0x001a);
  1066. byte secondary_mode = IN_BYTE(high_16 + 0x001b);
  1068. OUT_BYTE(udma_speed_flag | 0x10, high_16 + 0x001f);
  1069. mdelay(100);
  1070. OUT_BYTE(udma_speed_flag & ~0x10, high_16 + 0x001f);
  1071. mdelay(2000); /* 2 seconds ?! */
  1073. if (dev->resource[PCI_ROM_RESOURCE].start) {
  1074. pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
  1075. printk("%s: ROM enabled at 0x%08lxn", name, dev->resource[PCI_ROM_RESOURCE].start);
  1076. }
  1078. printk("%s: (U)DMA Burst Bit %sABLED " 
  1079. "Primary %s Mode " 
  1080. "Secondary %s Mode.n",
  1081. name,
  1082. (udma_speed_flag & 1) ? "EN" : "DIS",
  1083. (primary_mode & 1) ? "MASTER" : "PCI",
  1084. (secondary_mode & 1) ? "MASTER" : "PCI" );
  1086. #ifdef CONFIG_PDC202XX_BURST
  1087. if (!(udma_speed_flag & 1)) {
  1088. printk("%s: FORCING BURST BIT 0x%02x -> 0x%02x ", name, udma_speed_flag, (udma_speed_flag|1));
  1089. OUT_BYTE(udma_speed_flag|1, high_16 + 0x001f);
  1090. printk("%sCTIVEn", (IN_BYTE(high_16 + 0x001f) & 1) ? "A" : "INA");
  1091. }
  1092. #endif /* CONFIG_PDC202XX_BURST */
  1094. #ifdef CONFIG_PDC202XX_MASTER
  1095. if (!(primary_mode & 1)) {
  1096. printk("%s: FORCING PRIMARY MODE BIT 0x%02x -> 0x%02x ",
  1097. name, primary_mode, (primary_mode|1));
  1098. OUT_BYTE(primary_mode|1, high_16 + 0x001a);
  1099. printk("%sn", (IN_BYTE(high_16 + 0x001a) & 1) ? "MASTER" : "PCI");
  1100. }
  1102. if (!(secondary_mode & 1)) {
  1103. printk("%s: FORCING SECONDARY MODE BIT 0x%02x -> 0x%02x ",
  1104. name, secondary_mode, (secondary_mode|1));
  1105. OUT_BYTE(secondary_mode|1, high_16 + 0x001b);
  1106. printk("%sn", (IN_BYTE(high_16 + 0x001b) & 1) ? "MASTER" : "PCI");
  1107. }
  1108. #endif /* CONFIG_PDC202XX_MASTER */
  1110. #if defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS)
  1111. if (!pdc202xx_proc) {
  1112. pdc202xx_proc = 1;
  1113. bmide_dev = dev;
  1114. pdc202xx_display_info = &pdc202xx_get_info;
  1115. }
  1116. #endif /* DISPLAY_PDC202XX_TIMINGS && CONFIG_PROC_FS */
  1117. return dev->irq;
  1118. }
  1120. unsigned int __init ata66_pdc202xx (ide_hwif_t *hwif)
  1121. {
  1122. unsigned short mask = (hwif->channel) ? (1<<11) : (1<<10);
  1123. unsigned short CIS;
  1125.          switch(hwif->pci_dev->device) {
  1126. case PCI_DEVICE_ID_PROMISE_20276:
  1127. case PCI_DEVICE_ID_PROMISE_20275:
  1128. case PCI_DEVICE_ID_PROMISE_20269:
  1129. case PCI_DEVICE_ID_PROMISE_20268:
  1130. case PCI_DEVICE_ID_PROMISE_20270:
  1131. OUT_BYTE(0x0b, (hwif->dma_base + 1));
  1132. return (!(IN_BYTE((hwif->dma_base + 3)) & 0x04));
  1133. /* check 80pin cable */
  1134. default:
  1135. pci_read_config_word(hwif->pci_dev, 0x50, &CIS);
  1136. return (!(CIS & mask));
  1137. /* check 80pin cable */
  1138. }
  1139. }
  1141. void __init ide_init_pdc202xx (ide_hwif_t *hwif)
  1142. {
  1143. hwif->tuneproc  = &pdc202xx_tune_drive;
  1144. hwif->quirkproc = &pdc202xx_quirkproc;
  1145. hwif->resetproc = &pdc202xx_reset;
  1147.         switch(hwif->pci_dev->device) {
  1148. case PCI_DEVICE_ID_PROMISE_20276:
  1149. case PCI_DEVICE_ID_PROMISE_20275:
  1150. case PCI_DEVICE_ID_PROMISE_20269:
  1151. case PCI_DEVICE_ID_PROMISE_20268:
  1152. case PCI_DEVICE_ID_PROMISE_20270:
  1153. hwif->speedproc = &pdc202xx_new_tune_chipset;
  1154. break;
  1155. case PCI_DEVICE_ID_PROMISE_20267:
  1156. case PCI_DEVICE_ID_PROMISE_20265:
  1157. case PCI_DEVICE_ID_PROMISE_20262:
  1158. hwif->busproc   = &pdc202xx_tristate;
  1159. case PCI_DEVICE_ID_PROMISE_20246:
  1160. hwif->speedproc = &pdc202xx_tune_chipset;
  1161. default:
  1162. break;
  1163. }
  1165. #undef CONFIG_PDC202XX_32_UNMASK
  1166. #ifdef CONFIG_PDC202XX_32_UNMASK
  1167. hwif->drives[0].io_32bit = 1;
  1168. hwif->drives[1].io_32bit = 1;
  1169. hwif->drives[0].unmask = 1;
  1170. hwif->drives[1].unmask = 1;
  1171. #endif /* CONFIG_PDC202XX_32_UNMASK */
  1173. #ifdef CONFIG_BLK_DEV_IDEDMA
  1174. if (hwif->dma_base) {
  1175. hwif->dmaproc = &pdc202xx_dmaproc;
  1176. if (!noautodma)
  1177. hwif->autodma = 1;
  1178. } else {
  1179. hwif->drives[0].autotune = 1;
  1180. hwif->drives[1].autotune = 1;
  1181. hwif->autodma = 0;
  1182. }
  1183. #else /* !CONFIG_BLK_DEV_IDEDMA */
  1184. hwif->drives[0].autotune = 1;
  1185. hwif->drives[1].autotune = 1;
  1186. hwif->autodma = 0;
  1187. #endif /* CONFIG_BLK_DEV_IDEDMA */
  1188. }