source: GPL/branches/uniaud32-2.1.x/lib32/pci.c@ 498

Last change on this file since 498 was 458, checked in by Paul Smedley, 16 years ago

Revert ACPI fixes from changeset 453 due to reported hangs
File size: 34.3 KB
Line 
1/* $Id: pci.c,v 1.1.1.1 2003/07/02 13:57:02 eleph Exp $ */
2/*
3 * OS/2 implementation of Linux PCI functions (using direct port I/O)
4 *
5 * (C) 2000-2002 InnoTek Systemberatung GmbH
6 * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 * Parts based on Linux kernel sources
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the Free
22 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
23 * USA.
24 *
25 */
26
27#include "linux.h"
28#include <linux/init.h>
29#include <linux/poll.h>
30#include <asm/uaccess.h>
31#include <asm/hardirq.h>
32#include <asm/io.h>
33#include <sound/config.h>
34#include <sound/core.h>
35#include <sound/asound.h>
36
37#define LINUX
38#include <ossidc.h>
39#include <stacktoflat.h>
40#include <dbgos2.h>
41#include <osspci.h>
42
43#define MAX_PCI_BUSSES 16
44#define MAX_PCI_DEVICES 16
45
46struct pci_dev pci_devices[MAX_PCI_DEVICES] = {0};
47struct pci_bus pci_busses[MAX_PCI_BUSSES] = {0};
48
49BOOL fSuspended = FALSE;
50extern int nrCardsDetected;
51
52
53#define PCI_CONFIG_ENABLE 0x80000000
54#define PCI_CONFIG_ADDRESS 0xCF8
55#define PCI_CONFIG_DATA 0xCFC
56
57#ifdef ACPI
58APIRET APIENTRY ACPIFindPCIDevice(ULONG Bus, ULONG Dev, ULONG Fun, ULONG *PicIRQ, ULONG *ApicIRQ, ULONG *Hdl, char *Component);
59#endif
60
61//******************************************************************************
62#define CONFIG_CMD(dev, where) \
63 (PCI_CONFIG_ENABLE | (dev->bus->number<<16) | (dev->devfn<<8) | (where & ~3))
64//******************************************************************************
65int pci_read_config_byte(struct pci_dev *dev, int where, u8 *value)
66{
67 outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
68 *value = inb(PCI_CONFIG_DATA + (where&3));
69 return PCIBIOS_SUCCESSFUL;
70}
71//******************************************************************************
72//******************************************************************************
73int pci_read_config_word(struct pci_dev *dev, int where, u16 *value)
74{
75 outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
76 *value = inw(PCI_CONFIG_DATA + (where&2));
77 return PCIBIOS_SUCCESSFUL;
78}
79//******************************************************************************
80//******************************************************************************
81int pci_read_config_dword(struct pci_dev *dev, int where, u32 *value)
82{
83 outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
84 *value = inl(PCI_CONFIG_DATA);
85 return PCIBIOS_SUCCESSFUL;
86}
87//******************************************************************************
88//******************************************************************************
89int pci_write_config_byte(struct pci_dev *dev, int where, u8 value)
90{
91 outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
92 outb(value, PCI_CONFIG_DATA + (where&3));
93 return PCIBIOS_SUCCESSFUL;
94}
95//******************************************************************************
96//******************************************************************************
97int pci_write_config_word(struct pci_dev *dev, int where, u16 value)
98{
99 outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
100 outw(value, PCI_CONFIG_DATA + (where&2));
101 return PCIBIOS_SUCCESSFUL;
102}
103//******************************************************************************
104//******************************************************************************
105int pci_write_config_dword(struct pci_dev *dev, int where, u32 value)
106{
107 outl(CONFIG_CMD(dev,where), PCI_CONFIG_ADDRESS);
108 outl(value, PCI_CONFIG_DATA);
109 return PCIBIOS_SUCCESSFUL;
110}
111//******************************************************************************
112//******************************************************************************
113int pcidev_prepare(struct pci_dev *dev)
114{
115 dprintf(("pcidev_prepare %x not implemented", dev));
116 return 1; //todo: correct return value??
117}
118//******************************************************************************
119//******************************************************************************
120int pcidev_activate(struct pci_dev *dev)
121{
122 dprintf(("pcidev_activate %x not implemented", dev));
123 return 1; //todo: correct return value??
124}
125//******************************************************************************
126//******************************************************************************
127int pcidev_deactivate(struct pci_dev *dev)
128{
129 dprintf(("pcidev_deactivate %x not implemented", dev));
130 return 1; //todo: correct return value??
131}
132
133
134
135//******************************************************************************
136//******************************************************************************
137#ifdef ACPI
138struct SaveIRQForSlot
139{
140 ULONG ulSlotNo;
141 BYTE LowIRQ;
142 BYTE HighIRQ;
143 BYTE Pin;
144};
145extern struct SaveIRQForSlot sISRHigh[];
146extern int SaveIRQCounter;
147#endif
148
149static int pci_query_device(unsigned int vendor, unsigned int device,
150 struct pci_dev near *pcidev, int idx)
151{
152#ifdef ACPI
153 APIRET rc;
154#endif
155 int resNo, addr, found = 0;
156 u32 devNr, busNr, funcNr, detectedId, pciId, cfgaddrreg, temp, temp2;
157#ifdef ACPI
158 ULONG temp1,temp3; //PS++
159#endif
160 u8 headerType;
161
162 pciId = (device << 16) | vendor;
163
164 cfgaddrreg = inl(PCI_CONFIG_ADDRESS);
165 for(busNr=0;busNr<MAX_PCI_BUSSES;busNr++) //BusNumber<255
166 {
167 for(devNr=0;devNr<32;devNr++)
168 {
169 for(funcNr=0;funcNr<8;funcNr++)
170 {
171 headerType = 0;
172 temp = PCI_CONFIG_ENABLE | (busNr<<16) | (devNr<<11) | (funcNr<<8);
173 outl(temp, PCI_CONFIG_ADDRESS);
174 detectedId = inl(PCI_CONFIG_DATA);
175 if( detectedId != 0xffffffff )
176 {
177 outl(temp | (PCI_HEADER_TYPE & ~3), PCI_CONFIG_ADDRESS);
178 headerType = inb(PCI_CONFIG_DATA + (PCI_HEADER_TYPE & 3));
179 }
180 // printk("det: %x (%x), need: %x\n", detectedId, headerType, pciId);
181
182 if( detectedId == pciId &&
183 (headerType & 0x7f) == PCI_HEADER_TYPE_NORMAL )
184 {
185 if( found++ == idx )
186 {
187 memset((void near *)pcidev, 0, sizeof(struct pci_dev));
188
189 pcidev->vendor = vendor;
190 pcidev->device = device;
191 pcidev->bus = &pci_busses[busNr];
192 pcidev->bus->number = busNr;
193 pcidev->devfn = (devNr << 3) | funcNr;
194 pcidev->hdr_type = headerType & 0x7f;
195
196 pcidev->prepare = pcidev_prepare;
197 pcidev->activate = pcidev_activate;
198 pcidev->deactivate = pcidev_deactivate;
199 pcidev->active = 1;
200 pcidev->ro = 0;
201 pcidev->sibling = NULL;
202 pcidev->next = NULL;
203 pcidev->dma_mask = 0xFFFFFFFF;
204
205 // Subsystem ID
206 pci_read_config_word(pcidev, PCI_SUBSYSTEM_VENDOR_ID,
207 &pcidev->subsystem_vendor);
208 pci_read_config_word(pcidev, PCI_SUBSYSTEM_ID,
209 &pcidev->subsystem_device);
210
211 // I/O and MEM
212 resNo = 0;
213 for( addr = PCI_BASE_ADDRESS_0; addr <= PCI_BASE_ADDRESS_5; addr += 4 )
214 {
215 pci_read_config_dword(pcidev, addr, &temp);
216 if( temp != 0 && temp != 0xffffffff )
217 {
218 pci_write_config_dword(pcidev, addr, 0xffffffff);
219 pci_read_config_dword(pcidev, addr, &temp2);
220 pci_write_config_dword(pcidev, addr, temp);
221
222 if( temp & PCI_BASE_ADDRESS_SPACE_IO )
223 {
224 pcidev->resource[resNo].flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
225 pcidev->resource[resNo].start = temp & PCI_BASE_ADDRESS_IO_MASK;
226 pcidev->resource[resNo].end = pcidev->resource[resNo].start +
227 ~(temp2 & PCI_BASE_ADDRESS_IO_MASK) + 1;
228 }
229 else
230 {
231 pcidev->resource[resNo].flags = IORESOURCE_MEM | IORESOURCE_MEM_WRITEABLE;
232 pcidev->resource[resNo].start = temp & PCI_BASE_ADDRESS_MEM_MASK;
233 pcidev->resource[resNo].end = pcidev->resource[resNo].start +
234 ~(temp2 & PCI_BASE_ADDRESS_MEM_MASK) + 1;
235 }
236
237 resNo++;
238
239 }
240 }
241
242 // IRQ and PIN
243 pci_read_config_dword(pcidev, PCI_INTERRUPT_LINE, &temp);
244#ifdef ACPI
245 sISRHigh[SaveIRQCounter].Pin = (temp >> 8) & 0xf;
246 temp2 = temp3 = 0;
247 rc = ACPIFindPCIDevice( (ULONG)busNr, // Bus
248 (ULONG)devNr, // Dev
249 (ULONG)(pcidev->devfn >> 8) & 7, // Function
250 &temp1, // PIC IRQ
251 &temp3, // APIC IRQ
252 NULL, // ACPI handle to finding device
253 "Uniaud32"); // Name for acpi log
254 if (!rc)
255 {
256 // Check APIC IRQ, if we have /SMP /APIC, must be set
257 if (temp1)
258 temp = (temp & (~0xff)) | (temp1 & 0xff);
259 // Check PIC IRQ
260 else if (temp3)
261 temp = (temp & (~0xff)) | (temp3 & 0xff);
262 dprintf(("pci_query_device: IRQs ACPI PIC%d APIC%d", temp1, temp3));
263 sISRHigh[SaveIRQCounter].LowIRQ = temp1;
264 sISRHigh[SaveIRQCounter].HighIRQ = temp3;
265 }
266#endif /* ACPI */
267 if( (u8)temp && (u8)temp != 0xff )
268 {
269 pcidev->irq_resource[0].flags = IORESOURCE_IRQ;
270 pcidev->irq_resource[0].start =
271 pcidev->irq_resource[0].end = temp & 0xffff;
272 pcidev->irq = (u8)temp;
273 }
274
275 return 1;
276 }
277 }
278
279 // don't need to check more, if function 0 not present or single
280 if( funcNr == 0 && !(headerType & 0x80) ) break;
281 }
282 }
283 }
284 outl(cfgaddrreg, PCI_CONFIG_ADDRESS);
285 return 0;
286
287}
288
289//******************************************************************************
290//******************************************************************************
291struct pci_dev *pci_find_device (unsigned int vendor, unsigned int device, struct pci_dev *from)
292{
293 int i, idx;
294
295 if((int)from < 8) {
296 idx = (int)from; // dirty hack
297 // return 0;
298 } else
299 idx = 0;
300
301 for(i=0;i<MAX_PCI_DEVICES;i++)
302 {
303 if(pci_devices[i].devfn == 0)
304 {
305 if( pci_query_device(vendor, device, (struct pci_dev near *)&pci_devices[i], idx) )
306 return &pci_devices[i];
307 else
308 break;
309 }
310 }
311
312 return NULL;
313}
314//******************************************************************************
315//******************************************************************************
316struct resource * __request_region(struct resource *a, unsigned long start,
317 unsigned long n, const char *name)
318{
319 struct resource *resource;
320
321 if(a->flags & IORESOURCE_MEM) {
322 if(RMRequestMem(/*hResMgr,*/ start, n) == FALSE) {
323 printk("RMRequestIO failed for io %x, length %x\n", start, n);
324 return NULL;
325 }
326 }
327 else if(a->flags & IORESOURCE_IO) {
328 if(RMRequestIO(/*hResMgr,*/ start, n) == FALSE) {
329 printk("RMRequestIO failed for io %x, length %x\n", start, n);
330 return NULL;
331 }
332 }
333
334 resource = kmalloc(sizeof(struct resource), GFP_KERNEL);
335 if (resource == NULL)
336 return NULL;
337 resource->name = name;
338 resource->start = start;
339 resource->end = start + n; // - 1;
340 resource->flags = a->flags;
341 resource->parent =
342 resource->child = NULL;
343
344 // insert in list
345 resource->sibling = a->sibling;
346 a->sibling = resource;
347
348 return resource;
349}
350//******************************************************************************
351//******************************************************************************
352void __release_region(struct resource *a,
353 unsigned long start, unsigned long n)
354{
355 struct resource *resource;
356 struct resource **ppres = &a->sibling;
357 unsigned long end = start + n; // - 1;
358
359 while( *ppres )
360 {
361 resource = *ppres;
362
363 if( resource->start == start && resource->end == end )
364 {
365 // remove from list
366 *ppres = resource->sibling;
367 kfree(resource);
368 return;
369 }
370
371 ppres = &resource->sibling;
372 }
373}
374//******************************************************************************
375//******************************************************************************
376int pci_get_flags (struct pci_dev *dev, int n_base)
377{
378 if(n_base >= DEVICE_COUNT_RESOURCE || !dev->resource[n_base].flags) {
379 DebugInt3();
380 return 0;
381 }
382 return dev->resource[n_base].flags;
383}
384//******************************************************************************
385//******************************************************************************
386int pcibios_present(void)
387{
388 printk("pcibios_present -> pretend BIOS present\n");
389 return 1;
390}
391//******************************************************************************
392//******************************************************************************
393struct pci_dev *pci_find_slot (unsigned int bus, unsigned int devfn)
394{
395 printk("pci_find_slot %d %x not implemented!!\n", bus, devfn);
396 DebugInt3();
397 return NULL;
398}
399//******************************************************************************
400//******************************************************************************
401int pci_dma_supported(struct pci_dev *dev, unsigned long mask)
402{
403 printk("pci_dma_supported: return TRUE\n");
404 return 1;
405}
406//******************************************************************************
407//******************************************************************************
408int pci_find_capability(struct pci_dev *dev, int cap)
409{
410 u16 status;
411 u8 pos, id;
412 int ttl = 48;
413
414 pci_read_config_word(dev, PCI_STATUS, &status);
415 if (!(status & PCI_STATUS_CAP_LIST))
416 return 0;
417 pci_read_config_byte(dev, PCI_CAPABILITY_LIST, &pos);
418 while (ttl-- && pos >= 0x40) {
419 pos &= ~3;
420 pci_read_config_byte(dev, pos + PCI_CAP_LIST_ID, &id);
421 if (id == 0xff)
422 break;
423 if (id == cap)
424 return pos;
425 pci_read_config_byte(dev, pos + PCI_CAP_LIST_NEXT, &pos);
426 }
427 return 0;
428}
429//******************************************************************************
430/*
431 * Set power management state of a device. For transitions from state D3
432 * it isn't as straightforward as one could assume since many devices forget
433 * their configuration space during wakeup. Returns old power state.
434 */
435//******************************************************************************
436int pci_set_power_state(struct pci_dev *dev, int new_state)
437{
438 u32 base[5], romaddr;
439 u16 pci_command, pwr_command;
440 u8 pci_latency, pci_cacheline;
441 int i, old_state;
442 int pm = pci_find_capability(dev, PCI_CAP_ID_PM);
443
444 if (!pm)
445 return 0;
446 pci_read_config_word(dev, pm + PCI_PM_CTRL, &pwr_command);
447 old_state = pwr_command & PCI_PM_CTRL_STATE_MASK;
448 if (old_state == new_state)
449 return old_state;
450 if (old_state == 3) {
451 pci_read_config_word(dev, PCI_COMMAND, &pci_command);
452 pci_write_config_word(dev, PCI_COMMAND, pci_command & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
453 for (i = 0; i < 5; i++)
454 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + i*4, &base[i]);
455 pci_read_config_dword(dev, PCI_ROM_ADDRESS, &romaddr);
456 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
457 pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &pci_cacheline);
458 pci_write_config_word(dev, pm + PCI_PM_CTRL, new_state);
459 for (i = 0; i < 5; i++)
460 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + i*4, base[i]);
461 pci_write_config_dword(dev, PCI_ROM_ADDRESS, romaddr);
462 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
463 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cacheline);
464 pci_write_config_byte(dev, PCI_LATENCY_TIMER, pci_latency);
465 pci_write_config_word(dev, PCI_COMMAND, pci_command);
466 } else
467 pci_write_config_word(dev, pm + PCI_PM_CTRL, (pwr_command & ~PCI_PM_CTRL_STATE_MASK) | new_state);
468 return old_state;
469}
470//******************************************************************************
471/*
472 * Initialize device before it's used by a driver. Ask low-level code
473 * to enable I/O and memory. Wake up the device if it was suspended.
474 * Beware, this function can fail.
475 */
476//******************************************************************************
477int pci_enable_device(struct pci_dev *dev)
478{
479 u16 pci_command;
480
481 printk("pci_enable_device %x\n", dev);
482
483 pci_read_config_word(dev, PCI_COMMAND, &pci_command);
484 pci_write_config_word(dev, PCI_COMMAND, pci_command | (PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
485 pci_set_power_state(dev, 0);
486 return 0;
487}
488//******************************************************************************
489//******************************************************************************
490int pci_register_driver(struct pci_driver *driver)
491{
492 int i, j, dev_num;
493 struct pci_dev *pcidev;
494
495 for( i = 0; driver->id_table[i].vendor; i++)
496 {
497 dev_num = 0;
498 while( (pcidev = pci_find_device(driver->id_table[i].vendor,
499 driver->id_table[i].device,
500 (struct pci_dev *)dev_num)) != NULL )
501 {
502 RMInit();
503 if( driver->probe) {
504 printk("found: %x, id: %x idx %i\n",driver->id_table[i].vendor, driver->id_table[i].device, dev_num);
505
506 if(driver->probe(pcidev, &driver->id_table[i]) == 0) {
507 pcidev->pcidriver = (void *)driver;
508 pcidev->current_state = 4;
509
510 // create adapter
511 RMDone((driver->id_table[i].device << 16) | driver->id_table[i].vendor);
512 nrCardsDetected++;
513 }
514 else pcidev->devfn = 0;
515 }
516
517 RMDone(0);
518
519 dev_num++;
520
521 }
522 }
523 if (nrCardsDetected >=1)
524 return 1;
525
526 return 0;
527}
528//******************************************************************************
529//******************************************************************************
530int pci_module_init(struct pci_driver *drv)
531{
532 int res = pci_register_driver(drv);
533 if (res < 0)
534 return res;
535 if (res == 0)
536 return -ENODEV;
537 return 0;
538}
539//******************************************************************************
540//******************************************************************************
541int pci_unregister_driver(struct pci_driver *driver)
542{
543 struct pci_dev *pcidev;
544 int i = 0, j;
545
546 while(driver->id_table[i].vendor)
547 {
548 for(j=0;j<MAX_PCI_DEVICES;j++)
549 {
550 if(pci_devices[j].vendor == driver->id_table[i].vendor &&
551 pci_devices[j].device == driver->id_table[i].device)
552 {
553 if(driver->remove) {
554 driver->remove(&pci_devices[j]);
555 }
556 }
557 }
558 i++;
559 }
560 return 0;
561}
562//******************************************************************************
563//******************************************************************************
564void pci_set_master(struct pci_dev *dev)
565{
566 u16 cmd;
567
568 pci_read_config_word(dev, PCI_COMMAND, &cmd);
569 if (! (cmd & PCI_COMMAND_MASTER)) {
570 dprintf(("pci_set_master %x", dev));
571 cmd |= PCI_COMMAND_MASTER;
572 pci_write_config_word(dev, PCI_COMMAND, cmd);
573 }
574 return;
575}
576//******************************************************************************
577// * Register a device with power management
578//******************************************************************************
579struct pm_dev *pm_register(pm_dev_t type, unsigned long id, pm_callback callback)
580{
581 dprintf(("pm_register STUB"));
582 DebugInt3();
583 return NULL;
584}
585//******************************************************************************
586// * Unregister a device with power management
587//******************************************************************************
588void pm_unregister(struct pm_dev *dev)
589{
590 dprintf(("pm_unregister STUB"));
591}
592//******************************************************************************
593//******************************************************************************
594int __compat_get_order(unsigned long size)
595{
596 int order;
597
598 size = (size-1) >> (PAGE_SHIFT-1);
599 order = -1;
600 do {
601 size >>= 1;
602 order++;
603 } while (size);
604 return order;
605}
606//******************************************************************************
607//******************************************************************************
608void *pci_alloc_consistent(struct pci_dev *hwdev,
609 long size, dma_addr_t *dma_handle)
610{
611 void *ret = NULL;
612 int gfp = GFP_ATOMIC;
613 int order;
614#ifdef DEBUG
615 dprintf(("pci_alloc_consistent %d mask %x", size, (hwdev) ? hwdev->dma_mask : 0));
616#endif
617 if (hwdev == NULL || hwdev->dma_mask != 0xffffffff) {
618 //try not to exhaust low memory (< 16mb) so allocate from the high region first
619 //if that doesn't satisfy the dma mask requirement, then get it from the low
620 //regino anyway
621 if(hwdev->dma_mask > 0x00ffffff) {
622 order = __compat_get_order(size);
623 ret = (void *)__get_free_pages(gfp|GFP_DMAHIGHMEM, order);
624 *dma_handle = virt_to_bus(ret);
625 if(*dma_handle > hwdev->dma_mask) {
626 free_pages((unsigned long)ret, __compat_get_order(size));
627 //be sure and allocate below 16 mb
628 gfp |= GFP_DMA;
629 ret = NULL;
630 }
631 }
632 else { //must always allocate below 16 mb
633 gfp |= GFP_DMA;
634 }
635 }
636 if(ret == NULL) {
637 ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
638 }
639
640 if (ret != NULL) {
641 memset(ret, 0, size);
642 *dma_handle = virt_to_bus(ret);
643 }
644 return ret;
645}
646//******************************************************************************
647//******************************************************************************
648void pci_free_consistent(struct pci_dev *hwdev, long size,
649 void *vaddr, dma_addr_t dma_handle)
650{
651 free_pages((unsigned long)vaddr, __compat_get_order(size));
652}
653//******************************************************************************
654//******************************************************************************
655void pci_set_driver_data (struct pci_dev *dev, void *driver_data)
656{
657 if (dev)
658 dev->driver_data = driver_data;
659}
660//******************************************************************************
661//******************************************************************************
662void *pci_get_driver_data (struct pci_dev *dev)
663{
664 if (dev)
665 return dev->driver_data;
666 return 0;
667}
668//******************************************************************************
669//******************************************************************************
670unsigned long pci_get_dma_mask (struct pci_dev *dev)
671{
672 if (dev)
673 return dev->dma_mask;
674 return 0;
675}
676//******************************************************************************
677//******************************************************************************
678int release_resource(struct resource *newres)
679{
680 return 0;
681}
682
683//******************************************************************************
684//******************************************************************************
685int pci_set_latency_time(struct pci_dev *dev, int latency)
686{
687 pci_write_config_byte(dev, PCI_LATENCY_TIMER, latency);
688 return 0;
689}
690
691//******************************************************************************
692//******************************************************************************
693/**
694 * pci_save_state - save the PCI configuration space of a device before suspending
695 * @dev: - PCI device that we're dealing with
696 * @buffer: - buffer to hold config space context
697 *
698 * @buffer must be large enough to hold the entire PCI 2.2 config space
699 * (>= 64 bytes).
700 */
701int pci_orig_save_state(struct pci_dev *dev, u32 *buffer)
702{
703 int i;
704 if (buffer) {
705 /* XXX: 100% dword access ok here? */
706 for (i = 0; i < 16; i++)
707 pci_read_config_dword(dev, i * 4,&buffer[i]);
708 }
709 return 0;
710}
711
712/**
713 * pci_restore_state - Restore the saved state of a PCI device
714 * @dev: - PCI device that we're dealing with
715 * @buffer: - saved PCI config space
716 *
717 */
718int
719pci_orig_restore_state(struct pci_dev *dev, u32 *buffer)
720{
721 int i;
722
723 if (buffer) {
724 for (i = 0; i < 16; i++)
725 pci_write_config_dword(dev,i * 4, buffer[i]);
726 }
727 /*
728 * otherwise, write the context information we know from bootup.
729 * This works around a problem where warm-booting from Windows
730 * combined with a D3(hot)->D0 transition causes PCI config
731 * header data to be forgotten.
732 */
733 else {
734 for (i = 0; i < 6; i ++)
735 pci_write_config_dword(dev,
736 PCI_BASE_ADDRESS_0 + (i * 4),
737 dev->resource[i].start);
738 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
739 }
740 return 0;
741}
742
743struct saved_config_tbl {
744 struct pci_dev *pci;
745 u32 config[16];
746};
747static struct saved_config_tbl saved_tbl[16];
748
749int pci_save_state(struct pci_dev *pci)
750{
751 int i;
752 /* FIXME: mutex needed for race? */
753 for (i = 0; i < ARRAY_SIZE(saved_tbl); i++) {
754 if (! saved_tbl[i].pci) {
755 saved_tbl[i].pci = pci;
756 pci_orig_save_state(pci, saved_tbl[i].config);
757 return 1;
758 }
759 }
760 printk(KERN_DEBUG "snd: no pci config space found!\n");
761 return 0;
762}
763
764int pci_restore_state(struct pci_dev *pci)
765{
766 int i;
767 /* FIXME: mutex needed for race? */
768 for (i = 0; i < ARRAY_SIZE(saved_tbl); i++) {
769 if (saved_tbl[i].pci == pci) {
770 saved_tbl[i].pci = NULL;
771 pci_orig_restore_state(pci, saved_tbl[i].config);
772 return 0;
773 }
774 }
775 printk(KERN_DEBUG "snd: no saved pci config!\n");
776 return 1;
777}
778
779void pci_disable_device(struct pci_dev *dev)
780{
781 u16 pci_command;
782
783 pci_read_config_word(dev, PCI_COMMAND, &pci_command);
784 if (pci_command & PCI_COMMAND_MASTER) {
785 pci_command &= ~PCI_COMMAND_MASTER;
786 pci_write_config_word(dev, PCI_COMMAND, pci_command);
787 }
788}
789
790int pci_request_region(struct pci_dev *pdev, int bar, char *res_name)
791{
792 int flags;
793
794 if (pci_resource_len(pdev, bar) == 0)
795 return 0;
796 flags = pci_get_flags(pdev, bar);
797 if (flags & IORESOURCE_IO) {
798 if (check_region(pci_resource_start(pdev, bar), pci_resource_len(pdev, bar)))
799 goto err_out;
800 request_region(pci_resource_start(pdev, bar),
801 pci_resource_len(pdev, bar), res_name);
802 }
803 else if (flags & IORESOURCE_MEM) {
804 if (check_mem_region(pci_resource_start(pdev, bar), pci_resource_len(pdev, bar)))
805 goto err_out;
806 request_mem_region(pci_resource_start(pdev, bar),
807 pci_resource_len(pdev, bar), res_name);
808 }
809
810 return 0;
811
812err_out:
813 printk(KERN_WARNING "PCI: Unable to reserve %s region #%d:%lx@%lx for device %s\n",
814 flags & IORESOURCE_IO ? "I/O" : "mem",
815 bar + 1, /* PCI BAR # */
816 pci_resource_len(pdev, bar), pci_resource_start(pdev, bar),
817 res_name);
818 return -EBUSY;
819}
820
821void pci_release_region(struct pci_dev *pdev, int bar)
822{
823 int flags;
824
825 if (pci_resource_len(pdev, bar) == 0)
826 return;
827 flags = pci_get_flags(pdev, bar);
828 if (flags & IORESOURCE_IO) {
829 release_region(pci_resource_start(pdev, bar),
830 pci_resource_len(pdev, bar));
831 }
832 else if (flags & IORESOURCE_MEM) {
833 release_mem_region(pci_resource_start(pdev, bar),
834 pci_resource_len(pdev, bar));
835 }
836}
837
838int pci_request_regions(struct pci_dev *pdev, char *res_name)
839{
840 int i;
841
842 for (i = 0; i < 6; i++)
843 if (pci_request_region(pdev, i, res_name))
844 goto err;
845 return 0;
846 err:
847 while (--i >= 0)
848 pci_release_region(pdev, i);
849 return -EBUSY;
850}
851
852void pci_release_regions(struct pci_dev *pdev)
853{
854 int i;
855 for (i = 0; i < 6; i++)
856 pci_release_region(pdev, i);
857}
858
859const struct pci_device_id * pci_match_device(const struct pci_device_id *ids, struct pci_dev *dev)
860{
861 u16 subsystem_vendor, subsystem_device;
862
863 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &subsystem_vendor);
864 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &subsystem_device);
865
866 while (ids->vendor || ids->subvendor || ids->class_mask) {
867 if ((ids->vendor == PCI_ANY_ID || ids->vendor == dev->vendor) &&
868 (ids->device == PCI_ANY_ID || ids->device == dev->device) &&
869 (ids->subvendor == PCI_ANY_ID || ids->subvendor == subsystem_vendor) &&
870 (ids->subdevice == PCI_ANY_ID || ids->subdevice == subsystem_device) &&
871 !((ids->class ^ dev->_class) & ids->class_mask))
872 return ids;
873 ids++;
874 }
875 return NULL;
876}
877
878int snd_pci_dev_present(const struct pci_device_id *ids)
879{
880 while (ids->vendor || ids->subvendor) {
881 if (pci_find_device(ids->vendor, ids->subvendor, NULL))
882 return 1;
883 ids++;
884 }
885 return 0;
886}
887
888struct pci_driver_mapping {
889 struct pci_dev *dev;
890 struct pci_driver *drv;
891 unsigned long dma_mask;
892 void *driver_data;
893 u32 saved_config[16];
894};
895
896#define PCI_MAX_MAPPINGS 64
897static struct pci_driver_mapping drvmap [PCI_MAX_MAPPINGS] = { { NULL, } , };
898
899
900static struct pci_driver_mapping *get_pci_driver_mapping(struct pci_dev *dev)
901{
902 int i;
903
904 for (i = 0; i < PCI_MAX_MAPPINGS; i++)
905 if (drvmap[i].dev == dev)
906 return &drvmap[i];
907 return NULL;
908}
909
910struct pci_driver *snd_pci_compat_get_pci_driver(struct pci_dev *dev)
911{
912 struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
913 if (map)
914 return map->drv;
915 return NULL;
916}
917#if 0
918void * pci_get_drvdata (struct pci_dev *dev)
919{
920 struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
921 if (map)
922 return map->driver_data;
923 return NULL;
924}
925
926
927void pci_set_drvdata (struct pci_dev *dev, void *driver_data)
928{
929 struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
930 if (map)
931 map->driver_data = driver_data;
932}
933#endif
934
935
936//******************************************************************************
937//******************************************************************************
938OSSRET OSS32_APMResume()
939{
940 int i;
941 struct pci_driver *driver;
942
943 dprintf(("OSS32_APMResume"));
944
945 fSuspended = FALSE;
946
947 for(i=0;i<MAX_PCI_DEVICES;i++)
948 {
949 if(pci_devices[i].devfn)
950 {
951 driver = pci_devices[i].pcidriver;
952 if(driver && driver->resume) {
953 driver->resume(&pci_devices[i]);
954 }
955 }
956 }
957
958 return OSSERR_SUCCESS;
959}
960//******************************************************************************
961//******************************************************************************
962OSSRET OSS32_APMSuspend()
963{
964 int i;
965 struct pci_driver *driver;
966
967 dprintf(("OSS32_APMSuspend"));
968
969 fSuspended = TRUE;
970
971 for(i=0;i<MAX_PCI_DEVICES;i++)
972 {
973 if(pci_devices[i].devfn)
974 {
975 driver = pci_devices[i].pcidriver;
976 if(driver && driver->suspend) {
977 driver->suspend(&pci_devices[i], SNDRV_CTL_POWER_D3cold);
978 }
979 }
980 }
981
982 return OSSERR_SUCCESS;
983}
984
Note: See TracBrowser for help on using the repository browser.