return 0;}static int pci_pm_save_state(u32 state){	struct list_head *list;	struct pci_bus *bus;	int error = 0;	list_for_each(list, &pci_root_buses) {		bus = pci_bus_b(list);		error = pci_pm_save_state_bus(bus,state);		if (!error)			error = pci_pm_save_state_device(bus->self,state);	}	return error;}static int pci_pm_suspend(u32 state){	struct list_head *list;	struct pci_bus *bus;	list_for_each(list, &pci_root_buses) {		bus = pci_bus_b(list);		pci_pm_suspend_bus(bus,state);		pci_pm_suspend_device(bus->self,state);	}	return 0;}static int pci_pm_resume(void){	struct list_head *list;	struct pci_bus *bus;	list_for_each(list, &pci_root_buses) {		bus = pci_bus_b(list);		pci_pm_resume_device(bus->self);		pci_pm_resume_bus(bus);	}	return 0;}static int pci_pm_callback(struct pm_dev *pm_device, pm_request_t rqst, void *data){	int error = 0;	switch (rqst) {	case PM_SAVE_STATE:		error = pci_pm_save_state((u32)data);		break;	case PM_SUSPEND:		error = pci_pm_suspend((u32)data);		break;	case PM_RESUME:		error = pci_pm_resume();		break;	default: break;	}	return error;}#endif/* * Pool allocator ... wraps the pci_alloc_consistent page allocator, so * small blocks are easily used by drivers for bus mastering controllers. * This should probably be sharing the guts of the slab allocator. */struct pci_pool {	/* the pool */	struct list_head	page_list;	spinlock_t		lock;	size_t			blocks_per_page;	size_t			size;	int			flags;	struct pci_dev		*dev;	size_t			allocation;	char			name [32];	wait_queue_head_t	waitq;};struct pci_page {	/* cacheable header for 'allocation' bytes */	struct list_head	page_list;	void			*vaddr;	dma_addr_t		dma;	unsigned long		bitmap [0];};#define	POOL_TIMEOUT_JIFFIES	((100 /* msec */ * HZ) / 1000)#define	POOL_POISON_BYTE	0xa7// #define CONFIG_PCIPOOL_DEBUG/** * pci_pool_create - Creates a pool of pci consistent memory blocks, for dma. * @name: name of pool, for diagnostics * @pdev: pci device that will be doing the DMA * @size: size of the blocks in this pool. * @align: alignment requirement for blocks; must be a power of two * @allocation: returned blocks won't cross this boundary (or zero) * @flags: SLAB_* flags (not all are supported). * * Returns a pci allocation pool with the requested characteristics, or * null if one can't be created.  Given one of these pools, pci_pool_alloc() * may be used to allocate memory.  Such memory will all have "consistent" * DMA mappings, accessible by the device and its driver without using * cache flushing primitives.  The actual size of blocks allocated may be * larger than requested because of alignment. * * If allocation is nonzero, objects returned from pci_pool_alloc() won't * cross that size boundary.  This is useful for devices which have * addressing restrictions on individual DMA transfers, such as not crossing * boundaries of 4KBytes. */struct pci_pool *pci_pool_create (const char *name, struct pci_dev *pdev,	size_t size, size_t align, size_t allocation, int flags){	struct pci_pool		*retval;	if (align == 0)		align = 1;	if (size == 0)		return 0;	else if (size < align)		size = align;	else if ((size % align) != 0) {		size += align + 1;		size &= ~(align - 1);	}	if (allocation == 0) {		if (PAGE_SIZE < size)			allocation = size;		else			allocation = PAGE_SIZE;		// FIXME: round up for less fragmentation	} else if (allocation < size)		return 0;	if (!(retval = kmalloc (sizeof *retval, flags)))		return retval;#ifdef	CONFIG_PCIPOOL_DEBUG	flags |= SLAB_POISON;#endif	strncpy (retval->name, name, sizeof retval->name);	retval->name [sizeof retval->name - 1] = 0;	retval->dev = pdev;	INIT_LIST_HEAD (&retval->page_list);	spin_lock_init (&retval->lock);	retval->size = size;	retval->flags = flags;	retval->allocation = allocation;	retval->blocks_per_page = allocation / size;	init_waitqueue_head (&retval->waitq);#ifdef CONFIG_PCIPOOL_DEBUG	printk (KERN_DEBUG "pcipool create %s/%s size %d, %d/page (%d alloc)\n",		pdev ? pdev->slot_name : NULL, retval->name, size,		retval->blocks_per_page, allocation);#endif	return retval;}static struct pci_page *pool_alloc_page (struct pci_pool *pool, int mem_flags){	struct pci_page	*page;	int		mapsize;	mapsize = pool->blocks_per_page;	mapsize = (mapsize + BITS_PER_LONG - 1) / BITS_PER_LONG;	mapsize *= sizeof (long);	page = (struct pci_page *) kmalloc (mapsize + sizeof *page, mem_flags);	if (!page)		return 0;	page->vaddr = pci_alloc_consistent (pool->dev,					    pool->allocation,					    &page->dma);	if (page->vaddr) {		memset (page->bitmap, 0xff, mapsize);	// bit set == free		if (pool->flags & SLAB_POISON)			memset (page->vaddr, POOL_POISON_BYTE, pool->allocation);		list_add (&page->page_list, &pool->page_list);	} else {		kfree (page);		page = 0;	}	return page;}static inline intis_page_busy (int blocks, unsigned long *bitmap){	while (blocks > 0) {		if (*bitmap++ != ~0UL)			return 1;		blocks -= BITS_PER_LONG;	}	return 0;}static voidpool_free_page (struct pci_pool *pool, struct pci_page *page){	dma_addr_t	dma = page->dma;	if (pool->flags & SLAB_POISON)		memset (page->vaddr, POOL_POISON_BYTE, pool->allocation);	pci_free_consistent (pool->dev, pool->allocation, page->vaddr, dma);	list_del (&page->page_list);	kfree (page);}/** * pci_pool_destroy - destroys a pool of pci memory blocks. * @pool: pci pool that will be destroyed * * Caller guarantees that no more memory from the pool is in use, * and that nothing will try to use the pool after this call. */voidpci_pool_destroy (struct pci_pool *pool){	unsigned long		flags;#ifdef CONFIG_PCIPOOL_DEBUG	printk (KERN_DEBUG "pcipool destroy %s/%s\n",		pool->dev ? pool->dev->slot_name : NULL,		pool->name);#endif	spin_lock_irqsave (&pool->lock, flags);	while (!list_empty (&pool->page_list)) {		struct pci_page		*page;		page = list_entry (pool->page_list.next,				struct pci_page, page_list);		if (is_page_busy (pool->blocks_per_page, page->bitmap)) {			printk (KERN_ERR "pci_pool_destroy %s/%s, %p busy\n",				pool->dev ? pool->dev->slot_name : NULL,				pool->name, page->vaddr);			/* leak the still-in-use consistent memory */			list_del (&page->page_list);			kfree (page);		} else			pool_free_page (pool, page);	}	spin_unlock_irqrestore (&pool->lock, flags);	kfree (pool);}/** * pci_pool_alloc - get a block of consistent memory * @pool: pci pool that will produce the block * @mem_flags: SLAB_KERNEL or SLAB_ATOMIC * @handle: pointer to dma address of block * * This returns the kernel virtual address of a currently unused block, * and reports its dma address through the handle. * If such a memory block can't be allocated, null is returned. */void *pci_pool_alloc (struct pci_pool *pool, int mem_flags, dma_addr_t *handle){	unsigned long		flags;	struct list_head	*entry;	struct pci_page		*page;	int			map, block;	size_t			offset;	void			*retval;restart:	spin_lock_irqsave (&pool->lock, flags);	list_for_each (entry, &pool->page_list) {		int		i;		page = list_entry (entry, struct pci_page, page_list);		/* only cachable accesses here ... */		for (map = 0, i = 0;				i < pool->blocks_per_page;				i += BITS_PER_LONG, map++) {			if (page->bitmap [map] == 0)				continue;			block = ffz (~ page->bitmap [map]);			if ((i + block) < pool->blocks_per_page) {				clear_bit (block, &page->bitmap [map]);				offset = (BITS_PER_LONG * map) + block;				offset *= pool->size;				goto ready;			}		}	}	if (!(page = pool_alloc_page (pool, mem_flags))) {		if (mem_flags == SLAB_KERNEL) {			DECLARE_WAITQUEUE (wait, current);			current->state = TASK_INTERRUPTIBLE;			add_wait_queue (&pool->waitq, &wait);			spin_unlock_irqrestore (&pool->lock, flags);			schedule_timeout (POOL_TIMEOUT_JIFFIES);			current->state = TASK_RUNNING;			remove_wait_queue (&pool->waitq, &wait);			goto restart;		}		retval = 0;		goto done;	}	clear_bit (0, &page->bitmap [0]);	offset = 0;ready:	retval = offset + page->vaddr;	*handle = offset + page->dma;done:	spin_unlock_irqrestore (&pool->lock, flags);	return retval;}static struct pci_page *pool_find_page (struct pci_pool *pool, dma_addr_t dma){	unsigned long		flags;	struct list_head	*entry;	struct pci_page		*page;	spin_lock_irqsave (&pool->lock, flags);	list_for_each (entry, &pool->page_list) {		page = list_entry (entry, struct pci_page, page_list);		if (dma < page->dma)			continue;		if (dma < (page->dma + pool->allocation))			goto done;	}	page = 0;done:	spin_unlock_irqrestore (&pool->lock, flags);	return page;}/** * pci_pool_free - put block back into pci pool * @pool: the pci pool holding the block * @vaddr: virtual address of block * @dma: dma address of block * * Caller promises neither device nor driver will again touch this block * unless it is first re-allocated. */voidpci_pool_free (struct pci_pool *pool, void *vaddr, dma_addr_t dma){	struct pci_page		*page;	unsigned long		flags;	int			map, block;	if ((page = pool_find_page (pool, dma)) == 0) {		printk (KERN_ERR "pci_pool_free %s/%s, %p/%x (bad dma)\n",			pool->dev ? pool->dev->slot_name : NULL,			pool->name, vaddr, (int) (dma & 0xffffffff));		return;	}#ifdef	CONFIG_PCIPOOL_DEBUG	if (((dma - page->dma) + (void *)page->vaddr) != vaddr) {		printk (KERN_ERR "pci_pool_free %s/%s, %p (bad vaddr)/%x\n",			pool->dev ? pool->dev->slot_name : NULL,			pool->name, vaddr, (int) (dma & 0xffffffff));		return;	}#endif	block = dma - page->dma;	block /= pool->size;	map = block / BITS_PER_LONG;	block %= BITS_PER_LONG;#ifdef	CONFIG_PCIPOOL_DEBUG	if (page->bitmap [map] & (1UL << block)) {		printk (KERN_ERR "pci_pool_free %s/%s, dma %x already free\n",			pool->dev ? pool->dev->slot_name : NULL,			pool->name, dma);		return;	}#endif	if (pool->flags & SLAB_POISON)		memset (vaddr, POOL_POISON_BYTE, pool->size);	spin_lock_irqsave (&pool->lock, flags);	set_bit (block, &page->bitmap [map]);	if (waitqueue_active (&pool->waitq))		wake_up (&pool->waitq);	/*	 * Resist a temptation to do	 *    if (!is_page_busy(bpp, page->bitmap)) pool_free_page(pool, page);	 * it is not interrupt safe. Better have empty pages hang around.	 */	spin_unlock_irqrestore (&pool->lock, flags);}void __devinit  pci_init(void){	struct pci_dev *dev;	pcibios_init();	pci_for_each_dev(dev) {		pci_fixup_device(PCI_FIXUP_FINAL, dev);	}#ifdef CONFIG_PM	pm_register(PM_PCI_DEV, 0, pci_pm_callback);#endif}static int __devinit  pci_setup(char *str){	while (str) {		char *k = strchr(str, ',');		if (k)			*k++ = 0;		if (*str && (str = pcibios_setup(str)) && *str) {			/* PCI layer options should be handled here */			printk(KERN_ERR "PCI: Unknown option `%s'\n", str);		}		str = k;	}	return 1;}__setup("pci=", pci_setup);EXPORT_SYMBOL(pci_read_config_byte);EXPORT_SYMBOL(pci_read_config_word);EXPORT_SYMBOL(pci_read_config_dword);EXPORT_SYMBOL(pci_write_config_byte);EXPORT_SYMBOL(pci_write_config_word);EXPORT_SYMBOL(pci_write_config_dword);EXPORT_SYMBOL(pci_devices);EXPORT_SYMBOL(pci_root_buses);EXPORT_SYMBOL(pci_enable_device);EXPORT_SYMBOL(pci_disable_device);EXPORT_SYMBOL(pci_find_capability);EXPORT_SYMBOL(pci_release_regions);EXPORT_SYMBOL(pci_request_regions);EXPORT_SYMBOL(pci_find_class);EXPORT_SYMBOL(pci_find_device);EXPORT_SYMBOL(pci_find_slot);EXPORT_SYMBOL(pci_find_subsys);EXPORT_SYMBOL(pci_set_master);EXPORT_SYMBOL(pci_set_dma_mask);EXPORT_SYMBOL(pci_dac_set_dma_mask);EXPORT_SYMBOL(pci_assign_resource);EXPORT_SYMBOL(pci_register_driver);EXPORT_SYMBOL(pci_unregister_driver);EXPORT_SYMBOL(pci_dev_driver);EXPORT_SYMBOL(pci_match_device);EXPORT_SYMBOL(pci_find_parent_resource);#ifdef CONFIG_HOTPLUGEXPORT_SYMBOL(pci_setup_device);EXPORT_SYMBOL(pci_insert_device);EXPORT_SYMBOL(pci_remove_device);EXPORT_SYMBOL(pci_announce_device_to_drivers);EXPORT_SYMBOL(pci_add_new_bus);EXPORT_SYMBOL(pci_do_scan_bus);EXPORT_SYMBOL(pci_scan_slot);EXPORT_SYMBOL(pci_proc_attach_device);EXPORT_SYMBOL(pci_proc_detach_device);EXPORT_SYMBOL(pci_proc_attach_bus);EXPORT_SYMBOL(pci_proc_detach_bus);#endifEXPORT_SYMBOL(pci_set_power_state);EXPORT_SYMBOL(pci_save_state);EXPORT_SYMBOL(pci_restore_state);EXPORT_SYMBOL(pci_enable_wake);/* Obsolete functions */EXPORT_SYMBOL(pcibios_present);EXPORT_SYMBOL(pcibios_read_config_byte);EXPORT_SYMBOL(pcibios_read_config_word);EXPORT_SYMBOL(pcibios_read_config_dword);EXPORT_SYMBOL(pcibios_write_config_byte);EXPORT_SYMBOL(pcibios_write_config_word);EXPORT_SYMBOL(pcibios_write_config_dword);EXPORT_SYMBOL(pcibios_find_class);EXPORT_SYMBOL(pcibios_find_device);/* Quirk info */EXPORT_SYMBOL(isa_dma_bridge_buggy);EXPORT_SYMBOL(pci_pci_problems);/* Pool allocator */EXPORT_SYMBOL (pci_pool_create);EXPORT_SYMBOL (pci_pool_destroy);EXPORT_SYMBOL (pci_pool_alloc);EXPORT_SYMBOL (pci_pool_free);