struct my{
	int a;
	int b;
};

struct my *getmy;
getmy = container_of(pb,struct my,b);

#define container_of(ptr, type, member) ({			\
	const typeof( ((type *)0)->member ) *__mptr = (ptr); \
	(type *)( (char *)__mptr - offsetof(type,member) );})

#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
#else
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif

#define list_entry(ptr, type, member) \
	container_of(ptr, type, member)

PCI_DEVICE(vendor, device)
PCI_DEVICE_CLASS(device_class, device_class_mask)
/*分别使用厂家ID，设备ID来和设备类型来表示所支持的硬件*/
/*例子*/
/*drivers/usb/host/ehci-hcd.c:*/
static const struct pci_device_id pci_ids[ ] = { {
	/* handle any USB 2.0 EHCI controller */
	PCI_DEVICE_CLASS(
		((PCI_CLASS_SERIAL_USB << 8) | 0x20), ~0),
	.driver_data = (unsigned long) &ehci_driver,
	},
{ /* end: all zeroes */ }
};
/*drivers/i2c/busses/i2c-i810.c:*/
static struct pci_device_id i810_ids[ ] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL,
 			PCI_DEVICE_ID_INTEL_82810_IG1)
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL,
 			PCI_DEVICE_ID_INTEL_82810_IG3)
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL,
 			PCI_DEVICE_ID_INTEL_82810E_IG)
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL,
 			PCI_DEVICE_ID_INTEL_82815_CGC)
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL,
 			PCI_DEVICE_ID_INTEL_82845G_IG)
	{ 0, },
};

	MODULE_DEVICE_TABLE(pci, i810_ids);

const char *name;
/*驱动程序的名字*/
const struct pci_device_id *id_table;
/*pci_device_id表的指针*/
int (*probe) (struct pci_dev *dev, const struct 	 
			pci_device_id *id);
/*探测函数的指针*/
void (*remove) (struct pci_dev *dev);
/*移除函数的指针*/
int (*suspend) (struct pci_dev *dev, u32 state);
/*挂起函数的指针*/
int (*resume) (struct pci_dev *dev);
/*恢复函数的指针*/
/*例子*/
static struct pci_driver pci_driver = {
	.name = "pci_skel",
	.id_table = ids,
	.probe = probe,
	.remove = remove,
};
/*注册结构*/
static int __init pci_skel_init(void)
{
	return pci_register_driver(&pci_driver);
}
/*拆除*/
static void __exit pci_skel_exit(void)
{
	pci_unregister_driver(&pci_driver);
}

/*查找特定设备：*/
struct pci_dev *pci_get_device(unsigned int vendor, unsigned 
			int device,struct pci_dev *from);
 
/*查找后打开计数器会+1所以必须调用pci_dev_put函数来减少计数器*/
/*例子*/
struct pci_dev *dev;
dev = pci_get_device(PCI_VENDOR_FOO, PCI_DEVICE_FOO, NULL);
if (dev) {
	/* Use the PCI device */
	...
	pci_dev_put(dev);
}
/*查找设备时指定子系统:*/
struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,unsigned int ss_vendor, unsigned int ss_device,struct pci_dev *from);
/*在struct pci_bus 上的系统PCI设备列表中查询指定设备和功能编号：*/
struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);

int pci_enable_device(struct pci_dev *dev);

int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val);
int pci_read_config_word(struct pci_dev *dev, int where, u16 *val);
int pci_read_config_dword(struct pci_dev *dev, int where, u32 *val);
int pci_write_config_byte(struct pci_dev *dev, int where, u8 val);
int pci_write_config_word(struct pci_dev *dev, int where, u16 val);
int pci_write_config_dword(struct pci_dev *dev, int where, u32 val);
int pci_bus_read_config_byte (struct pci_bus *bus, unsigned int devfn, int
where, u8 *val);
int pci_bus_read_config_word (struct pci_bus *bus, unsigned int devfn, int
where, u16 *val);
int pci_bus_read_config_dword (struct pci_bus *bus, unsigned int devfn, int
where, u32 *val);

unsigned long pci_resource_start(struct pci_dev *dev, int bar);
unsigned long pci_resource_end(struct pci_dev *dev, int bar);
unsigned long pci_resource_flags(struct pci_dev *dev, int bar);
/*这些函数分别返回头地址，未地址和标志。*/
/*资源标志存储在<linux/ioport.h>中。其中重要的项目*/
IORESOURCE_IO
IORESOURCE_MEM
<h4>PCI中断</h4>
PCI的中断号能直接在配置寄存器中读取
<pre lang="C">
result = pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &myirq);

#include <asm/page.h>
int order = get_order(16*1024); /*传递的参数必须是2的幂*/
buf = get_free_pages(GFP_KERNEL,order);

u32 cpu_to_le32 (u32);
u32 le32_to_cpu (u32);

#include <asm/unaligned.h>
get_unaligned(ptr);
put_unaligned(val, ptr);

struct {
	u16 id;
	u64 lun;
	u16 reserved1;
	u32 reserved2;
} __attribute__ ((packed)) scsi;

#include <linux/err.h>
void *ERR_PTR(long error);/*错误码到指针类型的错误指针*/
long IS_ERR(const void *ptr);/*判断是否为错误指针*/
long PTR_ERR(const void *ptr);/*错误指针到错误码*/

	struct list_head {
	struct list_head *next, *prev;
};
使用链表：
<pre lang="C">
#include <linux/list.h>
struct todo_struct {
	struct list_head list;
	int priority; /* driver specific */
	/* 其他字段 */
};
/*运行时初始化链表头*/
struct list_head todo_list;
INIT_LIST_HEAD(&todo_list);
/*编译时初始化*/
LIST_HEAD(todo_list);
/*添加删除相关函数*/
list_add(struct list_head *new, struct list_head *head);
/*添加到头部*/
list_add_tail(struct list_head *new, struct list_head *head);
/*添加到尾部*/
list_del(struct list_head *entry);
list_del_init(struct list_head *entry);
/*删除链表项，如果可能插入到其他链表，使用init版本*/
list_move(struct list_head *entry, struct list_head *head);
list_move_tail(struct list_head *entry, struct list_head *head);
/*把给定的链表移动到头部或尾部*/
list_empty(struct list_head *head);
/*如果链表为空返回非零值*/
list_splice(struct list_head *list, struct list_head *head);
/*head之后插入list来合并链表*/

list_entry(struct list_head *ptr, type_of_struct, 				field_name);
/*ptr为链表结构，type_of_struct为包含链表的结构的名称
*field_name为结构中链表字段的名称
*/

list_for_each(struct list_head *cursor, struct list_head 			*list)
/*遍历链表*/
list_for_each_prev(struct list_head *cursor, struct 					list_head *list)
/*向前遍历链表*/
list_for_each_safe(struct list_head *cursor, struct 					list_head *next, struct
				list_head *list)
/*如果在遍历中需要删除链表使用此方法*/
list_for_each_entry(type *cursor, struct list_head *list, 				member)
list_for_each_entry_safe(type *cursor, type *next, struct 			list_head *list,member)
/*遍历并且直接获取包含链表的结构体的指针*/

void todo_add_entry(struct todo_struct *new)
{
	struct list_head *ptr;
	struct todo_struct *entry;
	for (ptr = todo_list.next; ptr != &todo_list; ptr = ptr->next) {
		entry = list_entry(ptr, struct todo_struct, list);
		if (entry->priority < new->priority) {
			list_add_tail(&new->list, ptr);
			return;
		}
	}
	list_add_tail(&new->list, &todo_struct)
}

void todo_add_entry(struct todo_struct *new)
{
	struct list_head *ptr;
	struct todo_struct *entry;
	list_for_each(ptr, &todo_list) {
		entry = list_entry(ptr, struct todo_struct, list);
		if (entry->priority < new->priority) {
			list_add_tail(&new->list, ptr);
			return;
		}
	}
	ist_add_tail(&new->list, &todo_struct)
}

#include <linux/interrupt.h>
int request_irq(unsigned int irq,
		irqreturn_t (*handler)(int, void *,
				 struct pt_regs *),
		unsigned long flags,
		const char *dev_name,
		void *dev_id);
/*函数request_irq函数返回0时表示成功，为负值时表示错误码 返回-EBUSY表示已经有另一个程序占用了中断信号线*/
void free_irq(unsigned int irq, void *dev_id);
int can_request_irq(unsigned int irq, unsigned long flags);
/*can_request_irq用于查询中断线是否可用，注意can_request_irq后request_irq之前可能发生一些事情导致中断线被其他程序占用*/

if (short_irq >= 0) {
	result = request_irq(short_irq, short_interrupt,
				SA_INTERRUPT, "short", NULL);
	if (result) {
		printk(KERN_INFO "short: can't get \
			assigned irq %i\n",short_irq);
		short_irq = -1;
	}else { 
		/* actually enable it -- assume this 
			*is* a parallel port */
		outb(0x10,short_base+2);
	}
}

if (short_irq < 0) /* 未指定信号线根据基地址使用默认值*/
	switch(short_base) {
		case 0x378: short_irq = 7;break;
		case 0x278: short_irq = 2;break;
		case 0x3bc: short_irq = 5;break;
}

#include <linux/interrupt.h>
unsigned long probe_irq_on(void);
/*返回一个未分配中断的掩码，返回值传递给probe_irq_off函数，
此函数执行后驱动程序要安排设备至少产生一次中断*/
int probe_irq_off(unsigned long);
/*请求设备产生中断以后以probe_irq_on的返回值为参数调用。
如果没有中断产生返回0，如果产生了多次中断（产生二义性）返回一个负值。*/

int count = 0;
do {
	unsigned long mask;
	mask = probe_irq_on( );
	outb_p(0x10,short_base+2); /* enable reporting */
	outb_p(0x00,short_base);
	/* clear the bit */
	outb_p(0xFF,short_base);
	/* set the bit: interrupt! */
	outb_p(0x00,short_base+2); /* disable reporting */
	udelay(5); /* give it some time */
	short_irq = probe_irq_off(mask);
	if (short_irq = = 0) { /* none of them? */
	printk(KERN_INFO "short: no irq reported by probe\n");
	short_irq = -1;
	}
	/*
	* if more than one line has been activated, the 
	*result is negative. We should service the interrup
	*(no need for lpt port) and loop over again. Loop 
	*at most five times, then give up
	*/
} while (short_irq < 0 && count++ < 5);
if (short_irq < 0)
	printk("short: probe failed %i times, 
		giving up\n", count);

<pre lang="C">
int trials[ ] = {3, 5, 7, 9, 0};
int tried[ ] = {0, 0, 0, 0, 0};
int i, count = 0;
/*
* install the probing handler for all possible lines.
*Remember the result (0 for success, or -EBUSY) in order
*to only free what has been acquired
*/
for (i = 0; trials[i]; i++)
	tried[i] = request_irq(trials[i], short_probing,
				SA_INTERRUPT, "short probe", NULL);
do {
	short_irq = 0; /* none got, yet */
	outb_p(0x10,short_base+2); /* enable */
	outb_p(0x00,short_base);
	outb_p(0xFF,short_base); /* toggle the bit */
	outb_p(0x00,short_base+2); /* disable */
	udelay(5); /* give it some time */
	/* the value has been set by the handler */
	if (short_irq = = 0) { /* none of them? */
		printk(KERN_INFO "short: no irq reported \
					by probe\n");
	}
	/*
	* If more than one line has been activated, 
	*the result is negative. We should service the
	*interrupt (but the lpt portdoesn't need it) and 
	*loop over again. Do it at most 5 times
	*/
	} while (short_irq <=0 && count++ < 5);
	/* end of loop, uninstall the handler */
	for (i = 0; trials[i]; i++)
		if (tried[i] = = 0)
	free_irq(trials[i], NULL);
	if (short_irq < 0)
		printk("short: probe failed %i times, giving \
				up\n", count);

irqreturn_t short_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct timeval tv;
int written;
do_gettimeofday(&tv);
/* Write a 16 byte record. Assume PAGE_SIZE is a multiple of 16 */
written = sprintf((char *)short_head,"%08u.%06u\n",
	(int)(tv.tv_sec % 100000000), (int)(tv.tv_usec));
BUG_ON(written != 16);
short_incr_bp(&short_head, written);
wake_up_interruptible(&short_queue); 
/* awake any reading process */
return IRQ_HANDLED;
}
static inline void short_incr_bp(volatile unsigned long *index, int delta)
{
	unsigned long new = *index + delta;
	barrier( ); /* Don't optimize these two together */
	*index = (new >= (short_buffer + PAGE_SIZE)) ? 		short_buffer : new;
}

irqreturn_t handler(int irq, void * dev_id,
			struct pt_regs *reg)

static irqreturn_t sample_interrupt(int irq, void *dev_id, 		struct pt_regs *regs)
{
	struct sample_dev *dev = dev_id;
	/* now `dev' points to the right hardware item */
	/* .... */
}
static void sample_open(struct inode *inode, struct file
				*filp)
{
	struct sample_dev *dev = hwinfo + MINOR(inode->i_rdev);
	request_irq(dev->irq, sample_interrupt,
		0 /* flags */, "sample", dev /* dev_id */);
	/*....*/
	return 0;
}
 
<h4>启用和禁用中断</h4>
<h5>禁用单个中断</h5>
<pre lang="C">
void disable_irq(int irq);
void disable_irq_nosync(int irq);/*立即返回*/
void enable_irq(int irq);

void local_irq_save(unsigned long flags);
void local_irq_disable(void);
void local_irq_restore(unsigned long flags);
void local_irq_enable(void);

irqreturn_t short_sh_interrupt(int irq, void *dev_id, 
					struct pt_regs *regs)
{
	int value, written;
	struct timeval tv;
	/* If it wasn't short, return immediately */
	value = inb(short_base);
	if (!(value & 0x80))
		return IRQ_NONE;
	/* clear the interrupting bit */
	outb(value & 0x7F, short_base);
	/* the rest is unchanged */
	do_gettimeofday(&tv);
	written = sprintf((char *)short_head,"%08u.%06u\n",
		(int)(tv.tv_sec % 100000000), (int)(tv.tv_usec));
	short_incr_bp(&short_head, written);
	wake_up_interruptible(&short_queue); 
	/* awake any 	reading process */
	return IRQ_HANDLED;
}