Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
msi.c
Go to the documentation of this file.
1 /*
2  * Copyright 2006 Jake Moilanen <[email protected]>, IBM Corp.
3  * Copyright 2006-2007 Michael Ellerman, IBM Corp.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; version 2 of the
8  * License.
9  *
10  */
11 
12 #include <linux/device.h>
13 #include <linux/irq.h>
14 #include <linux/msi.h>
15 
16 #include <asm/rtas.h>
17 #include <asm/hw_irq.h>
18 #include <asm/ppc-pci.h>
19 
20 static int query_token, change_token;
21 
22 #define RTAS_QUERY_FN 0
23 #define RTAS_CHANGE_FN 1
24 #define RTAS_RESET_FN 2
25 #define RTAS_CHANGE_MSI_FN 3
26 #define RTAS_CHANGE_MSIX_FN 4
27 
28 static struct pci_dn *get_pdn(struct pci_dev *pdev)
29 {
30  struct device_node *dn;
31  struct pci_dn *pdn;
32 
33  dn = pci_device_to_OF_node(pdev);
34  if (!dn) {
35  dev_dbg(&pdev->dev, "rtas_msi: No OF device node\n");
36  return NULL;
37  }
38 
39  pdn = PCI_DN(dn);
40  if (!pdn) {
41  dev_dbg(&pdev->dev, "rtas_msi: No PCI DN\n");
42  return NULL;
43  }
44 
45  return pdn;
46 }
47 
48 /* RTAS Helpers */
49 
50 static int rtas_change_msi(struct pci_dn *pdn, u32 func, u32 num_irqs)
51 {
52  u32 addr, seq_num, rtas_ret[3];
53  unsigned long buid;
54  int rc;
55 
56  addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
57  buid = pdn->phb->buid;
58 
59  seq_num = 1;
60  do {
61  if (func == RTAS_CHANGE_MSI_FN || func == RTAS_CHANGE_MSIX_FN)
62  rc = rtas_call(change_token, 6, 4, rtas_ret, addr,
63  BUID_HI(buid), BUID_LO(buid),
64  func, num_irqs, seq_num);
65  else
66  rc = rtas_call(change_token, 6, 3, rtas_ret, addr,
67  BUID_HI(buid), BUID_LO(buid),
68  func, num_irqs, seq_num);
69 
70  seq_num = rtas_ret[1];
71  } while (rtas_busy_delay(rc));
72 
73  /*
74  * If the RTAS call succeeded, return the number of irqs allocated.
75  * If not, make sure we return a negative error code.
76  */
77  if (rc == 0)
78  rc = rtas_ret[0];
79  else if (rc > 0)
80  rc = -rc;
81 
82  pr_debug("rtas_msi: ibm,change_msi(func=%d,num=%d), got %d rc = %d\n",
83  func, num_irqs, rtas_ret[0], rc);
84 
85  return rc;
86 }
87 
88 static void rtas_disable_msi(struct pci_dev *pdev)
89 {
90  struct pci_dn *pdn;
91 
92  pdn = get_pdn(pdev);
93  if (!pdn)
94  return;
95 
96  /*
97  * disabling MSI with the explicit interface also disables MSI-X
98  */
99  if (rtas_change_msi(pdn, RTAS_CHANGE_MSI_FN, 0) != 0) {
100  /*
101  * may have failed because explicit interface is not
102  * present
103  */
104  if (rtas_change_msi(pdn, RTAS_CHANGE_FN, 0) != 0) {
105  pr_debug("rtas_msi: Setting MSIs to 0 failed!\n");
106  }
107  }
108 }
109 
110 static int rtas_query_irq_number(struct pci_dn *pdn, int offset)
111 {
112  u32 addr, rtas_ret[2];
113  unsigned long buid;
114  int rc;
115 
116  addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
117  buid = pdn->phb->buid;
118 
119  do {
120  rc = rtas_call(query_token, 4, 3, rtas_ret, addr,
121  BUID_HI(buid), BUID_LO(buid), offset);
122  } while (rtas_busy_delay(rc));
123 
124  if (rc) {
125  pr_debug("rtas_msi: error (%d) querying source number\n", rc);
126  return rc;
127  }
128 
129  return rtas_ret[0];
130 }
131 
132 static void rtas_teardown_msi_irqs(struct pci_dev *pdev)
133 {
134  struct msi_desc *entry;
135 
136  list_for_each_entry(entry, &pdev->msi_list, list) {
137  if (entry->irq == NO_IRQ)
138  continue;
139 
140  irq_set_msi_desc(entry->irq, NULL);
141  irq_dispose_mapping(entry->irq);
142  }
143 
144  rtas_disable_msi(pdev);
145 }
146 
147 static int check_req(struct pci_dev *pdev, int nvec, char *prop_name)
148 {
149  struct device_node *dn;
150  struct pci_dn *pdn;
151  const u32 *req_msi;
152 
153  pdn = get_pdn(pdev);
154  if (!pdn)
155  return -ENODEV;
156 
157  dn = pdn->node;
158 
159  req_msi = of_get_property(dn, prop_name, NULL);
160  if (!req_msi) {
161  pr_debug("rtas_msi: No %s on %s\n", prop_name, dn->full_name);
162  return -ENOENT;
163  }
164 
165  if (*req_msi < nvec) {
166  pr_debug("rtas_msi: %s requests < %d MSIs\n", prop_name, nvec);
167 
168  if (*req_msi == 0) /* Be paranoid */
169  return -ENOSPC;
170 
171  return *req_msi;
172  }
173 
174  return 0;
175 }
176 
177 static int check_req_msi(struct pci_dev *pdev, int nvec)
178 {
179  return check_req(pdev, nvec, "ibm,req#msi");
180 }
181 
182 static int check_req_msix(struct pci_dev *pdev, int nvec)
183 {
184  return check_req(pdev, nvec, "ibm,req#msi-x");
185 }
186 
187 /* Quota calculation */
188 
189 static struct device_node *find_pe_total_msi(struct pci_dev *dev, int *total)
190 {
191  struct device_node *dn;
192  const u32 *p;
193 
194  dn = of_node_get(pci_device_to_OF_node(dev));
195  while (dn) {
196  p = of_get_property(dn, "ibm,pe-total-#msi", NULL);
197  if (p) {
198  pr_debug("rtas_msi: found prop on dn %s\n",
199  dn->full_name);
200  *total = *p;
201  return dn;
202  }
203 
204  dn = of_get_next_parent(dn);
205  }
206 
207  return NULL;
208 }
209 
210 static struct device_node *find_pe_dn(struct pci_dev *dev, int *total)
211 {
212  struct device_node *dn;
213  struct eeh_dev *edev;
214 
215  /* Found our PE and assume 8 at that point. */
216 
217  dn = pci_device_to_OF_node(dev);
218  if (!dn)
219  return NULL;
220 
221  /* Get the top level device in the PE */
222  edev = of_node_to_eeh_dev(dn);
223  if (edev->pe)
224  edev = list_first_entry(&edev->pe->edevs, struct eeh_dev, list);
225  dn = eeh_dev_to_of_node(edev);
226  if (!dn)
227  return NULL;
228 
229  /* We actually want the parent */
230  dn = of_get_parent(dn);
231  if (!dn)
232  return NULL;
233 
234  /* Hardcode of 8 for old firmwares */
235  *total = 8;
236  pr_debug("rtas_msi: using PE dn %s\n", dn->full_name);
237 
238  return dn;
239 }
240 
241 struct msi_counts {
244  int request;
245  int quota;
246  int spare;
248 };
249 
250 static void *count_non_bridge_devices(struct device_node *dn, void *data)
251 {
252  struct msi_counts *counts = data;
253  const u32 *p;
254  u32 class;
255 
256  pr_debug("rtas_msi: counting %s\n", dn->full_name);
257 
258  p = of_get_property(dn, "class-code", NULL);
259  class = p ? *p : 0;
260 
261  if ((class >> 8) != PCI_CLASS_BRIDGE_PCI)
262  counts->num_devices++;
263 
264  return NULL;
265 }
266 
267 static void *count_spare_msis(struct device_node *dn, void *data)
268 {
269  struct msi_counts *counts = data;
270  const u32 *p;
271  int req;
272 
273  if (dn == counts->requestor)
274  req = counts->request;
275  else {
276  /* We don't know if a driver will try to use MSI or MSI-X,
277  * so we just have to punt and use the larger of the two. */
278  req = 0;
279  p = of_get_property(dn, "ibm,req#msi", NULL);
280  if (p)
281  req = *p;
282 
283  p = of_get_property(dn, "ibm,req#msi-x", NULL);
284  if (p)
285  req = max(req, (int)*p);
286  }
287 
288  if (req < counts->quota)
289  counts->spare += counts->quota - req;
290  else if (req > counts->quota)
291  counts->over_quota++;
292 
293  return NULL;
294 }
295 
296 static int msi_quota_for_device(struct pci_dev *dev, int request)
297 {
298  struct device_node *pe_dn;
299  struct msi_counts counts;
300  int total;
301 
302  pr_debug("rtas_msi: calc quota for %s, request %d\n", pci_name(dev),
303  request);
304 
305  pe_dn = find_pe_total_msi(dev, &total);
306  if (!pe_dn)
307  pe_dn = find_pe_dn(dev, &total);
308 
309  if (!pe_dn) {
310  pr_err("rtas_msi: couldn't find PE for %s\n", pci_name(dev));
311  goto out;
312  }
313 
314  pr_debug("rtas_msi: found PE %s\n", pe_dn->full_name);
315 
316  memset(&counts, 0, sizeof(struct msi_counts));
317 
318  /* Work out how many devices we have below this PE */
319  traverse_pci_devices(pe_dn, count_non_bridge_devices, &counts);
320 
321  if (counts.num_devices == 0) {
322  pr_err("rtas_msi: found 0 devices under PE for %s\n",
323  pci_name(dev));
324  goto out;
325  }
326 
327  counts.quota = total / counts.num_devices;
328  if (request <= counts.quota)
329  goto out;
330 
331  /* else, we have some more calculating to do */
332  counts.requestor = pci_device_to_OF_node(dev);
333  counts.request = request;
334  traverse_pci_devices(pe_dn, count_spare_msis, &counts);
335 
336  /* If the quota isn't an integer multiple of the total, we can
337  * use the remainder as spare MSIs for anyone that wants them. */
338  counts.spare += total % counts.num_devices;
339 
340  /* Divide any spare by the number of over-quota requestors */
341  if (counts.over_quota)
342  counts.quota += counts.spare / counts.over_quota;
343 
344  /* And finally clamp the request to the possibly adjusted quota */
345  request = min(counts.quota, request);
346 
347  pr_debug("rtas_msi: request clamped to quota %d\n", request);
348 out:
349  of_node_put(pe_dn);
350 
351  return request;
352 }
353 
354 static int rtas_msi_check_device(struct pci_dev *pdev, int nvec, int type)
355 {
356  int quota, rc;
357 
358  if (type == PCI_CAP_ID_MSIX)
359  rc = check_req_msix(pdev, nvec);
360  else
361  rc = check_req_msi(pdev, nvec);
362 
363  if (rc)
364  return rc;
365 
366  quota = msi_quota_for_device(pdev, nvec);
367 
368  if (quota && quota < nvec)
369  return quota;
370 
371  return 0;
372 }
373 
374 static int check_msix_entries(struct pci_dev *pdev)
375 {
376  struct msi_desc *entry;
377  int expected;
378 
379  /* There's no way for us to express to firmware that we want
380  * a discontiguous, or non-zero based, range of MSI-X entries.
381  * So we must reject such requests. */
382 
383  expected = 0;
384  list_for_each_entry(entry, &pdev->msi_list, list) {
385  if (entry->msi_attrib.entry_nr != expected) {
386  pr_debug("rtas_msi: bad MSI-X entries.\n");
387  return -EINVAL;
388  }
389  expected++;
390  }
391 
392  return 0;
393 }
394 
395 static int rtas_setup_msi_irqs(struct pci_dev *pdev, int nvec_in, int type)
396 {
397  struct pci_dn *pdn;
398  int hwirq, virq, i, rc;
399  struct msi_desc *entry;
400  struct msi_msg msg;
401  int nvec = nvec_in;
402 
403  pdn = get_pdn(pdev);
404  if (!pdn)
405  return -ENODEV;
406 
407  if (type == PCI_CAP_ID_MSIX && check_msix_entries(pdev))
408  return -EINVAL;
409 
410  /*
411  * Firmware currently refuse any non power of two allocation
412  * so we round up if the quota will allow it.
413  */
414  if (type == PCI_CAP_ID_MSIX) {
415  int m = roundup_pow_of_two(nvec);
416  int quota = msi_quota_for_device(pdev, m);
417 
418  if (quota >= m)
419  nvec = m;
420  }
421 
422  /*
423  * Try the new more explicit firmware interface, if that fails fall
424  * back to the old interface. The old interface is known to never
425  * return MSI-Xs.
426  */
427 again:
428  if (type == PCI_CAP_ID_MSI) {
429  rc = rtas_change_msi(pdn, RTAS_CHANGE_MSI_FN, nvec);
430 
431  if (rc < 0) {
432  pr_debug("rtas_msi: trying the old firmware call.\n");
433  rc = rtas_change_msi(pdn, RTAS_CHANGE_FN, nvec);
434  }
435  } else
436  rc = rtas_change_msi(pdn, RTAS_CHANGE_MSIX_FN, nvec);
437 
438  if (rc != nvec) {
439  if (nvec != nvec_in) {
440  nvec = nvec_in;
441  goto again;
442  }
443  pr_debug("rtas_msi: rtas_change_msi() failed\n");
444  return rc;
445  }
446 
447  i = 0;
448  list_for_each_entry(entry, &pdev->msi_list, list) {
449  hwirq = rtas_query_irq_number(pdn, i++);
450  if (hwirq < 0) {
451  pr_debug("rtas_msi: error (%d) getting hwirq\n", rc);
452  return hwirq;
453  }
454 
455  virq = irq_create_mapping(NULL, hwirq);
456 
457  if (virq == NO_IRQ) {
458  pr_debug("rtas_msi: Failed mapping hwirq %d\n", hwirq);
459  return -ENOSPC;
460  }
461 
462  dev_dbg(&pdev->dev, "rtas_msi: allocated virq %d\n", virq);
463  irq_set_msi_desc(virq, entry);
464 
465  /* Read config space back so we can restore after reset */
466  read_msi_msg(virq, &msg);
467  entry->msg = msg;
468  }
469 
470  return 0;
471 }
472 
473 static void rtas_msi_pci_irq_fixup(struct pci_dev *pdev)
474 {
475  /* No LSI -> leave MSIs (if any) configured */
476  if (pdev->irq == NO_IRQ) {
477  dev_dbg(&pdev->dev, "rtas_msi: no LSI, nothing to do.\n");
478  return;
479  }
480 
481  /* No MSI -> MSIs can't have been assigned by fw, leave LSI */
482  if (check_req_msi(pdev, 1) && check_req_msix(pdev, 1)) {
483  dev_dbg(&pdev->dev, "rtas_msi: no req#msi/x, nothing to do.\n");
484  return;
485  }
486 
487  dev_dbg(&pdev->dev, "rtas_msi: disabling existing MSI.\n");
488  rtas_disable_msi(pdev);
489 }
490 
491 static int rtas_msi_init(void)
492 {
493  query_token = rtas_token("ibm,query-interrupt-source-number");
494  change_token = rtas_token("ibm,change-msi");
495 
496  if ((query_token == RTAS_UNKNOWN_SERVICE) ||
497  (change_token == RTAS_UNKNOWN_SERVICE)) {
498  pr_debug("rtas_msi: no RTAS tokens, no MSI support.\n");
499  return -1;
500  }
501 
502  pr_debug("rtas_msi: Registering RTAS MSI callbacks.\n");
503 
504  WARN_ON(ppc_md.setup_msi_irqs);
505  ppc_md.setup_msi_irqs = rtas_setup_msi_irqs;
506  ppc_md.teardown_msi_irqs = rtas_teardown_msi_irqs;
507  ppc_md.msi_check_device = rtas_msi_check_device;
508 
509  WARN_ON(ppc_md.pci_irq_fixup);
510  ppc_md.pci_irq_fixup = rtas_msi_pci_irq_fixup;
511 
512  return 0;
513 }
514 arch_initcall(rtas_msi_init);