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

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

Linux/Unix编程

开发平台：

Unix_Linux

jazzdma.c：源码内容
  1. /*
  2.  * Mips Jazz DMA controller support
  3.  * Copyright (C) 1995, 1996 by Andreas Busse
  4.  *
  5.  * NOTE: Some of the argument checking could be removed when
  6.  * things have settled down. Also, instead of returning 0xffffffff
  7.  * on failure of vdma_alloc() one could leave page #0 unused
  8.  * and return the more usual NULL pointer as logical address.
  9.  */
  10. #include <linux/kernel.h>
  11. #include <linux/init.h>
  12. #include <linux/errno.h>
  13. #include <linux/mm.h>
  14. #include <linux/bootmem.h>
  15. #include <asm/mipsregs.h>
  16. #include <asm/jazz.h>
  17. #include <asm/io.h>
  18. #include <asm/uaccess.h>
  19. #include <asm/dma.h>
  20. #include <asm/jazzdma.h>
  21. #include <asm/pgtable.h>
  23. /*
  24.  * Set this to one to enable additional vdma debug code.
  25.  */
  26. #define CONF_DEBUG_VDMA 0
  28. static unsigned long vdma_pagetable_start;
  30. /*
  31.  * Debug stuff
  32.  */
  33. #define vdma_debug     ((CONF_DEBUG_VDMA) ? debuglvl : 0)
  35. static int debuglvl = 3;
  37. /*
  38.  * Initialize the pagetable with a one-to-one mapping of
  39.  * the first 16 Mbytes of main memory and declare all
  40.  * entries to be unused. Using this method will at least
  41.  * allow some early device driver operations to work.
  42.  */
  43. static inline void vdma_pgtbl_init(void)
  44. {
  45. int i;
  46. unsigned long paddr = 0;
  47. VDMA_PGTBL_ENTRY *pgtbl =
  48.     (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
  50. for (i = 0; i < VDMA_PGTBL_ENTRIES; i++) {
  51. pgtbl[i].frame = paddr;
  52. pgtbl[i].owner = VDMA_PAGE_EMPTY;
  53. paddr += VDMA_PAGESIZE;
  54. }
  55. }
  57. /*
  58.  * Initialize the Jazz R4030 dma controller
  59.  */
  60. void __init vdma_init(void)
  61. {
  62. /*
  63.  * Allocate 32k of memory for DMA page tables.  This needs to be page
  64.  * aligned and should be uncached to avoid cache flushing after every
  65.  * update.
  66.  */
  67. vdma_pagetable_start = alloc_bootmem_low_pages(VDMA_PGTBL_SIZE);
  68. if (!vdma_pagetable_start)
  69. BUG();
  70. dma_cache_wback_inv(vdma_pagetable_start, VDMA_PGTBL_SIZE);
  71. vdma_pagetable_start = KSEG1ADDR(vdma_pagetable_start);
  73. /*
  74.  * Clear the R4030 translation table
  75.  */
  76. vdma_pgtbl_init();
  78. r4030_write_reg32(JAZZ_R4030_TRSTBL_BASE,
  79.   PHYSADDR(vdma_pagetable_start));
  80. r4030_write_reg32(JAZZ_R4030_TRSTBL_LIM, VDMA_PGTBL_SIZE);
  81. r4030_write_reg32(JAZZ_R4030_TRSTBL_INV, 0);
  83. printk("VDMA: R4030 DMA pagetables initialized.n");
  84. }
  86. /*
  87.  * Allocate DMA pagetables using a simple first-fit algorithm
  88.  */
  89. unsigned long vdma_alloc(unsigned long paddr, unsigned long size)
  90. {
  91. VDMA_PGTBL_ENTRY *entry =
  92.     (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
  93. int first;
  94. int last;
  95. int pages;
  96. unsigned int frame;
  97. unsigned long laddr;
  98. int i;
  99. unsigned long flags;
  101. /* check arguments */
  103. if (paddr > 0x1fffffff) {
  104. if (vdma_debug)
  105. printk("vdma_alloc: Invalid physical address: %08lxn",
  106.        paddr);
  107. return VDMA_ERROR; /* invalid physical address */
  108. }
  109. if (size > 0x400000 || size == 0) {
  110. if (vdma_debug)
  111. printk("vdma_alloc: Invalid size: %08lxn", size);
  112. return VDMA_ERROR; /* invalid physical address */
  113. }
  115. save_and_cli(flags);
  116. /*
  117.  * Find free chunk
  118.  */
  119. pages = (size + 4095) >> 12; /* no. of pages to allocate */
  120. first = 0;
  121. while (1) {
  122. while (entry[first].owner != VDMA_PAGE_EMPTY &&
  123.        first < VDMA_PGTBL_ENTRIES) first++;
  124. if (first + pages > VDMA_PGTBL_ENTRIES) { /* nothing free */
  125. restore_flags(flags);
  126. return VDMA_ERROR;
  127. }
  129. last = first + 1;
  130. while (entry[last].owner == VDMA_PAGE_EMPTY
  131.        && last - first < pages)
  132. last++;
  134. if (last - first == pages)
  135. break; /* found */
  136. }
  138. /*
  139.  * Mark pages as allocated
  140.  */
  141. laddr = (first << 12) + (paddr & (VDMA_PAGESIZE - 1));
  142. frame = paddr & ~(VDMA_PAGESIZE - 1);
  144. for (i = first; i < last; i++) {
  145. entry[i].frame = frame;
  146. entry[i].owner = laddr;
  147. frame += VDMA_PAGESIZE;
  148. }
  150. /*
  151.  * Update translation table and return logical start address
  152.  */
  153. r4030_write_reg32(JAZZ_R4030_TRSTBL_INV, 0);
  155. if (vdma_debug > 1)
  156. printk
  157.     ("vdma_alloc: Allocated %d pages starting from %08lxn",
  158.      pages, laddr);
  160. if (vdma_debug > 2) {
  161. printk("LADDR: ");
  162. for (i = first; i < last; i++)
  163. printk("%08x ", i << 12);
  164. printk("nPADDR: ");
  165. for (i = first; i < last; i++)
  166. printk("%08x ", entry[i].frame);
  167. printk("nOWNER: ");
  168. for (i = first; i < last; i++)
  169. printk("%08x ", entry[i].owner);
  170. printk("n");
  171. }
  173. restore_flags(flags);
  174. return laddr;
  175. }
  177. /*
  178.  * Free previously allocated dma translation pages
  179.  * Note that this does NOT change the translation table,
  180.  * it just marks the free'd pages as unused!
  181.  */
  182. int vdma_free(unsigned long laddr)
  183. {
  184. VDMA_PGTBL_ENTRY *pgtbl =
  185.     (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
  186. int i;
  188. i = laddr >> 12;
  190. if (pgtbl[i].owner != laddr) {
  191. printk
  192.     ("vdma_free: trying to free other's dma pages, laddr=%8lxn",
  193.      laddr);
  194. return -1;
  195. }
  197. while (pgtbl[i].owner == laddr && i < VDMA_PGTBL_ENTRIES) {
  198. pgtbl[i].owner = VDMA_PAGE_EMPTY;
  199. i++;
  200. }
  202. if (vdma_debug > 1)
  203. printk("vdma_free: freed %ld pages starting from %08lxn",
  204.        i - (laddr >> 12), laddr);
  206. return 0;
  207. }
  209. /*
  210.  * Map certain page(s) to another physical address.
  211.  * Caller must have allocated the page(s) before.
  212.  */
  213. int vdma_remap(unsigned long laddr, unsigned long paddr,
  214.        unsigned long size)
  215. {
  216. VDMA_PGTBL_ENTRY *pgtbl =
  217.     (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
  218. int first, pages, npages;
  220. if (laddr > 0xffffff) {
  221. if (vdma_debug)
  222. printk
  223.     ("vdma_map: Invalid logical address: %08lxn",
  224.      laddr);
  225. return -EINVAL; /* invalid logical address */
  226. }
  227. if (paddr > 0x1fffffff) {
  228. if (vdma_debug)
  229. printk
  230.     ("vdma_map: Invalid physical address: %08lxn",
  231.      paddr);
  232. return -EINVAL; /* invalid physical address */
  233. }
  235. npages = pages =
  236.     (((paddr & (VDMA_PAGESIZE - 1)) + size) >> 12) + 1;
  237. first = laddr >> 12;
  238. if (vdma_debug)
  239. printk("vdma_remap: first=%x, pages=%xn", first, pages);
  240. if (first + pages > VDMA_PGTBL_ENTRIES) {
  241. if (vdma_debug)
  242. printk("vdma_alloc: Invalid size: %08lxn", size);
  243. return -EINVAL;
  244. }
  246. paddr &= ~(VDMA_PAGESIZE - 1);
  247. while (pages > 0 && first < VDMA_PGTBL_ENTRIES) {
  248. if (pgtbl[first].owner != laddr) {
  249. if (vdma_debug)
  250. printk("Trying to remap other's pages.n");
  251. return -EPERM; /* not owner */
  252. }
  253. pgtbl[first].frame = paddr;
  254. paddr += VDMA_PAGESIZE;
  255. first++;
  256. pages--;
  257. }
  259. /*
  260.  * Update translation table
  261.  */
  262. r4030_write_reg32(JAZZ_R4030_TRSTBL_INV, 0);
  264. if (vdma_debug > 2) {
  265. int i;
  266. pages = (((paddr & (VDMA_PAGESIZE - 1)) + size) >> 12) + 1;
  267. first = laddr >> 12;
  268. printk("LADDR: ");
  269. for (i = first; i < first + pages; i++)
  270. printk("%08x ", i << 12);
  271. printk("nPADDR: ");
  272. for (i = first; i < first + pages; i++)
  273. printk("%08x ", pgtbl[i].frame);
  274. printk("nOWNER: ");
  275. for (i = first; i < first + pages; i++)
  276. printk("%08x ", pgtbl[i].owner);
  277. printk("n");
  278. }
  280. return 0;
  281. }
  283. /*
  284.  * Translate a physical address to a logical address.
  285.  * This will return the logical address of the first
  286.  * match.
  287.  */
  288. unsigned long vdma_phys2log(unsigned long paddr)
  289. {
  290. int i;
  291. int frame;
  292. VDMA_PGTBL_ENTRY *pgtbl =
  293.     (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
  295. frame = paddr & ~(VDMA_PAGESIZE - 1);
  297. for (i = 0; i < VDMA_PGTBL_ENTRIES; i++) {
  298. if (pgtbl[i].frame == frame)
  299. break;
  300. }
  302. if (i == VDMA_PGTBL_ENTRIES)
  303. return ~0UL;
  305. return (i << 12) + (paddr & (VDMA_PAGESIZE - 1));
  306. }
  308. /*
  309.  * Translate a logical DMA address to a physical address
  310.  */
  311. unsigned long vdma_log2phys(unsigned long laddr)
  312. {
  313. VDMA_PGTBL_ENTRY *pgtbl =
  314.     (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
  316. return pgtbl[laddr >> 12].frame + (laddr & (VDMA_PAGESIZE - 1));
  317. }
  319. /*
  320.  * Print DMA statistics
  321.  */
  322. void vdma_stats(void)
  323. {
  324. int i;
  326. printk("vdma_stats: CONFIG: %08xn",
  327.        r4030_read_reg32(JAZZ_R4030_CONFIG));
  328. printk("R4030 translation table base: %08xn",
  329.        r4030_read_reg32(JAZZ_R4030_TRSTBL_BASE));
  330. printk("R4030 translation table limit: %08xn",
  331.        r4030_read_reg32(JAZZ_R4030_TRSTBL_LIM));
  332. printk("vdma_stats: INV_ADDR: %08xn",
  333.        r4030_read_reg32(JAZZ_R4030_INV_ADDR));
  334. printk("vdma_stats: R_FAIL_ADDR: %08xn",
  335.        r4030_read_reg32(JAZZ_R4030_R_FAIL_ADDR));
  336. printk("vdma_stats: M_FAIL_ADDR: %08xn",
  337.        r4030_read_reg32(JAZZ_R4030_M_FAIL_ADDR));
  338. printk("vdma_stats: IRQ_SOURCE: %08xn",
  339.        r4030_read_reg32(JAZZ_R4030_IRQ_SOURCE));
  340. printk("vdma_stats: I386_ERROR: %08xn",
  341.        r4030_read_reg32(JAZZ_R4030_I386_ERROR));
  342. printk("vdma_chnl_modes:   ");
  343. for (i = 0; i < 8; i++)
  344. printk("%04x ",
  345.        (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_MODE +
  346.    (i << 5)));
  347. printk("n");
  348. printk("vdma_chnl_enables: ");
  349. for (i = 0; i < 8; i++)
  350. printk("%04x ",
  351.        (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  352.    (i << 5)));
  353. printk("n");
  354. }
  356. /*
  357.  * DMA transfer functions
  358.  */
  360. /*
  361.  * Enable a DMA channel. Also clear any error conditions.
  362.  */
  363. void vdma_enable(int channel)
  364. {
  365. int status;
  367. if (vdma_debug)
  368. printk("vdma_enable: channel %dn", channel);
  370. /*
  371.  * Check error conditions first
  372.  */
  373. status = r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5));
  374. if (status & 0x400)
  375. printk("VDMA: Channel %d: Address error!n", channel);
  376. if (status & 0x200)
  377. printk("VDMA: Channel %d: Memory error!n", channel);
  379. /*
  380.  * Clear all interrupt flags
  381.  */
  382. r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
  383.   r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  384.    (channel << 5)) | R4030_TC_INTR
  385.   | R4030_MEM_INTR | R4030_ADDR_INTR);
  387. /*
  388.  * Enable the desired channel
  389.  */
  390. r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
  391.   r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  392.    (channel << 5)) |
  393.   R4030_CHNL_ENABLE);
  394. }
  396. /*
  397.  * Disable a DMA channel
  398.  */
  399. void vdma_disable(int channel)
  400. {
  401. if (vdma_debug) {
  402. int status =
  403.     r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  404.      (channel << 5));
  406. printk("vdma_disable: channel %dn", channel);
  407. printk("VDMA: channel %d status: %04x (%s) mode: "
  408.        "%02x addr: %06x count: %06xn",
  409.        channel, status,
  410.        ((status & 0x600) ? "ERROR" : "OK"),
  411.        (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_MODE +
  412.    (channel << 5)),
  413.        (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_ADDR +
  414.    (channel << 5)),
  415.        (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_COUNT +
  416.    (channel << 5)));
  417. }
  419. r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
  420.   r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  421.    (channel << 5)) &
  422.   ~R4030_CHNL_ENABLE);
  424. /*
  425.  * After disabling a DMA channel a remote bus register should be
  426.  * read to ensure that the current DMA acknowledge cycle is completed.
  427.  */
  428. *((volatile unsigned int *) JAZZ_DUMMY_DEVICE);
  429. }
  431. /*
  432.  * Set DMA mode. This function accepts the mode values used
  433.  * to set a PC-style DMA controller. For the SCSI and FDC
  434.  * channels, we also set the default modes each time we're
  435.  * called.
  436.  * NOTE: The FAST and BURST dma modes are supported by the
  437.  * R4030 Rev. 2 and PICA chipsets only. I leave them disabled
  438.  * for now.
  439.  */
  440. void vdma_set_mode(int channel, int mode)
  441. {
  442. if (vdma_debug)
  443. printk("vdma_set_mode: channel %d, mode 0x%xn", channel,
  444.        mode);
  446. switch (channel) {
  447. case JAZZ_SCSI_DMA: /* scsi */
  448. r4030_write_reg32(JAZZ_R4030_CHNL_MODE + (channel << 5),
  449. /*   R4030_MODE_FAST | */
  450. /*   R4030_MODE_BURST | */
  451.   R4030_MODE_INTR_EN |
  452.   R4030_MODE_WIDTH_16 |
  453.   R4030_MODE_ATIME_80);
  454. break;
  456. case JAZZ_FLOPPY_DMA: /* floppy */
  457. r4030_write_reg32(JAZZ_R4030_CHNL_MODE + (channel << 5),
  458. /*   R4030_MODE_FAST | */
  459. /*   R4030_MODE_BURST | */
  460.   R4030_MODE_INTR_EN |
  461.   R4030_MODE_WIDTH_8 |
  462.   R4030_MODE_ATIME_120);
  463. break;
  465. case JAZZ_AUDIOL_DMA:
  466. case JAZZ_AUDIOR_DMA:
  467. printk("VDMA: Audio DMA not supported yet.n");
  468. break;
  470. default:
  471. printk
  472.     ("VDMA: vdma_set_mode() called with unsupported channel %d!n",
  473.      channel);
  474. }
  476. switch (mode) {
  477. case DMA_MODE_READ:
  478. r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
  479.   r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  480.    (channel << 5)) &
  481.   ~R4030_CHNL_WRITE);
  482. break;
  484. case DMA_MODE_WRITE:
  485. r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
  486.   r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
  487.    (channel << 5)) |
  488.   R4030_CHNL_WRITE);
  489. break;
  491. default:
  492. printk
  493.     ("VDMA: vdma_set_mode() called with unknown dma mode 0x%xn",
  494.      mode);
  495. }
  496. }
  498. /*
  499.  * Set Transfer Address
  500.  */
  501. void vdma_set_addr(int channel, long addr)
  502. {
  503. if (vdma_debug)
  504. printk("vdma_set_addr: channel %d, addr %lxn", channel,
  505.        addr);
  507. r4030_write_reg32(JAZZ_R4030_CHNL_ADDR + (channel << 5), addr);
  508. }
  510. /*
  511.  * Set Transfer Count
  512.  */
  513. void vdma_set_count(int channel, int count)
  514. {
  515. if (vdma_debug)
  516. printk("vdma_set_count: channel %d, count %08xn", channel,
  517.        (unsigned) count);
  519. r4030_write_reg32(JAZZ_R4030_CHNL_COUNT + (channel << 5), count);
  520. }
  522. /*
  523.  * Get Residual
  524.  */
  525. int vdma_get_residue(int channel)
  526. {
  527. int residual;
  529. residual =
  530.     r4030_read_reg32(JAZZ_R4030_CHNL_COUNT + (channel << 5));
  532. if (vdma_debug)
  533. printk("vdma_get_residual: channel %d: residual=%dn",
  534.        channel, residual);
  536. return residual;
  537. }
  539. /*
  540.  * Get DMA channel enable register
  541.  */
  542. int vdma_get_enable(int channel)
  543. {
  544. int enable;
  546. enable = r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5));
  548. if (vdma_debug)
  549. printk("vdma_get_enable: channel %d: enable=%dn", channel,
  550.        enable);
  552. return enable;
  553. }