arch/all-pc/boot/grub2-aros/grub-core/bus/pci.c

   1 /* pci.c - Generic PCI interfaces.  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2007,2009  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/dl.h>
  21 #include <grub/pci.h>
  22 #include <grub/mm.h>
  23 #include <grub/misc.h>
  24 #include <grub/mm_private.h>
  25 #include <grub/cache.h>
  26
  27 GRUB_MOD_LICENSE ("GPLv3+");
  28
  29 /* FIXME: correctly support 64-bit architectures.  */
  30 /* #if GRUB_TARGET_SIZEOF_VOID_P == 4 */
  31 struct grub_pci_dma_chunk *
  32 grub_memalign_dma32 (grub_size_t align, grub_size_t size)
  33 {
  34   void *ret;
  35   if (align < 64)
  36     align = 64;
  37   size = ALIGN_UP (size, align);
  38   ret = grub_memalign (align, size);
  39 #if GRUB_CPU_SIZEOF_VOID_P == 8
  40   if ((grub_addr_t) ret >> 32)
  41     {
  42       /* Shouldn't happend since the only platform in this case is
  43          x86_64-efi and it skips any regions > 4GiB because
  44          of EFI bugs anyway.  */
  45       grub_error (GRUB_ERR_BUG, "allocation outside 32-bit range");
  46       return 0;
  47     }
  48 #endif
  49   if (!ret)
  50     return 0;
  51   grub_arch_sync_dma_caches (ret, size);
  52   return ret;
  53 }
  54
  55 /* FIXME: evil.  */
  56 void
  57 grub_dma_free (struct grub_pci_dma_chunk *ch)
  58 {
  59   grub_size_t size = (((struct grub_mm_header *) ch) - 1)->size * GRUB_MM_ALIGN;
  60   grub_arch_sync_dma_caches (ch, size);
  61   grub_free (ch);
  62 }
  63 /* #endif */
  64
  65 #ifdef GRUB_MACHINE_MIPS_LOONGSON
  66 volatile void *
  67 grub_dma_get_virt (struct grub_pci_dma_chunk *ch)
  68 {
  69   return (void *) ((((grub_uint32_t) ch) & 0x1fffffff) | 0xa0000000);
  70 }
  71
  72 grub_uint32_t
  73 grub_dma_get_phys (struct grub_pci_dma_chunk *ch)
  74 {
  75   return (((grub_uint32_t) ch) & 0x1fffffff) | 0x80000000;
  76 }
  77 #else
  78
  79 volatile void *
  80 grub_dma_get_virt (struct grub_pci_dma_chunk *ch)
  81 {
  82   return (void *) ch;
  83 }
  84
  85 grub_uint32_t
  86 grub_dma_get_phys (struct grub_pci_dma_chunk *ch)
  87 {
  88   return (grub_uint32_t) (grub_addr_t) ch;
  89 }
  90
  91 #endif
  92
  93 grub_pci_address_t
  94 grub_pci_make_address (grub_pci_device_t dev, int reg)
  95 {
  96   return (1 << 31) | (dev.bus << 16) | (dev.device << 11)
  97     | (dev.function << 8) | reg;
  98 }
  99
 100 void
 101 grub_pci_iterate (grub_pci_iteratefunc_t hook, void *hook_data)
 102 {
 103   grub_pci_device_t dev;
 104   grub_pci_address_t addr;
 105   grub_pci_id_t id;
 106   grub_uint32_t hdr;
 107
 108   for (dev.bus = 0; dev.bus < GRUB_PCI_NUM_BUS; dev.bus++)
 109     {
 110       for (dev.device = 0; dev.device < GRUB_PCI_NUM_DEVICES; dev.device++)
 111         {
 112           for (dev.function = 0; dev.function < 8; dev.function++)
 113             {
 114               addr = grub_pci_make_address (dev, GRUB_PCI_REG_PCI_ID);
 115               id = grub_pci_read (addr);
 116
 117               /* Check if there is a device present.  */
 118               if (id >> 16 == 0xFFFF)
 119                 {
 120                   if (dev.function == 0)
 121                     /* Devices are required to implement function 0, so if
 122                        it's missing then there is no device here.  */
 123                     break;
 124                   else
 125                     continue;
 126                 }
 127
 128               if (hook (dev, id, hook_data))
 129                 return;
 130
 131               /* Probe only func = 0 if the device if not multifunction */
 132               if (dev.function == 0)
 133                 {
 134                   addr = grub_pci_make_address (dev, GRUB_PCI_REG_CACHELINE);
 135                   hdr = grub_pci_read (addr);
 136                   if (!(hdr & 0x800000))
 137                     break;
 138                 }
 139             }
 140         }
 141     }
 142 }
 143
 144 grub_uint8_t
 145 grub_pci_find_capability (grub_pci_device_t dev, grub_uint8_t cap)
 146 {
 147   grub_uint8_t pos = 0x34;
 148   int ttl = 48;
 149
 150   while (ttl--)
 151     {
 152       grub_uint8_t id;
 153       grub_pci_address_t addr;
 154
 155       addr = grub_pci_make_address (dev, pos);
 156       pos = grub_pci_read_byte (addr);
 157       if (pos < 0x40)
 158         break;
 159
 160       pos &= ~3;
 161
 162       addr = grub_pci_make_address (dev, pos);
 163       id = grub_pci_read_byte (addr);
 164
 165       if (id == 0xff)
 166         break;
 167
 168       if (id == cap)
 169         return pos;
 170       pos++;
 171     }
 172   return 0;
 173 }