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

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

Linux/Unix编程

开发平台：

Unix_Linux

ccio-dma.c：源码内容
  1. /*
  2. ** ccio-dma.c:
  3. ** DMA management routines for first generation cache-coherent machines.
  4. ** Program U2/Uturn in "Virtual Mode" and use the I/O MMU.
  5. **
  6. ** (c) Copyright 2000 Grant Grundler
  7. ** (c) Copyright 2000 Ryan Bradetich
  8. ** (c) Copyright 2000 Hewlett-Packard Company
  9. **
  10. ** This program is free software; you can redistribute it and/or modify
  11. ** it under the terms of the GNU General Public License as published by
  12. ** the Free Software Foundation; either version 2 of the License, or
  13. ** (at your option) any later version.
  14. **
  15. **
  16. **  "Real Mode" operation refers to U2/Uturn chip operation.
  17. **  U2/Uturn were designed to perform coherency checks w/o using
  18. **  the I/O MMU - basically what x86 does.
  19. **
  20. **  Philipp Rumpf has a "Real Mode" driver for PCX-W machines at:
  21. **      CVSROOT=:pserver:anonymous@198.186.203.37:/cvsroot/linux-parisc
  22. **      cvs -z3 co linux/arch/parisc/kernel/dma-rm.c
  23. **
  24. **  I've rewritten his code to work under TPG's tree. See ccio-rm-dma.c.
  25. **
  26. **  Drawbacks of using Real Mode are:
  27. ** o outbound DMA is slower - U2 won't prefetch data (GSC+ XQL signal).
  28. **      o Inbound DMA less efficient - U2 can't use DMA_FAST attribute.
  29. ** o Ability to do scatter/gather in HW is lost.
  30. ** o Doesn't work under PCX-U/U+ machines since they didn't follow
  31. **        the coherency design originally worked out. Only PCX-W does.
  32. */
  34. #include <linux/config.h>
  35. #include <linux/types.h>
  36. #include <linux/init.h>
  37. #include <linux/mm.h>
  38. #include <linux/spinlock.h>
  39. #include <linux/slab.h>
  40. #include <linux/string.h>
  41. #define PCI_DEBUG
  42. #include <linux/pci.h>
  43. #undef PCI_DEBUG
  45. #include <asm/byteorder.h>
  46. #include <asm/cache.h> /* for L1_CACHE_BYTES */
  47. #include <asm/uaccess.h>
  48. #include <asm/pgalloc.h>
  49. #include <asm/page.h>
  50. #include <asm/dma.h>
  51. #include <asm/io.h>
  52. #include <asm/gsc.h> /* for gsc_writeN()... */
  53. #include <asm/hardware.h>       /* for register_module() */
  55. /* 
  56. ** Choose "ccio" since that's what HP-UX calls it.
  57. ** Make it easier for folks to migrate from one to the other :^)
  58. */
  59. #define MODULE_NAME "ccio"
  61. #undef DEBUG_CCIO_RES
  62. #undef DEBUG_CCIO_RUN
  63. #undef DEBUG_CCIO_INIT
  64. #undef DEBUG_CCIO_RUN_SG
  66. #include <linux/proc_fs.h>
  67. #include <asm/runway.h> /* for proc_runway_root */
  69. #ifdef DEBUG_CCIO_INIT
  70. #define DBG_INIT(x...)  printk(x)
  71. #else
  72. #define DBG_INIT(x...)
  73. #endif
  75. #ifdef DEBUG_CCIO_RUN
  76. #define DBG_RUN(x...)   printk(x)
  77. #else
  78. #define DBG_RUN(x...)
  79. #endif
  81. #ifdef DEBUG_CCIO_RES
  82. #define DBG_RES(x...)   printk(x)
  83. #else
  84. #define DBG_RES(x...)
  85. #endif
  87. #ifdef DEBUG_CCIO_RUN_SG
  88. #define DBG_RUN_SG(x...) printk(x)
  89. #else
  90. #define DBG_RUN_SG(x...)
  91. #endif
  93. #define CCIO_INLINE /* inline */
  94. #define WRITE_U32(value, addr) gsc_writel(value, (u32 *)(addr))
  95. #define READ_U32(addr) gsc_readl((u32 *)(addr))
  97. #define U2_IOA_RUNWAY 0x580
  98. #define U2_BC_GSC     0x501
  99. #define UTURN_IOA_RUNWAY 0x581
  100. #define UTURN_BC_GSC     0x502
  102. #define IOA_NORMAL_MODE      0x00020080 /* IO_CONTROL to turn on CCIO        */
  103. #define CMD_TLB_DIRECT_WRITE 35         /* IO_COMMAND for I/O TLB Writes     */
  104. #define CMD_TLB_PURGE        33         /* IO_COMMAND to Purge I/O TLB entry */
  106. struct ioa_registers {
  107.         /* Runway Supervisory Set */
  108.         volatile int32_t    unused1[12];
  109.         volatile uint32_t   io_command;             /* Offset 12 */
  110.         volatile uint32_t   io_status;              /* Offset 13 */
  111.         volatile uint32_t   io_control;             /* Offset 14 */
  112.         volatile int32_t    unused2[1];
  114.         /* Runway Auxiliary Register Set */
  115.         volatile uint32_t   io_err_resp;            /* Offset  0 */
  116.         volatile uint32_t   io_err_info;            /* Offset  1 */
  117.         volatile uint32_t   io_err_req;             /* Offset  2 */
  118.         volatile uint32_t   io_err_resp_hi;         /* Offset  3 */
  119.         volatile uint32_t   io_tlb_entry_m;         /* Offset  4 */
  120.         volatile uint32_t   io_tlb_entry_l;         /* Offset  5 */
  121.         volatile uint32_t   unused3[1];
  122.         volatile uint32_t   io_pdir_base;           /* Offset  7 */
  123.         volatile uint32_t   io_io_low_hv;           /* Offset  8 */
  124.         volatile uint32_t   io_io_high_hv;          /* Offset  9 */
  125.         volatile uint32_t   unused4[1];
  126.         volatile uint32_t   io_chain_id_mask;       /* Offset 11 */
  127.         volatile uint32_t   unused5[2];
  128.         volatile uint32_t   io_io_low;              /* Offset 14 */
  129.         volatile uint32_t   io_io_high;             /* Offset 15 */
  130. };
  132. struct ioc {
  133. struct ioa_registers *ioc_hpa;  /* I/O MMU base address */
  134. u8  *res_map;                 /* resource map, bit == pdir entry */
  135. u64 *pdir_base;                 /* physical base address */
  136. u32 res_hint;                 /* next available IOVP - 
  137.    circular search */
  138. u32 res_size;      /* size of resource map in bytes */
  139. spinlock_t res_lock;
  141. #ifdef CONFIG_PROC_FS
  142. #define CCIO_SEARCH_SAMPLE 0x100
  143. unsigned long avg_search[CCIO_SEARCH_SAMPLE];
  144. unsigned long avg_idx;   /* current index into avg_search */
  145. unsigned long used_pages;
  146. unsigned long msingle_calls;
  147. unsigned long msingle_pages;
  148. unsigned long msg_calls;
  149. unsigned long msg_pages;
  150. unsigned long usingle_calls;
  151. unsigned long usingle_pages;
  152. unsigned long usg_calls;
  153. unsigned long usg_pages;
  155. unsigned short cujo20_bug;
  156. #endif
  158. /* STUFF We don't need in performance path */
  159. u32 pdir_size;  /* in bytes, determined by IOV Space size */
  160. u32 chainid_shift;  /* specify bit location of chain_id */
  161. struct ioc *next; /* Linked list of discovered iocs */
  162. const char *name; /* device name from firmware */
  163. unsigned int hw_path;           /* the hardware path this ioc is associatd with */
  164. struct pci_dev *fake_pci_dev;   /* the fake pci_dev for non-pci devs */
  165. struct resource mmio_region[2]; /* The "routed" MMIO regions */
  166. };
  168. /* Ratio of Host MEM to IOV Space size */
  169. static unsigned long ccio_mem_ratio = 4;
  170. static struct ioc *ioc_list;
  171. static int ioc_count;
  173. /**************************************************************
  174. *
  175. *   I/O Pdir Resource Management
  176. *
  177. *   Bits set in the resource map are in use.
  178. *   Each bit can represent a number of pages.
  179. *   LSbs represent lower addresses (IOVA's).
  180. *
  181. *   This was was copied from sba_iommu.c. Don't try to unify
  182. *   the two resource managers unless a way to have different
  183. *   allocation policies is also adjusted. We'd like to avoid
  184. *   I/O TLB thrashing by having resource allocation policy
  185. *   match the I/O TLB replacement policy.
  186. *
  187. ***************************************************************/
  188. #define IOVP_SIZE PAGE_SIZE
  189. #define IOVP_SHIFT PAGE_SHIFT
  190. #define IOVP_MASK PAGE_MASK
  192. /* Convert from IOVP to IOVA and vice versa. */
  193. #define CCIO_IOVA(iovp,offset) ((iovp) | (offset))
  194. #define CCIO_IOVP(iova) ((iova) & IOVP_MASK)
  196. #define PDIR_INDEX(iovp)    ((iovp)>>IOVP_SHIFT)
  197. #define MKIOVP(pdir_idx)    ((long)(pdir_idx) << IOVP_SHIFT)
  198. #define MKIOVA(iovp,offset) (dma_addr_t)((long)iovp | (long)offset)
  199. #define ROUNDUP(x,y) ((x + ((y)-1)) & ~((y)-1))
  201. /*
  202. ** Don't worry about the 150% average search length on a miss.
  203. ** If the search wraps around, and passes the res_hint, it will
  204. ** cause the kernel to panic anyhow.
  205. */
  206. #define CCIO_SEARCH_LOOP(ioc, res_idx, mask_ptr, size)  
  207.        for(; res_ptr < res_end; ++res_ptr) { 
  208.                if(0 == (*res_ptr & *mask_ptr)) { 
  209.                        *res_ptr |= *mask_ptr; 
  210.                        res_idx = (int)((unsigned long)res_ptr - (unsigned long)ioc->res_map); 
  211.                        ioc->res_hint = res_idx + (size >> 3); 
  212.                        goto resource_found; 
  213.                } 
  214.        }
  216. #define CCIO_FIND_FREE_MAPPING(ioa, res_idx, mask, size) 
  217.        u##size *res_ptr = (u##size *)&((ioc)->res_map[ioa->res_hint & ~((size >> 3) - 1)]); 
  218.        u##size *res_end = (u##size *)&(ioc)->res_map[ioa->res_size]; 
  219.        u##size *mask_ptr = (u##size *)&mask; 
  220.        CCIO_SEARCH_LOOP(ioc, res_idx, mask_ptr, size); 
  221.        res_ptr = (u##size *)&(ioc)->res_map[0]; 
  222.        CCIO_SEARCH_LOOP(ioa, res_idx, mask_ptr, size);
  224. /*
  225. ** Find available bit in this ioa's resource map.
  226. ** Use a "circular" search:
  227. **   o Most IOVA's are "temporary" - avg search time should be small.
  228. ** o keep a history of what happened for debugging
  229. ** o KISS.
  230. **
  231. ** Perf optimizations:
  232. ** o search for log2(size) bits at a time.
  233. ** o search for available resource bits using byte/word/whatever.
  234. ** o use different search for "large" (eg > 4 pages) or "very large"
  235. **   (eg > 16 pages) mappings.
  236. */
  238. /**
  239.  * ccio_alloc_range - Allocate pages in the ioc's resource map.
  240.  * @ioc: The I/O Controller.
  241.  * @pages_needed: The requested number of pages to be mapped into the
  242.  * I/O Pdir...
  243.  *
  244.  * This function searches the resource map of the ioc to locate a range
  245.  * of available pages for the requested size.
  246.  */
  247. static int
  248. ccio_alloc_range(struct ioc *ioc, unsigned long pages_needed)
  249. {
  250. int res_idx;
  251. unsigned long mask;
  252. #ifdef CONFIG_PROC_FS
  253. unsigned long cr_start = mfctl(16);
  254. #endif
  256. ASSERT(pages_needed);
  257. ASSERT((pages_needed * IOVP_SIZE) <= DMA_CHUNK_SIZE);
  258. ASSERT(pages_needed <= BITS_PER_LONG);
  260. mask = ~(~0UL >> pages_needed);
  261.      
  262. DBG_RES("%s() size: %d pages_needed %d mask 0x%08lxn", 
  263. __FUNCTION__, size, pages_needed, mask);
  265. /*
  266. ** "seek and ye shall find"...praying never hurts either...
  267. ** ggg sacrifices another 710 to the computer gods.
  268. */
  270. if(pages_needed <= 8) {
  271. CCIO_FIND_FREE_MAPPING(ioc, res_idx, mask, 8);
  272. } else if(pages_needed <= 16) {
  273. CCIO_FIND_FREE_MAPPING(ioc, res_idx, mask, 16);
  274. } else if(pages_needed <= 32) {
  275. CCIO_FIND_FREE_MAPPING(ioc, res_idx, mask, 32);
  276. #ifdef __LP64__
  277. } else if(pages_needed <= 64) {
  278. CCIO_FIND_FREE_MAPPING(ioc, res_idx, mask, 64);
  279. #endif
  280. } else {
  281. panic(__FILE__ ": %s() Too many pages to map. pages_needed: %ldn", 
  282.       __FUNCTION__, pages_needed);
  283. }
  285. panic(__FILE__ ": %s() I/O MMU is out of mapping resources.n", 
  286.       __FUNCTION__);
  288. resource_found:
  290. DBG_RES("%s() res_idx %d mask 0x%08lx res_hint: %dn",
  291. __FUNCTION__, res_idx, mask, ioc->res_hint);
  293. #ifdef CONFIG_PROC_FS
  294. {
  295. unsigned long cr_end = mfctl(16);
  296. unsigned long tmp = cr_end - cr_start;
  297. /* check for roll over */
  298. cr_start = (cr_end < cr_start) ?  -(tmp) : (tmp);
  299. }
  300. ioc->avg_search[ioc->avg_idx++] = cr_start;
  301. ioc->avg_idx &= CCIO_SEARCH_SAMPLE - 1;
  303. ioc->used_pages += pages_needed;
  304. #endif
  306. /* 
  307. ** return the bit address.
  308. */
  309. return res_idx << 3;
  310. }
  312. #define CCIO_FREE_MAPPINGS(ioc, res_idx, mask, size) 
  313.         u##size *res_ptr = (u##size *)&((ioc)->res_map[res_idx]); 
  314. u##size *mask_ptr = (u##size *)&mask; 
  315.         ASSERT((*res_ptr & *mask_ptr) == *mask_ptr); 
  316.         *res_ptr &= ~(*mask_ptr);
  318. /**
  319.  * ccio_free_range - Free pages from the ioc's resource map.
  320.  * @ioc: The I/O Controller.
  321.  * @iova: The I/O Virtual Address.
  322.  * @pages_mapped: The requested number of pages to be freed from the
  323.  * I/O Pdir.
  324.  *
  325.  * This function frees the resouces allocated for the iova.
  326.  */
  327. static void
  328. ccio_free_range(struct ioc *ioc, dma_addr_t iova, unsigned long pages_mapped)
  329. {
  330. unsigned long mask;
  331. unsigned long iovp = CCIO_IOVP(iova);
  332. unsigned int res_idx = PDIR_INDEX(iovp) >> 3;
  334. ASSERT(pages_mapped);
  335. ASSERT((pages_mapped * IOVP_SIZE) <= DMA_CHUNK_SIZE);
  336. ASSERT(pages_mapped <= BITS_PER_LONG);
  338. mask = ~(~0UL >> pages_mapped);
  340. DBG_RES("%s():  res_idx: %d pages_mapped %d mask 0x%08lxn", 
  341. __FUNCTION__, res_idx, pages_mapped, mask);
  343. #ifdef CONFIG_PROC_FS
  344. ioc->used_pages -= pages_mapped;
  345. #endif
  347. if(pages_mapped <= 8) {
  348. CCIO_FREE_MAPPINGS(ioc, res_idx, mask, 8);
  349. } else if(pages_mapped <= 16) {
  350. CCIO_FREE_MAPPINGS(ioc, res_idx, mask, 16);
  351. } else if(pages_mapped <= 32) {
  352. CCIO_FREE_MAPPINGS(ioc, res_idx, mask, 32);
  353. #ifdef __LP64__
  354. } else if(pages_mapped <= 64) {
  355. CCIO_FREE_MAPPINGS(ioc, res_idx, mask, 64);
  356. #endif
  357. } else {
  358. panic(__FILE__ ":%s() Too many pages to unmap.n", 
  359.       __FUNCTION__);
  360. }
  361. }
  363. /****************************************************************
  364. **
  365. **          CCIO dma_ops support routines
  366. **
  367. *****************************************************************/
  369. typedef unsigned long space_t;
  370. #define KERNEL_SPACE 0
  372. /*
  373. ** DMA "Page Type" and Hints 
  374. ** o if SAFE_DMA isn't set, mapping is for FAST_DMA. SAFE_DMA should be
  375. **   set for subcacheline DMA transfers since we don't want to damage the
  376. **   other part of a cacheline.
  377. ** o SAFE_DMA must be set for "memory" allocated via pci_alloc_consistent().
  378. **   This bit tells U2 to do R/M/W for partial cachelines. "Streaming"
  379. **   data can avoid this if the mapping covers full cache lines.
  380. ** o STOP_MOST is needed for atomicity across cachelines.
  381. **   Apperently only "some EISA devices" need this.
  382. **   Using CONFIG_ISA is hack. Only the IOA with EISA under it needs
  383. **   to use this hint iff the EISA devices needs this feature.
  384. **   According to the U2 ERS, STOP_MOST enabled pages hurt performance.
  385. ** o PREFETCH should *not* be set for cases like Multiple PCI devices
  386. **   behind GSCtoPCI (dino) bus converter. Only one cacheline per GSC
  387. **   device can be fetched and multiply DMA streams will thrash the
  388. **   prefetch buffer and burn memory bandwidth. See 6.7.3 "Prefetch Rules
  389. **   and Invalidation of Prefetch Entries".
  390. **
  391. ** FIXME: the default hints need to be per GSC device - not global.
  392. ** 
  393. ** HP-UX dorks: linux device driver programming model is totally different
  394. **    than HP-UX's. HP-UX always sets HINT_PREFETCH since it's drivers
  395. **    do special things to work on non-coherent platforms...linux has to
  396. **    be much more careful with this.
  397. */
  398. #define IOPDIR_VALID    0x01UL
  399. #define HINT_SAFE_DMA   0x02UL /* used for pci_alloc_consistent() pages */
  400. #ifdef CONFIG_ISA /* EISA support really */
  401. #define HINT_STOP_MOST  0x04UL /* LSL support */
  402. #else
  403. #define HINT_STOP_MOST  0x00UL /* only needed for "some EISA devices" */
  404. #endif
  405. #define HINT_UDPATE_ENB 0x08UL  /* not used/supported by U2 */
  406. #define HINT_PREFETCH   0x10UL /* for outbound pages which are not SAFE */
  409. /*
  410. ** Use direction (ie PCI_DMA_TODEVICE) to pick hint.
  411. ** ccio_alloc_consistent() depends on this to get SAFE_DMA
  412. ** when it passes in BIDIRECTIONAL flag.
  413. */
  414. static u32 hint_lookup[] = {
  415. [PCI_DMA_BIDIRECTIONAL]  HINT_STOP_MOST | HINT_SAFE_DMA | IOPDIR_VALID,
  416. [PCI_DMA_TODEVICE]       HINT_STOP_MOST | HINT_PREFETCH | IOPDIR_VALID,
  417. [PCI_DMA_FROMDEVICE]     HINT_STOP_MOST | IOPDIR_VALID,
  418. [PCI_DMA_NONE]           0,            /* not valid */
  419. };
  421. /**
  422.  * ccio_io_pdir_entry - Initialize an I/O Pdir.
  423.  * @pdir_ptr: A pointer into I/O Pdir.
  424.  * @sid: The Space Identifier.
  425.  * @vba: The virtual address.
  426.  * @hints: The DMA Hint.
  427.  *
  428.  * Given a virtual address (vba, arg2) and space id, (sid, arg1),
  429.  * load the I/O PDIR entry pointed to by pdir_ptr (arg0). Each IO Pdir
  430.  * entry consists of 8 bytes as shown below (MSB == bit 0):
  431.  *
  432.  *
  433.  * WORD 0:
  434.  * +------+----------------+-----------------------------------------------+
  435.  * | Phys | Virtual Index  |               Phys                            |
  436.  * | 0:3  |     0:11       |               4:19                            |
  437.  * |4 bits|   12 bits      |              16 bits                          |
  438.  * +------+----------------+-----------------------------------------------+
  439.  * WORD 1:
  440.  * +-----------------------+-----------------------------------------------+
  441.  * |      Phys    |  Rsvd  | Prefetch |Update |Rsvd  |Lock  |Safe  |Valid  |
  442.  * |     20:39    |        | Enable   |Enable |      |Enable|DMA   |       |
  443.  * |    20 bits   | 5 bits | 1 bit    |1 bit  |2 bits|1 bit |1 bit |1 bit  |
  444.  * +-----------------------+-----------------------------------------------+
  445.  *
  446.  * The virtual index field is filled with the results of the LCI
  447.  * (Load Coherence Index) instruction.  The 8 bits used for the virtual
  448.  * index are bits 12:19 of the value returned by LCI.
  449.  */ 
  450. void CCIO_INLINE
  451. ccio_io_pdir_entry(u64 *pdir_ptr, space_t sid, void * vba, unsigned long hints)
  452. {
  453. register unsigned long pa = (volatile unsigned long) vba;
  454. register unsigned long ci; /* coherent index */
  456. /* We currently only support kernel addresses */
  457. ASSERT(sid == KERNEL_SPACE);
  459. mtsp(sid,1);
  461. /*
  462. ** WORD 1 - low order word
  463. ** "hints" parm includes the VALID bit!
  464. ** "dep" clobbers the physical address offset bits as well.
  465. */
  466. pa = virt_to_phys(vba);
  467. asm volatile("depw  %1,31,12,%0" : "+r" (pa) : "r" (hints));
  468. ((u32 *)pdir_ptr)[1] = (u32) pa;
  470. /*
  471. ** WORD 0 - high order word
  472. */
  474. #ifdef __LP64__
  475. /*
  476. ** get bits 12:15 of physical address
  477. ** shift bits 16:31 of physical address
  478. ** and deposit them
  479. */
  480. asm volatile ("extrd,u %1,15,4,%0" : "=r" (ci) : "r" (pa));
  481. asm volatile ("extrd,u %1,31,16,%0" : "+r" (pa) : "r" (pa));
  482. asm volatile ("depd  %1,35,4,%0" : "+r" (pa) : "r" (ci));
  483. #else
  484. pa = 0;
  485. #endif
  486. /*
  487. ** get CPU coherency index bits
  488. ** Grab virtual index [0:11]
  489. ** Deposit virt_idx bits into I/O PDIR word
  490. */
  491. asm volatile ("lci 0(%%sr1, %1), %0" : "=r" (ci) : "r" (vba));
  492. asm volatile ("extru %1,19,12,%0" : "+r" (ci) : "r" (ci));
  493. asm volatile ("depw  %1,15,12,%0" : "+r" (pa) : "r" (ci));
  495. ((u32 *)pdir_ptr)[0] = (u32) pa;
  498. /* FIXME: PCX_W platforms don't need FDC/SYNC. (eg C360)
  499. **        PCX-U/U+ do. (eg C200/C240)
  500. **        PCX-T'? Don't know. (eg C110 or similar K-class)
  501. **
  502. ** See PDC_MODEL/option 0/SW_CAP word for "Non-coherent IO-PDIR bit".
  503. ** Hopefully we can patch (NOP) these out at boot time somehow.
  504. **
  505. ** "Since PCX-U employs an offset hash that is incompatible with
  506. ** the real mode coherence index generation of U2, the PDIR entry
  507. ** must be flushed to memory to retain coherence."
  508. */
  509. asm volatile("fdc 0(%0)" : : "r" (pdir_ptr));
  510. asm volatile("sync");
  511. }
  513. /**
  514.  * ccio_clear_io_tlb - Remove stale entries from the I/O TLB.
  515.  * @ioc: The I/O Controller.
  516.  * @iovp: The I/O Virtual Page.
  517.  * @byte_cnt: The requested number of bytes to be freed from the I/O Pdir.
  518.  *
  519.  * Purge invalid I/O PDIR entries from the I/O TLB.
  520.  *
  521.  * FIXME: Can we change the byte_cnt to pages_mapped?
  522.  */
  523. static CCIO_INLINE void
  524. ccio_clear_io_tlb(struct ioc *ioc, dma_addr_t iovp, size_t byte_cnt)
  525. {
  526. u32 chain_size = 1 << ioc->chainid_shift;
  528. iovp &= IOVP_MASK; /* clear offset bits, just want pagenum */
  529. byte_cnt += chain_size;
  531. while(byte_cnt > chain_size) {
  532. WRITE_U32(CMD_TLB_PURGE | iovp, &ioc->ioc_hpa->io_command);
  533. iovp += chain_size;
  534. byte_cnt -= chain_size;
  535.       }
  536. }
  538. /**
  539.  * ccio_mark_invalid - Mark the I/O Pdir entries invalid.
  540.  * @ioc: The I/O Controller.
  541.  * @iova: The I/O Virtual Address.
  542.  * @byte_cnt: The requested number of bytes to be freed from the I/O Pdir.
  543.  *
  544.  * Mark the I/O Pdir entries invalid and blow away the corresponding I/O
  545.  * TLB entries.
  546.  *
  547.  * FIXME: at some threshhold it might be "cheaper" to just blow
  548.  *        away the entire I/O TLB instead of individual entries.
  549.  *
  550.  * FIXME: Uturn has 256 TLB entries. We don't need to purge every
  551.  *        PDIR entry - just once for each possible TLB entry.
  552.  *        (We do need to maker I/O PDIR entries invalid regardless).
  553.  *
  554.  * FIXME: Can we change byte_cnt to pages_mapped?
  555.  */ 
  556. static CCIO_INLINE void
  557. ccio_mark_invalid(struct ioc *ioc, dma_addr_t iova, size_t byte_cnt)
  558. {
  559. u32 iovp = (u32)CCIO_IOVP(iova);
  560. size_t saved_byte_cnt;
  562. /* round up to nearest page size */
  563. saved_byte_cnt = byte_cnt = ROUNDUP(byte_cnt, IOVP_SIZE);
  565. while(byte_cnt > 0) {
  566. /* invalidate one page at a time */
  567. unsigned int idx = PDIR_INDEX(iovp);
  568. char *pdir_ptr = (char *) &(ioc->pdir_base[idx]);
  570. ASSERT(idx < (ioc->pdir_size / sizeof(u64)));
  571. pdir_ptr[7] = 0; /* clear only VALID bit */ 
  572. /*
  573. ** FIXME: PCX_W platforms don't need FDC/SYNC. (eg C360)
  574. **   PCX-U/U+ do. (eg C200/C240)
  575. ** See PDC_MODEL/option 0/SW_CAP for "Non-coherent IO-PDIR bit".
  576. **
  577. ** Hopefully someone figures out how to patch (NOP) the
  578. ** FDC/SYNC out at boot time.
  579. */
  580. asm volatile("fdc 0(%0)" : : "r" (pdir_ptr[7]));
  582. iovp     += IOVP_SIZE;
  583. byte_cnt -= IOVP_SIZE;
  584. }
  586. asm volatile("sync");
  587. ccio_clear_io_tlb(ioc, CCIO_IOVP(iova), saved_byte_cnt);
  588. }
  590. /****************************************************************
  591. **
  592. **          CCIO dma_ops
  593. **
  594. *****************************************************************/
  596. /**
  597.  * ccio_dma_supported - Verify the IOMMU supports the DMA address range.
  598.  * @dev: The PCI device.
  599.  * @mask: A bit mask describing the DMA address range of the device.
  600.  *
  601.  * This function implements the pci_dma_supported function.
  602.  */
  603. static int 
  604. ccio_dma_supported(struct pci_dev *dev, u64 mask)
  605. {
  606. if(dev == NULL) {
  607. printk(KERN_ERR MODULE_NAME ": EISA/ISA/et al not supportedn");
  608. BUG();
  609. return 0;
  610. }
  612. dev->dma_mask = mask;   /* save it */
  614. /* only support 32-bit devices (ie PCI/GSC) */
  615. return (int)(mask == 0xffffffffUL);
  616. }
  618. /**
  619.  * ccio_map_single - Map an address range into the IOMMU.
  620.  * @dev: The PCI device.
  621.  * @addr: The start address of the DMA region.
  622.  * @size: The length of the DMA region.
  623.  * @direction: The direction of the DMA transaction (to/from device).
  624.  *
  625.  * This function implements the pci_map_single function.
  626.  */
  627. static dma_addr_t 
  628. ccio_map_single(struct pci_dev *dev, void *addr, size_t size, int direction)
  629. {
  630. int idx;
  631. struct ioc *ioc;
  632. unsigned long flags;
  633. dma_addr_t iovp;
  634. dma_addr_t offset;
  635. u64 *pdir_start;
  636. unsigned long hint = hint_lookup[direction];
  638. ASSERT(dev);
  639. ASSERT(dev->sysdata);
  640. ASSERT(HBA_DATA(dev->sysdata)->iommu);
  641. ioc = GET_IOC(dev);
  643. ASSERT(size > 0);
  645. /* save offset bits */
  646. offset = ((unsigned long) addr) & ~IOVP_MASK;
  648. /* round up to nearest IOVP_SIZE */
  649. size = ROUNDUP(size + offset, IOVP_SIZE);
  650. spin_lock_irqsave(&ioc->res_lock, flags);
  652. #ifdef CONFIG_PROC_FS
  653. ioc->msingle_calls++;
  654. ioc->msingle_pages += size >> IOVP_SHIFT;
  655. #endif
  657. idx = ccio_alloc_range(ioc, (size >> IOVP_SHIFT));
  658. iovp = (dma_addr_t)MKIOVP(idx);
  660. pdir_start = &(ioc->pdir_base[idx]);
  662. DBG_RUN("%s() 0x%p -> 0x%lx size: %0x%xn",
  663. __FUNCTION__, addr, (long)iovp | offset, size);
  665. /* If not cacheline aligned, force SAFE_DMA on the whole mess */
  666. if((size % L1_CACHE_BYTES) || ((unsigned long)addr % L1_CACHE_BYTES))
  667. hint |= HINT_SAFE_DMA;
  669. while(size > 0) {
  670. ccio_io_pdir_entry(pdir_start, KERNEL_SPACE, addr, hint);
  672. DBG_RUN(" pdir %p %08x%08xn",
  673. pdir_start,
  674. (u32) (((u32 *) pdir_start)[0]),
  675. (u32) (((u32 *) pdir_start)[1]));
  676. ++pdir_start;
  677. addr += IOVP_SIZE;
  678. size -= IOVP_SIZE;
  679. }
  681. spin_unlock_irqrestore(&ioc->res_lock, flags);
  683. /* form complete address */
  684. return CCIO_IOVA(iovp, offset);
  685. }
  687. /**
  688.  * ccio_unmap_single - Unmap an address range from the IOMMU.
  689.  * @dev: The PCI device.
  690.  * @addr: The start address of the DMA region.
  691.  * @size: The length of the DMA region.
  692.  * @direction: The direction of the DMA transaction (to/from device).
  693.  *
  694.  * This function implements the pci_unmap_single function.
  695.  */
  696. static void 
  697. ccio_unmap_single(struct pci_dev *dev, dma_addr_t iova, size_t size, 
  698.   int direction)
  699. {
  700. struct ioc *ioc;
  701. unsigned long flags; 
  702. dma_addr_t offset = iova & ~IOVP_MASK;
  704. ASSERT(dev);
  705. ASSERT(dev->sysdata);
  706. ASSERT(HBA_DATA(dev->sysdata)->iommu);
  707. ioc = GET_IOC(dev);
  709. DBG_RUN("%s() iovp 0x%lx/%xn",
  710. __FUNCTION__, (long)iova, size);
  712. iova ^= offset;        /* clear offset bits */
  713. size += offset;
  714. size = ROUNDUP(size, IOVP_SIZE);
  716. spin_lock_irqsave(&ioc->res_lock, flags);
  718. #ifdef CONFIG_PROC_FS
  719. ioc->usingle_calls++;
  720. ioc->usingle_pages += size >> IOVP_SHIFT;
  721. #endif
  723. ccio_mark_invalid(ioc, iova, size);
  724. ccio_free_range(ioc, iova, (size >> IOVP_SHIFT));
  725. spin_unlock_irqrestore(&ioc->res_lock, flags);
  726. }
  728. /**
  729.  * ccio_alloc_consistent - Allocate a consistent DMA mapping.
  730.  * @dev: The PCI device.
  731.  * @size: The length of the DMA region.
  732.  * @dma_handle: The DMA address handed back to the device (not the cpu).
  733.  *
  734.  * This function implements the pci_alloc_consistent function.
  735.  */
  736. static void * 
  737. ccio_alloc_consistent(struct pci_dev *dev, size_t size, dma_addr_t *dma_handle)
  738. {
  739.       void *ret;
  740. #if 0
  741. /* GRANT Need to establish hierarchy for non-PCI devs as well
  742. ** and then provide matching gsc_map_xxx() functions for them as well.
  743. */
  744. if(!hwdev) {
  745. /* only support PCI */
  746. *dma_handle = 0;
  747. return 0;
  748. }
  749. #endif
  750.         ret = (void *) __get_free_pages(GFP_ATOMIC, get_order(size));
  752. if (ret) {
  753. memset(ret, 0, size);
  754. *dma_handle = ccio_map_single(dev, ret, size, PCI_DMA_BIDIRECTIONAL);
  755. }
  757. return ret;
  758. }
  760. /**
  761.  * ccio_free_consistent - Free a consistent DMA mapping.
  762.  * @dev: The PCI device.
  763.  * @size: The length of the DMA region.
  764.  * @cpu_addr: The cpu address returned from the ccio_alloc_consistent.
  765.  * @dma_handle: The device address returned from the ccio_alloc_consistent.
  766.  *
  767.  * This function implements the pci_free_consistent function.
  768.  */
  769. static void 
  770. ccio_free_consistent(struct pci_dev *dev, size_t size, void *cpu_addr, 
  771.      dma_addr_t dma_handle)
  772. {
  773. ccio_unmap_single(dev, dma_handle, size, 0);
  774. free_pages((unsigned long)cpu_addr, get_order(size));
  775. }
  777. /*
  778. ** Since 0 is a valid pdir_base index value, can't use that
  779. ** to determine if a value is valid or not. Use a flag to indicate
  780. ** the SG list entry contains a valid pdir index.
  781. */
  782. #define PIDE_FLAG 0x80000000UL
  784. /**
  785.  * ccio_fill_pdir - Insert coalesced scatter/gather chunks into the I/O Pdir.
  786.  * @ioc: The I/O Controller.
  787.  * @startsg: The scatter/gather list of coalesced chunks.
  788.  * @nents: The number of entries in the scatter/gather list.
  789.  * @hint: The DMA Hint.
  790.  *
  791.  * This function inserts the coalesced scatter/gather list chunks into the
  792.  * I/O Controller's I/O Pdir.
  793.  */ 
  794. static CCIO_INLINE int
  795. ccio_fill_pdir(struct ioc *ioc, struct scatterlist *startsg, int nents, 
  796.        unsigned long hint)
  797. {
  798. struct scatterlist *dma_sg = startsg; /* pointer to current DMA */
  799. int n_mappings = 0;
  800. u64 *pdirp = 0;
  801. unsigned long dma_offset = 0;
  803. dma_sg--;
  804. while (nents-- > 0) {
  805. int cnt = sg_dma_len(startsg);
  806. sg_dma_len(startsg) = 0;
  808. DBG_RUN_SG(" %d : %08lx/%05x %p/%05xn", nents,
  809.    (unsigned long)sg_dma_address(startsg), cnt,
  810.    startsg->address, startsg->length
  811. );
  813. /*
  814. ** Look for the start of a new DMA stream
  815. */
  816. if(sg_dma_address(startsg) & PIDE_FLAG) {
  817. u32 pide = sg_dma_address(startsg) & ~PIDE_FLAG;
  818. dma_offset = (unsigned long) pide & ~IOVP_MASK;
  819. sg_dma_address(startsg) = 0;
  820. dma_sg++;
  821. sg_dma_address(dma_sg) = pide;
  822. pdirp = &(ioc->pdir_base[pide >> IOVP_SHIFT]);
  823. n_mappings++;
  824. }
  826. /*
  827. ** Look for a VCONTIG chunk
  828. */
  829. if (cnt) {
  830. unsigned long vaddr = (unsigned long)startsg->address;
  831. ASSERT(pdirp);
  833. /* Since multiple Vcontig blocks could make up
  834. ** one DMA stream, *add* cnt to dma_len.
  835. */
  836. sg_dma_len(dma_sg) += cnt;
  837. cnt += dma_offset;
  838. dma_offset=0; /* only want offset on first chunk */
  839. cnt = ROUNDUP(cnt, IOVP_SIZE);
  840. #ifdef CONFIG_PROC_FS
  841. ioc->msg_pages += cnt >> IOVP_SHIFT;
  842. #endif
  843. do {
  844. ccio_io_pdir_entry(pdirp, KERNEL_SPACE, 
  845.    (void *)vaddr, hint);
  846. vaddr += IOVP_SIZE;
  847. cnt -= IOVP_SIZE;
  848. pdirp++;
  849. } while (cnt > 0);
  850. }
  851. startsg++;
  852. }
  853. return(n_mappings);
  854. }
  856. /*
  857. ** First pass is to walk the SG list and determine where the breaks are
  858. ** in the DMA stream. Allocates PDIR entries but does not fill them.
  859. ** Returns the number of DMA chunks.
  860. **
  861. ** Doing the fill seperate from the coalescing/allocation keeps the
  862. ** code simpler. Future enhancement could make one pass through
  863. ** the sglist do both.
  864. */
  866. static CCIO_INLINE int
  867. ccio_coalesce_chunks(struct ioc *ioc, struct scatterlist *startsg, int nents)
  868. {
  869. struct scatterlist *vcontig_sg;    /* VCONTIG chunk head */
  870. unsigned long vcontig_len;         /* len of VCONTIG chunk */
  871. unsigned long vcontig_end;
  872. struct scatterlist *dma_sg;        /* next DMA stream head */
  873. unsigned long dma_offset, dma_len; /* start/len of DMA stream */
  874. int n_mappings = 0;
  876. while (nents > 0) {
  878. /*
  879. ** Prepare for first/next DMA stream
  880. */
  881. dma_sg = vcontig_sg = startsg;
  882. dma_len = vcontig_len = vcontig_end = startsg->length;
  883. vcontig_end += (unsigned long) startsg->address;
  884. dma_offset = (unsigned long) startsg->address & ~IOVP_MASK;
  886. /* PARANOID: clear entries */
  887. sg_dma_address(startsg) = 0;
  888. sg_dma_len(startsg) = 0;
  890. /*
  891. ** This loop terminates one iteration "early" since
  892. ** it's always looking one "ahead".
  893. */
  894. while(--nents > 0) {
  895. unsigned long startsg_end;
  897. startsg++;
  898. startsg_end = (unsigned long)startsg->address + 
  899. startsg->length;
  901. /* PARANOID: clear entries */
  902. sg_dma_address(startsg) = 0;
  903. sg_dma_len(startsg) = 0;
  905. /*
  906. ** First make sure current dma stream won't
  907. ** exceed DMA_CHUNK_SIZE if we coalesce the
  908. ** next entry.
  909. */   
  910. if(ROUNDUP(dma_len + dma_offset + startsg->length,
  911.    IOVP_SIZE) > DMA_CHUNK_SIZE)
  912. break;
  914. /*
  915. ** Append the next transaction?
  916. */
  917. if(vcontig_end == (unsigned long) startsg->address) {
  918. vcontig_len += startsg->length;
  919. vcontig_end += startsg->length;
  920. dma_len     += startsg->length;
  921. continue;
  922. }
  924. /*
  925. ** Not virtually contigous.
  926. ** Terminate prev chunk.
  927. ** Start a new chunk.
  928. **
  929. ** Once we start a new VCONTIG chunk, dma_offset
  930. ** can't change. And we need the offset from the first
  931. ** chunk - not the last one. Ergo Successive chunks
  932. ** must start on page boundaries and dove tail
  933. ** with it's predecessor.
  934. */
  935. sg_dma_len(vcontig_sg) = vcontig_len;
  937. vcontig_sg = startsg;
  938. vcontig_len = startsg->length;
  939. break;
  940. }
  942. /*
  943. ** End of DMA Stream
  944. ** Terminate last VCONTIG block.
  945. ** Allocate space for DMA stream.
  946. */
  947. sg_dma_len(vcontig_sg) = vcontig_len;
  948. dma_len = ROUNDUP(dma_len + dma_offset, IOVP_SIZE);
  949. sg_dma_address(dma_sg) =
  950. PIDE_FLAG 
  951. | (ccio_alloc_range(ioc, (dma_len >> IOVP_SHIFT)) << IOVP_SHIFT)
  952. | dma_offset;
  953. n_mappings++;
  954. }
  956. return n_mappings;
  957. }
  959. /**
  960.  * ccio_map_sg - Map the scatter/gather list into the IOMMU.
  961.  * @dev: The PCI device.
  962.  * @sglist: The scatter/gather list to be mapped in the IOMMU.
  963.  * @nents: The number of entries in the scatter/gather list.
  964.  * @direction: The direction of the DMA transaction (to/from device).
  965.  *
  966.  * This function implements the pci_map_sg function.
  967.  */
  968. static int
  969. ccio_map_sg(struct pci_dev *dev, struct scatterlist *sglist, int nents, 
  970.     int direction)
  971. {
  972. struct ioc *ioc;
  973. int coalesced, filled = 0;
  974. unsigned long flags;
  975. unsigned long hint = hint_lookup[direction];
  977. ASSERT(dev);
  978. ASSERT(dev->sysdata);
  979. ASSERT(HBA_DATA(dev->sysdata)->iommu);
  980. ioc = GET_IOC(dev);
  982. DBG_RUN_SG("%s() START %d entriesn", __FUNCTION__, nents);
  984. /* Fast path single entry scatterlists. */
  985. if(nents == 1) {
  986. sg_dma_address(sglist)= ccio_map_single(dev, sglist->address,
  987. sglist->length, 
  988. direction);
  989. sg_dma_len(sglist)= sglist->length;
  990. return 1;
  991. }
  993. spin_lock_irqsave(&ioc->res_lock, flags);
  995. #ifdef CONFIG_PROC_FS
  996. ioc->msg_calls++;
  997. #endif
  999. /*
  1000. ** First coalesce the chunks and allocate I/O pdir space
  1001. **
  1002. ** If this is one DMA stream, we can properly map using the
  1003. ** correct virtual address associated with each DMA page.
  1004. ** w/o this association, we wouldn't have coherent DMA!
  1005. ** Access to the virtual address is what forces a two pass algorithm.
  1006. */
  1007. coalesced = ccio_coalesce_chunks(ioc, sglist, nents);
  1009. /*
  1010. ** Program the I/O Pdir
  1011. **
  1012. ** map the virtual addresses to the I/O Pdir
  1013. ** o dma_address will contain the pdir index
  1014. ** o dma_len will contain the number of bytes to map 
  1015. ** o address contains the virtual address.
  1016. */
  1017. filled = ccio_fill_pdir(ioc, sglist, nents, hint);
  1019. spin_unlock_irqrestore(&ioc->res_lock, flags);
  1021. ASSERT(coalesced == filled);
  1022. DBG_RUN_SG("%s() DONE %d mappingsn", __FUNCTION__, filled);
  1024. return filled;
  1025. }
  1027. /**
  1028.  * ccio_unmap_sg - Unmap the scatter/gather list from the IOMMU.
  1029.  * @dev: The PCI device.
  1030.  * @sglist: The scatter/gather list to be unmapped from the IOMMU.
  1031.  * @nents: The number of entries in the scatter/gather list.
  1032.  * @direction: The direction of the DMA transaction (to/from device).
  1033.  *
  1034.  * This function implements the pci_unmap_sg function.
  1035.  */
  1036. static void 
  1037. ccio_unmap_sg(struct pci_dev *dev, struct scatterlist *sglist, int nents, 
  1038.       int direction)
  1039. {
  1040. struct ioc *ioc;
  1042. ASSERT(dev);
  1043. ASSERT(dev->sysdata);
  1044. ASSERT(HBA_DATA(dev->sysdata)->iommu);
  1045. ioc = GET_IOC(dev);
  1047. DBG_RUN_SG("%s() START %d entries,  %p,%xn",
  1048. __FUNCTION__, nents, sglist->address, sglist->length);
  1050. #ifdef CONFIG_PROC_FS
  1051. ioc->usg_calls++;
  1052. #endif
  1054. while(sg_dma_len(sglist) && nents--) {
  1056. #ifdef CONFIG_PROC_FS
  1057. ioc->usg_pages += sg_dma_len(sglist) >> PAGE_SHIFT;
  1058. #endif
  1059. ccio_unmap_single(dev, sg_dma_address(sglist),
  1060.   sg_dma_len(sglist), direction);
  1061. ++sglist;
  1062. }
  1064. DBG_RUN_SG("%s() DONE (nents %d)n", __FUNCTION__, nents);
  1065. }
  1067. static struct pci_dma_ops ccio_ops = {
  1068. ccio_dma_supported,
  1069. ccio_alloc_consistent,
  1070. ccio_free_consistent,
  1071. ccio_map_single,
  1072. ccio_unmap_single,
  1073. ccio_map_sg,
  1074. ccio_unmap_sg,
  1075. NULL,                   /* dma_sync_single : NOP for U2/Uturn */
  1076. NULL,                   /* dma_sync_sg     : ditto */
  1077. };
  1079. #ifdef CONFIG_PROC_FS
  1080. static int proc_append(char *src, int len, char **dst, off_t *offset, int *max)
  1081. {
  1082. if (len < *offset) {
  1083. *offset -= len;
  1084. return 0;
  1085. }
  1086. if (*offset > 0) {
  1087. src += *offset;
  1088. len -= *offset;
  1089. *offset = 0;
  1090. }
  1091. if (len > *max) {
  1092. len = *max;
  1093. }
  1094. memcpy(*dst, src, len);
  1095. *dst += len;
  1096. *max -= len;
  1097. return (*max == 0);
  1098. }
  1100. static int ccio_proc_info(char *buf, char **start, off_t offset, int count,
  1101.   int *eof, void *data)
  1102. {
  1103. int max = count;
  1104. char tmp[80]; /* width of an ANSI-standard terminal */
  1105. struct ioc *ioc = ioc_list;
  1107. while (ioc != NULL) {
  1108. unsigned int total_pages = ioc->res_size << 3;
  1109. unsigned long avg = 0, min, max;
  1110. int j, len;
  1112. len = sprintf(tmp, "%sn", ioc->name);
  1113. if (proc_append(tmp, len, &buf, &offset, &count))
  1114. break;
  1116. len = sprintf(tmp, "Cujo 2.0 bug    : %sn",
  1117.       (ioc->cujo20_bug ? "yes" : "no"));
  1118. if (proc_append(tmp, len, &buf, &offset, &count))
  1119. break;
  1121. len = sprintf(tmp, "IO PDIR size    : %d bytes (%d entries)n",
  1122.       total_pages * 8, total_pages);
  1123. if (proc_append(tmp, len, &buf, &offset, &count))
  1124. break;
  1126. len = sprintf(tmp, "IO PDIR entries : %ld free  %ld used (%d%%)n",
  1127.       total_pages - ioc->used_pages, ioc->used_pages,
  1128.       (int)(ioc->used_pages * 100 / total_pages));
  1129. if (proc_append(tmp, len, &buf, &offset, &count))
  1130. break;
  1132. len = sprintf(tmp, "Resource bitmap : %d bytes (%d pages)n", 
  1133. ioc->res_size, total_pages);
  1134. if (proc_append(tmp, len, &buf, &offset, &count))
  1135. break;
  1137. min = max = ioc->avg_search[0];
  1138. for(j = 0; j < CCIO_SEARCH_SAMPLE; ++j) {
  1139. avg += ioc->avg_search[j];
  1140. if(ioc->avg_search[j] > max) 
  1141. max = ioc->avg_search[j];
  1142. if(ioc->avg_search[j] < min) 
  1143. min = ioc->avg_search[j];
  1144. }
  1145. avg /= CCIO_SEARCH_SAMPLE;
  1146. len = sprintf(tmp, "  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)n",
  1147.       min, avg, max);
  1148. if (proc_append(tmp, len, &buf, &offset, &count))
  1149. break;
  1151. len = sprintf(tmp, "pci_map_single(): %8ld calls  %8ld pages (avg %d/1000)n",
  1152.       ioc->msingle_calls, ioc->msingle_pages,
  1153.       (int)((ioc->msingle_pages * 1000)/ioc->msingle_calls));
  1154. if (proc_append(tmp, len, &buf, &offset, &count))
  1155. break;
  1158. /* KLUGE - unmap_sg calls unmap_single for each mapped page */
  1159. min = ioc->usingle_calls - ioc->usg_calls;
  1160. max = ioc->usingle_pages - ioc->usg_pages;
  1161. len = sprintf(tmp, "pci_unmap_single: %8ld calls  %8ld pages (avg %d/1000)n",
  1162.       min, max, (int)((max * 1000)/min));
  1163. if (proc_append(tmp, len, &buf, &offset, &count))
  1164. break;
  1165.  
  1166. len = sprintf(tmp, "pci_map_sg()    : %8ld calls  %8ld pages (avg %d/1000)n",
  1167.       ioc->msg_calls, ioc->msg_pages,
  1168.       (int)((ioc->msg_pages * 1000)/ioc->msg_calls));
  1169. if (proc_append(tmp, len, &buf, &offset, &count))
  1170. break;
  1171. len = sprintf(tmp, "pci_unmap_sg()  : %8ld calls  %8ld pages (avg %d/1000)nnn",
  1172.       ioc->usg_calls, ioc->usg_pages,
  1173.       (int)((ioc->usg_pages * 1000)/ioc->usg_calls));
  1174. if (proc_append(tmp, len, &buf, &offset, &count))
  1175. break;
  1177. ioc = ioc->next;
  1178. }
  1180. if (count == 0) {
  1181. *eof = 1;
  1182. }
  1183. return (max - count);
  1184. }
  1186. static int ccio_resource_map(char *buf, char **start, off_t offset, int len,
  1187.      int *eof, void *data)
  1188. {
  1189. struct ioc *ioc = ioc_list;
  1191. buf[0] = '';
  1192. while (ioc != NULL) {
  1193. u32 *res_ptr = (u32 *)ioc->res_map;
  1194. int j;
  1196. for (j = 0; j < (ioc->res_size / sizeof(u32)); j++) {
  1197. if ((j & 7) == 0)
  1198. strcat(buf,"n   ");
  1199. sprintf(buf, "%s %08x", buf, *res_ptr);
  1200. res_ptr++;
  1201. }
  1202. strcat(buf, "nn");
  1203. ioc = ioc->next;
  1204. break; /* XXX - remove me */
  1205. }
  1207. return strlen(buf);
  1208. }
  1209. #endif
  1211. /**
  1212.  * ccio_find_ioc - Find the ioc in the ioc_list
  1213.  * @hw_path: The hardware path of the ioc.
  1214.  *
  1215.  * This function searches the ioc_list for an ioc that matches
  1216.  * the provide hardware path.
  1217.  */
  1218. static struct ioc * ccio_find_ioc(int hw_path)
  1219. {
  1220. int i;
  1221. struct ioc *ioc;
  1223. ioc = ioc_list;
  1224. for (i = 0; i < ioc_count; i++) {
  1225. if (ioc->hw_path == hw_path)
  1226. return ioc;
  1228. ioc = ioc->next;
  1229. }
  1231. return NULL;
  1232. }
  1234. /**
  1235.  * ccio_get_iommu - Find the iommu which controls this device
  1236.  * @dev: The parisc device.
  1237.  *
  1238.  * This function searches through the registerd IOMMU's and returns the
  1239.  * appropriate IOMMU for the device based upon the devices hardware path.
  1240.  */
  1241. void * ccio_get_iommu(const struct parisc_device *dev)
  1242. {
  1243. dev = find_pa_parent_type(dev, HPHW_IOA);
  1244. if (!dev)
  1245. return NULL;
  1247. return ccio_find_ioc(dev->hw_path);
  1248. }
  1250. #define CUJO_20_STEP       0x10000000 /* inc upper nibble */
  1252. /* Cujo 2.0 has a bug which will silently corrupt data being transferred
  1253.  * to/from certain pages.  To avoid this happening, we mark these pages
  1254.  * as `used', and ensure that nothing will try to allocate from them.
  1255.  */
  1256. void ccio_cujo20_fixup(struct parisc_device *dev, u32 iovp)
  1257. {
  1258. unsigned int idx;
  1259. struct ioc *ioc = ccio_get_iommu(dev);
  1260. u8 *res_ptr;
  1262. #ifdef CONFIG_PROC_FS
  1263. ioc->cujo20_bug = 1;
  1264. #endif
  1265. res_ptr = ioc->res_map;
  1266. idx = PDIR_INDEX(iovp) >> 3;
  1268. while (idx < ioc->res_size) {
  1269.   res_ptr[idx] |= 0xff;
  1270. idx += PDIR_INDEX(CUJO_20_STEP) >> 3;
  1271. }
  1272. }
  1274. #if 0
  1275. /* GRANT -  is this needed for U2 or not? */
  1277. /*
  1278. ** Get the size of the I/O TLB for this I/O MMU.
  1279. **
  1280. ** If spa_shift is non-zero (ie probably U2),
  1281. ** then calculate the I/O TLB size using spa_shift.
  1282. **
  1283. ** Otherwise we are supposed to get the IODC entry point ENTRY TLB
  1284. ** and execute it. However, both U2 and Uturn firmware supplies spa_shift.
  1285. ** I think only Java (K/D/R-class too?) systems don't do this.
  1286. */
  1287. static int
  1288. ccio_get_iotlb_size(struct parisc_device *dev)
  1289. {
  1290. if (dev->spa_shift == 0) {
  1291. panic("%s() : Can't determine I/O TLB size.n", __FUNCTION__);
  1292. }
  1293. return (1 << dev->spa_shift);
  1294. }
  1295. #else
  1297. /* Uturn supports 256 TLB entries */
  1298. #define CCIO_CHAINID_SHIFT 8
  1299. #define CCIO_CHAINID_MASK 0xff
  1300. #endif /* 0 */
  1302. /**
  1303.  * ccio_ioc_init - Initalize the I/O Controller
  1304.  * @ioc: The I/O Controller.
  1305.  *
  1306.  * Initalize the I/O Controller which includes setting up the
  1307.  * I/O Page Directory, the resource map, and initalizing the
  1308.  * U2/Uturn chip into virtual mode.
  1309.  */
  1310. static void
  1311. ccio_ioc_init(struct ioc *ioc)
  1312. {
  1313. int i, iov_order;
  1314. u32 iova_space_size;
  1315. unsigned long physmem;
  1317. /*
  1318. ** Determine IOVA Space size from memory size.
  1319. **
  1320. ** Ideally, PCI drivers would register the maximum number
  1321. ** of DMA they can have outstanding for each device they
  1322. ** own.  Next best thing would be to guess how much DMA
  1323. ** can be outstanding based on PCI Class/sub-class. Both
  1324. ** methods still require some "extra" to support PCI
  1325. ** Hot-Plug/Removal of PCI cards. (aka PCI OLARD).
  1326. */
  1328. /* limit IOVA space size to 1MB-1GB */
  1330. physmem = num_physpages << PAGE_SHIFT;
  1331. if(physmem < (ccio_mem_ratio * 1024 * 1024)) {
  1332. iova_space_size = 1024 * 1024;
  1333. #ifdef __LP64__
  1334. } else if(physmem > (ccio_mem_ratio * 512 * 1024 * 1024)) {
  1335. iova_space_size = 512 * 1024 * 1024;
  1336. #endif
  1337. } else {
  1338. iova_space_size = (u32)(physmem / ccio_mem_ratio);
  1339. }
  1341. /*
  1342. ** iova space must be log2() in size.
  1343. ** thus, pdir/res_map will also be log2().
  1344. */
  1346. /* We could use larger page sizes in order to *decrease* the number
  1347. ** of mappings needed.  (ie 8k pages means 1/2 the mappings).
  1348. **
  1349. ** Note: Grant Grunder says "Using 8k I/O pages isn't trivial either
  1350. **   since the pages must also be physically contiguous - typically
  1351. **   this is the case under linux."
  1352. */
  1354. iov_order = get_order(iova_space_size) >> (IOVP_SHIFT - PAGE_SHIFT);
  1355. ASSERT(iov_order <= (30 - IOVP_SHIFT));   /* iova_space_size <= 1GB */
  1356. ASSERT(iov_order >= (20 - IOVP_SHIFT));   /* iova_space_size >= 1MB */
  1357. iova_space_size = 1 << (iov_order + IOVP_SHIFT);
  1359. ioc->pdir_size = (iova_space_size / IOVP_SIZE) * sizeof(u64);
  1361. ASSERT(ioc->pdir_size < 4 * 1024 * 1024);   /* max pdir size < 4MB */
  1363. /* Verify it's a power of two */
  1364. ASSERT((1 << get_order(ioc->pdir_size)) == (ioc->pdir_size >> PAGE_SHIFT));
  1366. DBG_INIT("%s() hpa 0x%p mem %luMB IOV %dMB (%d bits) PDIR size 0x%0x",
  1367. __FUNCTION__, ioc->ioc_hpa, physmem>>20, iova_space_size>>20,
  1368.  iov_order + PAGE_SHIFT, ioc->pdir_size);
  1370. ioc->pdir_base = (u64 *)__get_free_pages(GFP_KERNEL, 
  1371.  get_order(ioc->pdir_size));
  1372. if(NULL == ioc->pdir_base) {
  1373. panic(__FILE__ ":%s() could not allocate I/O Page Tablen", __FUNCTION__);
  1374. }
  1375. memset(ioc->pdir_base, 0, ioc->pdir_size);
  1377. ASSERT((((unsigned long)ioc->pdir_base) & PAGE_MASK) == (unsigned long)ioc->pdir_base);
  1378. DBG_INIT(" base %p", ioc->pdir_base);
  1380. /* resource map size dictated by pdir_size */
  1381.   ioc->res_size = (ioc->pdir_size / sizeof(u64)) >> 3;
  1382. DBG_INIT("%s() res_size 0x%xn", __FUNCTION__, ioc->res_size);
  1384. ioc->res_map = (u8 *)__get_free_pages(GFP_KERNEL, 
  1385.       get_order(ioc->res_size));
  1386. if(NULL == ioc->res_map) {
  1387. panic(__FILE__ ":%s() could not allocate resource mapn", __FUNCTION__);
  1388. }
  1389. memset(ioc->res_map, 0, ioc->res_size);
  1391. /* Initialize the res_hint to 16 */
  1392. ioc->res_hint = 16;
  1394. /* Initialize the spinlock */
  1395. spin_lock_init(&ioc->res_lock);
  1397. /*
  1398. ** Chainid is the upper most bits of an IOVP used to determine
  1399. ** which TLB entry an IOVP will use.
  1400. */
  1401. ioc->chainid_shift = get_order(iova_space_size) + PAGE_SHIFT - CCIO_CHAINID_SHIFT;
  1402. DBG_INIT(" chainid_shift 0x%xn", ioc->chainid_shift);
  1404. /*
  1405. ** Initialize IOA hardware
  1406. */
  1407. WRITE_U32(CCIO_CHAINID_MASK << ioc->chainid_shift, 
  1408.   &ioc->ioc_hpa->io_chain_id_mask);
  1410. WRITE_U32(virt_to_phys(ioc->pdir_base), 
  1411.   &ioc->ioc_hpa->io_pdir_base);
  1413. /*
  1414. ** Go to "Virtual Mode"
  1415. */
  1416. WRITE_U32(IOA_NORMAL_MODE, &ioc->ioc_hpa->io_control);
  1418. /*
  1419. ** Initialize all I/O TLB entries to 0 (Valid bit off).
  1420. */
  1421. WRITE_U32(0, &ioc->ioc_hpa->io_tlb_entry_m);
  1422. WRITE_U32(0, &ioc->ioc_hpa->io_tlb_entry_l);
  1424. for(i = 1 << CCIO_CHAINID_SHIFT; i ; i--) {
  1425. WRITE_U32((CMD_TLB_DIRECT_WRITE | (i << ioc->chainid_shift)),
  1426.   &ioc->ioc_hpa->io_command);
  1427. }
  1428. }
  1430. static void
  1431. ccio_init_resource(struct resource *res, char *name, unsigned long ioaddr)
  1432. {
  1433. int result;
  1435. res->flags = IORESOURCE_MEM;
  1436. res->start = (unsigned long)(signed) __raw_readl(ioaddr) << 16;
  1437. res->end = (unsigned long)(signed) (__raw_readl(ioaddr + 4) << 16) - 1;
  1438. if (res->end + 1 == res->start)
  1439. return;
  1440. res->name = name;
  1441. result = request_resource(&iomem_resource, res);
  1442. if (result < 0) {
  1443. printk(KERN_ERR 
  1444.        "%s: failed to claim CCIO bus address space (%p,%p)n", 
  1445.        __FILE__, res->start, res->end);
  1446. }
  1447. }
  1449. static void __init ccio_init_resources(struct ioc *ioc)
  1450. {
  1451. struct resource *res = ioc->mmio_region;
  1452. char *name = kmalloc(14, GFP_KERNEL);
  1454. sprintf(name, "GSC Bus [%d/]", ioc->hw_path);
  1456. ccio_init_resource(res, name, (unsigned long)&ioc->ioc_hpa->io_io_low);
  1457. ccio_init_resource(res + 1, name,
  1458. (unsigned long)&ioc->ioc_hpa->io_io_low_hv);
  1459. }
  1461. static void expand_ioc_area(struct ioc *ioc, unsigned long size,
  1462. unsigned long min, unsigned long max, unsigned long align)
  1463. {
  1464. #ifdef NASTY_HACK_FOR_K_CLASS
  1465. __raw_writel(0xfffff600, (unsigned long)&(ioc->ioc_hpa->io_io_high));
  1466. ioc->mmio_region[0].end = 0xf5ffffff;
  1467. #endif
  1468. }
  1470. static struct resource *ccio_get_resource(struct ioc* ioc,
  1471. const struct parisc_device *dev)
  1472. {
  1473. if (!ioc) {
  1474. return &iomem_resource;
  1475. } else if ((ioc->mmio_region->start <= dev->hpa) &&
  1476. (dev->hpa < ioc->mmio_region->end)) {
  1477. return ioc->mmio_region;
  1478. } else if (((ioc->mmio_region + 1)->start <= dev->hpa) &&
  1479. (dev->hpa < (ioc->mmio_region + 1)->end)) {
  1480. return ioc->mmio_region + 1;
  1481. } else {
  1482. return NULL;
  1483. }
  1484. }
  1486. int ccio_allocate_resource(const struct parisc_device *dev,
  1487. struct resource *res, unsigned long size,
  1488. unsigned long min, unsigned long max, unsigned long align,
  1489. void (*alignf)(void *, struct resource *, unsigned long),
  1490. void *alignf_data)
  1491. {
  1492. struct ioc *ioc = ccio_get_iommu(dev);
  1493. struct resource *parent = ccio_get_resource(ioc, dev);
  1494. if (!parent)
  1495. return -EBUSY;
  1497. if (!allocate_resource(parent, res, size, min, max, align, alignf,
  1498. alignf_data))
  1499. return 0;
  1501. expand_ioc_area(ioc, size, min, max, align);
  1502. return allocate_resource(parent, res, size, min, max, align, alignf,
  1503. alignf_data);
  1504. }
  1506. int ccio_request_resource(const struct parisc_device *dev,
  1507. struct resource *res)
  1508. {
  1509. struct ioc *ioc = ccio_get_iommu(dev);
  1510. struct resource *parent = ccio_get_resource(ioc, dev);
  1512. return request_resource(parent, res);
  1513. }
  1514. /**
  1515.  * ccio_probe - Determine if ccio should claim this device.
  1516.  * @dev: The device which has been found
  1517.  *
  1518.  * Determine if ccio should claim this chip (return 0) or not (return 1).
  1519.  * If so, initialize the chip and tell other partners in crime they
  1520.  * have work to do.
  1521.  */
  1522. static int ccio_probe(struct parisc_device *dev)
  1523. {
  1524. int i;
  1525. struct ioc *ioc, **ioc_p = &ioc_list;
  1527. ioc = kmalloc(sizeof(struct ioc), GFP_KERNEL);
  1528. if (ioc == NULL) {
  1529. printk(KERN_ERR MODULE_NAME ": memory allocation failuren");
  1530. return 1;
  1531. }
  1532. memset(ioc, 0, sizeof(struct ioc));
  1534. ioc->name = dev->id.hversion == U2_IOA_RUNWAY ? "U2" : "UTurn";
  1536. printk(KERN_INFO "Found %s at 0x%lxn", ioc->name, dev->hpa);
  1538. for (i = 0; i < ioc_count; i++) {
  1539. ioc_p = &(*ioc_p)->next;
  1540. }
  1541. *ioc_p = ioc;
  1543. ioc->hw_path = dev->hw_path;
  1544. ioc->ioc_hpa = (struct ioa_registers *)dev->hpa;
  1545. ccio_ioc_init(ioc);
  1546. ccio_init_resources(ioc);
  1547. hppa_dma_ops = &ccio_ops;
  1549. if (ioc_count == 0) {
  1550. /* XXX: Create separate entries for each ioc */
  1551. create_proc_read_entry(MODULE_NAME, S_IRWXU, proc_runway_root,
  1552.        ccio_proc_info, NULL);
  1553. create_proc_read_entry(MODULE_NAME"-bitmap", S_IRWXU,
  1554.        proc_runway_root, ccio_resource_map, NULL);
  1555. }
  1557. ioc_count++;
  1558. return 0;
  1559. }
  1561. struct pci_dev * ccio_get_fake(const struct parisc_device *dev)
  1562. {
  1563. struct ioc *ioc;
  1565. dev = find_pa_parent_type(dev, HPHW_IOA);
  1566. if(!dev)
  1567. return NULL;
  1569. ioc = ccio_find_ioc(dev->hw_path);
  1570. if(!ioc)
  1571. return NULL;
  1573. if(ioc->fake_pci_dev)
  1574. return ioc->fake_pci_dev;
  1576. ioc->fake_pci_dev = kmalloc(sizeof(struct pci_dev), GFP_KERNEL);
  1577. if(ioc->fake_pci_dev == NULL) {
  1578. printk(KERN_ERR MODULE_NAME ": memory allocation failuren");
  1579. return NULL;
  1580. }
  1581. memset(ioc->fake_pci_dev, 0, sizeof(struct pci_dev));
  1583. ioc->fake_pci_dev->sysdata = kmalloc(sizeof(struct pci_hba_data), GFP_KERNEL);
  1584. if(ioc->fake_pci_dev->sysdata == NULL) {
  1585. printk(KERN_ERR MODULE_NAME ": memory allocation failuren");
  1586. return NULL;
  1587. }
  1589. HBA_DATA(ioc->fake_pci_dev->sysdata)->iommu = ioc;
  1590. return ioc->fake_pci_dev;
  1591. }
  1593. /* We *can't* support JAVA (T600). Venture there at your own risk. */
  1594. static struct parisc_device_id ccio_tbl[] = {
  1595. { HPHW_IOA, HVERSION_REV_ANY_ID, U2_IOA_RUNWAY, 0xb }, /* U2 */
  1596. { HPHW_IOA, HVERSION_REV_ANY_ID, UTURN_IOA_RUNWAY, 0xb }, /* UTurn */
  1597. { 0, }
  1598. };
  1600. static struct parisc_driver ccio_driver = {
  1601. name: "U2/Uturn",
  1602. id_table: ccio_tbl,
  1603. probe: ccio_probe,
  1604. };
  1606. /**
  1607.  * ccio_init - ccio initalization procedure.
  1608.  *
  1609.  * Register this driver.
  1610.  */
  1611. void __init ccio_init(void)
  1612. {
  1613. register_parisc_driver(&ccio_driver);
  1614. }