1 /* 2 * (C) Copyright IBM Corporation 2006 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * on the rights to use, copy, modify, merge, publish, distribute, sub 9 * license, and/or sell copies of the Software, and to permit persons to whom 10 * the Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 19 * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 25 /** 26 * \file common_iterator.c 27 * Platform independent iterator support routines. 28 * 29 * \author Ian Romanick <[email protected]> 30 */ 31 32 #include <stdlib.h> 33 #include <string.h> 34 35 #include "pciaccess.h" 36 #include "pciaccess_private.h" 37 38 /** 39 * Track device iteration state 40 * 41 * \private 42 */ 43 struct pci_device_iterator { 44 unsigned next_index; 45 46 enum { 47 match_any, 48 match_slot, 49 match_id 50 } mode; 51 52 union { 53 struct pci_slot_match slot; 54 struct pci_id_match id; 55 } match; 56 }; 57 58 59 /** 60 * Create an iterator based on a regular expression. 61 * 62 * \return 63 * A pointer to a fully initialized \c pci_device_iterator structure on 64 * success, or \c NULL on failure. 65 * 66 * \sa pci_id_match_iterator_create, pci_device_next, pci_iterator_destroy 67 */ 68 struct pci_device_iterator * 69 pci_slot_match_iterator_create( const struct pci_slot_match * match ) 70 { 71 struct pci_device_iterator * iter; 72 73 if ( pci_sys == NULL ) { 74 return NULL; 75 } 76 77 iter = malloc( sizeof( *iter ) ); 78 if ( iter != NULL ) { 79 iter->next_index = 0; 80 81 if ( match != NULL ) { 82 iter->mode = match_slot; 83 84 (void) memcpy( & iter->match.slot, match, sizeof( *match ) ); 85 } 86 else { 87 iter->mode = match_any; 88 } 89 } 90 91 return iter; 92 } 93 94 95 /** 96 * Create an iterator based on a regular expression. 97 * 98 * \return 99 * A pointer to a fully initialized \c pci_device_iterator structure on 100 * success, or \c NULL on failure. 101 * 102 * \sa pci_slot_match_iterator_create, pci_device_next, pci_iterator_destroy 103 */ 104 struct pci_device_iterator * 105 pci_id_match_iterator_create( const struct pci_id_match * match ) 106 { 107 struct pci_device_iterator * iter; 108 109 if ( pci_sys == NULL ) { 110 return NULL; 111 } 112 113 iter = malloc( sizeof( *iter ) ); 114 if ( iter != NULL ) { 115 iter->next_index = 0; 116 117 if ( match != NULL ) { 118 iter->mode = match_id; 119 120 (void) memcpy( & iter->match.id, match, sizeof( *match ) ); 121 } 122 else { 123 iter->mode = match_any; 124 } 125 } 126 127 return iter; 128 } 129 130 131 /** 132 * Destroy an iterator previously created with \c pci_iterator_create. 133 * 134 * \param iter Iterator to be destroyed. 135 * 136 * \sa pci_device_next, pci_iterator_create 137 */ 138 void 139 pci_iterator_destroy( struct pci_device_iterator * iter ) 140 { 141 if ( iter != NULL ) { 142 free( iter ); 143 } 144 } 145 146 147 /** 148 * Iterate to the next PCI device. 149 * 150 * \param iter Device iterator returned by \c pci_device_iterate. 151 * 152 * \return 153 * A pointer to a \c pci_device, or \c NULL when all devices have been 154 * iterated. 155 */ 156 struct pci_device * 157 pci_device_next( struct pci_device_iterator * iter ) 158 { 159 struct pci_device_private * d = NULL; 160 161 if (!iter) 162 return NULL; 163 164 switch( iter->mode ) { 165 case match_any: 166 if ( iter->next_index < pci_sys->num_devices ) { 167 d = & pci_sys->devices[ iter->next_index ]; 168 iter->next_index++; 169 } 170 171 break; 172 173 case match_slot: { 174 while ( iter->next_index < pci_sys->num_devices ) { 175 struct pci_device_private * const temp = 176 & pci_sys->devices[ iter->next_index ]; 177 178 iter->next_index++; 179 if ( PCI_ID_COMPARE( iter->match.slot.domain, temp->base.domain ) 180 && PCI_ID_COMPARE( iter->match.slot.bus, temp->base.bus ) 181 && PCI_ID_COMPARE( iter->match.slot.dev, temp->base.dev ) 182 && PCI_ID_COMPARE( iter->match.slot.func, temp->base.func ) ) { 183 d = temp; 184 break; 185 } 186 } 187 188 break; 189 } 190 191 case match_id: { 192 while ( iter->next_index < pci_sys->num_devices ) { 193 struct pci_device_private * const temp = 194 & pci_sys->devices[ iter->next_index ]; 195 196 iter->next_index++; 197 if ( PCI_ID_COMPARE( iter->match.id.vendor_id, temp->base.vendor_id ) 198 && PCI_ID_COMPARE( iter->match.id.device_id, temp->base.device_id ) 199 && PCI_ID_COMPARE( iter->match.id.subvendor_id, temp->base.subvendor_id ) 200 && PCI_ID_COMPARE( iter->match.id.subdevice_id, temp->base.subdevice_id ) 201 && ((temp->base.device_class & iter->match.id.device_class_mask) 202 == iter->match.id.device_class) ) { 203 d = temp; 204 break; 205 } 206 } 207 208 break; 209 } 210 } 211 212 return (struct pci_device *) d; 213 } 214 215 216 struct pci_device * 217 pci_device_find_by_slot( uint32_t domain, uint32_t bus, uint32_t dev, 218 uint32_t func ) 219 { 220 struct pci_device_iterator iter; 221 222 223 iter.next_index = 0; 224 iter.mode = match_slot; 225 iter.match.slot.domain = domain; 226 iter.match.slot.bus = bus; 227 iter.match.slot.dev = dev; 228 iter.match.slot.func = func; 229 230 return pci_device_next( & iter ); 231 } 232