LXR linux/arch/ia64/sn/pci/pcibr/pcibr

   1/*
   2 * This file is subject to the terms and conditions of the GNU General Public
   3 * License.  See the file "COPYING" in the main directory of this archive
   4 * for more details.
   5 *
   6 * Copyright (C) 2001-2006 Silicon Graphics, Inc. All rights reserved.
   7 */
   8
   9#include <linux/types.h>
  10#include <asm/sn/sn_sal.h>
  11#include <asm/sn/pcibr_provider.h>
  12#include <asm/sn/pcibus_provider_defs.h>
  13#include <asm/sn/pcidev.h>
  14
  15int pcibr_invalidate_ate;       /* by default don't invalidate ATE on free */
  16
  17/*
  18 * mark_ate: Mark the ate as either free or inuse.
  19 */
  20static void mark_ate(struct ate_resource *ate_resource, int start, int number,
  21                     u64 value)
  22{
  23        u64 *ate = ate_resource->ate;
  24        int index;
  25        int length = 0;
  26
  27        for (index = start; length < number; index++, length++)
  28                ate[index] = value;
  29}
  30
  31/*
  32 * find_free_ate:  Find the first free ate index starting from the given
  33 *                 index for the desired consecutive count.
  34 */
  35static int find_free_ate(struct ate_resource *ate_resource, int start,
  36                         int count)
  37{
  38        u64 *ate = ate_resource->ate;
  39        int index;
  40        int start_free;
  41
  42        for (index = start; index < ate_resource->num_ate;) {
  43                if (!ate[index]) {
  44                        int i;
  45                        int free;
  46                        free = 0;
  47                        start_free = index;     /* Found start free ate */
  48                        for (i = start_free; i < ate_resource->num_ate; i++) {
  49                                if (!ate[i]) {  /* This is free */
  50                                        if (++free == count)
  51                                                return start_free;
  52                                } else {
  53                                        index = i + 1;
  54                                        break;
  55                                }
  56                        }
  57                        if (i >= ate_resource->num_ate)
  58                                return -1;
  59                } else
  60                        index++;        /* Try next ate */
  61        }
  62
  63        return -1;
  64}
  65
  66/*
  67 * free_ate_resource:  Free the requested number of ATEs.
  68 */
  69static inline void free_ate_resource(struct ate_resource *ate_resource,
  70                                     int start)
  71{
  72        mark_ate(ate_resource, start, ate_resource->ate[start], 0);
  73        if ((ate_resource->lowest_free_index > start) ||
  74            (ate_resource->lowest_free_index < 0))
  75                ate_resource->lowest_free_index = start;
  76}
  77
  78/*
  79 * alloc_ate_resource:  Allocate the requested number of ATEs.
  80 */
  81static inline int alloc_ate_resource(struct ate_resource *ate_resource,
  82                                     int ate_needed)
  83{
  84        int start_index;
  85
  86        /*
  87         * Check for ate exhaustion.
  88         */
  89        if (ate_resource->lowest_free_index < 0)
  90                return -1;
  91
  92        /*
  93         * Find the required number of free consecutive ates.
  94         */
  95        start_index =
  96            find_free_ate(ate_resource, ate_resource->lowest_free_index,
  97                          ate_needed);
  98        if (start_index >= 0)
  99                mark_ate(ate_resource, start_index, ate_needed, ate_needed);
 100
 101        ate_resource->lowest_free_index =
 102            find_free_ate(ate_resource, ate_resource->lowest_free_index, 1);
 103
 104        return start_index;
 105}
 106
 107/*
 108 * Allocate "count" contiguous Bridge Address Translation Entries
 109 * on the specified bridge to be used for PCI to XTALK mappings.
 110 * Indices in rm map range from 1..num_entries.  Indices returned
 111 * to caller range from 0..num_entries-1.
 112 *
 113 * Return the start index on success, -1 on failure.
 114 */
 115int pcibr_ate_alloc(struct pcibus_info *pcibus_info, int count)
 116{
 117        int status;
 118        unsigned long flags;
 119
 120        spin_lock_irqsave(&pcibus_info->pbi_lock, flags);
 121        status = alloc_ate_resource(&pcibus_info->pbi_int_ate_resource, count);
 122        spin_unlock_irqrestore(&pcibus_info->pbi_lock, flags);
 123
 124        return status;
 125}
 126
 127/*
 128 * Setup an Address Translation Entry as specified.  Use either the Bridge
 129 * internal maps or the external map RAM, as appropriate.
 130 */
 131static inline u64 __iomem *pcibr_ate_addr(struct pcibus_info *pcibus_info,
 132                                       int ate_index)
 133{
 134        if (ate_index < pcibus_info->pbi_int_ate_size) {
 135                return pcireg_int_ate_addr(pcibus_info, ate_index);
 136        }
 137        panic("pcibr_ate_addr: invalid ate_index 0x%x", ate_index);
 138}
 139
 140/*
 141 * Update the ate.
 142 */
 143inline void
 144ate_write(struct pcibus_info *pcibus_info, int ate_index, int count,
 145          volatile u64 ate)
 146{
 147        while (count-- > 0) {
 148                if (ate_index < pcibus_info->pbi_int_ate_size) {
 149                        pcireg_int_ate_set(pcibus_info, ate_index, ate);
 150                } else {
 151                        panic("ate_write: invalid ate_index 0x%x", ate_index);
 152                }
 153                ate_index++;
 154                ate += IOPGSIZE;
 155        }
 156
 157        pcireg_tflush_get(pcibus_info); /* wait until Bridge PIO complete */
 158}
 159
 160void pcibr_ate_free(struct pcibus_info *pcibus_info, int index)
 161{
 162
 163        volatile u64 ate;
 164        int count;
 165        unsigned long flags;
 166
 167        if (pcibr_invalidate_ate) {
 168                /* For debugging purposes, clear the valid bit in the ATE */
 169                ate = *pcibr_ate_addr(pcibus_info, index);
 170                count = pcibus_info->pbi_int_ate_resource.ate[index];
 171                ate_write(pcibus_info, index, count, (ate & ~PCI32_ATE_V));
 172        }
 173
 174        spin_lock_irqsave(&pcibus_info->pbi_lock, flags);
 175        free_ate_resource(&pcibus_info->pbi_int_ate_resource, index);
 176        spin_unlock_irqrestore(&pcibus_info->pbi_lock, flags);
 177}
 178