1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
/*
* Linux Plug and Play Support
* Copyright by Adam Belay <ambx1@neo.rr.com>
*
* Reduced and backported for compatibility reasons for 2.2 and
* 2.4 kernels by Jaroslav Kysela <perex@suse.cz>
*
*/
#ifndef _LINUX_PNP_H
#define _LINUX_PNP_H
#ifdef __KERNEL__
#include <linux/isapnp.h>
#include <linux/list.h>
#define PNP_MAX_PORT 8
#define PNP_MAX_MEM 4
#define PNP_MAX_IRQ 2
#define PNP_MAX_DMA 2
#define PNP_MAX_DEVICES 8
#define PNP_ID_LEN 8
#ifndef ISAPNP_ALSA_LOCAL
#define isapnp_dev pci_dev
#define isapnp_card pci_bus
#endif
struct pnp_card {
struct isapnp_card p;
};
struct pnp_dev {
struct isapnp_dev p;
};
/*
* Resource Management
*/
/* Use these instead of directly reading pnp_dev to get resource information */
#define pnp_port_start(dev,bar) ((dev)->p.resource[(bar)].start)
#define pnp_port_end(dev,bar) ((dev)->p.resource[(bar)].end)
#define pnp_port_flags(dev,bar) ((dev)->p.resource[(bar)].flags)
#define pnp_port_valid(dev,bar) (pnp_port_flags((dev),(bar)) & IORESOURCE_IO)
#define pnp_port_len(dev,bar) \
((pnp_port_start((dev),(bar)) == 0 && \
pnp_port_end((dev),(bar)) == \
pnp_port_start((dev),(bar))) ? 0 : \
\
(pnp_port_end((dev),(bar)) - \
pnp_port_start((dev),(bar)) + 1))
#define pnp_mem_start(dev,bar) ((dev)->p.resource[(bar)+8].start)
#define pnp_mem_end(dev,bar) ((dev)->p.resource[(bar)+8].end)
#define pnp_mem_flags(dev,bar) ((dev)->p.resource[(bar)+8].flags)
#define pnp_mem_valid(dev,bar) (pnp_mem_flags((dev),(bar)) & IORESOURCE_MEM)
#define pnp_mem_len(dev,bar) \
((pnp_mem_start((dev),(bar)) == 0 && \
pnp_mem_end((dev),(bar)) == \
pnp_mem_start((dev),(bar))) ? 0 : \
\
(pnp_mem_end((dev),(bar)) - \
pnp_mem_start((dev),(bar)) + 1))
#define pnp_irq(dev,bar) ((dev)->p.irq_resource[(bar)].start)
#define pnp_irq_flags(dev,bar) ((dev)->p.irq_resource[(bar)].flags)
#define pnp_irq_valid(dev,bar) (pnp_irq_flags((dev),(bar)) & IORESOURCE_IRQ)
#define pnp_dma(dev,bar) ((dev)->p.dma_resource[(bar)].start)
#define pnp_dma_flags(dev,bar) ((dev)->p.dma_resource[(bar)].flags)
#define pnp_dma_valid(dev,bar) (pnp_dma_flags((dev),(bar)) & IORESOURCE_DMA)
#define PNP_PORT_FLAG_16BITADDR ISAPNP_PORT_FLAG_16BITADDR
#define PNP_PORT_FLAG_FIXED ISAPNP_PORT_FLAG_FIXED
#define PNP_RES_PRIORITY_PREFERRED ISAPNP_RES_PRIORITY_PREFERRED
#define PNP_RES_PRIORITY_ACCEPTABLE ISAPNP_RES_PRIORITY_ACCEPTABLE
#define PNP_RES_PRIORITY_FUNCTIONAL ISAPNP_RES_PRIORITY_FUNCTIONAL
#define PNP_RES_PRIORITY_INVALID ISAPNP_RES_PRIORITY_INVALID
struct pnp_resource_table {
struct resource port_resource[PNP_MAX_PORT];
struct resource mem_resource[PNP_MAX_MEM];
struct resource dma_resource[PNP_MAX_DMA];
struct resource irq_resource[PNP_MAX_IRQ];
};
/*
* Device Managemnt
*/
struct pnp_card_link {
struct pnp_card * card;
struct pnp_card_driver * driver;
void * driver_data;
};
static inline void *pnp_get_card_drvdata (struct pnp_card_link *pcard)
{
return pcard->driver_data;
}
static inline void pnp_set_card_drvdata (struct pnp_card_link *pcard, void *data)
{
pcard->driver_data = data;
}
struct pnp_fixup {
char id[7];
void (*quirk_function)(struct pnp_dev *dev); /* fixup function */
};
/* config modes */
#define PNP_CONFIG_AUTO 0x0001 /* Use the Resource Configuration Engine to determine resource settings */
#define PNP_CONFIG_MANUAL 0x0002 /* the config has been manually specified */
#define PNP_CONFIG_FORCE 0x0004 /* disables validity checking */
#define PNP_CONFIG_INVALID 0x0008 /* If this flag is set, the pnp layer will refuse to activate the device */
/* capabilities */
#define PNP_READ 0x0001
#define PNP_WRITE 0x0002
#define PNP_DISABLE 0x0004
#define PNP_CONFIGURABLE 0x0008
#define PNP_REMOVABLE 0x0010
#define pnp_can_read(dev) 1
#define pnp_can_write(dev) 1
#define pnp_can_disable(dev) 0
#define pnp_can_configure(dev) 1
#define pnp_device_is_isapnp(dev) 1
#define isapnp_card_number(dev) (dev->p.bus->number)
#define isapnp_csn_number(dev) (dev->p.devfn)
/*
* Driver Management
*/
struct pnp_id {
char id[PNP_ID_LEN];
struct pnp_id * next;
};
struct pnp_device_id {
char id[PNP_ID_LEN];
unsigned long driver_data; /* data private to the driver */
};
struct pnp_card_device_id {
char id[PNP_ID_LEN];
unsigned long driver_data; /* data private to the driver */
struct {
char id[PNP_ID_LEN];
} devs[PNP_MAX_DEVICES]; /* logical devices */
};
struct pnp_driver {
char * name;
const struct pnp_device_id *id_table;
unsigned int flags;
int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id);
void (*remove) (struct pnp_dev *dev);
};
#define to_pnp_driver(drv) container_of(drv, struct pnp_driver, driver)
struct pnp_card_driver {
struct list_head global_list;
char * name;
const struct pnp_card_device_id *id_table;
unsigned int flags;
int (*probe) (struct pnp_card_link *card, const struct pnp_card_device_id *card_id);
void (*remove) (struct pnp_card_link *card);
struct pnp_driver link;
};
#define to_pnp_card_driver(drv) container_of(drv, struct pnp_card_driver, link)
/* pnp driver flags */
#define PNP_DRIVER_RES_DO_NOT_CHANGE 0x0001 /* do not change the state of the device */
#define PNP_DRIVER_RES_DISABLE 0x0003 /* ensure the device is disabled */
#define pnp_resource_change(resource, start, size) isapnp_resource_change(resource, start, size)
#if defined(CONFIG_PNP)
struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from);
void pnp_release_card_device(struct pnp_dev * dev);
int pnp_register_card_driver(struct pnp_card_driver * drv);
void pnp_unregister_card_driver(struct pnp_card_driver * drv);
int pnp_register_driver(struct pnp_driver *drv);
void pnp_unregister_driver(struct pnp_driver *drv);
void pnp_init_resource_table(struct pnp_resource_table *table);
int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode);
int pnp_activate_dev(struct pnp_dev *dev);
static inline int pnp_is_active(struct pnp_dev *dev) { return dev->p.active; }
int pnp_disable_dev(struct pnp_dev *dev);
#else
static inline struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from) { return NULL; }
static inline void pnp_release_card_device(struct pnp_dev * dev) { ; }
static inline int pnp_register_card_driver(struct pnp_card_driver * drv) { return 0; }
static inline void pnp_unregister_card_driver(struct pnp_card_driver * drv) { ; }
static inline int pnp_register_driver(struct pnp_driver *drv) { return 0; }
static inline void pnp_unregister_driver(struct pnp_driver *drv) { ; }
static inline void pnp_init_resource_table(struct pnp_resource_table *table) { ; }
static inline int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode) { return -ENODEV; }
static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
static inline int pnp_is_active(struct pnp_dev * dev) { return -ENODEV; }
static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
#endif
#endif /* __KERNEL__ */
#endif /* _LINUX_PNP_H */
|
