1 /* 2 * Copyright IBM Corp. 2012 3 * 4 * Author(s): 5 * Jan Glauber <jang@linux.vnet.ibm.com> 6 */ 7 8 #define COMPONENT "zPCI" 9 #define pr_fmt(fmt) COMPONENT ": " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/slab.h> 13 #include <linux/err.h> 14 #include <linux/delay.h> 15 #include <linux/pci.h> 16 #include <asm/pci_debug.h> 17 #include <asm/pci_clp.h> 18 19 /* 20 * Call Logical Processor 21 * Retry logic is handled by the caller. 22 */ 23 static inline u8 clp_instr(void *data) 24 { 25 struct { u8 _[CLP_BLK_SIZE]; } *req = data; 26 u64 ignored; 27 u8 cc; 28 29 asm volatile ( 30 " .insn rrf,0xb9a00000,%[ign],%[req],0x0,0x2\n" 31 " ipm %[cc]\n" 32 " srl %[cc],28\n" 33 : [cc] "=d" (cc), [ign] "=d" (ignored), "+m" (*req) 34 : [req] "a" (req) 35 : "cc"); 36 return cc; 37 } 38 39 static void *clp_alloc_block(gfp_t gfp_mask) 40 { 41 return (void *) __get_free_pages(gfp_mask, get_order(CLP_BLK_SIZE)); 42 } 43 44 static void clp_free_block(void *ptr) 45 { 46 free_pages((unsigned long) ptr, get_order(CLP_BLK_SIZE)); 47 } 48 49 static void clp_store_query_pci_fngrp(struct zpci_dev *zdev, 50 struct clp_rsp_query_pci_grp *response) 51 { 52 zdev->tlb_refresh = response->refresh; 53 zdev->dma_mask = response->dasm; 54 zdev->msi_addr = response->msia; 55 zdev->fmb_update = response->mui; 56 57 pr_debug("Supported number of MSI vectors: %u\n", response->noi); 58 switch (response->version) { 59 case 1: 60 zdev->max_bus_speed = PCIE_SPEED_5_0GT; 61 break; 62 default: 63 zdev->max_bus_speed = PCI_SPEED_UNKNOWN; 64 break; 65 } 66 } 67 68 static int clp_query_pci_fngrp(struct zpci_dev *zdev, u8 pfgid) 69 { 70 struct clp_req_rsp_query_pci_grp *rrb; 71 int rc; 72 73 rrb = clp_alloc_block(GFP_KERNEL); 74 if (!rrb) 75 return -ENOMEM; 76 77 memset(rrb, 0, sizeof(*rrb)); 78 rrb->request.hdr.len = sizeof(rrb->request); 79 rrb->request.hdr.cmd = CLP_QUERY_PCI_FNGRP; 80 rrb->response.hdr.len = sizeof(rrb->response); 81 rrb->request.pfgid = pfgid; 82 83 rc = clp_instr(rrb); 84 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK) 85 clp_store_query_pci_fngrp(zdev, &rrb->response); 86 else { 87 pr_err("Query PCI FNGRP failed with response: %x cc: %d\n", 88 rrb->response.hdr.rsp, rc); 89 rc = -EIO; 90 } 91 clp_free_block(rrb); 92 return rc; 93 } 94 95 static int clp_store_query_pci_fn(struct zpci_dev *zdev, 96 struct clp_rsp_query_pci *response) 97 { 98 int i; 99 100 for (i = 0; i < PCI_BAR_COUNT; i++) { 101 zdev->bars[i].val = le32_to_cpu(response->bar[i]); 102 zdev->bars[i].size = response->bar_size[i]; 103 } 104 zdev->start_dma = response->sdma; 105 zdev->end_dma = response->edma; 106 zdev->pchid = response->pchid; 107 zdev->pfgid = response->pfgid; 108 return 0; 109 } 110 111 static int clp_query_pci_fn(struct zpci_dev *zdev, u32 fh) 112 { 113 struct clp_req_rsp_query_pci *rrb; 114 int rc; 115 116 rrb = clp_alloc_block(GFP_KERNEL); 117 if (!rrb) 118 return -ENOMEM; 119 120 memset(rrb, 0, sizeof(*rrb)); 121 rrb->request.hdr.len = sizeof(rrb->request); 122 rrb->request.hdr.cmd = CLP_QUERY_PCI_FN; 123 rrb->response.hdr.len = sizeof(rrb->response); 124 rrb->request.fh = fh; 125 126 rc = clp_instr(rrb); 127 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK) { 128 rc = clp_store_query_pci_fn(zdev, &rrb->response); 129 if (rc) 130 goto out; 131 if (rrb->response.pfgid) 132 rc = clp_query_pci_fngrp(zdev, rrb->response.pfgid); 133 } else { 134 pr_err("Query PCI failed with response: %x cc: %d\n", 135 rrb->response.hdr.rsp, rc); 136 rc = -EIO; 137 } 138 out: 139 clp_free_block(rrb); 140 return rc; 141 } 142 143 int clp_add_pci_device(u32 fid, u32 fh, int configured) 144 { 145 struct zpci_dev *zdev; 146 int rc; 147 148 zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid, fh, configured); 149 zdev = zpci_alloc_device(); 150 if (IS_ERR(zdev)) 151 return PTR_ERR(zdev); 152 153 zdev->fh = fh; 154 zdev->fid = fid; 155 156 /* Query function properties and update zdev */ 157 rc = clp_query_pci_fn(zdev, fh); 158 if (rc) 159 goto error; 160 161 if (configured) 162 zdev->state = ZPCI_FN_STATE_CONFIGURED; 163 else 164 zdev->state = ZPCI_FN_STATE_STANDBY; 165 166 rc = zpci_create_device(zdev); 167 if (rc) 168 goto error; 169 return 0; 170 171 error: 172 zpci_free_device(zdev); 173 return rc; 174 } 175 176 /* 177 * Enable/Disable a given PCI function defined by its function handle. 178 */ 179 static int clp_set_pci_fn(u32 *fh, u8 nr_dma_as, u8 command) 180 { 181 struct clp_req_rsp_set_pci *rrb; 182 int rc, retries = 100; 183 184 rrb = clp_alloc_block(GFP_KERNEL); 185 if (!rrb) 186 return -ENOMEM; 187 188 do { 189 memset(rrb, 0, sizeof(*rrb)); 190 rrb->request.hdr.len = sizeof(rrb->request); 191 rrb->request.hdr.cmd = CLP_SET_PCI_FN; 192 rrb->response.hdr.len = sizeof(rrb->response); 193 rrb->request.fh = *fh; 194 rrb->request.oc = command; 195 rrb->request.ndas = nr_dma_as; 196 197 rc = clp_instr(rrb); 198 if (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY) { 199 retries--; 200 if (retries < 0) 201 break; 202 msleep(20); 203 } 204 } while (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY); 205 206 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK) 207 *fh = rrb->response.fh; 208 else { 209 zpci_dbg(0, "SPF fh:%x, cc:%d, resp:%x\n", *fh, rc, 210 rrb->response.hdr.rsp); 211 rc = -EIO; 212 } 213 clp_free_block(rrb); 214 return rc; 215 } 216 217 int clp_enable_fh(struct zpci_dev *zdev, u8 nr_dma_as) 218 { 219 u32 fh = zdev->fh; 220 int rc; 221 222 rc = clp_set_pci_fn(&fh, nr_dma_as, CLP_SET_ENABLE_PCI_FN); 223 if (!rc) 224 /* Success -> store enabled handle in zdev */ 225 zdev->fh = fh; 226 227 zpci_dbg(3, "ena fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc); 228 return rc; 229 } 230 231 int clp_disable_fh(struct zpci_dev *zdev) 232 { 233 u32 fh = zdev->fh; 234 int rc; 235 236 if (!zdev_enabled(zdev)) 237 return 0; 238 239 rc = clp_set_pci_fn(&fh, 0, CLP_SET_DISABLE_PCI_FN); 240 if (!rc) 241 /* Success -> store disabled handle in zdev */ 242 zdev->fh = fh; 243 244 zpci_dbg(3, "dis fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc); 245 return rc; 246 } 247 248 static int clp_list_pci(struct clp_req_rsp_list_pci *rrb, 249 void (*cb)(struct clp_fh_list_entry *entry)) 250 { 251 u64 resume_token = 0; 252 int entries, i, rc; 253 254 do { 255 memset(rrb, 0, sizeof(*rrb)); 256 rrb->request.hdr.len = sizeof(rrb->request); 257 rrb->request.hdr.cmd = CLP_LIST_PCI; 258 /* store as many entries as possible */ 259 rrb->response.hdr.len = CLP_BLK_SIZE - LIST_PCI_HDR_LEN; 260 rrb->request.resume_token = resume_token; 261 262 /* Get PCI function handle list */ 263 rc = clp_instr(rrb); 264 if (rc || rrb->response.hdr.rsp != CLP_RC_OK) { 265 pr_err("List PCI failed with response: 0x%x cc: %d\n", 266 rrb->response.hdr.rsp, rc); 267 rc = -EIO; 268 goto out; 269 } 270 271 WARN_ON_ONCE(rrb->response.entry_size != 272 sizeof(struct clp_fh_list_entry)); 273 274 entries = (rrb->response.hdr.len - LIST_PCI_HDR_LEN) / 275 rrb->response.entry_size; 276 pr_info("Detected number of PCI functions: %u\n", entries); 277 278 /* Store the returned resume token as input for the next call */ 279 resume_token = rrb->response.resume_token; 280 281 for (i = 0; i < entries; i++) 282 cb(&rrb->response.fh_list[i]); 283 } while (resume_token); 284 285 pr_debug("Maximum number of supported PCI functions: %u\n", 286 rrb->response.max_fn); 287 out: 288 return rc; 289 } 290 291 static void __clp_add(struct clp_fh_list_entry *entry) 292 { 293 if (!entry->vendor_id) 294 return; 295 296 clp_add_pci_device(entry->fid, entry->fh, entry->config_state); 297 } 298 299 static void __clp_rescan(struct clp_fh_list_entry *entry) 300 { 301 struct zpci_dev *zdev; 302 303 if (!entry->vendor_id) 304 return; 305 306 zdev = get_zdev_by_fid(entry->fid); 307 if (!zdev) { 308 clp_add_pci_device(entry->fid, entry->fh, entry->config_state); 309 return; 310 } 311 312 if (!entry->config_state) { 313 /* 314 * The handle is already disabled, that means no iota/irq freeing via 315 * the firmware interfaces anymore. Need to free resources manually 316 * (DMA memory, debug, sysfs)... 317 */ 318 zpci_stop_device(zdev); 319 } 320 } 321 322 static void __clp_update(struct clp_fh_list_entry *entry) 323 { 324 struct zpci_dev *zdev; 325 326 if (!entry->vendor_id) 327 return; 328 329 zdev = get_zdev_by_fid(entry->fid); 330 if (!zdev) 331 return; 332 333 zdev->fh = entry->fh; 334 } 335 336 int clp_scan_pci_devices(void) 337 { 338 struct clp_req_rsp_list_pci *rrb; 339 int rc; 340 341 rrb = clp_alloc_block(GFP_KERNEL); 342 if (!rrb) 343 return -ENOMEM; 344 345 rc = clp_list_pci(rrb, __clp_add); 346 347 clp_free_block(rrb); 348 return rc; 349 } 350 351 int clp_rescan_pci_devices(void) 352 { 353 struct clp_req_rsp_list_pci *rrb; 354 int rc; 355 356 rrb = clp_alloc_block(GFP_KERNEL); 357 if (!rrb) 358 return -ENOMEM; 359 360 rc = clp_list_pci(rrb, __clp_rescan); 361 362 clp_free_block(rrb); 363 return rc; 364 } 365 366 int clp_rescan_pci_devices_simple(void) 367 { 368 struct clp_req_rsp_list_pci *rrb; 369 int rc; 370 371 rrb = clp_alloc_block(GFP_NOWAIT); 372 if (!rrb) 373 return -ENOMEM; 374 375 rc = clp_list_pci(rrb, __clp_update); 376 377 clp_free_block(rrb); 378 return rc; 379 } 380