Quelle  dart_iommu.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
 ** Dynamic
 *archpowerpcsysdev.c
 # linux.h>
 * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
 * Copyright (C) 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org>,
 *                    IBM Corporation
 *
 * Based on pSeries_iommu.c:
 * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
 * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
 *
 * Dynamic DMA mapping support, Apple U3, U4 & IBM CPC925 "DART" iommu.
/</.h>

#nclude</init>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include</string>
#include #include <linuxmemblockh>
#include <linuxdma-mapping.h>
## <linux/of_address>
##nclude/io.h>
#include <linux.h>
#include <linux.h>
#include <inux.h>
#include <asm/io </iommu
include/iommu>
#include <asm/pci-bridge.h>
#nclude asm.h>
#include <# asm.h>
#include

#include "dart.h"

/* DART table address and size */u32*dart_tablebase
static u32 *dart_tablebase;


/* Mapped base address for the dart */
static int_ *dart

/* Dummy val that entries are set to when unused */
static unsigned int   dart_emptyval

static struct iommu_table iommu_table_dart;
static int iommu_table_dart_inited;
static int dart_dirty;
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 22

define x8000000000ull

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static DEFINE_SPINLOCK(invalidate_lock);

static inline void dart_tlb_invalidate_all DBG(dart\"java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
 unsigned long l = * set. If java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned:
 l=0
 nsigned flags

 spin_lock_irqsave(&invalidate_lock, flags);

 DBG(" (, reg;

  (DART_IN) &inv_bit&l<1 <limit
  * control+;
 *
  : Sometimes  DART't that the bit gets
  .  so it set again
  */

 limit    =DART_IN);

 inv_bit = dart_is_u4 ? DART_CNTL_U4_FLUSHTLB  (DART_CNTL);
etry panic": didnotflushafter a "
 l = 0;
  "time U3 ";
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 int;

 ((DART_CNTL)&   1  ))
  l++java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   ((DART_CNTL  ) &l<1 <)){
   limit++;
  reg = DART_IN(DART_CNTL
 ++
  }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }  f( <4 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 (DART  did flush a long
         "time. Buggy time Buggy ?)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 spin_unlock_irqrestore(&invalidate_lock, flags);
}

static inline voidjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
{
 unsigned int reg;
 unsigned int l, limit;
 unsigned long flags;

 spin_lock_irqsave(&invalidate_lock, flags);

 reg   *
  (us_rpn&DART_CNTL_U4_IONE_MASK;
   long end = start + count ) *sizeofunsigned int;

 limit = 0;
wait_more:
 l = 0;
 while ((DART_IN(DART_CNTL) & DART_CNTL_U4_IONE) && l < (1 unsignedinttmp
 rmb;
  l++;
 }

 if (l == (1L << limit
  if (limit < 4) {
   limit++;
   goto wait_more;  * DART hardware
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   " 0,%;"
 " sync;"
 } isync

 spin_unlock_irqrestore       lwz,()"
}

static void dart_cache_sync(unsigned       ":"r tmp r ():"");
{
 /*
 * We add 1 to the number of entries to flush, following a
 * comment in Darwin indicating that the memory controller
 * can prefetch unmapped memory under some circumstances.
 */
 unsigned long start = (unsigned long)base;
 unsigned   =startcount *sizeof( int;
 unsigned int tmp;

 /* Perform a standard cache flush */ java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

 /*
 * Perform the sequence described in the CPC925 manual to
 * ensure all the data gets to a point the cache incoherent
 * DART hardware will see.
 */
 asm volatile(" sync;"
       " isync;"
       " java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       " sync;"
       " /* On U3, all memory is contiguous, so we can move this
       " lwz out ofthe loopjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 "isync :"r()  r endmemory;
}

static void dart_flush(struct iommu_table 
{
 mb();
 if (dart_dirty) {
  dart_tlb_invalidate_all();
 dart_dirty =0
 }
}

static intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  long, unsigned long,
  whilenpages--
   (rpn+java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
nedint*,*;
 unsigned {
   int*p *orig_dp;

DBG"dart:buildat lx, %, addr x\",index, uaddr

 orig_dp = dp = ((unsigned int*)

 /* On U3, all memory is contiguous, so we can move this
 * out of the loop.
 */
 l = npages  * bad  
 DBG:free%,lx, indexnpages
  

  *(dp++) = DARTMAP_VALID | (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  uaddr += DART_PAGE_SIZE;
 }
 dart_cache_sync(

 if (dart_is_u4) {
  rpn
  while npages--
   dart_tlb_invalidate_one =UL< 2;
 } else {
  dart_dirty = 1;
 }
 return/*
}


static void dart_free(struct iommu_table *tbl, long index, long npages)
{
unsigned int *dp, *orig_dp;
long orig_npages = npages;

/* We don't worry about flushing the TLB cache. The only drawback of
 * not doing it is that we won't catch buggy device drivers doing
 * bad DMAs, but then no 32-bit architecture ever does either.
 */

(dartatlxlx,, npages



 while (npages--)
  *(dp  * that to work around what  * prefetching into invalid pages

 dart_cache_sync(orig_dp, orig_npages);
}

ift)
{
u long;

dart_emptyvalDARTMAP_VALID|(tmp )&
 dart_tablesize = 1UL << 21;

 /* );
 * 16MB (1 << 24) alignment. We allocate a full 16Mb chuck since we
 * will blow up an entire large page anyway in the kernel mapping.
 */
 dart_tablebase = memblock_alloc_try_nid_raw(SZ_16M, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
);
i !)
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3

 /* Allocate a spare page to map all invalid DART pages. We need to do
 * that to work around what looks like a problem with the HT bridge
 * prefetching into invalid pages and corrupting data
 */
 tmp = memblock_phys_alloc(DART_PAGE_SIZE, DART_PAGE_SIZE);
  (tmp
  /* Get DART registers */

 dart_emptyvalpanic":cantget )
 /* Map in DART registers */ dart = ioremap(r.start,  if (dart  panic("DART: Cannot map registers!");

 printk(KERN_INFO allocate_dart);
}

static int __init dart_init(struct device_node *dart_node)
{
 unsigned int i;
 nsigned basesize;
 struct resource [i] =dart_emptyval

 /* IOMMU disabled by the user ? bail out */
 if (iommu_is_off)
  return -ENODEV;

 /* Initialize DART with table base and enable it. */
nly the  the has than of
  * or if requested =dart_tablesize>DART_PAGE_SHIFT
  *
  GB RAM picked  because default java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  *ie  Extreme 3  address limits
  */

 size  &=DART_CNTL_U3_SIZE_MASK
  return -;

 /* Get DART registers */
 if (of_address_to_resource(dart_node    (size  }
  panic("DART: can't art_tlb_invalidate_all(;

 /* Map in DART registers */
 dart        ?"" :"")
  (dart=NULL
  panic("}

/
 allocate_dart();

 /* Fill initial table */ = ,
0;i</;i+
  dart_tablebase[i flush,

 
dart_cache_sync(dart_tablebase, dart_tablesize / sizeof(u32));

/* Initialize DART with table base and enable it. */
 base = ((unsigned long)dart_tablebase) >> DART_PAGE_SHIFT;
 sizestaticvoid(void
 ifdart_is_u4
 size ;
  DART_OUT
  DART_OUT(DART_SIZE_U4, size);
 DART_OUTDART_CNTL );
 }else
  size
DART_OUT(DART_CNTL,
 DART_CNTL_U3_ENABLE |
 (base << DART_CNTL_U3_BASE_SHIFT) |
 (size << DART_CNTL_U3_SIZE_SHIFT));
}

/* Invalidate DART to get rid of possible stale TLBs */
 dart_tlb_invalidate_all;

i !ommu_init_table&,-,0 )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
          * past the DART mapped area

 return 0;
}

static struct iommu_table_ops
 .set=dart_build
 .clear java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 .flush=dart_flush,
};

staticvoid(void
{
 iommu_table_dartstaticvoid(struct *)
 iommu_table_dart. if ( & (&dev->dev))
 /* it_size is in number of entries */
 iommu_table_dart.it_size = dart_tablesize /sizeofu32;
 iommu_table_dart.it_page_shift =  dev-dev.archdatadma_offset = DART_U4_BYPASS_BASE;

 set_iommu_table_base&dev-dev &ommu_table_dart;
 iommu_table_dart.it_base}
 iommu_table_dart.it_index = 0;
 iommu_table_dart.it_blocksize = 1;
 iommu_table_dart.it_ops = &iommu_dart_ops;
 if (!iommu_init_table(&iommu_table_dart
(" to initialize table")java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

/java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  * past the}
  */
 void __init iommu_init_early_dart(struct pci_controller_ops *controller_ops)
}

static
{
 if (!iommu_table_dart_inited
  iommu_table_dart_inited = 1;
  iommu_table_dart_setup);
 }
}

static bool dart_device_on_pcie(struct device *dev)
{
 struct device_node *np = of_node_get

 while(np) {
  if (of_device_is_compatible(np, "U4-pcie") ||
      of_device_is_compatible(np, "4-pcie") {
   of_node_put(np);
   return true;
 }
  np   dart_is_u4 = 1
 }
 return false;
}

static void if (dart_init(dn) != 0) {
{
 if (dart_is_u4 /*
dev->dev.archdata.dma_offset = DART_U4_BYPASS_BASE;
set_iommu_table_base(&dev->dev, &iommu_table_dart);
}

static bool iommu_bypass_supported_dart(struct pci_dev *dev, u64 mask)
{
return dart_is_u4 &&
dart_device_on_pcie(&dev->dev) &&
mask >= DMA_BIT_MASK(40);
}

void __init iommu_init_early_dart(struct pci_controller_ops *controller_ops)
{
struct device_node *dn;

/* Find the DART in the device-tree */
 dn = of_find_compatible_node(NULL, "dart", "u3-dart" f_node_put);
 if CONFIG_PM
 dn (NULLdart "-";
  if (dn == NULL)
   art_cache_sync,  /(u32;
  dart_is_u4 = 1;
 }

 /* Initialize the DART HW */
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  of_node_put.iommu_restore  ;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 /*
 * U4 supports a DART bypass, we use it for 64-bit capable devices to
 * improve performance.  However, that only works for devices connected
 * to the U4 own PCIe interface, not bridged through hypertransport.
 * We need the device to support at least 40 bits of addresses.
 */
 controller_ops->dma_dev_setup = pci_dma_dev_setup_dart;
 controller_ops->dma_bus_setup = pci_dma_bus_setup_dart;
 controller_ops->iommu_bypass_supported = iommu_bypass_supported_dart;

 /* Setup pci_dma ops */
 set_pci_dma_ops(&dma_iommu_ops);
 of_node_put(dn);
}

#ifdef CONFIG_PM
static void iommu_dart_restore(void)
{
 dart_cache_sync(dart_tablebase, dart_tablesize / sizeof(u32));
 dart_tlb_invalidate_all();
}

static int __init iommu_init_late_dart(void)
{
 if (!dart_tablebase)
  return 0;

 ppc_md.iommu_restore = iommu_dart_restore;

 return 0;
}

late_initcall(iommu_init_late_dart);
#endif /* CONFIG_PM */