1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/pci.h>
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/pm.h>
14#include <linux/string.h>
15#include <linux/slab.h>
16#include <linux/pcieport_if.h>
17
18#include "../pci.h"
19#include "portdrv.h"
20
21
22
23
24
25
26
27
28static void release_pcie_device(struct device *dev)
29{
30 kfree(to_pcie_device(dev));
31}
32
33
34
35
36
37
38
39
40
41static int pcie_port_msix_add_entry(
42 struct msix_entry *entries, int new_entry, int nr_entries)
43{
44 int j;
45
46 for (j = 0; j < nr_entries; j++)
47 if (entries[j].entry == new_entry)
48 return j;
49
50 entries[j].entry = new_entry;
51 return j;
52}
53
54
55
56
57
58
59
60
61
62static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask)
63{
64 struct msix_entry *msix_entries;
65 int idx[PCIE_PORT_DEVICE_MAXSERVICES];
66 int nr_entries, status, pos, i, nvec;
67 u16 reg16;
68 u32 reg32;
69
70 nr_entries = pci_msix_table_size(dev);
71 if (!nr_entries)
72 return -EINVAL;
73 if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
74 nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;
75
76 msix_entries = kzalloc(sizeof(*msix_entries) * nr_entries, GFP_KERNEL);
77 if (!msix_entries)
78 return -ENOMEM;
79
80
81
82
83
84
85
86 for (i = 0; i < nr_entries; i++)
87 msix_entries[i].entry = i;
88
89 status = pci_enable_msix(dev, msix_entries, nr_entries);
90 if (status)
91 goto Exit;
92
93 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
94 idx[i] = -1;
95 status = -EIO;
96 nvec = 0;
97
98 if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
99 int entry;
100
101
102
103
104
105
106
107
108
109
110
111 pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
112 pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, ®16);
113 entry = (reg16 >> 9) & PCIE_PORT_MSI_VECTOR_MASK;
114 if (entry >= nr_entries)
115 goto Error;
116
117 i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
118 if (i == nvec)
119 nvec++;
120
121 idx[PCIE_PORT_SERVICE_PME_SHIFT] = i;
122 idx[PCIE_PORT_SERVICE_HP_SHIFT] = i;
123 }
124
125 if (mask & PCIE_PORT_SERVICE_AER) {
126 int entry;
127
128
129
130
131
132
133
134
135
136
137 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
138 pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, ®32);
139 entry = reg32 >> 27;
140 if (entry >= nr_entries)
141 goto Error;
142
143 i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
144 if (i == nvec)
145 nvec++;
146
147 idx[PCIE_PORT_SERVICE_AER_SHIFT] = i;
148 }
149
150
151
152
153
154
155 if (nvec == nr_entries) {
156 status = 0;
157 } else {
158
159 pci_disable_msix(dev);
160
161
162 status = pci_enable_msix(dev, msix_entries, nvec);
163 if (status)
164 goto Exit;
165 }
166
167 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
168 vectors[i] = idx[i] >= 0 ? msix_entries[idx[i]].vector : -1;
169
170 Exit:
171 kfree(msix_entries);
172 return status;
173
174 Error:
175 pci_disable_msix(dev);
176 goto Exit;
177}
178
179
180
181
182
183
184
185
186
187
188static int assign_interrupt_mode(struct pci_dev *dev, int *vectors, int mask)
189{
190 int irq, interrupt_mode = PCIE_PORT_NO_IRQ;
191 int i;
192
193
194 if (!pcie_port_enable_msix(dev, vectors, mask))
195 return PCIE_PORT_MSIX_MODE;
196
197
198 if (!pci_enable_msi(dev))
199 interrupt_mode = PCIE_PORT_MSI_MODE;
200
201 if (interrupt_mode == PCIE_PORT_NO_IRQ && dev->pin)
202 interrupt_mode = PCIE_PORT_INTx_MODE;
203
204 irq = interrupt_mode != PCIE_PORT_NO_IRQ ? dev->irq : -1;
205 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
206 vectors[i] = irq;
207
208 vectors[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
209
210 return interrupt_mode;
211}
212
213
214
215
216
217
218
219
220
221
222
223static int get_port_device_capability(struct pci_dev *dev)
224{
225 int services = 0, pos;
226 u16 reg16;
227 u32 reg32;
228
229 pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
230 pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, ®16);
231
232 if (reg16 & PORT_TO_SLOT_MASK) {
233 pci_read_config_dword(dev,
234 pos + PCIE_SLOT_CAPABILITIES_REG, ®32);
235 if (reg32 & SLOT_HP_CAPABLE_MASK)
236 services |= PCIE_PORT_SERVICE_HP;
237 }
238
239 if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR))
240 services |= PCIE_PORT_SERVICE_AER;
241
242 if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
243 services |= PCIE_PORT_SERVICE_VC;
244
245 return services;
246}
247
248
249
250
251
252
253
254
255
256static void pcie_device_init(struct pci_dev *parent, struct pcie_device *dev,
257 int service_type, int irq)
258{
259 struct pcie_port_data *port_data = pci_get_drvdata(parent);
260 struct device *device;
261 int port_type = port_data->port_type;
262
263 dev->port = parent;
264 dev->irq = irq;
265 dev->service = service_type;
266
267
268 device = &dev->device;
269 memset(device, 0, sizeof(struct device));
270 device->bus = &pcie_port_bus_type;
271 device->driver = NULL;
272 dev_set_drvdata(device, NULL);
273 device->release = release_pcie_device;
274 dev_set_name(device, "%s:pcie%02x",
275 pci_name(parent), get_descriptor_id(port_type, service_type));
276 device->parent = &parent->dev;
277}
278
279
280
281
282
283
284
285
286static struct pcie_device* alloc_pcie_device(struct pci_dev *parent,
287 int service_type, int irq)
288{
289 struct pcie_device *device;
290
291 device = kzalloc(sizeof(struct pcie_device), GFP_KERNEL);
292 if (!device)
293 return NULL;
294
295 pcie_device_init(parent, device, service_type, irq);
296 return device;
297}
298
299
300
301
302
303int pcie_port_device_probe(struct pci_dev *dev)
304{
305 int pos, type;
306 u16 reg;
307
308 if (!(pos = pci_find_capability(dev, PCI_CAP_ID_EXP)))
309 return -ENODEV;
310
311 pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, ®);
312 type = (reg >> 4) & PORT_TYPE_MASK;
313 if ( type == PCIE_RC_PORT || type == PCIE_SW_UPSTREAM_PORT ||
314 type == PCIE_SW_DOWNSTREAM_PORT )
315 return 0;
316
317 return -ENODEV;
318}
319
320
321
322
323
324
325
326
327int pcie_port_device_register(struct pci_dev *dev)
328{
329 struct pcie_port_data *port_data;
330 int status, capabilities, irq_mode, i, nr_serv;
331 int vectors[PCIE_PORT_DEVICE_MAXSERVICES];
332 u16 reg16;
333
334 port_data = kzalloc(sizeof(*port_data), GFP_KERNEL);
335 if (!port_data)
336 return -ENOMEM;
337 pci_set_drvdata(dev, port_data);
338
339
340 pci_read_config_word(dev,
341 pci_find_capability(dev, PCI_CAP_ID_EXP) +
342 PCIE_CAPABILITIES_REG, ®16);
343 port_data->port_type = (reg16 >> 4) & PORT_TYPE_MASK;
344
345 capabilities = get_port_device_capability(dev);
346
347 if (port_data->port_type == PCIE_RC_PORT)
348 capabilities |= PCIE_PORT_SERVICE_PME;
349
350 irq_mode = assign_interrupt_mode(dev, vectors, capabilities);
351 if (irq_mode == PCIE_PORT_NO_IRQ) {
352
353
354
355
356 if (!(capabilities & PCIE_PORT_SERVICE_VC)) {
357 status = -ENODEV;
358 goto Error;
359 }
360 capabilities = PCIE_PORT_SERVICE_VC;
361 }
362 port_data->port_irq_mode = irq_mode;
363
364 status = pci_enable_device(dev);
365 if (status)
366 goto Error;
367 pci_set_master(dev);
368
369
370 for (i = 0, nr_serv = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
371 struct pcie_device *child;
372 int service = 1 << i;
373
374 if (!(capabilities & service))
375 continue;
376
377 child = alloc_pcie_device(dev, service, vectors[i]);
378 if (!child)
379 continue;
380
381 status = device_register(&child->device);
382 if (status) {
383 kfree(child);
384 continue;
385 }
386
387 get_device(&child->device);
388 nr_serv++;
389 }
390 if (!nr_serv) {
391 pci_disable_device(dev);
392 status = -ENODEV;
393 goto Error;
394 }
395
396 return 0;
397
398 Error:
399 kfree(port_data);
400 return status;
401}
402
403#ifdef CONFIG_PM
404static int suspend_iter(struct device *dev, void *data)
405{
406 struct pcie_port_service_driver *service_driver;
407
408 if ((dev->bus == &pcie_port_bus_type) &&
409 (dev->driver)) {
410 service_driver = to_service_driver(dev->driver);
411 if (service_driver->suspend)
412 service_driver->suspend(to_pcie_device(dev));
413 }
414 return 0;
415}
416
417
418
419
420
421int pcie_port_device_suspend(struct device *dev)
422{
423 return device_for_each_child(dev, NULL, suspend_iter);
424}
425
426static int resume_iter(struct device *dev, void *data)
427{
428 struct pcie_port_service_driver *service_driver;
429
430 if ((dev->bus == &pcie_port_bus_type) &&
431 (dev->driver)) {
432 service_driver = to_service_driver(dev->driver);
433 if (service_driver->resume)
434 service_driver->resume(to_pcie_device(dev));
435 }
436 return 0;
437}
438
439
440
441
442
443int pcie_port_device_resume(struct device *dev)
444{
445 return device_for_each_child(dev, NULL, resume_iter);
446}
447#endif
448
449static int remove_iter(struct device *dev, void *data)
450{
451 if (dev->bus == &pcie_port_bus_type) {
452 put_device(dev);
453 device_unregister(dev);
454 }
455 return 0;
456}
457
458
459
460
461
462
463
464
465void pcie_port_device_remove(struct pci_dev *dev)
466{
467 struct pcie_port_data *port_data = pci_get_drvdata(dev);
468
469 device_for_each_child(&dev->dev, NULL, remove_iter);
470 pci_disable_device(dev);
471
472 switch (port_data->port_irq_mode) {
473 case PCIE_PORT_MSIX_MODE:
474 pci_disable_msix(dev);
475 break;
476 case PCIE_PORT_MSI_MODE:
477 pci_disable_msi(dev);
478 break;
479 }
480
481 kfree(port_data);
482}
483
484
485
486
487
488
489
490
491
492static int pcie_port_probe_service(struct device *dev)
493{
494 struct pcie_device *pciedev;
495 struct pcie_port_service_driver *driver;
496 int status;
497
498 if (!dev || !dev->driver)
499 return -ENODEV;
500
501 driver = to_service_driver(dev->driver);
502 if (!driver || !driver->probe)
503 return -ENODEV;
504
505 pciedev = to_pcie_device(dev);
506 status = driver->probe(pciedev);
507 if (!status) {
508 dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
509 driver->name);
510 get_device(dev);
511 }
512 return status;
513}
514
515
516
517
518
519
520
521
522
523
524static int pcie_port_remove_service(struct device *dev)
525{
526 struct pcie_device *pciedev;
527 struct pcie_port_service_driver *driver;
528
529 if (!dev || !dev->driver)
530 return 0;
531
532 pciedev = to_pcie_device(dev);
533 driver = to_service_driver(dev->driver);
534 if (driver && driver->remove) {
535 dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
536 driver->name);
537 driver->remove(pciedev);
538 put_device(dev);
539 }
540 return 0;
541}
542
543
544
545
546
547
548
549
550
551
552static void pcie_port_shutdown_service(struct device *dev) {}
553
554
555
556
557
558int pcie_port_service_register(struct pcie_port_service_driver *new)
559{
560 new->driver.name = (char *)new->name;
561 new->driver.bus = &pcie_port_bus_type;
562 new->driver.probe = pcie_port_probe_service;
563 new->driver.remove = pcie_port_remove_service;
564 new->driver.shutdown = pcie_port_shutdown_service;
565
566 return driver_register(&new->driver);
567}
568
569
570
571
572
573void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
574{
575 driver_unregister(&drv->driver);
576}
577
578EXPORT_SYMBOL(pcie_port_service_register);
579EXPORT_SYMBOL(pcie_port_service_unregister);
580