Blame view
drivers/pci/vc.c
12.2 KB
425c1b223 PCI: Add Virtual ... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
/* * PCI Virtual Channel support * * Copyright (C) 2013 Red Hat, Inc. All rights reserved. * Author: Alex Williamson <alex.williamson@redhat.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include <linux/device.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/pci.h> #include <linux/pci_regs.h> #include <linux/types.h> /** * pci_vc_save_restore_dwords - Save or restore a series of dwords * @dev: device * @pos: starting config space position * @buf: buffer to save to or restore from * @dwords: number of dwords to save/restore * @save: whether to save or restore */ static void pci_vc_save_restore_dwords(struct pci_dev *dev, int pos, u32 *buf, int dwords, bool save) { int i; for (i = 0; i < dwords; i++, buf++) { if (save) pci_read_config_dword(dev, pos + (i * 4), buf); else pci_write_config_dword(dev, pos + (i * 4), *buf); } } /** * pci_vc_load_arb_table - load and wait for VC arbitration table * @dev: device * @pos: starting position of VC capability (VC/VC9/MFVC) * * Set Load VC Arbitration Table bit requesting hardware to apply the VC * Arbitration Table (previously loaded). When the VC Arbitration Table * Status clears, hardware has latched the table into VC arbitration logic. */ static void pci_vc_load_arb_table(struct pci_dev *dev, int pos) { u16 ctrl; pci_read_config_word(dev, pos + PCI_VC_PORT_CTRL, &ctrl); pci_write_config_word(dev, pos + PCI_VC_PORT_CTRL, ctrl | PCI_VC_PORT_CTRL_LOAD_TABLE); if (pci_wait_for_pending(dev, pos + PCI_VC_PORT_STATUS, PCI_VC_PORT_STATUS_TABLE)) return; dev_err(&dev->dev, "VC arbitration table failed to load "); } /** * pci_vc_load_port_arb_table - Load and wait for VC port arbitration table * @dev: device * @pos: starting position of VC capability (VC/VC9/MFVC) * @res: VC resource number, ie. VCn (0-7) * * Set Load Port Arbitration Table bit requesting hardware to apply the Port * Arbitration Table (previously loaded). When the Port Arbitration Table * Status clears, hardware has latched the table into port arbitration logic. */ static void pci_vc_load_port_arb_table(struct pci_dev *dev, int pos, int res) { int ctrl_pos, status_pos; u32 ctrl; ctrl_pos = pos + PCI_VC_RES_CTRL + (res * PCI_CAP_VC_PER_VC_SIZEOF); status_pos = pos + PCI_VC_RES_STATUS + (res * PCI_CAP_VC_PER_VC_SIZEOF); pci_read_config_dword(dev, ctrl_pos, &ctrl); pci_write_config_dword(dev, ctrl_pos, ctrl | PCI_VC_RES_CTRL_LOAD_TABLE); if (pci_wait_for_pending(dev, status_pos, PCI_VC_RES_STATUS_TABLE)) return; dev_err(&dev->dev, "VC%d port arbitration table failed to load ", res); } /** * pci_vc_enable - Enable virtual channel * @dev: device * @pos: starting position of VC capability (VC/VC9/MFVC) * @res: VC res number, ie. VCn (0-7) * * A VC is enabled by setting the enable bit in matching resource control * registers on both sides of a link. We therefore need to find the opposite * end of the link. To keep this simple we enable from the downstream device. * RC devices do not have an upstream device, nor does it seem that VC9 do * (spec is unclear). Once we find the upstream device, match the VC ID to * get the correct resource, disable and enable on both ends. */ static void pci_vc_enable(struct pci_dev *dev, int pos, int res) { int ctrl_pos, status_pos, id, pos2, evcc, i, ctrl_pos2, status_pos2; |
274127a1f PCI: Rename PCI_V... |
109 |
u32 ctrl, header, cap1, ctrl2; |
425c1b223 PCI: Add Virtual ... |
110 111 112 |
struct pci_dev *link = NULL; /* Enable VCs from the downstream device */ |
777e61ea4 PCI: Use dev->has... |
113 |
if (!dev->has_secondary_link) |
425c1b223 PCI: Add Virtual ... |
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 |
return; ctrl_pos = pos + PCI_VC_RES_CTRL + (res * PCI_CAP_VC_PER_VC_SIZEOF); status_pos = pos + PCI_VC_RES_STATUS + (res * PCI_CAP_VC_PER_VC_SIZEOF); pci_read_config_dword(dev, ctrl_pos, &ctrl); id = ctrl & PCI_VC_RES_CTRL_ID; pci_read_config_dword(dev, pos, &header); /* If there is no opposite end of the link, skip to enable */ if (PCI_EXT_CAP_ID(header) == PCI_EXT_CAP_ID_VC9 || pci_is_root_bus(dev->bus)) goto enable; pos2 = pci_find_ext_capability(dev->bus->self, PCI_EXT_CAP_ID_VC); if (!pos2) goto enable; |
274127a1f PCI: Rename PCI_V... |
132 133 |
pci_read_config_dword(dev->bus->self, pos2 + PCI_VC_PORT_CAP1, &cap1); evcc = cap1 & PCI_VC_CAP1_EVCC; |
425c1b223 PCI: Add Virtual ... |
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 |
/* VC0 is hardwired enabled, so we can start with 1 */ for (i = 1; i < evcc + 1; i++) { ctrl_pos2 = pos2 + PCI_VC_RES_CTRL + (i * PCI_CAP_VC_PER_VC_SIZEOF); status_pos2 = pos2 + PCI_VC_RES_STATUS + (i * PCI_CAP_VC_PER_VC_SIZEOF); pci_read_config_dword(dev->bus->self, ctrl_pos2, &ctrl2); if ((ctrl2 & PCI_VC_RES_CTRL_ID) == id) { link = dev->bus->self; break; } } if (!link) goto enable; /* Disable if enabled */ if (ctrl2 & PCI_VC_RES_CTRL_ENABLE) { ctrl2 &= ~PCI_VC_RES_CTRL_ENABLE; pci_write_config_dword(link, ctrl_pos2, ctrl2); } /* Enable on both ends */ ctrl2 |= PCI_VC_RES_CTRL_ENABLE; pci_write_config_dword(link, ctrl_pos2, ctrl2); enable: ctrl |= PCI_VC_RES_CTRL_ENABLE; pci_write_config_dword(dev, ctrl_pos, ctrl); if (!pci_wait_for_pending(dev, status_pos, PCI_VC_RES_STATUS_NEGO)) dev_err(&dev->dev, "VC%d negotiation stuck pending ", id); if (link && !pci_wait_for_pending(link, status_pos2, PCI_VC_RES_STATUS_NEGO)) dev_err(&link->dev, "VC%d negotiation stuck pending ", id); } /** * pci_vc_do_save_buffer - Size, save, or restore VC state * @dev: device * @pos: starting position of VC capability (VC/VC9/MFVC) * @save_state: buffer for save/restore * @name: for error message * @save: if provided a buffer, this indicates what to do with it * * Walking Virtual Channel config space to size, save, or restore it * is complicated, so we do it all from one function to reduce code and * guarantee ordering matches in the buffer. When called with NULL * @save_state, return the size of the necessary save buffer. When called * with a non-NULL @save_state, @save determines whether we save to the * buffer or restore from it. */ static int pci_vc_do_save_buffer(struct pci_dev *dev, int pos, struct pci_cap_saved_state *save_state, bool save) { |
274127a1f PCI: Rename PCI_V... |
193 |
u32 cap1; |
425c1b223 PCI: Add Virtual ... |
194 195 196 197 198 199 200 201 202 203 204 205 |
char evcc, lpevcc, parb_size; int i, len = 0; u8 *buf = save_state ? (u8 *)save_state->cap.data : NULL; /* Sanity check buffer size for save/restore */ if (buf && save_state->cap.size != pci_vc_do_save_buffer(dev, pos, NULL, save)) { dev_err(&dev->dev, "VC save buffer size does not match @0x%x ", pos); return -ENOMEM; } |
274127a1f PCI: Rename PCI_V... |
206 |
pci_read_config_dword(dev, pos + PCI_VC_PORT_CAP1, &cap1); |
425c1b223 PCI: Add Virtual ... |
207 |
/* Extended VC Count (not counting VC0) */ |
274127a1f PCI: Rename PCI_V... |
208 |
evcc = cap1 & PCI_VC_CAP1_EVCC; |
425c1b223 PCI: Add Virtual ... |
209 |
/* Low Priority Extended VC Count (not counting VC0) */ |
274127a1f PCI: Rename PCI_V... |
210 |
lpevcc = (cap1 & PCI_VC_CAP1_LPEVCC) >> 4; |
425c1b223 PCI: Add Virtual ... |
211 |
/* Port Arbitration Table Entry Size (bits) */ |
274127a1f PCI: Rename PCI_V... |
212 |
parb_size = 1 << ((cap1 & PCI_VC_CAP1_ARB_SIZE) >> 10); |
425c1b223 PCI: Add Virtual ... |
213 214 215 216 217 218 219 220 221 222 223 224 225 226 |
/* * Port VC Control Register contains VC Arbitration Select, which * cannot be modified when more than one LPVC is in operation. We * therefore save/restore it first, as only VC0 should be enabled * after device reset. */ if (buf) { if (save) pci_read_config_word(dev, pos + PCI_VC_PORT_CTRL, (u16 *)buf); else pci_write_config_word(dev, pos + PCI_VC_PORT_CTRL, *(u16 *)buf); |
ef0dab4aa PCI: Fix unaligne... |
227 |
buf += 4; |
425c1b223 PCI: Add Virtual ... |
228 |
} |
ef0dab4aa PCI: Fix unaligne... |
229 |
len += 4; |
425c1b223 PCI: Add Virtual ... |
230 231 232 233 234 235 |
/* * If we have any Low Priority VCs and a VC Arbitration Table Offset * in Port VC Capability Register 2 then save/restore it next. */ if (lpevcc) { |
274127a1f PCI: Rename PCI_V... |
236 |
u32 cap2; |
425c1b223 PCI: Add Virtual ... |
237 |
int vcarb_offset; |
274127a1f PCI: Rename PCI_V... |
238 239 |
pci_read_config_dword(dev, pos + PCI_VC_PORT_CAP2, &cap2); vcarb_offset = ((cap2 & PCI_VC_CAP2_ARB_OFF) >> 24) * 16; |
425c1b223 PCI: Add Virtual ... |
240 241 242 |
if (vcarb_offset) { int size, vcarb_phases = 0; |
274127a1f PCI: Rename PCI_V... |
243 |
if (cap2 & PCI_VC_CAP2_128_PHASE) |
425c1b223 PCI: Add Virtual ... |
244 |
vcarb_phases = 128; |
274127a1f PCI: Rename PCI_V... |
245 |
else if (cap2 & PCI_VC_CAP2_64_PHASE) |
425c1b223 PCI: Add Virtual ... |
246 |
vcarb_phases = 64; |
274127a1f PCI: Rename PCI_V... |
247 |
else if (cap2 & PCI_VC_CAP2_32_PHASE) |
425c1b223 PCI: Add Virtual ... |
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 |
vcarb_phases = 32; /* Fixed 4 bits per phase per lpevcc (plus VC0) */ size = ((lpevcc + 1) * vcarb_phases * 4) / 8; if (size && buf) { pci_vc_save_restore_dwords(dev, pos + vcarb_offset, (u32 *)buf, size / 4, save); /* * On restore, we need to signal hardware to * re-load the VC Arbitration Table. */ if (!save) pci_vc_load_arb_table(dev, pos); buf += size; } len += size; } } /* * In addition to each VC Resource Control Register, we may have a * Port Arbitration Table attached to each VC. The Port Arbitration * Table Offset in each VC Resource Capability Register tells us if * it exists. The entry size is global from the Port VC Capability * Register1 above. The number of phases is determined per VC. */ for (i = 0; i < evcc + 1; i++) { u32 cap; int parb_offset; pci_read_config_dword(dev, pos + PCI_VC_RES_CAP + (i * PCI_CAP_VC_PER_VC_SIZEOF), &cap); parb_offset = ((cap & PCI_VC_RES_CAP_ARB_OFF) >> 24) * 16; if (parb_offset) { int size, parb_phases = 0; if (cap & PCI_VC_RES_CAP_256_PHASE) parb_phases = 256; else if (cap & (PCI_VC_RES_CAP_128_PHASE | PCI_VC_RES_CAP_128_PHASE_TB)) parb_phases = 128; else if (cap & PCI_VC_RES_CAP_64_PHASE) parb_phases = 64; else if (cap & PCI_VC_RES_CAP_32_PHASE) parb_phases = 32; size = (parb_size * parb_phases) / 8; if (size && buf) { pci_vc_save_restore_dwords(dev, pos + parb_offset, (u32 *)buf, size / 4, save); buf += size; } len += size; } /* VC Resource Control Register */ if (buf) { int ctrl_pos = pos + PCI_VC_RES_CTRL + (i * PCI_CAP_VC_PER_VC_SIZEOF); if (save) pci_read_config_dword(dev, ctrl_pos, (u32 *)buf); else { u32 tmp, ctrl = *(u32 *)buf; /* * For an FLR case, the VC config may remain. * Preserve enable bit, restore the rest. */ pci_read_config_dword(dev, ctrl_pos, &tmp); tmp &= PCI_VC_RES_CTRL_ENABLE; tmp |= ctrl & ~PCI_VC_RES_CTRL_ENABLE; pci_write_config_dword(dev, ctrl_pos, tmp); /* Load port arbitration table if used */ if (ctrl & PCI_VC_RES_CTRL_ARB_SELECT) pci_vc_load_port_arb_table(dev, pos, i); /* Re-enable if needed */ if ((ctrl ^ tmp) & PCI_VC_RES_CTRL_ENABLE) pci_vc_enable(dev, pos, i); } buf += 4; } len += 4; } return buf ? 0 : len; } static struct { u16 id; const char *name; } vc_caps[] = { { PCI_EXT_CAP_ID_MFVC, "MFVC" }, { PCI_EXT_CAP_ID_VC, "VC" }, { PCI_EXT_CAP_ID_VC9, "VC9" } }; /** * pci_save_vc_state - Save VC state to pre-allocate save buffer * @dev: device * * For each type of VC capability, VC/VC9/MFVC, find the capability and * save it to the pre-allocated save buffer. */ int pci_save_vc_state(struct pci_dev *dev) { int i; for (i = 0; i < ARRAY_SIZE(vc_caps); i++) { int pos, ret; struct pci_cap_saved_state *save_state; pos = pci_find_ext_capability(dev, vc_caps[i].id); if (!pos) continue; save_state = pci_find_saved_ext_cap(dev, vc_caps[i].id); if (!save_state) { dev_err(&dev->dev, "%s buffer not found in %s ", vc_caps[i].name, __func__); return -ENOMEM; } ret = pci_vc_do_save_buffer(dev, pos, save_state, true); if (ret) { dev_err(&dev->dev, "%s save unsuccessful %s ", vc_caps[i].name, __func__); return ret; } } return 0; } /** * pci_restore_vc_state - Restore VC state from save buffer * @dev: device * * For each type of VC capability, VC/VC9/MFVC, find the capability and * restore it from the previously saved buffer. */ void pci_restore_vc_state(struct pci_dev *dev) { int i; for (i = 0; i < ARRAY_SIZE(vc_caps); i++) { int pos; struct pci_cap_saved_state *save_state; pos = pci_find_ext_capability(dev, vc_caps[i].id); save_state = pci_find_saved_ext_cap(dev, vc_caps[i].id); if (!save_state || !pos) continue; pci_vc_do_save_buffer(dev, pos, save_state, false); } } /** * pci_allocate_vc_save_buffers - Allocate save buffers for VC caps * @dev: device * * For each type of VC capability, VC/VC9/MFVC, find the capability, size * it, and allocate a buffer for save/restore. */ void pci_allocate_vc_save_buffers(struct pci_dev *dev) { int i; for (i = 0; i < ARRAY_SIZE(vc_caps); i++) { int len, pos = pci_find_ext_capability(dev, vc_caps[i].id); if (!pos) continue; len = pci_vc_do_save_buffer(dev, pos, NULL, false); if (pci_add_ext_cap_save_buffer(dev, vc_caps[i].id, len)) dev_err(&dev->dev, "unable to preallocate %s save buffer ", vc_caps[i].name); } } |