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

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

嵌入式Linux

开发平台：

Unix_Linux

icside.c：源码内容
  1. /*
  2.  * linux/drivers/ide/icside.c
  3.  *
  4.  * Copyright (c) 1996,1997 Russell King.
  5.  *
  6.  * Changelog:
  7.  *  08-Jun-1996 RMK Created
  8.  *  12-Sep-1997 RMK Added interrupt enable/disable
  9.  *  17-Apr-1999 RMK Added support for V6 EASI
  10.  *  22-May-1999 RMK Added support for V6 DMA
  11.  */
  13. #include <linux/config.h>
  14. #include <linux/string.h>
  15. #include <linux/module.h>
  16. #include <linux/ioport.h>
  17. #include <linux/slab.h>
  18. #include <linux/blkdev.h>
  19. #include <linux/errno.h>
  20. #include <linux/hdreg.h>
  21. #include <linux/ide.h>
  22. #include <linux/pci.h>
  23. #include <linux/init.h>
  25. #include <asm/dma.h>
  26. #include <asm/ecard.h>
  27. #include <asm/io.h>
  29. extern char *ide_xfer_verbose (byte xfer_rate);
  30. extern char *ide_dmafunc_verbose(ide_dma_action_t dmafunc);
  32. /*
  33.  * Maximum number of interfaces per card
  34.  */
  35. #define MAX_IFS 2
  37. #define ICS_IDENT_OFFSET 0x8a0
  39. #define ICS_ARCIN_V5_INTRSTAT 0x000
  40. #define ICS_ARCIN_V5_INTROFFSET 0x001
  41. #define ICS_ARCIN_V5_IDEOFFSET 0xa00
  42. #define ICS_ARCIN_V5_IDEALTOFFSET 0xae0
  43. #define ICS_ARCIN_V5_IDESTEPPING 4
  45. #define ICS_ARCIN_V6_IDEOFFSET_1 0x800
  46. #define ICS_ARCIN_V6_INTROFFSET_1 0x880
  47. #define ICS_ARCIN_V6_INTRSTAT_1 0x8a4
  48. #define ICS_ARCIN_V6_IDEALTOFFSET_1 0x8e0
  49. #define ICS_ARCIN_V6_IDEOFFSET_2 0xc00
  50. #define ICS_ARCIN_V6_INTROFFSET_2 0xc80
  51. #define ICS_ARCIN_V6_INTRSTAT_2 0xca4
  52. #define ICS_ARCIN_V6_IDEALTOFFSET_2 0xce0
  53. #define ICS_ARCIN_V6_IDESTEPPING 4
  55. struct cardinfo {
  56. unsigned int dataoffset;
  57. unsigned int ctrloffset;
  58. unsigned int stepping;
  59. };
  61. static struct cardinfo icside_cardinfo_v5 = {
  62. ICS_ARCIN_V5_IDEOFFSET,
  63. ICS_ARCIN_V5_IDEALTOFFSET,
  64. ICS_ARCIN_V5_IDESTEPPING
  65. };
  67. static struct cardinfo icside_cardinfo_v6_1 = {
  68. ICS_ARCIN_V6_IDEOFFSET_1,
  69. ICS_ARCIN_V6_IDEALTOFFSET_1,
  70. ICS_ARCIN_V6_IDESTEPPING
  71. };
  73. static struct cardinfo icside_cardinfo_v6_2 = {
  74. ICS_ARCIN_V6_IDEOFFSET_2,
  75. ICS_ARCIN_V6_IDEALTOFFSET_2,
  76. ICS_ARCIN_V6_IDESTEPPING
  77. };
  79. struct icside_state {
  80. unsigned int channel;
  81. unsigned int enabled;
  82. unsigned int irq_port;
  83. };
  85. static const card_ids icside_cids[] = {
  86. { MANU_ICS,  PROD_ICS_IDE  },
  87. { MANU_ICS2, PROD_ICS2_IDE },
  88. { 0xffff, 0xffff }
  89. };
  91. typedef enum {
  92. ics_if_unknown,
  93. ics_if_arcin_v5,
  94. ics_if_arcin_v6
  95. } iftype_t;
  97. /* ---------------- Version 5 PCB Support Functions --------------------- */
  98. /* Prototype: icside_irqenable_arcin_v5 (struct expansion_card *ec, int irqnr)
  99.  * Purpose  : enable interrupts from card
  100.  */
  101. static void icside_irqenable_arcin_v5 (struct expansion_card *ec, int irqnr)
  102. {
  103. unsigned int memc_port = (unsigned int)ec->irq_data;
  104. outb (0, memc_port + ICS_ARCIN_V5_INTROFFSET);
  105. }
  107. /* Prototype: icside_irqdisable_arcin_v5 (struct expansion_card *ec, int irqnr)
  108.  * Purpose  : disable interrupts from card
  109.  */
  110. static void icside_irqdisable_arcin_v5 (struct expansion_card *ec, int irqnr)
  111. {
  112. unsigned int memc_port = (unsigned int)ec->irq_data;
  113. inb (memc_port + ICS_ARCIN_V5_INTROFFSET);
  114. }
  116. static const expansioncard_ops_t icside_ops_arcin_v5 = {
  117. icside_irqenable_arcin_v5,
  118. icside_irqdisable_arcin_v5,
  119. NULL,
  120. NULL,
  121. NULL,
  122. NULL
  123. };
  126. /* ---------------- Version 6 PCB Support Functions --------------------- */
  127. /* Prototype: icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
  128.  * Purpose  : enable interrupts from card
  129.  */
  130. static void icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
  131. {
  132. struct icside_state *state = ec->irq_data;
  133. unsigned int base = state->irq_port;
  135. state->enabled = 1;
  137. switch (state->channel) {
  138. case 0:
  139. outb(0, base + ICS_ARCIN_V6_INTROFFSET_1);
  140. inb(base + ICS_ARCIN_V6_INTROFFSET_2);
  141. break;
  142. case 1:
  143. outb(0, base + ICS_ARCIN_V6_INTROFFSET_2);
  144. inb(base + ICS_ARCIN_V6_INTROFFSET_1);
  145. break;
  146. }
  147. }
  149. /* Prototype: icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
  150.  * Purpose  : disable interrupts from card
  151.  */
  152. static void icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
  153. {
  154. struct icside_state *state = ec->irq_data;
  156. state->enabled = 0;
  158. inb (state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
  159. inb (state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
  160. }
  162. /* Prototype: icside_irqprobe(struct expansion_card *ec)
  163.  * Purpose  : detect an active interrupt from card
  164.  */
  165. static int icside_irqpending_arcin_v6(struct expansion_card *ec)
  166. {
  167. struct icside_state *state = ec->irq_data;
  169. return inb(state->irq_port + ICS_ARCIN_V6_INTRSTAT_1) & 1 ||
  170.        inb(state->irq_port + ICS_ARCIN_V6_INTRSTAT_2) & 1;
  171. }
  173. static const expansioncard_ops_t icside_ops_arcin_v6 = {
  174. icside_irqenable_arcin_v6,
  175. icside_irqdisable_arcin_v6,
  176. icside_irqpending_arcin_v6,
  177. NULL,
  178. NULL,
  179. NULL
  180. };
  182. /* Prototype: icside_identifyif (struct expansion_card *ec)
  183.  * Purpose  : identify IDE interface type
  184.  * Notes    : checks the description string
  185.  */
  186. static iftype_t __init icside_identifyif (struct expansion_card *ec)
  187. {
  188. unsigned int addr;
  189. iftype_t iftype;
  190. int id = 0;
  192. iftype = ics_if_unknown;
  194. addr = ecard_address (ec, ECARD_IOC, ECARD_FAST) + ICS_IDENT_OFFSET;
  196. id = inb (addr) & 1;
  197. id |= (inb (addr + 1) & 1) << 1;
  198. id |= (inb (addr + 2) & 1) << 2;
  199. id |= (inb (addr + 3) & 1) << 3;
  201. switch (id) {
  202. case 0: /* A3IN */
  203. printk("icside: A3IN unsupportedn");
  204. break;
  206. case 1: /* A3USER */
  207. printk("icside: A3USER unsupportedn");
  208. break;
  210. case 3: /* ARCIN V6 */
  211. printk(KERN_DEBUG "icside: detected ARCIN V6 in slot %dn", ec->slot_no);
  212. iftype = ics_if_arcin_v6;
  213. break;
  215. case 15:/* ARCIN V5 (no id) */
  216. printk(KERN_DEBUG "icside: detected ARCIN V5 in slot %dn", ec->slot_no);
  217. iftype = ics_if_arcin_v5;
  218. break;
  220. default:/* we don't know - complain very loudly */
  221. printk("icside: ***********************************n");
  222. printk("icside: *** UNKNOWN ICS INTERFACE id=%d ***n", id);
  223. printk("icside: ***********************************n");
  224. printk("icside: please report this to linux@arm.linux.org.ukn");
  225. printk("icside: defaulting to ARCIN V5n");
  226. iftype = ics_if_arcin_v5;
  227. break;
  228. }
  230. return iftype;
  231. }
  233. /*
  234.  * Handle routing of interrupts.  This is called before
  235.  * we write a command to the drive.
  236.  */
  237. static void icside_maskproc(ide_drive_t *drive, int mask)
  238. {
  239. ide_hwif_t *hwif = HWIF(drive);
  240. struct icside_state *state = hwif->hw.priv;
  241. unsigned long flags;
  243. local_irq_save(flags);
  245. state->channel = hwif->channel;
  247. if (state->enabled && !mask) {
  248. switch (hwif->channel) {
  249. case 0:
  250. outb(0, state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
  251. inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
  252. break;
  253. case 1:
  254. outb(0, state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
  255. inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
  256. break;
  257. }
  258. } else {
  259. inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
  260. inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
  261. }
  263. local_irq_restore(flags);
  264. }
  266. #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
  268. static int icside_dmaproc(ide_dma_action_t func, ide_drive_t *drive);
  270. /*
  271.  * SG-DMA support.
  272.  *
  273.  * Similar to the BM-DMA, but we use the RiscPCs IOMD DMA controllers.
  274.  * There is only one DMA controller per card, which means that only
  275.  * one drive can be accessed at one time.  NOTE! We do not enforce that
  276.  * here, but we rely on the main IDE driver spotting that both
  277.  * interfaces use the same IRQ, which should guarantee this.
  278.  */
  279. #define NR_ENTRIES 256
  280. #define TABLE_SIZE (NR_ENTRIES * 8)
  282. static int icside_build_dmatable(ide_drive_t *drive, int dma_mode)
  283. {
  284. ide_hwif_t *hwif = HWIF(drive);
  285. struct request *rq = HWGROUP(drive)->rq;
  286. struct buffer_head *bh;
  287. struct scatterlist *sg = hwif->sg_table;
  288. int nents = 0;
  290. bh = rq->bh;
  291. do {
  292. char *virt_addr;
  294. memset(sg, 0, sizeof(*sg));
  295. sg->address = virt_addr = bh->b_data;
  297. do {
  298. virt_addr += bh->b_size;
  300. bh = bh->b_reqnext;
  301. if (bh == NULL)
  302. break;
  304. } while (virt_addr == bh->b_data);
  306. sg->length = virt_addr - (char *)sg->address;
  307. sg++;
  308. nents++;
  309. } while (bh != NULL);
  311. if (dma_mode == DMA_MODE_READ)
  312. hwif->sg_dma_direction = PCI_DMA_FROMDEVICE;
  313. else
  314. hwif->sg_dma_direction = PCI_DMA_TODEVICE;
  316. hwif->sg_nents = pci_map_sg(NULL, hwif->sg_table, nents,
  317.     hwif->sg_dma_direction);
  319. return hwif->sg_nents;
  320. }
  322. /* Teardown mappings after DMA has completed.  */
  323. static inline void icside_destroy_dmatable(ide_hwif_t *hwif)
  324. {
  325. pci_unmap_sg(NULL, hwif->sg_table, hwif->sg_nents,
  326.      hwif->sg_dma_direction);
  327. }
  329. /*
  330.  * Configure the IOMD to give the appropriate timings for the transfer
  331.  * mode being requested.  We take the advice of the ATA standards, and
  332.  * calculate the cycle time based on the transfer mode, and the EIDE
  333.  * MW DMA specs that the drive provides in the IDENTIFY command.
  334.  *
  335.  * We have the following IOMD DMA modes to choose from:
  336.  *
  337.  * Type Active Recovery Cycle
  338.  * A 250 (250) 312 (550) 562 (800)
  339.  * B 187 250 437
  340.  * C 125 (125) 125 (375) 250 (500)
  341.  * D 62 125 187
  342.  *
  343.  * (figures in brackets are actual measured timings)
  344.  *
  345.  * However, we also need to take care of the read/write active and
  346.  * recovery timings:
  347.  *
  348.  * Read Write
  349.  *   Mode Active -- Recovery -- Cycle IOMD type
  350.  * MW0 215 50 215 480 A
  351.  * MW1 80 50 50 150 C
  352.  * MW2 70 25 25 120 C
  353.  */
  354. static int icside_speedproc(ide_drive_t *drive, byte xfer_mode)
  355. {
  356. int func = ide_dma_off;
  357. int cycle_time = 0, use_dma_info = 0;
  359. /*
  360.  * Limit the transfer speed to MW_DMA_2.
  361.  */
  362. if (xfer_mode > XFER_MW_DMA_2)
  363. xfer_mode = XFER_MW_DMA_2;
  365. switch (xfer_mode) {
  366. case XFER_MW_DMA_2:
  367. cycle_time = 250;
  368. use_dma_info = 1;
  369. break;
  370. case XFER_MW_DMA_1:
  371. cycle_time = 250;
  372. use_dma_info = 1;
  373. break;
  374. case XFER_MW_DMA_0:
  375. cycle_time = 480;
  376. break;
  378. case XFER_SW_DMA_2:
  379. case XFER_SW_DMA_1:
  380. case XFER_SW_DMA_0:
  381. cycle_time = 480;
  382. break;
  384. default:
  385. func = ide_dma_off;
  386. break;
  387. }
  389. /*
  390.  * If we're going to be doing MW_DMA_1 or MW_DMA_2, we should
  391.  * take care to note the values in the ID...
  392.  */
  393. if (use_dma_info && drive->id->eide_dma_time > cycle_time)
  394. cycle_time = drive->id->eide_dma_time;
  396. drive->drive_data = cycle_time;
  398. if (cycle_time && ide_config_drive_speed(drive, xfer_mode) == 0)
  399. func = ide_dma_on;
  400. else
  401. drive->drive_data = 480;
  403. if (!drive->init_speed)
  404. drive->init_speed = xfer_mode;
  405. else if (cycle_time)
  406. printk("%s: %s selected (peak %dMB/s)n", drive->name,
  407. ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data);
  409. drive->current_speed = xfer_mode;
  411. return func;
  412. }
  414. /*
  415.  * dma_intr() is the handler for disk read/write DMA interrupts
  416.  */
  417. static ide_startstop_t icside_dmaintr(ide_drive_t *drive)
  418. {
  419. byte stat, dma_stat;
  421. dma_stat = icside_dmaproc(ide_dma_end, drive);
  423. /*
  424.  * Verify the drive status
  425.  */
  426. stat = GET_STAT();
  427. if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
  428. if (!dma_stat) {
  429. struct request *rq = HWGROUP(drive)->rq;
  430. int i;
  432. for (i = rq->nr_sectors; i > 0;) {
  433. i -= rq->current_nr_sectors;
  434. ide_end_request(1, HWGROUP(drive));
  435. }
  437. return ide_stopped;
  438. }
  439. printk("%s: dma_intr: bad DMA status (dma_stat=%x)n", 
  440.        drive->name, dma_stat);
  441. }
  442. return ide_error(drive, "dma_intr", stat);
  443. }
  445. /*
  446.  * The following is a sick duplication from ide-dma.c ;(
  447.  *
  448.  * This should be defined in one place only.
  449.  */
  450. struct drive_list_entry {
  451. char * id_model;
  452. char * id_firmware;
  453. };
  455. static struct drive_list_entry drive_whitelist [] = {
  456. { "Micropolis 2112A", "ALL" },
  457. { "CONNER CTMA 4000", "ALL" },
  458. { "CONNER CTT8000-A", "ALL" },
  459. { "ST34342A", "ALL" },
  460. { NULL, 0 }
  461. };
  463. static struct drive_list_entry drive_blacklist [] = {
  464. { "WDC AC11000H", "ALL" },
  465. { "WDC AC22100H", "ALL" },
  466. { "WDC AC32500H", "ALL" },
  467. { "WDC AC33100H", "ALL" },
  468. { "WDC AC31600H", "ALL" },
  469. { "WDC AC32100H", "24.09P07" },
  470. { "WDC AC23200L", "21.10N21" },
  471. { "Compaq CRD-8241B", "ALL" },
  472. { "CRD-8400B", "ALL" },
  473. { "CRD-8480B", "ALL" },
  474. { "CRD-8480C", "ALL" },
  475. { "CRD-8482B", "ALL" },
  476.   { "CRD-84", "ALL" },
  477. { "SanDisk SDP3B", "ALL" },
  478. { "SanDisk SDP3B-64", "ALL" },
  479. { "SANYO CD-ROM CRD", "ALL" },
  480. { "HITACHI CDR-8", "ALL" },
  481. { "HITACHI CDR-8335", "ALL" },
  482. { "HITACHI CDR-8435", "ALL" },
  483. { "Toshiba CD-ROM XM-6202B", "ALL" },
  484. { "CD-532E-A", "ALL" },
  485. { "E-IDE CD-ROM CR-840", "ALL" },
  486. { "CD-ROM Drive/F5A", "ALL" },
  487. { "RICOH CD-R/RW MP7083A", "ALL" },
  488. { "WPI CDD-820", "ALL" },
  489. { "SAMSUNG CD-ROM SC-148C", "ALL" },
  490. { "SAMSUNG CD-ROM SC-148F", "ALL" },
  491. { "SAMSUNG CD-ROM SC", "ALL" },
  492. { "SanDisk SDP3B-64", "ALL" },
  493. { "SAMSUNG CD-ROM SN-124", "ALL" },
  494. { "PLEXTOR CD-R PX-W8432T", "ALL" },
  495. { "ATAPI CD-ROM DRIVE 40X MAXIMUM", "ALL" },
  496. { "_NEC DV5800A", "ALL" },
  497. { NULL, 0 }
  498. };
  500. static int
  501. in_drive_list(struct hd_driveid *id, struct drive_list_entry *drive_table)
  502. {
  503. for ( ; drive_table->id_model ; drive_table++)
  504. if ((!strcmp(drive_table->id_model, id->model)) &&
  505.     ((!strstr(drive_table->id_firmware, id->fw_rev)) ||
  506.      (!strcmp(drive_table->id_firmware, "ALL"))))
  507. return 1;
  508. return 0;
  509. }
  511. static int icside_check_drive_lists(ide_drive_t *drive, ide_dma_action_t func)
  512. {
  513. struct hd_driveid *id = drive->id;
  514. int found;
  516. if (func == ide_dma_good_drive) {
  517. found = in_drive_list(id, drive_whitelist);
  518. } else {
  519. found = in_drive_list(id, drive_blacklist);
  520. if (found)
  521. printk("%s: Disabling DMA for %s (blacklisted)n",
  522. drive->name, id->model);
  523. }
  524. return found;
  525. }
  527. static int icside_dma_check(ide_drive_t *drive)
  528. {
  529. struct hd_driveid *id = drive->id;
  530. ide_hwif_t *hwif = HWIF(drive);
  531. int autodma = hwif->autodma;
  532. int xfer_mode = XFER_PIO_2;
  533. int func = ide_dma_off_quietly;
  535. if (!id || !(id->capability & 1) || !autodma)
  536. goto out;
  538. /*
  539.  * Consult the list of known "bad" drives
  540.  */
  541. if (icside_check_drive_lists(drive, ide_dma_bad_drive))
  542. goto out;
  544. /*
  545.  * Enable DMA on any drive that has multiword DMA
  546.  */
  547. if (id->field_valid & 2) {
  548. if (id->dma_mword & 4) {
  549. xfer_mode = XFER_MW_DMA_2;
  550. func = ide_dma_on;
  551. } else if (id->dma_mword & 2) {
  552. xfer_mode = XFER_MW_DMA_1;
  553. func = ide_dma_on;
  554. } else if (id->dma_mword & 1) {
  555. xfer_mode = XFER_MW_DMA_0;
  556. func = ide_dma_on;
  557. }
  558. goto out;
  559. }
  561. /*
  562.  * Consult the list of known "good" drives
  563.  */
  564. if (icside_check_drive_lists(drive, ide_dma_good_drive)) {
  565. if (id->eide_dma_time > 150)
  566. goto out;
  567. xfer_mode = XFER_MW_DMA_1;
  568. func = ide_dma_on;
  569. }
  571. out:
  572. func = icside_speedproc(drive, xfer_mode);
  574. return icside_dmaproc(func, drive);
  575. }
  577. static int icside_dma_verbose(ide_drive_t *drive)
  578. {
  579. printk(", %s (peak %dMB/s)",
  580. ide_xfer_verbose(drive->current_speed),
  581. 2000 / drive->drive_data);
  582. return 1;
  583. }
  585. static int icside_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
  586. {
  587. ide_hwif_t *hwif = HWIF(drive);
  588. struct icside_state *state = hwif->hw.priv;
  589. int count, dma_mode = DMA_MODE_READ;
  591. switch (func) {
  592. case ide_dma_off:
  593. printk("%s: DMA disabledn", drive->name);
  594. /*FALLTHROUGH*/
  596. case ide_dma_off_quietly:
  597. case ide_dma_on:
  598. drive->using_dma = (func == ide_dma_on);
  599. return 0;
  601. case ide_dma_check:
  602. return icside_dma_check(drive);
  604. case ide_dma_write:
  605. dma_mode = DMA_MODE_WRITE;
  606. case ide_dma_read:
  607. count = icside_build_dmatable(drive, dma_mode);
  608. if (!count)
  609. return 1;
  610. disable_dma(hwif->hw.dma);
  612. /*
  613.  * Ensure that we have the right interrupt routed.
  614.  */
  615. icside_maskproc(drive, 0);
  617. /*
  618.  * Route the DMA signals to to the correct interface.
  619.  */
  620. outb(hwif->select_data, hwif->config_data);
  622. /*
  623.  * Select the correct timing for this drive.
  624.  */
  625. set_dma_speed(hwif->hw.dma, drive->drive_data);
  626. set_dma_sg(hwif->hw.dma, HWIF(drive)->sg_table, count);
  627. set_dma_mode(hwif->hw.dma, dma_mode);
  629. drive->waiting_for_dma = 1;
  630. if (drive->media != ide_disk)
  631. return 0;
  633. ide_set_handler(drive, &icside_dmaintr, WAIT_CMD, NULL);
  634. OUT_BYTE(dma_mode == DMA_MODE_READ ?
  635.  WIN_READDMA : WIN_WRITEDMA, IDE_COMMAND_REG);
  636. /*FALLTHROUGH*/
  638. case ide_dma_begin:
  639. enable_dma(hwif->hw.dma);
  640. return 0;
  642. case ide_dma_end:
  643. drive->waiting_for_dma = 0;
  644. disable_dma(hwif->hw.dma);
  645. icside_destroy_dmatable(hwif);
  646. return get_dma_residue(hwif->hw.dma) != 0;
  648. case ide_dma_test_irq:
  649. return inb(state->irq_port +
  650. (hwif->channel ?
  651. ICS_ARCIN_V6_INTRSTAT_2 :
  652. ICS_ARCIN_V6_INTRSTAT_1)) & 1;
  654. case ide_dma_bad_drive:
  655. case ide_dma_good_drive:
  656. return icside_check_drive_lists(drive, func);
  658. case ide_dma_verbose:
  659. return icside_dma_verbose(drive);
  661. case ide_dma_lostirq:
  662. case ide_dma_timeout:
  663. default:
  664. printk("icside_dmaproc: unsupported %s func: %dn",
  665. ide_dmafunc_verbose(func), func);
  666. }
  667. return 1;
  668. }
  670. static int icside_setup_dma(ide_hwif_t *hwif, int autodma)
  671. {
  672. hwif->sg_table = kmalloc(sizeof(struct scatterlist) * NR_ENTRIES,
  673.  GFP_KERNEL);
  674. if (!hwif->sg_table)
  675. goto failed;
  677. hwif->dmatable_cpu = NULL;
  678. hwif->dmatable_dma = 0;
  679. hwif->speedproc    = icside_speedproc;
  680. hwif->dmaproc      = icside_dmaproc;
  681. hwif->autodma      = autodma;
  683. return 1;
  685. failed:
  686. printk(" -- ERROR, unable to allocate DMA tablen");
  687. return 0;
  688. }
  690. int ide_release_dma(ide_hwif_t *hwif)
  691. {
  692. if (hwif->sg_table) {
  693. kfree(hwif->sg_table);
  694. hwif->sg_table = NULL;
  695. }
  696. return 1;
  697. }
  698. #endif
  700. static ide_hwif_t *icside_find_hwif(unsigned long dataport)
  701. {
  702. ide_hwif_t *hwif;
  703. int index;
  705. for (index = 0; index < MAX_HWIFS; ++index) {
  706. hwif = &ide_hwifs[index];
  707. if (hwif->io_ports[IDE_DATA_OFFSET] == (ide_ioreg_t)dataport)
  708. goto found;
  709. }
  711. for (index = 0; index < MAX_HWIFS; ++index) {
  712. hwif = &ide_hwifs[index];
  713. if (!hwif->io_ports[IDE_DATA_OFFSET])
  714. goto found;
  715. }
  717. hwif = NULL;
  718. found:
  719. return hwif;
  720. }
  722. static ide_hwif_t *
  723. icside_setup(unsigned long base, struct cardinfo *info, int irq)
  724. {
  725. unsigned long port = base + info->dataoffset;
  726. ide_hwif_t *hwif;
  728. hwif = icside_find_hwif(base);
  729. if (hwif) {
  730. int i;
  732. memset(&hwif->hw, 0, sizeof(hw_regs_t));
  734. for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
  735. hwif->hw.io_ports[i] = (ide_ioreg_t)port;
  736. hwif->io_ports[i] = (ide_ioreg_t)port;
  737. port += 1 << info->stepping;
  738. }
  739. hwif->hw.io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
  740. hwif->io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
  741. hwif->hw.irq  = irq;
  742. hwif->irq  = irq;
  743. hwif->hw.dma  = NO_DMA;
  744. hwif->noprobe  = 0;
  745. hwif->chipset  = ide_acorn;
  746. }
  748. return hwif;
  749. }
  751. static int __init icside_register_v5(struct expansion_card *ec, int autodma)
  752. {
  753. unsigned long slot_port;
  754. ide_hwif_t *hwif;
  756. slot_port = ecard_address(ec, ECARD_MEMC, 0);
  758. ec->irqaddr  = (unsigned char *)ioaddr(slot_port + ICS_ARCIN_V5_INTRSTAT);
  759. ec->irqmask  = 1;
  760. ec->irq_data = (void *)slot_port;
  761. ec->ops      = (expansioncard_ops_t *)&icside_ops_arcin_v5;
  763. /*
  764.  * Be on the safe side - disable interrupts
  765.  */
  766. inb(slot_port + ICS_ARCIN_V5_INTROFFSET);
  768. hwif = icside_setup(slot_port, &icside_cardinfo_v5, ec->irq);
  770. return hwif ? 0 : -ENODEV;
  771. }
  773. static int __init icside_register_v6(struct expansion_card *ec, int autodma)
  774. {
  775. unsigned long slot_port, port;
  776. struct icside_state *state;
  777. ide_hwif_t *hwif, *mate;
  778. unsigned int sel = 0;
  780. slot_port = ecard_address(ec, ECARD_IOC, ECARD_FAST);
  781. port      = ecard_address(ec, ECARD_EASI, ECARD_FAST);
  783. if (port == 0)
  784. port = slot_port;
  785. else
  786. sel = 1 << 5;
  788. outb(sel, slot_port);
  790. /*
  791.  * Be on the safe side - disable interrupts
  792.  */
  793. inb(port + ICS_ARCIN_V6_INTROFFSET_1);
  794. inb(port + ICS_ARCIN_V6_INTROFFSET_2);
  796. /*
  797.  * Find and register the interfaces.
  798.  */
  799. hwif = icside_setup(port, &icside_cardinfo_v6_1, ec->irq);
  800. mate = icside_setup(port, &icside_cardinfo_v6_2, ec->irq);
  802. if (!hwif || !mate)
  803. return -ENODEV;
  805. state = kmalloc(sizeof(struct icside_state), GFP_KERNEL);
  806. if (!state)
  807. return -ENOMEM;
  809. state->channel    = 0;
  810. state->enabled    = 0;
  811. state->irq_port   = port;
  813. ec->irq_data      = state;
  814. ec->ops           = (expansioncard_ops_t *)&icside_ops_arcin_v6;
  816. hwif->maskproc    = icside_maskproc;
  817. hwif->channel     = 0;
  818. hwif->hw.priv     = state;
  819. hwif->mate        = mate;
  820. hwif->serialized  = 1;
  821. hwif->config_data = slot_port;
  822. hwif->select_data = sel;
  823. hwif->hw.dma      = ec->dma;
  825. mate->maskproc    = icside_maskproc;
  826. mate->channel     = 1;
  827. mate->hw.priv     = state;
  828. mate->mate        = hwif;
  829. mate->serialized  = 1;
  830. mate->config_data = slot_port;
  831. mate->select_data = sel | 1;
  832. mate->hw.dma      = ec->dma;
  834. #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
  835. if (ec->dma != NO_DMA && !request_dma(ec->dma, hwif->name)) {
  836. icside_setup_dma(hwif, autodma);
  837. icside_setup_dma(mate, autodma);
  838. }
  839. #endif
  840. return 0;
  841. }
  843. int __init icside_init(void)
  844. {
  845. int autodma = 0;
  847. #ifdef CONFIG_IDEDMA_ICS_AUTO
  848. autodma = 1;
  849. #endif
  851. ecard_startfind ();
  853. do {
  854. struct expansion_card *ec;
  855. int result;
  857. ec = ecard_find(0, icside_cids);
  858. if (ec == NULL)
  859. break;
  861. ecard_claim(ec);
  863. switch (icside_identifyif(ec)) {
  864. case ics_if_arcin_v5:
  865. result = icside_register_v5(ec, autodma);
  866. break;
  868. case ics_if_arcin_v6:
  869. result = icside_register_v6(ec, autodma);
  870. break;
  872. default:
  873. result = -1;
  874. break;
  875. }
  877. if (result)
  878. ecard_release(ec);
  879. } while (1);
  881. return 0;
  882. }