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

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

Linux/Unix编程

开发平台：

Unix_Linux

sba_iommu.c：源码内容
  1. /*
  2. **  System Bus Adapter (SBA) I/O MMU manager
  3. **
  4. ** (c) Copyright 2000 Grant Grundler
  5. ** (c) Copyright 2000 Hewlett-Packard Company
  6. **
  7. ** Portions (c) 1999 Dave S. Miller (from sparc64 I/O MMU code)
  8. **
  9. ** This program is free software; you can redistribute it and/or modify
  10. ** it under the terms of the GNU General Public License as published by
  11. **      the Free Software Foundation; either version 2 of the License, or
  12. **      (at your option) any later version.
  13. **
  14. **
  15. ** This module initializes the IOC (I/O Controller) found on B1000/C3000/
  16. ** J5000/J7000/N-class/L-class machines and their successors.
  17. **
  18. ** FIXME: add DMA hint support programming in both sba and lba modules.
  19. */
  21. #include <linux/config.h>
  22. #include <linux/types.h>
  23. #include <linux/kernel.h>
  24. #include <linux/spinlock.h>
  25. #include <linux/slab.h>
  26. #include <linux/init.h>
  28. #include <linux/mm.h>
  29. #include <linux/string.h>
  30. #undef PCI_DEBUG /* for ASSERT */
  31. #include <linux/pci.h>
  32. #undef PCI_DEBUG
  34. #include <asm/byteorder.h>
  35. #include <asm/io.h>
  36. #include <asm/dma.h> /* for DMA_CHUNK_SIZE */
  38. #include <asm/hardware.h> /* for register_parisc_driver() stuff */
  39. #include <asm/gsc.h> /* FIXME: for gsc_read/gsc_write */
  41. #include <linux/proc_fs.h>
  42. #include <asm/runway.h> /* for proc_runway_root */
  43. #include <asm/pdc.h> /* for PDC_MODEL_* */
  45. #define MODULE_NAME "SBA"
  47. /*
  48. ** The number of debug flags is a clue - this code is fragile.
  49. ** Don't even think about messing with it unless you have
  50. ** plenty of 710's to sacrifice to the computer gods. :^)
  51. */
  52. #undef DEBUG_SBA_INIT
  53. #undef DEBUG_SBA_RUN
  54. #undef DEBUG_SBA_RUN_SG
  55. #undef DEBUG_SBA_RESOURCE
  56. #undef ASSERT_PDIR_SANITY
  57. #undef DEBUG_LARGE_SG_ENTRIES
  58. #undef DEBUG_DMB_TRAP
  60. #define SBA_INLINE __inline__
  62. #ifdef DEBUG_SBA_INIT
  63. #define DBG_INIT(x...) printk(x)
  64. #else
  65. #define DBG_INIT(x...)
  66. #endif
  68. #ifdef DEBUG_SBA_RUN
  69. #define DBG_RUN(x...) printk(x)
  70. #else
  71. #define DBG_RUN(x...)
  72. #endif
  74. #ifdef DEBUG_SBA_RUN_SG
  75. #define DBG_RUN_SG(x...) printk(x)
  76. #else
  77. #define DBG_RUN_SG(x...)
  78. #endif
  81. #ifdef DEBUG_SBA_RESOURCE
  82. #define DBG_RES(x...) printk(x)
  83. #else
  84. #define DBG_RES(x...)
  85. #endif
  87. /*
  88. ** The number of pdir entries to "free" before issueing
  89. ** a read to PCOM register to flush out PCOM writes.
  90. ** Interacts with allocation granularity (ie 4 or 8 entries
  91. ** allocated and free'd/purged at a time might make this
  92. ** less interesting).
  93. */
  94. #define DELAYED_RESOURCE_CNT 16
  96. #define DEFAULT_DMA_HINT_REG 0
  98. #define ASTRO_RUNWAY_PORT 0x582
  99. #define ASTRO_ROPES_PORT 0x780
  101. #define IKE_MERCED_PORT 0x803
  102. #define IKE_ROPES_PORT 0x781
  104. #define REO_MERCED_PORT 0x804
  105. #define REO_ROPES_PORT 0x782
  107. #define REOG_MERCED_PORT 0x805
  108. #define REOG_ROPES_PORT 0x783
  110. #define SBA_FUNC_ID 0x0000 /* function id */
  111. #define SBA_FCLASS 0x0008 /* function class, bist, header, rev... */
  113. #define IS_ASTRO(id) 
  114. (((id)->hversion == ASTRO_RUNWAY_PORT) || ((id)->hversion == ASTRO_ROPES_PORT))
  116. #define IS_IKE(id) 
  117. (((id)->hversion == IKE_MERCED_PORT) || ((id)->hversion == IKE_ROPES_PORT))
  119. #define SBA_FUNC_SIZE 4096   /* SBA configuration function reg set */
  121. #define ASTRO_IOC_OFFSET 0x20000
  122. /* Ike's IOC's occupy functions 2 and 3 (not 0 and 1) */
  123. #define IKE_IOC_OFFSET(p) ((p+2)*SBA_FUNC_SIZE)
  125. #define IOC_CTRL          0x8 /* IOC_CTRL offset */
  126. #define IOC_CTRL_TC       (1 << 0) /* TOC Enable */
  127. #define IOC_CTRL_CE       (1 << 1) /* Coalesce Enable */
  128. #define IOC_CTRL_DE       (1 << 2) /* Dillon Enable */
  129. #define IOC_CTRL_RM       (1 << 8) /* Real Mode */
  130. #define IOC_CTRL_NC       (1 << 9) /* Non Coherent Mode */
  132. #define MAX_IOC 2 /* per Ike. Astro only has 1 */
  135. /*
  136. ** Offsets into MBIB (Function 0 on Ike and hopefully Astro)
  137. ** Firmware programs this stuff. Don't touch it.
  138. */
  139. #define IOS_DIST_BASE 0x390
  140. #define IOS_DIST_MASK 0x398
  141. #define IOS_DIST_ROUTE 0x3A0
  143. #define IOS_DIRECT_BASE 0x3C0
  144. #define IOS_DIRECT_MASK 0x3C8
  145. #define IOS_DIRECT_ROUTE 0x3D0
  147. /*
  148. ** Offsets into I/O TLB (Function 2 and 3 on Ike)
  149. */
  150. #define ROPE0_CTL 0x200  /* "regbus pci0" */
  151. #define ROPE1_CTL 0x208
  152. #define ROPE2_CTL 0x210
  153. #define ROPE3_CTL 0x218
  154. #define ROPE4_CTL 0x220
  155. #define ROPE5_CTL 0x228
  156. #define ROPE6_CTL 0x230
  157. #define ROPE7_CTL 0x238
  159. #define HF_ENABLE 0x40
  162. #define IOC_IBASE 0x300 /* IO TLB */
  163. #define IOC_IMASK 0x308
  164. #define IOC_PCOM 0x310
  165. #define IOC_TCNFG 0x318
  166. #define IOC_PDIR_BASE 0x320
  168. #define IOC_IOVA_SPACE_BASE 0 /* IOVA ranges start at 0 */
  170. /*
  171. ** IOC supports 4/8/16/64KB page sizes (see TCNFG register)
  172. ** It's safer (avoid memory corruption) to keep DMA page mappings
  173. ** equivalently sized to VM PAGE_SIZE.
  174. **
  175. ** We really can't avoid generating a new mapping for each
  176. ** page since the Virtual Coherence Index has to be generated
  177. ** and updated for each page.
  178. **
  179. ** IOVP_SIZE could only be greater than PAGE_SIZE if we are
  180. ** confident the drivers really only touch the next physical
  181. ** page iff that driver instance owns it.
  182. */
  183. #define IOVP_SIZE PAGE_SIZE
  184. #define IOVP_SHIFT PAGE_SHIFT
  185. #define IOVP_MASK PAGE_MASK
  187. #define SBA_PERF_CFG 0x708 /* Performance Counter stuff */
  188. #define SBA_PERF_MASK1 0x718
  189. #define SBA_PERF_MASK2 0x730
  192. /*
  193. ** Offsets into PCI Performance Counters (functions 12 and 13)
  194. ** Controlled by PERF registers in function 2 & 3 respectively.
  195. */
  196. #define SBA_PERF_CNT1 0x200
  197. #define SBA_PERF_CNT2 0x208
  198. #define SBA_PERF_CNT3 0x210
  201. struct ioc {
  202. unsigned long ioc_hpa; /* I/O MMU base address */
  203. char *res_map; /* resource map, bit == pdir entry */
  204. u64 *pdir_base; /* physical base address */
  206. unsigned long *res_hint; /* next avail IOVP - circular search */
  207. spinlock_t res_lock;
  208. unsigned long hint_mask_pdir; /* bits used for DMA hints */
  209. unsigned int res_bitshift; /* from the LEFT! */
  210. unsigned int res_size; /* size of resource map in bytes */
  211. unsigned int hint_shift_pdir;
  212. #if DELAYED_RESOURCE_CNT > 0
  213. int saved_cnt;
  214. struct sba_dma_pair {
  215. dma_addr_t iova;
  216. size_t size;
  217. } saved[DELAYED_RESOURCE_CNT];
  218. #endif
  220. #ifdef CONFIG_PROC_FS
  221. #define SBA_SEARCH_SAMPLE 0x100
  222. unsigned long avg_search[SBA_SEARCH_SAMPLE];
  223. unsigned long avg_idx; /* current index into avg_search */
  224. unsigned long used_pages;
  225. unsigned long msingle_calls;
  226. unsigned long msingle_pages;
  227. unsigned long msg_calls;
  228. unsigned long msg_pages;
  229. unsigned long usingle_calls;
  230. unsigned long usingle_pages;
  231. unsigned long usg_calls;
  232. unsigned long usg_pages;
  233. #endif
  235. /* STUFF We don't need in performance path */
  236. unsigned int pdir_size; /* in bytes, determined by IOV Space size */
  237. unsigned long ibase; /* pdir IOV Space base - shared w/lba_pci */
  238. unsigned long imask; /* pdir IOV Space mask - shared w/lba_pci */
  239. };
  241. struct sba_device {
  242. struct sba_device *next; /* list of SBA's in system */
  243. struct parisc_device *dev; /* dev found in bus walk */
  244. struct parisc_device_id *iodc; /* data about dev from firmware */
  245. const char  *name;
  246. unsigned long sba_hpa; /* base address */
  247. spinlock_t sba_lock;
  248. unsigned int flags;  /* state/functionality enabled */
  249. unsigned int hw_rev;  /* HW revision of chip */
  251. unsigned int num_ioc;  /* number of on-board IOC's */
  252. struct ioc ioc[MAX_IOC];
  253. };
  256. static struct sba_device *sba_list;
  258. static unsigned long ioc_needs_fdc = 0;
  260. /* Ratio of Host MEM to IOV Space size */
  261. static unsigned long sba_mem_ratio = 8;
  263. /* global count of IOMMUs in the system */
  264. static unsigned int global_ioc_cnt = 0;
  266. /* PA8700 (Piranha 2.2) bug workaround */
  267. static unsigned long piranha_bad_128k = 0;
  269. /* Looks nice and keeps the compiler happy */
  270. #define SBA_DEV(d) ((struct sba_device *) (d))
  273. #define ROUNDUP(x,y) ((x + ((y)-1)) & ~((y)-1))
  276. /************************************
  277. ** SBA register read and write support
  278. **
  279. ** BE WARNED: register writes are posted.
  280. **  (ie follow writes which must reach HW with a read)
  281. **
  282. ** Superdome (in particular, REO) allows only 64-bit CSR accesses.
  283. */
  284. #define READ_REG32(addr)  le32_to_cpu(__raw_readl(addr))
  285. #define READ_REG64(addr)  le64_to_cpu(__raw_readq(addr))
  286. #define WRITE_REG32(val, addr) __raw_writel(cpu_to_le32(val), addr)
  287. #define WRITE_REG64(val, addr) __raw_writeq(cpu_to_le64(val), addr)
  289. #ifdef __LP64__
  290. #define READ_REG(addr) READ_REG64(addr)
  291. #define WRITE_REG(value, addr) WRITE_REG64(value, addr)
  292. #else
  293. #define READ_REG(addr) READ_REG32(addr)
  294. #define WRITE_REG(value, addr) WRITE_REG32(value, addr)
  295. #endif
  297. #ifdef DEBUG_SBA_INIT
  299. /* NOTE: When __LP64__ isn't defined, READ_REG64() is two 32-bit reads */
  301. /**
  302.  * sba_dump_ranges - debugging only - print ranges assigned to this IOA
  303.  * @hpa: base address of the sba
  304.  *
  305.  * Print the MMIO and IO Port address ranges forwarded by an Astro/Ike/RIO
  306.  * IO Adapter (aka Bus Converter).
  307.  */
  308. static void
  309. sba_dump_ranges(unsigned long hpa)
  310. {
  311. DBG_INIT("SBA at 0x%lxn", hpa);
  312. DBG_INIT("IOS_DIST_BASE   : %Lxn", READ_REG64(hpa+IOS_DIST_BASE));
  313. DBG_INIT("IOS_DIST_MASK   : %Lxn", READ_REG64(hpa+IOS_DIST_MASK));
  314. DBG_INIT("IOS_DIST_ROUTE  : %Lxn", READ_REG64(hpa+IOS_DIST_ROUTE));
  315. DBG_INIT("n");
  316. DBG_INIT("IOS_DIRECT_BASE : %Lxn", READ_REG64(hpa+IOS_DIRECT_BASE));
  317. DBG_INIT("IOS_DIRECT_MASK : %Lxn", READ_REG64(hpa+IOS_DIRECT_MASK));
  318. DBG_INIT("IOS_DIRECT_ROUTE: %Lxn", READ_REG64(hpa+IOS_DIRECT_ROUTE));
  319. }
  321. /**
  322.  * sba_dump_tlb - debugging only - print IOMMU operating parameters
  323.  * @hpa: base address of the IOMMU
  324.  *
  325.  * Print the size/location of the IO MMU PDIR.
  326.  */
  327. static void
  328. sba_dump_tlb(unsigned long hpa)
  329. {
  330. DBG_INIT("IO TLB at 0x%lxn", hpa);
  331. DBG_INIT("IOC_IBASE    : %Lxn", READ_REG64(hpa+IOC_IBASE));
  332. DBG_INIT("IOC_IMASK    : %Lxn", READ_REG64(hpa+IOC_IMASK));
  333. DBG_INIT("IOC_TCNFG    : %Lxn", READ_REG64(hpa+IOC_TCNFG));
  334. DBG_INIT("IOC_PDIR_BASE: %Lxn", READ_REG64(hpa+IOC_PDIR_BASE));
  335. DBG_INIT("n");
  336. }
  337. #endif
  340. #ifdef ASSERT_PDIR_SANITY
  342. /**
  343.  * sba_dump_pdir_entry - debugging only - print one IOMMU PDIR entry
  344.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  345.  * @msg: text to print ont the output line.
  346.  * @pide: pdir index.
  347.  *
  348.  * Print one entry of the IO MMU PDIR in human readable form.
  349.  */
  350. static void
  351. sba_dump_pdir_entry(struct ioc *ioc, char *msg, uint pide)
  352. {
  353. /* start printing from lowest pde in rval */
  354. u64 *ptr = &(ioc->pdir_base[pide & (~0U * BITS_PER_LONG)]);
  355. unsigned long *rptr = (unsigned long *) &(ioc->res_map[(pide >>3) & ~(sizeof(unsigned long) - 1)]);
  356. uint rcnt;
  358. printk(KERN_DEBUG "SBA: %s rp %p bit %d rval 0x%lxn",
  359.  msg,
  360.  rptr, pide & (BITS_PER_LONG - 1), *rptr);
  362. rcnt = 0;
  363. while (rcnt < BITS_PER_LONG) {
  364. printk(KERN_DEBUG "%s %2d %p %016Lxn",
  365. (rcnt == (pide & (BITS_PER_LONG - 1)))
  366. ? "    -->" : "       ",
  367. rcnt, ptr, *ptr );
  368. rcnt++;
  369. ptr++;
  370. }
  371. printk(KERN_DEBUG "%s", msg);
  372. }
  375. /**
  376.  * sba_check_pdir - debugging only - consistency checker
  377.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  378.  * @msg: text to print ont the output line.
  379.  *
  380.  * Verify the resource map and pdir state is consistent
  381.  */
  382. static int
  383. sba_check_pdir(struct ioc *ioc, char *msg)
  384. {
  385. u32 *rptr_end = (u32 *) &(ioc->res_map[ioc->res_size]);
  386. u32 *rptr = (u32 *) ioc->res_map; /* resource map ptr */
  387. u64 *pptr = ioc->pdir_base; /* pdir ptr */
  388. uint pide = 0;
  390. while (rptr < rptr_end) {
  391. u32 rval = *rptr;
  392. int rcnt = 32; /* number of bits we might check */
  394. while (rcnt) {
  395. /* Get last byte and highest bit from that */
  396. u32 pde = ((u32) (((char *)pptr)[7])) << 24;
  397. if ((rval ^ pde) & 0x80000000)
  398. {
  399. /*
  400. ** BUMMER!  -- res_map != pdir --
  401. ** Dump rval and matching pdir entries
  402. */
  403. sba_dump_pdir_entry(ioc, msg, pide);
  404. return(1);
  405. }
  406. rcnt--;
  407. rval <<= 1; /* try the next bit */
  408. pptr++;
  409. pide++;
  410. }
  411. rptr++; /* look at next word of res_map */
  412. }
  413. /* It'd be nice if we always got here :^) */
  414. return 0;
  415. }
  418. /**
  419.  * sba_dump_sg - debugging only - print Scatter-Gather list
  420.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  421.  * @startsg: head of the SG list
  422.  * @nents: number of entries in SG list
  423.  *
  424.  * print the SG list so we can verify it's correct by hand.
  425.  */
  426. static void
  427. sba_dump_sg( struct ioc *ioc, struct scatterlist *startsg, int nents)
  428. {
  429. while (nents-- > 0) {
  430. printk(KERN_DEBUG " %d : %08lx/%05x %p/%05xn",
  431. nents,
  432. (unsigned long) sg_dma_address(startsg),
  433. sg_dma_len(startsg),
  434. sg_virt_addr(startsg), startsg->length);
  435. startsg++;
  436. }
  437. }
  439. #endif /* ASSERT_PDIR_SANITY */
  444. /**************************************************************
  445. *
  446. *   I/O Pdir Resource Management
  447. *
  448. *   Bits set in the resource map are in use.
  449. *   Each bit can represent a number of pages.
  450. *   LSbs represent lower addresses (IOVA's).
  451. *
  452. ***************************************************************/
  453. #define PAGES_PER_RANGE 1 /* could increase this to 4 or 8 if needed */
  455. /* Convert from IOVP to IOVA and vice versa. */
  456. #define SBA_IOVA(ioc,iovp,offset,hint_reg) ((iovp) | (offset) | ((hint_reg)<<(ioc->hint_shift_pdir)))
  457. #define SBA_IOVP(ioc,iova) ((iova) & ioc->hint_mask_pdir)
  459. /* FIXME : review these macros to verify correctness and usage */
  460. #define PDIR_INDEX(iovp)   ((iovp)>>IOVP_SHIFT)
  461. #define MKIOVP(dma_hint,pide)  (dma_addr_t)((long)(dma_hint) | ((long)(pide) << IOVP_SHIFT))
  462. #define MKIOVA(iovp,offset) (dma_addr_t)((long)iovp | (long)offset)
  464. #define RESMAP_MASK(n)    (~0UL << (BITS_PER_LONG - (n)))
  465. #define RESMAP_IDX_MASK   (sizeof(unsigned long) - 1)
  468. /**
  469.  * sba_search_bitmap - find free space in IO PDIR resource bitmap
  470.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  471.  * @bits_wanted: number of entries we need.
  472.  *
  473.  * Find consecutive free bits in resource bitmap.
  474.  * Each bit represents one entry in the IO Pdir.
  475.  * Cool perf optimization: search for log2(size) bits at a time.
  476.  */
  477. static SBA_INLINE unsigned long
  478. sba_search_bitmap(struct ioc *ioc, unsigned long bits_wanted)
  479. {
  480. unsigned long *res_ptr = ioc->res_hint;
  481. unsigned long *res_end = (unsigned long *) &(ioc->res_map[ioc->res_size]);
  482. unsigned long pide = ~0UL;
  484. ASSERT(((unsigned long) ioc->res_hint & (sizeof(unsigned long) - 1UL)) == 0);
  485. ASSERT(res_ptr < res_end);
  486. if (bits_wanted > (BITS_PER_LONG/2)) {
  487. /* Search word at a time - no mask needed */
  488. for(; res_ptr < res_end; ++res_ptr) {
  489. if (*res_ptr == 0) {
  490. *res_ptr = RESMAP_MASK(bits_wanted);
  491. pide = ((unsigned long)res_ptr - (unsigned long)ioc->res_map);
  492. pide <<= 3; /* convert to bit address */
  493. break;
  494. }
  495. }
  496. /* point to the next word on next pass */
  497. res_ptr++;
  498. ioc->res_bitshift = 0;
  499. } else {
  500. /*
  501. ** Search the resource bit map on well-aligned values.
  502. ** "o" is the alignment.
  503. ** We need the alignment to invalidate I/O TLB using
  504. ** SBA HW features in the unmap path.
  505. */
  506. unsigned long o = 1 << get_order(bits_wanted << PAGE_SHIFT);
  507. uint bitshiftcnt = ROUNDUP(ioc->res_bitshift, o);
  508. unsigned long mask;
  510. if (bitshiftcnt >= BITS_PER_LONG) {
  511. bitshiftcnt = 0;
  512. res_ptr++;
  513. }
  514. mask = RESMAP_MASK(bits_wanted) >> bitshiftcnt;
  516. DBG_RES("%s() o %ld %p", __FUNCTION__, o, res_ptr);
  517. while(res_ptr < res_end)
  518. { 
  519. DBG_RES("    %p %lx %lxn", res_ptr, mask, *res_ptr);
  520. ASSERT(0 != mask);
  521. if(0 == ((*res_ptr) & mask)) {
  522. *res_ptr |= mask;     /* mark resources busy! */
  523. pide = ((unsigned long)res_ptr - (unsigned long)ioc->res_map);
  524. pide <<= 3; /* convert to bit address */
  525. pide += bitshiftcnt;
  526. break;
  527. }
  528. mask >>= o;
  529. bitshiftcnt += o;
  530. if (0 == mask) {
  531. mask = RESMAP_MASK(bits_wanted);
  532. bitshiftcnt=0;
  533. res_ptr++;
  534. }
  535. }
  536. /* look in the same word on the next pass */
  537. ioc->res_bitshift = bitshiftcnt + bits_wanted;
  538. }
  540. /* wrapped ? */
  541. if (res_end <= res_ptr) {
  542. ioc->res_hint = (unsigned long *) ioc->res_map;
  543. ioc->res_bitshift = 0;
  544. } else {
  545. ioc->res_hint = res_ptr;
  546. }
  547. return (pide);
  548. }
  551. /**
  552.  * sba_alloc_range - find free bits and mark them in IO PDIR resource bitmap
  553.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  554.  * @size: number of bytes to create a mapping for
  555.  *
  556.  * Given a size, find consecutive unmarked and then mark those bits in the
  557.  * resource bit map.
  558.  */
  559. static int
  560. sba_alloc_range(struct ioc *ioc, size_t size)
  561. {
  562. unsigned int pages_needed = size >> IOVP_SHIFT;
  563. #ifdef CONFIG_PROC_FS
  564. unsigned long cr_start = mfctl(16);
  565. #endif
  566. unsigned long pide;
  568. ASSERT(pages_needed);
  569. ASSERT((pages_needed * IOVP_SIZE) <= DMA_CHUNK_SIZE);
  570. ASSERT(pages_needed <= BITS_PER_LONG);
  571. ASSERT(0 == (size & ~IOVP_MASK));
  573. /*
  574. ** "seek and ye shall find"...praying never hurts either...
  575. ** ggg sacrifices another 710 to the computer gods.
  576. */
  578. pide = sba_search_bitmap(ioc, pages_needed);
  579. if (pide >= (ioc->res_size << 3)) {
  580. pide = sba_search_bitmap(ioc, pages_needed);
  581. if (pide >= (ioc->res_size << 3))
  582. panic(__FILE__ ": I/O MMU @ %lx is out of mapping resourcesn", ioc->ioc_hpa);
  583. }
  585. #ifdef ASSERT_PDIR_SANITY
  586. /* verify the first enable bit is clear */
  587. if(0x00 != ((u8 *) ioc->pdir_base)[pide*sizeof(u64) + 7]) {
  588. sba_dump_pdir_entry(ioc, "sba_search_bitmap() botched it?", pide);
  589. }
  590. #endif
  592. DBG_RES("%s(%x) %d -> %lx hint %x/%xn",
  593. __FUNCTION__, size, pages_needed, pide,
  594. (uint) ((unsigned long) ioc->res_hint - (unsigned long) ioc->res_map),
  595. ioc->res_bitshift );
  597. #ifdef CONFIG_PROC_FS
  598. {
  599. unsigned long cr_end = mfctl(16);
  600. unsigned long tmp = cr_end - cr_start;
  601. /* check for roll over */
  602. cr_start = (cr_end < cr_start) ?  -(tmp) : (tmp);
  603. }
  604. ioc->avg_search[ioc->avg_idx++] = cr_start;
  605. ioc->avg_idx &= SBA_SEARCH_SAMPLE - 1;
  607. ioc->used_pages += pages_needed;
  608. #endif
  610. return (pide);
  611. }
  614. /**
  615.  * sba_free_range - unmark bits in IO PDIR resource bitmap
  616.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  617.  * @iova: IO virtual address which was previously allocated.
  618.  * @size: number of bytes to create a mapping for
  619.  *
  620.  * clear bits in the ioc's resource map
  621.  */
  622. static SBA_INLINE void
  623. sba_free_range(struct ioc *ioc, dma_addr_t iova, size_t size)
  624. {
  625. unsigned long iovp = SBA_IOVP(ioc, iova);
  626. unsigned int pide = PDIR_INDEX(iovp);
  627. unsigned int ridx = pide >> 3; /* convert bit to byte address */
  628. unsigned long *res_ptr = (unsigned long *) &((ioc)->res_map[ridx & ~RESMAP_IDX_MASK]);
  630. int bits_not_wanted = size >> IOVP_SHIFT;
  632. /* 3-bits "bit" address plus 2 (or 3) bits for "byte" == bit in word */
  633. unsigned long m = RESMAP_MASK(bits_not_wanted) >> (pide & (BITS_PER_LONG - 1));
  635. DBG_RES("%s( ,%x,%x) %x/%lx %x %p %lxn",
  636. __FUNCTION__, (uint) iova, size,
  637. bits_not_wanted, m, pide, res_ptr, *res_ptr);
  639. #ifdef CONFIG_PROC_FS
  640. ioc->used_pages -= bits_not_wanted;
  641. #endif
  643. ASSERT(m != 0);
  644. ASSERT(bits_not_wanted);
  645. ASSERT((bits_not_wanted * IOVP_SIZE) <= DMA_CHUNK_SIZE);
  646. ASSERT(bits_not_wanted <= BITS_PER_LONG);
  647. ASSERT((*res_ptr & m) == m); /* verify same bits are set */
  648. *res_ptr &= ~m;
  649. }
  652. /**************************************************************
  653. *
  654. *   "Dynamic DMA Mapping" support (aka "Coherent I/O")
  655. *
  656. ***************************************************************/
  658. #define SBA_DMA_HINT(ioc, val) ((val) << (ioc)->hint_shift_pdir)
  661. typedef unsigned long space_t;
  662. #define KERNEL_SPACE 0
  664. /**
  665.  * sba_io_pdir_entry - fill in one IO PDIR entry
  666.  * @pdir_ptr:  pointer to IO PDIR entry
  667.  * @sid: process Space ID
  668.  * @vba: Virtual CPU address of buffer to map
  669.  *
  670.  * SBA Mapping Routine
  671.  *
  672.  * Given a virtual address (vba, arg2) and space id, (sid, arg1)
  673.  * sba_io_pdir_entry() loads the I/O PDIR entry pointed to by
  674.  * pdir_ptr (arg0). Each IO Pdir entry consists of 8 bytes as
  675.  * shown below (MSB == bit 0):
  676.  *
  677.  *  0                    19                                 51   55       63
  678.  * +-+---------------------+----------------------------------+----+--------+
  679.  * |V|        U            |            PPN[43:12]            | U  |   VI   |
  680.  * +-+---------------------+----------------------------------+----+--------+
  681.  *
  682.  *  V  == Valid Bit
  683.  *  U  == Unused
  684.  * PPN == Physical Page Number
  685.  * VI  == Virtual Index (aka Coherent Index)
  686.  *
  687.  * The physical address fields are filled with the results of the LPA
  688.  * instruction.  The virtual index field is filled with the results of
  689.  * of the LCI (Load Coherence Index) instruction.  The 8 bits used for
  690.  * the virtual index are bits 12:19 of the value returned by LCI.
  691.  *
  692.  * We need to pre-swap the bytes since PCX-W is Big Endian.
  693.  */
  696. void SBA_INLINE
  697. sba_io_pdir_entry(u64 *pdir_ptr, space_t sid, unsigned long vba)
  698. {
  699. u64 pa; /* physical address */
  700. register unsigned ci; /* coherent index */
  702. /* We currently only support kernel addresses.
  703.  * fdc instr below will need to reload sr1 with KERNEL_SPACE
  704.  * once we try to support direct DMA to user space.
  705.  */
  706. ASSERT(sid == KERNEL_SPACE);
  708. pa = virt_to_phys(vba);
  709. pa &= ~4095ULL; /* clear out offset bits */
  711. mtsp(sid,1);
  712. asm("lci 0(%%sr1, %1), %0" : "=r" (ci) : "r" (vba));
  713. pa |= (ci >> 12) & 0xff;  /* move CI (8 bits) into lowest byte */
  715. pa |= 0x8000000000000000ULL; /* set "valid" bit */
  716. *pdir_ptr = cpu_to_le64(pa); /* swap and store into I/O Pdir */
  718. /*
  719.  * If the PDC_MODEL capabilities has Non-coherent IO-PDIR bit set
  720.  * (bit #61, big endian), we have to flush and sync every time
  721.  * IO-PDIR is changed in Ike/Astro.
  722.  */
  723. if (ioc_needs_fdc) {
  724. asm volatile("fdc 0(%%sr1,%0)ntsync" : : "r" (pdir_ptr));
  725. }
  726. }
  729. /**
  730.  * sba_mark_invalid - invalidate one or more IO PDIR entries
  731.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  732.  * @iova:  IO Virtual Address mapped earlier
  733.  * @byte_cnt:  number of bytes this mapping covers.
  734.  *
  735.  * Marking the IO PDIR entry(ies) as Invalid and invalidate
  736.  * corresponding IO TLB entry. The Ike PCOM (Purge Command Register)
  737.  * is to purge stale entries in the IO TLB when unmapping entries.
  738.  *
  739.  * The PCOM register supports purging of multiple pages, with a minium
  740.  * of 1 page and a maximum of 2GB. Hardware requires the address be
  741.  * aligned to the size of the range being purged. The size of the range
  742.  * must be a power of 2. The "Cool perf optimization" in the
  743.  * allocation routine helps keep that true.
  744.  */
  745. static SBA_INLINE void
  746. sba_mark_invalid(struct ioc *ioc, dma_addr_t iova, size_t byte_cnt)
  747. {
  748. u32 iovp = (u32) SBA_IOVP(ioc,iova);
  750. /* Even though this is a big-endian machine, the entries
  751. ** in the iopdir are little endian. That's why we clear the byte
  752. ** at +7 instead of at +0.
  753. */
  754. int off = PDIR_INDEX(iovp)*sizeof(u64)+7;
  756. /* Must be non-zero and rounded up */
  757. ASSERT(byte_cnt > 0);
  758. ASSERT(0 == (byte_cnt & ~IOVP_MASK));
  760. #ifdef ASSERT_PDIR_SANITY
  761. /* Assert first pdir entry is set */
  762. if (0x80 != (((u8 *) ioc->pdir_base)[off])) {
  763. sba_dump_pdir_entry(ioc,"sba_mark_invalid()", PDIR_INDEX(iovp));
  764. }
  765. #endif
  767. if (byte_cnt <= IOVP_SIZE)
  768. {
  769. ASSERT( off < ioc->pdir_size);
  771. iovp |= IOVP_SHIFT;     /* set "size" field for PCOM */
  773. /*
  774. ** clear I/O PDIR entry "valid" bit
  775. ** Do NOT clear the rest - save it for debugging.
  776. ** We should only clear bits that have previously
  777. ** been enabled.
  778. */
  779. ((u8 *)(ioc->pdir_base))[off] = 0;
  780. } else {
  781. u32 t = get_order(byte_cnt) + PAGE_SHIFT;
  783. iovp |= t;
  784. ASSERT(t <= 31);   /* 2GB! Max value of "size" field */
  786. do {
  787. /* verify this pdir entry is enabled */
  788. ASSERT(0x80 == (((u8 *) ioc->pdir_base)[off] & 0x80));
  789. /* clear I/O Pdir entry "valid" bit first */
  790. ((u8 *)(ioc->pdir_base))[off] = 0;
  791. off += sizeof(u64);
  792. byte_cnt -= IOVP_SIZE;
  793. } while (byte_cnt > 0);
  794. }
  796. WRITE_REG(iovp, ioc->ioc_hpa+IOC_PCOM);
  797. }
  799. /**
  800.  * sba_dma_supported - PCI driver can query DMA support
  801.  * @dev: instance of PCI owned by the driver that's asking
  802.  * @mask:  number of address bits this PCI device can handle
  803.  *
  804.  * See Documentation/DMA-mapping.txt
  805.  */
  806. static int
  807. sba_dma_supported( struct pci_dev *dev, u64 mask)
  808. {
  809. if (dev == NULL) {
  810. printk(KERN_ERR MODULE_NAME ": EISA/ISA/et al not supportedn");
  811. BUG();
  812. return(0);
  813. }
  815. dev->dma_mask = mask; /* save it */
  817. /* only support 32-bit PCI devices - no DAC support (yet) */
  818. return((int) (mask == 0xffffffff));
  819. }
  822. /**
  823.  * sba_map_single - map one buffer and return IOVA for DMA
  824.  * @dev: instance of PCI owned by the driver that's asking.
  825.  * @addr:  driver buffer to map.
  826.  * @size:  number of bytes to map in driver buffer.
  827.  * @direction:  R/W or both.
  828.  *
  829.  * See Documentation/DMA-mapping.txt
  830.  */
  831. static dma_addr_t
  832. sba_map_single(struct pci_dev *dev, void *addr, size_t size, int direction)
  833. {
  834. struct ioc *ioc;
  835. unsigned long flags; 
  836. dma_addr_t iovp;
  837. dma_addr_t offset;
  838. u64 *pdir_start;
  839. int pide;
  841. ASSERT(size > 0);
  842. ASSERT(size <= DMA_CHUNK_SIZE);
  844. ASSERT(dev->sysdata);
  845. ioc = GET_IOC(dev);
  846. ASSERT(ioc);
  848. /* save offset bits */
  849. offset = ((dma_addr_t) (long) addr) & ~IOVP_MASK;
  851. /* round up to nearest IOVP_SIZE */
  852. size = (size + offset + ~IOVP_MASK) & IOVP_MASK;
  854. spin_lock_irqsave(&ioc->res_lock, flags);
  855. #ifdef ASSERT_PDIR_SANITY
  856. sba_check_pdir(ioc,"Check before sba_map_single()");
  857. #endif
  859. #ifdef CONFIG_PROC_FS
  860. ioc->msingle_calls++;
  861. ioc->msingle_pages += size >> IOVP_SHIFT;
  862. #endif
  863. pide = sba_alloc_range(ioc, size);
  864. iovp = (dma_addr_t) pide << IOVP_SHIFT;
  866. DBG_RUN("%s() 0x%p -> 0x%lx",
  867. __FUNCTION__, addr, (long) iovp | offset);
  869. pdir_start = &(ioc->pdir_base[pide]);
  871. while (size > 0) {
  872. ASSERT(((u8 *)pdir_start)[7] == 0); /* verify availability */
  873. sba_io_pdir_entry(pdir_start, KERNEL_SPACE, (unsigned long) addr);
  875. DBG_RUN(" pdir 0x%p %02x%02x%02x%02x%02x%02x%02x%02xn",
  876. pdir_start,
  877. (u8) (((u8 *) pdir_start)[7]),
  878. (u8) (((u8 *) pdir_start)[6]),
  879. (u8) (((u8 *) pdir_start)[5]),
  880. (u8) (((u8 *) pdir_start)[4]),
  881. (u8) (((u8 *) pdir_start)[3]),
  882. (u8) (((u8 *) pdir_start)[2]),
  883. (u8) (((u8 *) pdir_start)[1]),
  884. (u8) (((u8 *) pdir_start)[0])
  885. );
  887. addr += IOVP_SIZE;
  888. size -= IOVP_SIZE;
  889. pdir_start++;
  890. }
  891. /* form complete address */
  892. #ifdef ASSERT_PDIR_SANITY
  893. sba_check_pdir(ioc,"Check after sba_map_single()");
  894. #endif
  895. spin_unlock_irqrestore(&ioc->res_lock, flags);
  896. return SBA_IOVA(ioc, iovp, offset, DEFAULT_DMA_HINT_REG);
  897. }
  900. /**
  901.  * sba_unmap_single - unmap one IOVA and free resources
  902.  * @dev: instance of PCI owned by the driver that's asking.
  903.  * @iova:  IOVA of driver buffer previously mapped.
  904.  * @size:  number of bytes mapped in driver buffer.
  905.  * @direction:  R/W or both.
  906.  *
  907.  * See Documentation/DMA-mapping.txt
  908.  */
  909. static void
  910. sba_unmap_single(struct pci_dev *dev, dma_addr_t iova, size_t size, int direction)
  911. {
  912. struct ioc *ioc;
  913. #if DELAYED_RESOURCE_CNT > 0
  914. struct sba_dma_pair *d;
  915. #endif
  916. unsigned long flags; 
  917. dma_addr_t offset;
  919. ASSERT(dev->sysdata);
  920. ioc = GET_IOC(dev);
  921. ASSERT(ioc);
  923. offset = iova & ~IOVP_MASK;
  925. DBG_RUN("%s() iovp 0x%lx/%xn",
  926. __FUNCTION__, (long) iova, size);
  928. iova ^= offset;        /* clear offset bits */
  929. size += offset;
  930. size = ROUNDUP(size, IOVP_SIZE);
  932. spin_lock_irqsave(&ioc->res_lock, flags);
  934. #ifdef CONFIG_PROC_FS
  935. ioc->usingle_calls++;
  936. ioc->usingle_pages += size >> IOVP_SHIFT;
  937. #endif
  939. #if DELAYED_RESOURCE_CNT > 0
  940. d = &(ioc->saved[ioc->saved_cnt]);
  941. d->iova = iova;
  942. d->size = size;
  943. if (++(ioc->saved_cnt) >= DELAYED_RESOURCE_CNT) {
  944. int cnt = ioc->saved_cnt;
  945. while (cnt--) {
  946. sba_mark_invalid(ioc, d->iova, d->size);
  947. sba_free_range(ioc, d->iova, d->size);
  948. d--;
  949. }
  950. ioc->saved_cnt = 0;
  951. READ_REG(ioc->ioc_hpa+IOC_PCOM); /* flush purges */
  952. }
  953. #else /* DELAYED_RESOURCE_CNT == 0 */
  954. sba_mark_invalid(ioc, iova, size);
  955. sba_free_range(ioc, iova, size);
  956. READ_REG(ioc->ioc_hpa+IOC_PCOM); /* flush purges */
  957. #endif /* DELAYED_RESOURCE_CNT == 0 */
  958. spin_unlock_irqrestore(&ioc->res_lock, flags);
  960. /* XXX REVISIT for 2.5 Linux - need syncdma for zero-copy support.
  961. ** For Astro based systems this isn't a big deal WRT performance.
  962. ** As long as 2.4 kernels copyin/copyout data from/to userspace,
  963. ** we don't need the syncdma. The issue here is I/O MMU cachelines
  964. ** are *not* coherent in all cases.  May be hwrev dependent.
  965. ** Need to investigate more.
  966. asm volatile("syncdma");
  967. */
  968. }
  971. /**
  972.  * sba_alloc_consistent - allocate/map shared mem for DMA
  973.  * @hwdev: instance of PCI owned by the driver that's asking.
  974.  * @size:  number of bytes mapped in driver buffer.
  975.  * @dma_handle:  IOVA of new buffer.
  976.  *
  977.  * See Documentation/DMA-mapping.txt
  978.  */
  979. static void *
  980. sba_alloc_consistent(struct pci_dev *hwdev, size_t size, dma_addr_t *dma_handle)
  981. {
  982. void *ret;
  984. if (!hwdev) {
  985. /* only support PCI */
  986. *dma_handle = 0;
  987. return 0;
  988. }
  990.         ret = (void *) __get_free_pages(GFP_ATOMIC, get_order(size));
  992. if (ret) {
  993. memset(ret, 0, size);
  994. *dma_handle = sba_map_single(hwdev, ret, size, 0);
  995. }
  997. return ret;
  998. }
  1001. /**
  1002.  * sba_free_consistent - free/unmap shared mem for DMA
  1003.  * @hwdev: instance of PCI owned by the driver that's asking.
  1004.  * @size:  number of bytes mapped in driver buffer.
  1005.  * @vaddr:  virtual address IOVA of "consistent" buffer.
  1006.  * @dma_handler:  IO virtual address of "consistent" buffer.
  1007.  *
  1008.  * See Documentation/DMA-mapping.txt
  1009.  */
  1010. static void
  1011. sba_free_consistent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle)
  1012. {
  1013. sba_unmap_single(hwdev, dma_handle, size, 0);
  1014. free_pages((unsigned long) vaddr, get_order(size));
  1015. }
  1018. /*
  1019. ** Since 0 is a valid pdir_base index value, can't use that
  1020. ** to determine if a value is valid or not. Use a flag to indicate
  1021. ** the SG list entry contains a valid pdir index.
  1022. */
  1023. #define PIDE_FLAG 0x80000000UL
  1025. #ifdef DEBUG_LARGE_SG_ENTRIES
  1026. int dump_run_sg = 0;
  1027. #endif
  1030. /**
  1031.  * sba_fill_pdir - write allocated SG entries into IO PDIR
  1032.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  1033.  * @startsg:  list of IOVA/size pairs
  1034.  * @nents: number of entries in startsg list
  1035.  *
  1036.  * Take preprocessed SG list and write corresponding entries
  1037.  * in the IO PDIR.
  1038.  */
  1040. static SBA_INLINE int
  1041. sba_fill_pdir(
  1042. struct ioc *ioc,
  1043. struct scatterlist *startsg,
  1044. int nents)
  1045. {
  1046. struct scatterlist *dma_sg = startsg; /* pointer to current DMA */
  1047. int n_mappings = 0;
  1048. u64 *pdirp = 0;
  1049. unsigned long dma_offset = 0;
  1051. dma_sg--;
  1052. while (nents-- > 0) {
  1053. int     cnt = sg_dma_len(startsg);
  1054. sg_dma_len(startsg) = 0;
  1056. #ifdef DEBUG_LARGE_SG_ENTRIES
  1057. if (dump_run_sg)
  1058. printk(KERN_DEBUG " %2d : %08lx/%05x %p/%05xn",
  1059. nents,
  1060. (unsigned long) sg_dma_address(startsg), cnt,
  1061. sg_virt_address(startsg), startsg->length
  1062. );
  1063. #else
  1064. DBG_RUN_SG(" %d : %08lx/%05x %p/%05xn",
  1065. nents,
  1066. (unsigned long) sg_dma_address(startsg), cnt,
  1067. sg_virt_addr(startsg), startsg->length
  1068. );
  1069. #endif
  1070. /*
  1071. ** Look for the start of a new DMA stream
  1072. */
  1073. if (sg_dma_address(startsg) & PIDE_FLAG) {
  1074. u32 pide = sg_dma_address(startsg) & ~PIDE_FLAG;
  1075. dma_offset = (unsigned long) pide & ~IOVP_MASK;
  1076. sg_dma_address(startsg) = 0;
  1077. dma_sg++;
  1078. sg_dma_address(dma_sg) = pide;
  1079. pdirp = &(ioc->pdir_base[pide >> IOVP_SHIFT]);
  1080. n_mappings++;
  1081. }
  1083. /*
  1084. ** Look for a VCONTIG chunk
  1085. */
  1086. if (cnt) {
  1087. unsigned long vaddr = (unsigned long) sg_virt_addr(startsg);
  1088. ASSERT(pdirp);
  1090. /* Since multiple Vcontig blocks could make up
  1091. ** one DMA stream, *add* cnt to dma_len.
  1092. */
  1093. sg_dma_len(dma_sg) += cnt;
  1094. cnt += dma_offset;
  1095. dma_offset=0; /* only want offset on first chunk */
  1096. cnt = ROUNDUP(cnt, IOVP_SIZE);
  1097. #ifdef CONFIG_PROC_FS
  1098. ioc->msg_pages += cnt >> IOVP_SHIFT;
  1099. #endif
  1100. do {
  1101. sba_io_pdir_entry(pdirp, KERNEL_SPACE, vaddr);
  1102. vaddr += IOVP_SIZE;
  1103. cnt -= IOVP_SIZE;
  1104. pdirp++;
  1105. } while (cnt > 0);
  1106. }
  1107. startsg++;
  1108. }
  1109. #ifdef DEBUG_LARGE_SG_ENTRIES
  1110. dump_run_sg = 0;
  1111. #endif
  1112. return(n_mappings);
  1113. }
  1116. /*
  1117. ** Two address ranges are DMA contiguous *iff* "end of prev" and
  1118. ** "start of next" are both on a page boundry.
  1119. **
  1120. ** (shift left is a quick trick to mask off upper bits)
  1121. */
  1122. #define DMA_CONTIG(__X, __Y) 
  1123. (((((unsigned long) __X) | ((unsigned long) __Y)) << (BITS_PER_LONG - PAGE_SHIFT)) == 0UL)
  1126. /**
  1127.  * sba_coalesce_chunks - preprocess the SG list
  1128.  * @ioc: IO MMU structure which owns the pdir we are interested in.
  1129.  * @startsg:  list of IOVA/size pairs
  1130.  * @nents: number of entries in startsg list
  1131.  *
  1132.  * First pass is to walk the SG list and determine where the breaks are
  1133.  * in the DMA stream. Allocates PDIR entries but does not fill them.
  1134.  * Returns the number of DMA chunks.
  1135.  *
  1136.  * Doing the fill seperate from the coalescing/allocation keeps the
  1137.  * code simpler. Future enhancement could make one pass through
  1138.  * the sglist do both.
  1139.  */
  1140. static SBA_INLINE int
  1141. sba_coalesce_chunks( struct ioc *ioc,
  1142. struct scatterlist *startsg,
  1143. int nents)
  1144. {
  1145. struct scatterlist *vcontig_sg;    /* VCONTIG chunk head */
  1146. unsigned long vcontig_len;         /* len of VCONTIG chunk */
  1147. unsigned long vcontig_end;
  1148. struct scatterlist *dma_sg;        /* next DMA stream head */
  1149. unsigned long dma_offset, dma_len; /* start/len of DMA stream */
  1150. int n_mappings = 0;
  1152. while (nents > 0) {
  1153. unsigned long vaddr = (unsigned long) sg_virt_addr(startsg); 
  1155. /*
  1156. ** Prepare for first/next DMA stream
  1157. */
  1158. dma_sg = vcontig_sg = startsg;
  1159. dma_len = vcontig_len = vcontig_end = startsg->length;
  1160. vcontig_end +=  vaddr;
  1161. dma_offset = vaddr & ~IOVP_MASK;
  1163. /* PARANOID: clear entries */
  1164. sg_dma_address(startsg) = 0;
  1165. sg_dma_len(startsg) = 0;
  1167. /*
  1168. ** This loop terminates one iteration "early" since
  1169. ** it's always looking one "ahead".
  1170. */
  1171. while (--nents > 0) {
  1172. unsigned long vaddr; /* tmp */
  1174. startsg++;
  1176. /* PARANOID: clear entries */
  1177. sg_dma_address(startsg) = 0;
  1178. sg_dma_len(startsg) = 0;
  1180. /* catch brokenness in SCSI layer */
  1181. ASSERT(startsg->length <= DMA_CHUNK_SIZE);
  1183. /*
  1184. ** First make sure current dma stream won't
  1185. ** exceed DMA_CHUNK_SIZE if we coalesce the
  1186. ** next entry.
  1187. */
  1188. if (((dma_len + dma_offset + startsg->length + ~IOVP_MASK) & IOVP_MASK) > DMA_CHUNK_SIZE)
  1189. break;
  1191. /*
  1192. ** Then look for virtually contiguous blocks.
  1193. ** PARISC needs to associate a virtual address
  1194. ** with each IO address mapped. The CPU cache is
  1195. ** virtually tagged and the IOMMU uses part
  1196. ** of the virtual address to participate in
  1197. ** CPU cache coherency.
  1198. **
  1199. ** append the next transaction?
  1200. */
  1201. vaddr = (unsigned long) sg_virt_addr(startsg);
  1202. if  (vcontig_end == vaddr)
  1203. {
  1204. vcontig_len += startsg->length;
  1205. vcontig_end += startsg->length;
  1206. dma_len     += startsg->length;
  1207. continue;
  1208. }
  1210. #ifdef DEBUG_LARGE_SG_ENTRIES
  1211. dump_run_sg = (vcontig_len > IOVP_SIZE);
  1212. #endif
  1214. /*
  1215. ** Not virtually contigous.
  1216. ** Terminate prev chunk.
  1217. ** Start a new chunk.
  1218. **
  1219. ** Once we start a new VCONTIG chunk, dma_offset
  1220. ** can't change. And we need the offset from the first
  1221. ** chunk - not the last one. Ergo Successive chunks
  1222. ** must start on page boundaries and dove tail
  1223. ** with it's predecessor.
  1224. */
  1225. sg_dma_len(vcontig_sg) = vcontig_len;
  1227. vcontig_sg = startsg;
  1228. vcontig_len = startsg->length;
  1230. /*
  1231. ** 3) do the entries end/start on page boundaries?
  1232. **    Don't update vcontig_end until we've checked.
  1233. */
  1234. if (DMA_CONTIG(vcontig_end, vaddr))
  1235. {
  1236. vcontig_end = vcontig_len + vaddr;
  1237. dma_len += vcontig_len;
  1238. continue;
  1239. } else {
  1240. break;
  1241. }
  1242. }
  1244. /*
  1245. ** End of DMA Stream
  1246. ** Terminate last VCONTIG block.
  1247. ** Allocate space for DMA stream.
  1248. */
  1249. sg_dma_len(vcontig_sg) = vcontig_len;
  1250. dma_len = (dma_len + dma_offset + ~IOVP_MASK) & IOVP_MASK;
  1251. ASSERT(dma_len <= DMA_CHUNK_SIZE);
  1252. sg_dma_address(dma_sg) =
  1253. PIDE_FLAG 
  1254. | (sba_alloc_range(ioc, dma_len) << IOVP_SHIFT)
  1255. | dma_offset;
  1256. n_mappings++;
  1257. }
  1259. return n_mappings;
  1260. }
  1263. /**
  1264.  * sba_map_sg - map Scatter/Gather list
  1265.  * @dev: instance of PCI owned by the driver that's asking.
  1266.  * @sglist:  array of buffer/length pairs
  1267.  * @nents:  number of entries in list
  1268.  * @direction:  R/W or both.
  1269.  *
  1270.  * See Documentation/DMA-mapping.txt
  1271.  */
  1272. static int
  1273. sba_map_sg(struct pci_dev *dev, struct scatterlist *sglist, int nents, int direction)
  1274. {
  1275. struct ioc *ioc;
  1276. int coalesced, filled = 0;
  1277. unsigned long flags;
  1279. DBG_RUN_SG("%s() START %d entriesn", __FUNCTION__, nents);
  1281. ASSERT(dev->sysdata);
  1282. ioc = GET_IOC(dev);
  1283. ASSERT(ioc);
  1285. /* Fast path single entry scatterlists. */
  1286. if (nents == 1) {
  1287. sg_dma_address(sglist) = sba_map_single(dev,
  1288. sg_virt_addr(sglist),
  1289. sglist->length, direction);
  1290. sg_dma_len(sglist)     = sglist->length;
  1291. return 1;
  1292. }
  1294. spin_lock_irqsave(&ioc->res_lock, flags);
  1296. #ifdef ASSERT_PDIR_SANITY
  1297. if (sba_check_pdir(ioc,"Check before sba_map_sg()"))
  1298. {
  1299. sba_dump_sg(ioc, sglist, nents);
  1300. panic("Check before sba_map_sg()");
  1301. }
  1302. #endif
  1304. #ifdef CONFIG_PROC_FS
  1305. ioc->msg_calls++;
  1306. #endif
  1308. /*
  1309. ** First coalesce the chunks and allocate I/O pdir space
  1310. **
  1311. ** If this is one DMA stream, we can properly map using the
  1312. ** correct virtual address associated with each DMA page.
  1313. ** w/o this association, we wouldn't have coherent DMA!
  1314. ** Access to the virtual address is what forces a two pass algorithm.
  1315. */
  1316. coalesced = sba_coalesce_chunks(ioc, sglist, nents);
  1318. /*
  1319. ** Program the I/O Pdir
  1320. **
  1321. ** map the virtual addresses to the I/O Pdir
  1322. ** o dma_address will contain the pdir index
  1323. ** o dma_len will contain the number of bytes to map 
  1324. ** o address contains the virtual address.
  1325. */
  1326. filled = sba_fill_pdir(ioc, sglist, nents);
  1328. #ifdef ASSERT_PDIR_SANITY
  1329. if (sba_check_pdir(ioc,"Check after sba_map_sg()"))
  1330. {
  1331. sba_dump_sg(ioc, sglist, nents);
  1332. panic("Check after sba_map_sg()n");
  1333. }
  1334. #endif
  1336. spin_unlock_irqrestore(&ioc->res_lock, flags);
  1338. ASSERT(coalesced == filled);
  1339. DBG_RUN_SG("%s() DONE %d mappingsn", __FUNCTION__, filled);
  1341. return filled;
  1342. }
  1345. /**
  1346.  * sba_unmap_sg - unmap Scatter/Gather list
  1347.  * @dev: instance of PCI owned by the driver that's asking.
  1348.  * @sglist:  array of buffer/length pairs
  1349.  * @nents:  number of entries in list
  1350.  * @direction:  R/W or both.
  1351.  *
  1352.  * See Documentation/DMA-mapping.txt
  1353.  */
  1354. static void 
  1355. sba_unmap_sg(struct pci_dev *dev, struct scatterlist *sglist, int nents, int direction)
  1356. {
  1357. struct ioc *ioc;
  1358. #ifdef ASSERT_PDIR_SANITY
  1359. unsigned long flags;
  1360. #endif
  1362. DBG_RUN_SG("%s() START %d entries,  %p,%xn",
  1363. __FUNCTION__, nents, sg_virt_addr(sglist), sglist->length);
  1365. ASSERT(dev->sysdata);
  1366. ioc = GET_IOC(dev);
  1367. ASSERT(ioc);
  1369. #ifdef CONFIG_PROC_FS
  1370. ioc->usg_calls++;
  1371. #endif
  1373. #ifdef ASSERT_PDIR_SANITY
  1374. spin_lock_irqsave(&ioc->res_lock, flags);
  1375. sba_check_pdir(ioc,"Check before sba_unmap_sg()");
  1376. spin_unlock_irqrestore(&ioc->res_lock, flags);
  1377. #endif
  1379. while (sg_dma_len(sglist) && nents--) {
  1381. sba_unmap_single(dev, sg_dma_address(sglist), sg_dma_len(sglist), direction);
  1382. #ifdef CONFIG_PROC_FS
  1383. ioc->usg_pages += ((sg_dma_address(sglist) & ~IOVP_MASK) + sg_dma_len(sglist) + IOVP_SIZE - 1) >> PAGE_SHIFT;
  1384. ioc->usingle_calls--; /* kluge since call is unmap_sg() */
  1385. #endif
  1386. ++sglist;
  1387. }
  1389. DBG_RUN_SG("%s() DONE (nents %d)n", __FUNCTION__,  nents);
  1391. #ifdef ASSERT_PDIR_SANITY
  1392. spin_lock_irqsave(&ioc->res_lock, flags);
  1393. sba_check_pdir(ioc,"Check after sba_unmap_sg()");
  1394. spin_unlock_irqrestore(&ioc->res_lock, flags);
  1395. #endif
  1397. }
  1399. static struct pci_dma_ops sba_ops = {
  1400. sba_dma_supported,
  1401. sba_alloc_consistent, /* allocate cacheable host mem */
  1402. sba_free_consistent, /* release cacheable host mem */
  1403. sba_map_single,
  1404. sba_unmap_single,
  1405. sba_map_sg,
  1406. sba_unmap_sg,
  1407. NULL, /* dma_sync_single */
  1408. NULL /* dma_sync_sg */
  1409. };
  1412. /**************************************************************************
  1413. **
  1414. **   SBA PAT PDC support
  1415. **
  1416. **   o call pdc_pat_cell_module()
  1417. **   o store ranges in PCI "resource" structures
  1418. **
  1419. **************************************************************************/
  1421. static void
  1422. sba_get_pat_resources(struct sba_device *sba_dev)
  1423. {
  1424. #if 0
  1425. /*
  1426. ** TODO/REVISIT/FIXME: support for directed ranges requires calls to
  1427. **      PAT PDC to program the SBA/LBA directed range registers...this
  1428. **      burden may fall on the LBA code since it directly supports the
  1429. **      PCI subsystem. It's not clear yet. - ggg
  1430. */
  1431. PAT_MOD(mod)->mod_info.mod_pages   = PAT_GET_MOD_PAGES(temp);
  1432. FIXME : ???
  1433. PAT_MOD(mod)->mod_info.dvi         = PAT_GET_DVI(temp);
  1434. Tells where the dvi bits are located in the address.
  1435. PAT_MOD(mod)->mod_info.ioc         = PAT_GET_IOC(temp);
  1436. FIXME : ???
  1437. #endif
  1438. }
  1441. /**************************************************************
  1442. *
  1443. *   Initialization and claim
  1444. *
  1445. ***************************************************************/
  1446. #define PIRANHA_ADDR_MASK 0x00160000UL /* bit 17,18,20 */
  1447. #define PIRANHA_ADDR_VAL 0x00060000UL /* bit 17,18 on */
  1448. static void *
  1449. sba_alloc_pdir(unsigned int pdir_size)
  1450. {
  1451.         unsigned long pdir_base;
  1452. unsigned long pdir_order = get_order(pdir_size);
  1454. pdir_base = __get_free_pages(GFP_KERNEL, pdir_order);
  1455. if (NULL == (void *) pdir_base)
  1456. panic("sba_ioc_init() could not allocate I/O Page Tablen");
  1458. /* If this is not PA8700 (PCX-W2)
  1459. ** OR newer than ver 2.2
  1460. ** OR in a system that doesn't need VINDEX bits from SBA,
  1461. **
  1462. ** then we aren't exposed to the HW bug.
  1463. */
  1464. if ( ((boot_cpu_data.pdc.cpuid >> 5) & 0x7f) != 0x13
  1465. || (boot_cpu_data.pdc.versions > 0x202)
  1466. || (boot_cpu_data.pdc.capabilities & 0x08L) )
  1467. return (void *) pdir_base;
  1469. /*
  1470.  * PA8700 (PCX-W2, aka piranha) silent data corruption fix
  1471.  *
  1472.  * An interaction between PA8700 CPU (Ver 2.2 or older) and
  1473.  * Ike/Astro can cause silent data corruption. This is only
  1474.  * a problem if the I/O PDIR is located in memory such that
  1475.  * (little-endian)  bits 17 and 18 are on and bit 20 is off.
  1476.  *
  1477.  * Since the max IO Pdir size is 2MB, by cleverly allocating the
  1478.  * right physical address, we can either avoid (IOPDIR <= 1MB)
  1479.  * or minimize (2MB IO Pdir) the problem if we restrict the
  1480.  * IO Pdir to a maximum size of 2MB-128K (1902K).
  1481.  *
  1482.  * Because we always allocate 2^N sized IO pdirs, either of the
  1483.  * "bad" regions will be the last 128K if at all. That's easy
  1484.  * to test for.
  1485.  * 
  1486.  */
  1487. if (pdir_order <= (19-12)) {
  1488. if (((virt_to_phys(pdir_base)+pdir_size-1) & PIRANHA_ADDR_MASK) == PIRANHA_ADDR_VAL) {
  1489. /* allocate a new one on 512k alignment */
  1490. unsigned long new_pdir = __get_free_pages(GFP_KERNEL, (19-12));
  1491. /* release original */
  1492. free_pages(pdir_base, pdir_order);
  1494. pdir_base = new_pdir;
  1496. /* release excess */
  1497. while (pdir_order < (19-12)) {
  1498. new_pdir += pdir_size;
  1499. free_pages(new_pdir, pdir_order);
  1500. pdir_order +=1;
  1501. pdir_size <<=1;
  1502. }
  1503. }
  1504. } else {
  1505. /*
  1506. ** 1MB or 2MB Pdir
  1507. ** Needs to be aligned on an "odd" 1MB boundary.
  1508. */
  1509. unsigned long new_pdir = __get_free_pages(GFP_KERNEL, pdir_order+1); /* 2 or 4MB */
  1511. /* release original */
  1512. free_pages( pdir_base, pdir_order);
  1514. /* release first 1MB */
  1515. free_pages(new_pdir, 20-12);
  1517. pdir_base = new_pdir + 1024*1024;
  1519. if (pdir_order > (20-12)) {
  1520. /*
  1521. ** 2MB Pdir.
  1522. **
  1523. ** Flag tells init_bitmap() to mark bad 128k as used
  1524. ** and to reduce the size by 128k.
  1525. */
  1526. piranha_bad_128k = 1;
  1528. new_pdir += 3*1024*1024;
  1529. /* release last 1MB */
  1530. free_pages(new_pdir, 20-12);
  1532. /* release unusable 128KB */
  1533. free_pages(new_pdir - 128*1024 , 17-12);
  1535. pdir_size -= 128*1024;
  1536. }
  1537. }
  1539. memset((void *) pdir_base, 0, pdir_size);
  1540. return (void *) pdir_base;
  1541. }
  1544. static void
  1545. sba_ioc_init(struct parisc_device *sba, struct ioc *ioc, int ioc_num)
  1546. {
  1547. /* lba_set_iregs() is in arch/parisc/kernel/lba_pci.c */
  1548. extern void lba_set_iregs(struct parisc_device *, u32, u32);
  1550. u32 iova_space_size, iova_space_mask;
  1551. int pdir_size, iov_order;
  1552. unsigned long physmem;
  1553. struct parisc_device *lba;
  1555. /*
  1556. ** Determine IOVA Space size from memory size.
  1557. **
  1558. ** Ideally, PCI drivers would register the maximum number
  1559. ** of DMA they can have outstanding for each device they
  1560. ** own.  Next best thing would be to guess how much DMA
  1561. ** can be outstanding based on PCI Class/sub-class. Both
  1562. ** methods still require some "extra" to support PCI
  1563. ** Hot-Plug/Removal of PCI cards. (aka PCI OLARD).
  1564. **
  1565. ** While we have 32-bits "IOVA" space, top two 2 bits are used
  1566. ** for DMA hints - ergo only 30 bits max.
  1567. */
  1569. physmem = num_physpages << PAGE_SHIFT;
  1570. iova_space_size = (u32) (physmem/(sba_mem_ratio*global_ioc_cnt));
  1572. /* limit IOVA space size to 1MB-1GB */
  1573. if (iova_space_size < 1024*1024) {
  1574. iova_space_size = 1024*1024;
  1575. }
  1576. #ifdef __LP64__
  1577. else if (iova_space_size > 512*1024*1024) {
  1578. iova_space_size = 512*1024*1024;
  1579. }
  1580. #endif
  1582. /*
  1583. ** iova space must be log2() in size.
  1584. ** thus, pdir/res_map will also be log2().
  1585. ** PIRANHA BUG: Exception is when IO Pdir is 2MB (gets reduced)
  1586. */
  1587. iov_order = get_order(iova_space_size >> (IOVP_SHIFT-PAGE_SHIFT));
  1588. ASSERT(iov_order <= (30 - IOVP_SHIFT));   /* iova_space_size <= 1GB */
  1589. ASSERT(iov_order >= (20 - IOVP_SHIFT));   /* iova_space_size >= 1MB */
  1590. iova_space_size = 1 << (iov_order + IOVP_SHIFT);
  1592. ioc->pdir_size = pdir_size = (iova_space_size/IOVP_SIZE) * sizeof(u64);
  1594. ASSERT(pdir_size < 4*1024*1024);   /* max pdir size == 2MB */
  1596. /* Verify it's a power of two */
  1597. ASSERT((1 << get_order(pdir_size)) == (pdir_size >> PAGE_SHIFT));
  1599. DBG_INIT("%s() hpa 0x%lx mem %dMB IOV %dMB (%d bits) PDIR size 0x%0xn",
  1600. __FUNCTION__, ioc->ioc_hpa, (int) (physmem>>20),
  1601. iova_space_size>>20, iov_order + PAGE_SHIFT, pdir_size);
  1603. /* FIXME : DMA HINTs not used */
  1604. ioc->hint_shift_pdir = iov_order + PAGE_SHIFT;
  1605. ioc->hint_mask_pdir = ~(0x3 << (iov_order + PAGE_SHIFT));
  1607. ioc->pdir_base = sba_alloc_pdir(pdir_size);
  1609. DBG_INIT("%s() pdir %p size %x hint_shift_pdir %x hint_mask_pdir %lxn",
  1610. __FUNCTION__, ioc->pdir_base, pdir_size,
  1611. ioc->hint_shift_pdir, ioc->hint_mask_pdir);
  1613. ASSERT((((unsigned long) ioc->pdir_base) & PAGE_MASK) == (unsigned long) ioc->pdir_base);
  1614. WRITE_REG64(virt_to_phys(ioc->pdir_base), ioc->ioc_hpa + IOC_PDIR_BASE);
  1616. /* build IMASK for IOC and Elroy */
  1617. iova_space_mask =  0xffffffff;
  1618. iova_space_mask <<= (iov_order + PAGE_SHIFT);
  1620. /*
  1621. ** On C3000 w/512MB mem, HP-UX 10.20 reports:
  1622. **     ibase=0, imask=0xFE000000, size=0x2000000.
  1623. */
  1624. ioc->ibase = IOC_IOVA_SPACE_BASE | 1; /* bit 0 == enable bit */
  1625. ioc->imask = iova_space_mask; /* save it */
  1627. DBG_INIT("%s() IOV base 0x%lx mask 0x%0lxn",
  1628. __FUNCTION__, ioc->ibase, ioc->imask);
  1630. /*
  1631. ** FIXME: Hint registers are programmed with default hint
  1632. ** values during boot, so hints should be sane even if we
  1633. ** can't reprogram them the way drivers want.
  1634. */
  1636. /*
  1637. ** setup Elroy IBASE/IMASK registers as well.
  1638. */
  1639. for (lba = sba->child; lba; lba = lba->sibling) {
  1640. int rope_num = (lba->hpa >> 13) & 0xf;
  1641. if (rope_num >> 3 == ioc_num)
  1642. lba_set_iregs(lba, ioc->ibase, ioc->imask);
  1643. }
  1645. /*
  1646. ** Program the IOC's ibase and enable IOVA translation
  1647. */
  1648. WRITE_REG(ioc->ibase, ioc->ioc_hpa+IOC_IBASE);
  1649. WRITE_REG(ioc->imask, ioc->ioc_hpa+IOC_IMASK);
  1651. /* Set I/O PDIR Page size to 4K */
  1652. WRITE_REG(0, ioc->ioc_hpa+IOC_TCNFG);
  1654. /*
  1655. ** Clear I/O TLB of any possible entries.
  1656. ** (Yes. This is a bit paranoid...but so what)
  1657. */
  1658. WRITE_REG(0 | 31, ioc->ioc_hpa+IOC_PCOM);
  1660. DBG_INIT("%s() DONEn", __FUNCTION__);
  1661. }
  1665. /**************************************************************************
  1666. **
  1667. **   SBA initialization code (HW and SW)
  1668. **
  1669. **   o identify SBA chip itself
  1670. **   o initialize SBA chip modes (HardFail)
  1671. **   o initialize SBA chip modes (HardFail)
  1672. **   o FIXME: initialize DMA hints for reasonable defaults
  1673. **
  1674. **************************************************************************/
  1676. static void
  1677. sba_hw_init(struct sba_device *sba_dev)
  1678. { 
  1679. int i;
  1680. int num_ioc;
  1681. u64 ioc_ctl;
  1683. ioc_ctl = READ_REG(sba_dev->sba_hpa+IOC_CTRL);
  1684. DBG_INIT("%s() hpa 0x%lx ioc_ctl 0x%Lx ->",
  1685. __FUNCTION__, sba_dev->sba_hpa, ioc_ctl);
  1686. ioc_ctl &= ~(IOC_CTRL_RM | IOC_CTRL_NC | IOC_CTRL_CE);
  1687. ioc_ctl |= IOC_CTRL_TC; /* Astro: firmware enables this */
  1689. WRITE_REG(ioc_ctl, sba_dev->sba_hpa+IOC_CTRL);
  1691. #ifdef DEBUG_SBA_INIT
  1692. ioc_ctl = READ_REG64(sba_dev->sba_hpa+IOC_CTRL);
  1693. DBG_INIT(" 0x%Lxn", ioc_ctl);
  1694. #endif
  1696. if (IS_ASTRO(sba_dev->iodc)) {
  1697. /* PAT_PDC (L-class) also reports the same goofy base */
  1698. sba_dev->ioc[0].ioc_hpa = ASTRO_IOC_OFFSET;
  1699. num_ioc = 1;
  1700. } else {
  1701. sba_dev->ioc[0].ioc_hpa = sba_dev->ioc[1].ioc_hpa = 0;
  1702. num_ioc = 2;
  1703. }
  1705. sba_dev->num_ioc = num_ioc;
  1706. for (i = 0; i < num_ioc; i++) {
  1707. sba_dev->ioc[i].ioc_hpa += sba_dev->sba_hpa + IKE_IOC_OFFSET(i);
  1709. /*
  1710. ** Make sure the box crashes if we get any errors on a rope.
  1711. */
  1712. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE0_CTL);
  1713. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE1_CTL);
  1714. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE2_CTL);
  1715. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE3_CTL);
  1716. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE4_CTL);
  1717. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE5_CTL);
  1718. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE6_CTL);
  1719. WRITE_REG(HF_ENABLE, sba_dev->ioc[i].ioc_hpa + ROPE7_CTL);
  1721. /* flush out the writes */
  1722. READ_REG(sba_dev->ioc[i].ioc_hpa + ROPE7_CTL);
  1724. sba_ioc_init(sba_dev->dev, &(sba_dev->ioc[i]), i);
  1725. }
  1726. }
  1728. static void
  1729. sba_common_init(struct sba_device *sba_dev)
  1730. {
  1731. int i;
  1733. /* add this one to the head of the list (order doesn't matter)
  1734. ** This will be useful for debugging - especially if we get coredumps
  1735. */
  1736. sba_dev->next = sba_list;
  1737. sba_list = sba_dev;
  1739. for(i=0; i< sba_dev->num_ioc; i++) {
  1740. int res_size;
  1741. #ifdef DEBUG_DMB_TRAP
  1742. extern void iterate_pages(unsigned long , unsigned long ,
  1743.   void (*)(pte_t * , unsigned long),
  1744.   unsigned long );
  1745. void set_data_memory_break(pte_t * , unsigned long);
  1746. #endif
  1747. /* resource map size dictated by pdir_size */
  1748. res_size = sba_dev->ioc[i].pdir_size/sizeof(u64); /* entries */
  1750. /* Second part of PIRANHA BUG */
  1751. if (piranha_bad_128k) {
  1752. res_size -= (128*1024)/sizeof(u64);
  1753. }
  1755. res_size >>= 3;  /* convert bit count to byte count */
  1756. DBG_INIT("%s() res_size 0x%xn",
  1757. __FUNCTION__, res_size);
  1759. sba_dev->ioc[i].res_size = res_size;
  1760. sba_dev->ioc[i].res_map = (char *) __get_free_pages(GFP_KERNEL, get_order(res_size));
  1762. #ifdef DEBUG_DMB_TRAP
  1763. iterate_pages( sba_dev->ioc[i].res_map, res_size,
  1764. set_data_memory_break, 0);
  1765. #endif
  1767. if (NULL == sba_dev->ioc[i].res_map)
  1768. {
  1769. panic(__FILE__ ":%s() could not allocate resource mapn", __FUNCTION__ );
  1770. }
  1772. memset(sba_dev->ioc[i].res_map, 0, res_size);
  1773. /* next available IOVP - circular search */
  1774. sba_dev->ioc[i].res_hint = (unsigned long *)
  1775. &(sba_dev->ioc[i].res_map[L1_CACHE_BYTES]);
  1777. #ifdef ASSERT_PDIR_SANITY
  1778. /* Mark first bit busy - ie no IOVA 0 */
  1779. sba_dev->ioc[i].res_map[0] = 0x80;
  1780. sba_dev->ioc[i].pdir_base[0] = 0xeeffc0addbba0080ULL;
  1781. #endif
  1783. /* Third (and last) part of PIRANHA BUG */
  1784. if (piranha_bad_128k) {
  1785. /* region from +1408K to +1536 is un-usable. */
  1787. int idx_start = (1408*1024/sizeof(u64)) >> 3;
  1788. int idx_end   = (1536*1024/sizeof(u64)) >> 3;
  1789. long *p_start = (long *) &(sba_dev->ioc[i].res_map[idx_start]);
  1790. long *p_end   = (long *) &(sba_dev->ioc[i].res_map[idx_end]);
  1792. /* mark that part of the io pdir busy */
  1793. while (p_start < p_end)
  1794. *p_start++ = -1;
  1796. }
  1798. #ifdef DEBUG_DMB_TRAP
  1799. iterate_pages( sba_dev->ioc[i].res_map, res_size,
  1800. set_data_memory_break, 0);
  1801. iterate_pages( sba_dev->ioc[i].pdir_base, sba_dev->ioc[i].pdir_size,
  1802. set_data_memory_break, 0);
  1803. #endif
  1805. DBG_INIT("%s() %d res_map %x %pn",
  1806. __FUNCTION__, i, res_size, sba_dev->ioc[i].res_map);
  1807. }
  1809. sba_dev->sba_lock = SPIN_LOCK_UNLOCKED;
  1810. ioc_needs_fdc = boot_cpu_data.pdc.capabilities & PDC_MODEL_IOPDIR_FDC;
  1812. #ifdef DEBUG_SBA_INIT
  1813. /*
  1814.  * If the PDC_MODEL capabilities has Non-coherent IO-PDIR bit set
  1815.  * (bit #61, big endian), we have to flush and sync every time
  1816.  * IO-PDIR is changed in Ike/Astro.
  1817.  */
  1818. if (boot_cpu_data.pdc.capabilities & PDC_MODEL_IOPDIR_FDC) {
  1819. printk(KERN_INFO MODULE_NAME " FDC/SYNC required.n");
  1820. } else {
  1821. printk(KERN_INFO MODULE_NAME " IOC has cache coherent PDIR.n");
  1822. }
  1823. #endif
  1824. }
  1826. #ifdef CONFIG_PROC_FS
  1827. static int sba_proc_info(char *buf, char **start, off_t offset, int len)
  1828. {
  1829. struct sba_device *sba_dev = sba_list;
  1830. struct ioc *ioc = &sba_dev->ioc[0]; /* FIXME: Multi-IOC support! */
  1831. int total_pages = (int) (ioc->res_size << 3); /* 8 bits per byte */
  1832. unsigned long i = 0, avg = 0, min, max;
  1834. sprintf(buf, "%s rev %d.%dn",
  1835. sba_dev->name,
  1836. (sba_dev->hw_rev & 0x7) + 1,
  1837. (sba_dev->hw_rev & 0x18) >> 3
  1838. );
  1839. sprintf(buf, "%sIO PDIR size    : %d bytes (%d entries)n",
  1840. buf,
  1841. (int) ((ioc->res_size << 3) * sizeof(u64)), /* 8 bits/byte */
  1842. total_pages);
  1844. sprintf(buf, "%sIO PDIR entries : %ld free  %ld used (%d%%)n", buf,
  1845. total_pages - ioc->used_pages, ioc->used_pages,
  1846. (int) (ioc->used_pages * 100 / total_pages));
  1848. sprintf(buf, "%sResource bitmap : %d bytes (%d pages)n", 
  1849. buf, ioc->res_size, ioc->res_size << 3);   /* 8 bits per byte */
  1851. min = max = ioc->avg_search[0];
  1852. for (i = 0; i < SBA_SEARCH_SAMPLE; i++) {
  1853. avg += ioc->avg_search[i];
  1854. if (ioc->avg_search[i] > max) max = ioc->avg_search[i];
  1855. if (ioc->avg_search[i] < min) min = ioc->avg_search[i];
  1856. }
  1857. avg /= SBA_SEARCH_SAMPLE;
  1858. sprintf(buf, "%s  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)n",
  1859. buf, min, avg, max);
  1861. sprintf(buf, "%spci_map_single(): %12ld calls  %12ld pages (avg %d/1000)n",
  1862. buf, ioc->msingle_calls, ioc->msingle_pages,
  1863. (int) ((ioc->msingle_pages * 1000)/ioc->msingle_calls));
  1865. /* KLUGE - unmap_sg calls unmap_single for each mapped page */
  1866. min = ioc->usingle_calls;
  1867. max = ioc->usingle_pages - ioc->usg_pages;
  1868. sprintf(buf, "%spci_unmap_single: %12ld calls  %12ld pages (avg %d/1000)n",
  1869. buf, min, max,
  1870. (int) ((max * 1000)/min));
  1872. sprintf(buf, "%spci_map_sg()    : %12ld calls  %12ld pages (avg %d/1000)n",
  1873. buf, ioc->msg_calls, ioc->msg_pages,
  1874. (int) ((ioc->msg_pages * 1000)/ioc->msg_calls));
  1876. sprintf(buf, "%spci_unmap_sg()  : %12ld calls  %12ld pages (avg %d/1000)n",
  1877. buf, ioc->usg_calls, ioc->usg_pages,
  1878. (int) ((ioc->usg_pages * 1000)/ioc->usg_calls));
  1880. return strlen(buf);
  1881. }
  1883. #if 0
  1884. /* XXX too much output - exceeds 4k limit and needs to be re-written */
  1885. static int
  1886. sba_resource_map(char *buf, char **start, off_t offset, int len)
  1887. {
  1888. struct sba_device *sba_dev = sba_list;
  1889. struct ioc *ioc = &sba_dev->ioc[0]; /* FIXME: Mutli-IOC suppoer! */
  1890. unsigned int *res_ptr = (unsigned int *)ioc->res_map;
  1891. int i;
  1893. buf[0] = '';
  1894. for(i = 0; i < (ioc->res_size / sizeof(unsigned int)); ++i, ++res_ptr) {
  1895. if ((i & 7) == 0)
  1896.     strcat(buf,"n   ");
  1897. sprintf(buf, "%s %08x", buf, *res_ptr);
  1898. }
  1899. strcat(buf, "n");
  1901. return strlen(buf);
  1902. }
  1903. #endif /* 0 */
  1904. #endif /* CONFIG_PROC_FS */
  1906. static struct parisc_device_id sba_tbl[] = {
  1907. { HPHW_IOA, HVERSION_REV_ANY_ID, ASTRO_RUNWAY_PORT, 0xb },
  1908. { HPHW_BCPORT, HVERSION_REV_ANY_ID, IKE_MERCED_PORT, 0xc },
  1909. { HPHW_BCPORT, HVERSION_REV_ANY_ID, REO_MERCED_PORT, 0xc },
  1910. { HPHW_BCPORT, HVERSION_REV_ANY_ID, REOG_MERCED_PORT, 0xc },
  1911. /* These two entries commented out because we don't find them in a
  1912.  * buswalk yet.  If/when we do, they would cause us to think we had
  1913.  * many more SBAs then we really do.
  1914.  * { HPHW_BCPORT, HVERSION_REV_ANY_ID, ASTRO_ROPES_PORT, 0xc },
  1915.  * { HPHW_BCPORT, HVERSION_REV_ANY_ID, IKE_ROPES_PORT, 0xc },
  1916.  */
  1917. { 0, }
  1918. };
  1920. int sba_driver_callback(struct parisc_device *);
  1922. static struct parisc_driver sba_driver = {
  1923. name: MODULE_NAME,
  1924. id_table: sba_tbl,
  1925. probe: sba_driver_callback,
  1926. };
  1928. /*
  1929. ** Determine if lba should claim this chip (return 0) or not (return 1).
  1930. ** If so, initialize the chip and tell other partners in crime they
  1931. ** have work to do.
  1932. */
  1933. int
  1934. sba_driver_callback(struct parisc_device *dev)
  1935. {
  1936. struct sba_device *sba_dev;
  1937. u32 func_class;
  1938. int i;
  1939. char *version;
  1941. #ifdef DEBUG_SBA_INIT
  1942. sba_dump_ranges(dev->hpa);
  1943. #endif
  1945. /* Read HW Rev First */
  1946. func_class = READ_REG(dev->hpa + SBA_FCLASS);
  1948. if (IS_ASTRO(&dev->id)) {
  1949. unsigned long fclass;
  1950. static char astro_rev[]="Astro ?.?";
  1952. /* Astro is broken...Read HW Rev First */
  1953. fclass = READ_REG(dev->hpa);
  1955. astro_rev[6] = '1' + (char) (fclass & 0x7);
  1956. astro_rev[8] = '0' + (char) ((fclass & 0x18) >> 3);
  1957. version = astro_rev;
  1959. } else if (IS_IKE(&dev->id)) {
  1960. static char ike_rev[]="Ike rev ?";
  1962. ike_rev[8] = '0' + (char) (func_class & 0xff);
  1963. version = ike_rev;
  1964. } else {
  1965. static char reo_rev[]="REO rev ?";
  1967. reo_rev[8] = '0' + (char) (func_class & 0xff);
  1968. version = reo_rev;
  1969. }
  1971. if (!global_ioc_cnt) {
  1972. global_ioc_cnt = count_parisc_driver(&sba_driver);
  1974. /* Only Astro has one IOC per SBA */
  1975. if (!IS_ASTRO(&dev->id))
  1976. global_ioc_cnt *= 2;
  1977. }
  1979. printk(KERN_INFO "%s found %s at 0x%lxn",
  1980. MODULE_NAME, version, dev->hpa);
  1982. #ifdef DEBUG_SBA_INIT
  1983. sba_dump_tlb(dev->hpa);
  1984. #endif
  1986. sba_dev = kmalloc(sizeof(struct sba_device), GFP_KERNEL);
  1987. if (NULL == sba_dev) {
  1988. printk(KERN_ERR MODULE_NAME " - couldn't alloc sba_devicen");
  1989. return(1);
  1990. }
  1992. dev->sysdata = (void *) sba_dev;
  1993. memset(sba_dev, 0, sizeof(struct sba_device));
  1995. for(i=0; i<MAX_IOC; i++)
  1996. spin_lock_init(&(sba_dev->ioc[i].res_lock));
  1998. sba_dev->dev = dev;
  1999. sba_dev->hw_rev = func_class;
  2000. sba_dev->iodc = &dev->id;
  2001. sba_dev->name = dev->name;
  2002. sba_dev->sba_hpa = dev->hpa;  /* faster access */
  2004. sba_get_pat_resources(sba_dev);
  2005. sba_hw_init(sba_dev);
  2006. sba_common_init(sba_dev);
  2008. hppa_dma_ops = &sba_ops;
  2010. #ifdef CONFIG_PROC_FS
  2011. if (IS_ASTRO(&dev->id)) {
  2012. create_proc_info_entry("Astro", 0, proc_runway_root, sba_proc_info);
  2013. } else if (IS_IKE(&dev->id)) {
  2014. create_proc_info_entry("Ike", 0, proc_runway_root, sba_proc_info);
  2015. } else {
  2016. create_proc_info_entry("Reo", 0, proc_runway_root, sba_proc_info);
  2017. }
  2018. #if 0
  2019. create_proc_info_entry("bitmap", 0, proc_runway_root, sba_resource_map);
  2020. #endif
  2021. #endif
  2022. return 0;
  2023. }
  2025. /*
  2026. ** One time initialization to let the world know the SBA was found.
  2027. ** This is the only routine which is NOT static.
  2028. ** Must be called exactly once before pci_init().
  2029. */
  2030. void __init sba_init(void)
  2031. {
  2032. register_parisc_driver(&sba_driver);
  2033. }
  2036. /**
  2037.  * sba_get_iommu - Assign the iommu pointer for the pci bus controller.
  2038.  * @dev: The parisc device.
  2039.  *
  2040.  * This function searches through the registerd IOMMU's and returns the
  2041.  * appropriate IOMMU data for the given parisc PCI controller.
  2042.  */
  2043. void * sba_get_iommu(struct parisc_device *pci_hba)
  2044. {
  2045. struct sba_device *sba = (struct sba_device *) pci_hba->parent->sysdata;
  2046. char t = pci_hba->parent->id.hw_type;
  2047. int iocnum = (pci_hba->hw_path >> 3); /* rope # */
  2049. if ((t!=HPHW_IOA) && (t!=HPHW_BCPORT))
  2050. BUG();
  2052. return &(sba->ioc[iocnum]);
  2053. }