]>
Commit | Line | Data |
---|---|---|
1a8d4663 DB |
1 | /* |
2 | * PCMCIA 16-bit resource management functions | |
3 | * | |
4 | * The initial developer of the original code is David A. Hinds | |
5 | * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds | |
6 | * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. | |
7 | * | |
8 | * Copyright (C) 1999 David A. Hinds | |
9 | * Copyright (C) 2004-2005 Dominik Brodowski | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify | |
12 | * it under the terms of the GNU General Public License version 2 as | |
13 | * published by the Free Software Foundation. | |
14 | * | |
15 | */ | |
16 | ||
1a8d4663 DB |
17 | #include <linux/module.h> |
18 | #include <linux/kernel.h> | |
19 | #include <linux/interrupt.h> | |
20 | #include <linux/delay.h> | |
21 | #include <linux/pci.h> | |
22 | #include <linux/device.h> | |
91284224 | 23 | #include <linux/netdevice.h> |
5a0e3ad6 | 24 | #include <linux/slab.h> |
1a8d4663 | 25 | |
6f0f38c4 DB |
26 | #include <asm/irq.h> |
27 | ||
1a8d4663 DB |
28 | #include <pcmcia/cs_types.h> |
29 | #include <pcmcia/ss.h> | |
30 | #include <pcmcia/cs.h> | |
1a8d4663 DB |
31 | #include <pcmcia/cistpl.h> |
32 | #include <pcmcia/cisreg.h> | |
33 | #include <pcmcia/ds.h> | |
34 | ||
35 | #include "cs_internal.h" | |
1a8d4663 DB |
36 | |
37 | ||
1a8d4663 | 38 | /* Access speed for IO windows */ |
9fea84f4 | 39 | static int io_speed; |
1a8d4663 DB |
40 | module_param(io_speed, int, 0444); |
41 | ||
42 | ||
a3ac9af5 DB |
43 | int pcmcia_validate_mem(struct pcmcia_socket *s) |
44 | { | |
45 | if (s->resource_ops->validate_mem) | |
46 | return s->resource_ops->validate_mem(s); | |
47 | /* if there is no callback, we can assume that everything is OK */ | |
48 | return 0; | |
49 | } | |
50 | ||
51 | struct resource *pcmcia_find_mem_region(u_long base, u_long num, u_long align, | |
52 | int low, struct pcmcia_socket *s) | |
53 | { | |
54 | if (s->resource_ops->find_mem) | |
55 | return s->resource_ops->find_mem(base, num, align, low, s); | |
56 | return NULL; | |
57 | } | |
58 | ||
1a8d4663 | 59 | |
1a8d4663 DB |
60 | /** alloc_io_space |
61 | * | |
62 | * Special stuff for managing IO windows, because they are scarce | |
63 | */ | |
64 | ||
ecb8a847 OJ |
65 | static int alloc_io_space(struct pcmcia_socket *s, u_int attr, |
66 | unsigned int *base, unsigned int num, u_int lines) | |
1a8d4663 | 67 | { |
b19a7275 | 68 | unsigned int align; |
1a8d4663 DB |
69 | |
70 | align = (*base) ? (lines ? 1<<lines : 0) : 1; | |
71 | if (align && (align < num)) { | |
72 | if (*base) { | |
d50dbec3 | 73 | dev_dbg(&s->dev, "odd IO request: num %#x align %#x\n", |
1a8d4663 DB |
74 | num, align); |
75 | align = 0; | |
76 | } else | |
9fea84f4 DB |
77 | while (align && (align < num)) |
78 | align <<= 1; | |
1a8d4663 DB |
79 | } |
80 | if (*base & ~(align-1)) { | |
d50dbec3 | 81 | dev_dbg(&s->dev, "odd IO request: base %#x align %#x\n", |
1a8d4663 DB |
82 | *base, align); |
83 | align = 0; | |
84 | } | |
b19a7275 DB |
85 | |
86 | return s->resource_ops->find_io(s, attr, base, num, align); | |
1a8d4663 DB |
87 | } /* alloc_io_space */ |
88 | ||
89 | ||
ecb8a847 OJ |
90 | static void release_io_space(struct pcmcia_socket *s, unsigned int base, |
91 | unsigned int num) | |
1a8d4663 DB |
92 | { |
93 | int i; | |
94 | ||
95 | for (i = 0; i < MAX_IO_WIN; i++) { | |
c7d00693 DB |
96 | if (!s->io[i].res) |
97 | continue; | |
98 | if ((s->io[i].res->start <= base) && | |
99 | (s->io[i].res->end >= base+num-1)) { | |
1a8d4663 DB |
100 | s->io[i].InUse -= num; |
101 | /* Free the window if no one else is using it */ | |
102 | if (s->io[i].InUse == 0) { | |
1a8d4663 DB |
103 | release_resource(s->io[i].res); |
104 | kfree(s->io[i].res); | |
105 | s->io[i].res = NULL; | |
106 | } | |
107 | } | |
108 | } | |
109 | } /* release_io_space */ | |
110 | ||
111 | ||
112 | /** pccard_access_configuration_register | |
113 | * | |
114 | * Access_configuration_register() reads and writes configuration | |
115 | * registers in attribute memory. Memory window 0 is reserved for | |
116 | * this and the tuple reading services. | |
117 | */ | |
118 | ||
855cdf13 | 119 | int pcmcia_access_configuration_register(struct pcmcia_device *p_dev, |
1a8d4663 DB |
120 | conf_reg_t *reg) |
121 | { | |
855cdf13 | 122 | struct pcmcia_socket *s; |
1a8d4663 DB |
123 | config_t *c; |
124 | int addr; | |
125 | u_char val; | |
059f667d | 126 | int ret = 0; |
1a8d4663 | 127 | |
855cdf13 | 128 | if (!p_dev || !p_dev->function_config) |
3939c1ef | 129 | return -EINVAL; |
1a8d4663 | 130 | |
855cdf13 | 131 | s = p_dev->socket; |
94a819f8 DB |
132 | |
133 | mutex_lock(&s->ops_mutex); | |
855cdf13 | 134 | c = p_dev->function_config; |
1a8d4663 | 135 | |
6d9a299f DB |
136 | if (!(c->state & CONFIG_LOCKED)) { |
137 | dev_dbg(&s->dev, "Configuration isnt't locked\n"); | |
94a819f8 | 138 | mutex_unlock(&s->ops_mutex); |
943f70f1 | 139 | return -EACCES; |
6d9a299f | 140 | } |
1a8d4663 DB |
141 | |
142 | addr = (c->ConfigBase + reg->Offset) >> 1; | |
143 | ||
144 | switch (reg->Action) { | |
145 | case CS_READ: | |
059f667d | 146 | ret = pcmcia_read_cis_mem(s, 1, addr, 1, &val); |
1a8d4663 DB |
147 | reg->Value = val; |
148 | break; | |
149 | case CS_WRITE: | |
150 | val = reg->Value; | |
151 | pcmcia_write_cis_mem(s, 1, addr, 1, &val); | |
152 | break; | |
153 | default: | |
6d9a299f | 154 | dev_dbg(&s->dev, "Invalid conf register request\n"); |
059f667d | 155 | ret = -EINVAL; |
1a8d4663 DB |
156 | break; |
157 | } | |
059f667d DB |
158 | mutex_unlock(&s->ops_mutex); |
159 | return ret; | |
855cdf13 | 160 | } /* pcmcia_access_configuration_register */ |
3448139b DB |
161 | EXPORT_SYMBOL(pcmcia_access_configuration_register); |
162 | ||
1a8d4663 | 163 | |
868575d1 MD |
164 | int pcmcia_map_mem_page(struct pcmcia_device *p_dev, window_handle_t wh, |
165 | memreq_t *req) | |
1a8d4663 | 166 | { |
0bdf9b3d | 167 | struct pcmcia_socket *s = p_dev->socket; |
6b8e087b | 168 | int ret; |
868575d1 | 169 | |
0bdf9b3d MD |
170 | wh--; |
171 | if (wh >= MAX_WIN) | |
ffb8da20 | 172 | return -EINVAL; |
610e2374 | 173 | if (req->Page != 0) { |
d50dbec3 | 174 | dev_dbg(&s->dev, "failure: requested page is zero\n"); |
610e2374 DB |
175 | return -EINVAL; |
176 | } | |
6b8e087b | 177 | mutex_lock(&s->ops_mutex); |
82f88e36 | 178 | s->win[wh].card_start = req->CardOffset; |
6b8e087b DB |
179 | ret = s->ops->set_mem_map(s, &s->win[wh]); |
180 | if (ret) | |
181 | dev_warn(&s->dev, "failed to set_mem_map\n"); | |
182 | mutex_unlock(&s->ops_mutex); | |
183 | return ret; | |
1a8d4663 DB |
184 | } /* pcmcia_map_mem_page */ |
185 | EXPORT_SYMBOL(pcmcia_map_mem_page); | |
186 | ||
187 | ||
188 | /** pcmcia_modify_configuration | |
189 | * | |
190 | * Modify a locked socket configuration | |
191 | */ | |
2bc5a9bd | 192 | int pcmcia_modify_configuration(struct pcmcia_device *p_dev, |
1a8d4663 DB |
193 | modconf_t *mod) |
194 | { | |
195 | struct pcmcia_socket *s; | |
196 | config_t *c; | |
4e06e240 | 197 | int ret; |
1a8d4663 | 198 | |
2bc5a9bd | 199 | s = p_dev->socket; |
94a819f8 DB |
200 | |
201 | mutex_lock(&s->ops_mutex); | |
dbb22f0d DB |
202 | c = p_dev->function_config; |
203 | ||
6d9a299f DB |
204 | if (!(s->state & SOCKET_PRESENT)) { |
205 | dev_dbg(&s->dev, "No card present\n"); | |
4e06e240 JS |
206 | ret = -ENODEV; |
207 | goto unlock; | |
6d9a299f DB |
208 | } |
209 | if (!(c->state & CONFIG_LOCKED)) { | |
210 | dev_dbg(&s->dev, "Configuration isnt't locked\n"); | |
4e06e240 JS |
211 | ret = -EACCES; |
212 | goto unlock; | |
6d9a299f | 213 | } |
1a8d4663 | 214 | |
0cb3c49c DB |
215 | if (mod->Attributes & (CONF_IRQ_CHANGE_VALID | CONF_VCC_CHANGE_VALID)) { |
216 | dev_dbg(&s->dev, | |
217 | "changing Vcc or IRQ is not allowed at this time\n"); | |
4e06e240 JS |
218 | ret = -EINVAL; |
219 | goto unlock; | |
d8b0a49d | 220 | } |
1a8d4663 DB |
221 | |
222 | /* We only allow changing Vpp1 and Vpp2 to the same value */ | |
223 | if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) && | |
224 | (mod->Attributes & CONF_VPP2_CHANGE_VALID)) { | |
60df3de8 | 225 | if (mod->Vpp1 != mod->Vpp2) { |
d50dbec3 | 226 | dev_dbg(&s->dev, "Vpp1 and Vpp2 must be the same\n"); |
4e06e240 JS |
227 | ret = -EINVAL; |
228 | goto unlock; | |
60df3de8 | 229 | } |
71ed90d8 | 230 | s->socket.Vpp = mod->Vpp1; |
d8b0a49d DB |
231 | if (s->ops->set_socket(s, &s->socket)) { |
232 | dev_printk(KERN_WARNING, &s->dev, | |
233 | "Unable to set VPP\n"); | |
4e06e240 JS |
234 | ret = -EIO; |
235 | goto unlock; | |
d8b0a49d | 236 | } |
1a8d4663 | 237 | } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) || |
d8b0a49d | 238 | (mod->Attributes & CONF_VPP2_CHANGE_VALID)) { |
d50dbec3 | 239 | dev_dbg(&s->dev, "changing Vcc is not allowed at this time\n"); |
4e06e240 JS |
240 | ret = -EINVAL; |
241 | goto unlock; | |
d8b0a49d | 242 | } |
1a8d4663 | 243 | |
4bbed523 DB |
244 | if (mod->Attributes & CONF_IO_CHANGE_WIDTH) { |
245 | pccard_io_map io_off = { 0, 0, 0, 0, 1 }; | |
246 | pccard_io_map io_on; | |
247 | int i; | |
248 | ||
249 | io_on.speed = io_speed; | |
250 | for (i = 0; i < MAX_IO_WIN; i++) { | |
251 | if (!s->io[i].res) | |
252 | continue; | |
253 | io_off.map = i; | |
254 | io_on.map = i; | |
255 | ||
256 | io_on.flags = MAP_ACTIVE | IO_DATA_PATH_WIDTH_8; | |
257 | io_on.start = s->io[i].res->start; | |
258 | io_on.stop = s->io[i].res->end; | |
259 | ||
260 | s->ops->set_io_map(s, &io_off); | |
261 | mdelay(40); | |
262 | s->ops->set_io_map(s, &io_on); | |
263 | } | |
264 | } | |
4e06e240 JS |
265 | ret = 0; |
266 | unlock: | |
94a819f8 | 267 | mutex_unlock(&s->ops_mutex); |
4bbed523 | 268 | |
4e06e240 | 269 | return ret; |
1a8d4663 DB |
270 | } /* modify_configuration */ |
271 | EXPORT_SYMBOL(pcmcia_modify_configuration); | |
272 | ||
273 | ||
2bc5a9bd | 274 | int pcmcia_release_configuration(struct pcmcia_device *p_dev) |
1a8d4663 DB |
275 | { |
276 | pccard_io_map io = { 0, 0, 0, 0, 1 }; | |
2bc5a9bd | 277 | struct pcmcia_socket *s = p_dev->socket; |
94a819f8 | 278 | config_t *c; |
1a8d4663 DB |
279 | int i; |
280 | ||
9e86749c | 281 | mutex_lock(&s->ops_mutex); |
94a819f8 | 282 | c = p_dev->function_config; |
e2d40963 DB |
283 | if (p_dev->_locked) { |
284 | p_dev->_locked = 0; | |
1a8d4663 DB |
285 | if (--(s->lock_count) == 0) { |
286 | s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */ | |
287 | s->socket.Vpp = 0; | |
288 | s->socket.io_irq = 0; | |
289 | s->ops->set_socket(s, &s->socket); | |
290 | } | |
5f2a71fc DB |
291 | } |
292 | if (c->state & CONFIG_LOCKED) { | |
293 | c->state &= ~CONFIG_LOCKED; | |
1a8d4663 DB |
294 | if (c->state & CONFIG_IO_REQ) |
295 | for (i = 0; i < MAX_IO_WIN; i++) { | |
c7d00693 | 296 | if (!s->io[i].res) |
1a8d4663 DB |
297 | continue; |
298 | s->io[i].Config--; | |
299 | if (s->io[i].Config != 0) | |
300 | continue; | |
301 | io.map = i; | |
302 | s->ops->set_io_map(s, &io); | |
303 | } | |
1a8d4663 | 304 | } |
9e86749c | 305 | mutex_unlock(&s->ops_mutex); |
1a8d4663 | 306 | |
4c89e88b | 307 | return 0; |
1a8d4663 | 308 | } /* pcmcia_release_configuration */ |
1a8d4663 DB |
309 | |
310 | ||
311 | /** pcmcia_release_io | |
312 | * | |
313 | * Release_io() releases the I/O ranges allocated by a client. This | |
314 | * may be invoked some time after a card ejection has already dumped | |
315 | * the actual socket configuration, so if the client is "stale", we | |
316 | * don't bother checking the port ranges against the current socket | |
317 | * values. | |
318 | */ | |
b4c88400 | 319 | static int pcmcia_release_io(struct pcmcia_device *p_dev, io_req_t *req) |
1a8d4663 | 320 | { |
2bc5a9bd | 321 | struct pcmcia_socket *s = p_dev->socket; |
94a819f8 DB |
322 | int ret = -EINVAL; |
323 | config_t *c; | |
324 | ||
325 | mutex_lock(&s->ops_mutex); | |
326 | c = p_dev->function_config; | |
1a8d4663 | 327 | |
9fea84f4 | 328 | if (!p_dev->_io) |
94a819f8 | 329 | goto out; |
5f2a71fc | 330 | |
e2d40963 | 331 | p_dev->_io = 0; |
1a8d4663 | 332 | |
5f2a71fc DB |
333 | if ((c->io.BasePort1 != req->BasePort1) || |
334 | (c->io.NumPorts1 != req->NumPorts1) || | |
335 | (c->io.BasePort2 != req->BasePort2) || | |
336 | (c->io.NumPorts2 != req->NumPorts2)) | |
94a819f8 | 337 | goto out; |
5f2a71fc DB |
338 | |
339 | c->state &= ~CONFIG_IO_REQ; | |
1a8d4663 DB |
340 | |
341 | release_io_space(s, req->BasePort1, req->NumPorts1); | |
342 | if (req->NumPorts2) | |
343 | release_io_space(s, req->BasePort2, req->NumPorts2); | |
344 | ||
94a819f8 DB |
345 | out: |
346 | mutex_unlock(&s->ops_mutex); | |
347 | ||
348 | return ret; | |
1a8d4663 | 349 | } /* pcmcia_release_io */ |
1a8d4663 DB |
350 | |
351 | ||
f5560da5 | 352 | int pcmcia_release_window(struct pcmcia_device *p_dev, window_handle_t wh) |
1a8d4663 | 353 | { |
0bdf9b3d | 354 | struct pcmcia_socket *s = p_dev->socket; |
82f88e36 | 355 | pccard_mem_map *win; |
1a8d4663 | 356 | |
0bdf9b3d MD |
357 | wh--; |
358 | if (wh >= MAX_WIN) | |
ffb8da20 | 359 | return -EINVAL; |
0bdf9b3d | 360 | |
6b8e087b | 361 | mutex_lock(&s->ops_mutex); |
0bdf9b3d MD |
362 | win = &s->win[wh]; |
363 | ||
364 | if (!(p_dev->_win & CLIENT_WIN_REQ(wh))) { | |
6d9a299f | 365 | dev_dbg(&s->dev, "not releasing unknown window\n"); |
6b8e087b | 366 | mutex_unlock(&s->ops_mutex); |
ffb8da20 | 367 | return -EINVAL; |
6d9a299f | 368 | } |
1a8d4663 DB |
369 | |
370 | /* Shut down memory window */ | |
82f88e36 DB |
371 | win->flags &= ~MAP_ACTIVE; |
372 | s->ops->set_mem_map(s, win); | |
0bdf9b3d | 373 | s->state &= ~SOCKET_WIN_REQ(wh); |
1a8d4663 DB |
374 | |
375 | /* Release system memory */ | |
82f88e36 DB |
376 | if (win->res) { |
377 | release_resource(win->res); | |
378 | kfree(win->res); | |
379 | win->res = NULL; | |
1a8d4663 | 380 | } |
0bdf9b3d | 381 | p_dev->_win &= ~CLIENT_WIN_REQ(wh); |
6b8e087b | 382 | mutex_unlock(&s->ops_mutex); |
1a8d4663 | 383 | |
4c89e88b | 384 | return 0; |
1a8d4663 DB |
385 | } /* pcmcia_release_window */ |
386 | EXPORT_SYMBOL(pcmcia_release_window); | |
387 | ||
388 | ||
2bc5a9bd | 389 | int pcmcia_request_configuration(struct pcmcia_device *p_dev, |
1a8d4663 DB |
390 | config_req_t *req) |
391 | { | |
392 | int i; | |
393 | u_int base; | |
2bc5a9bd | 394 | struct pcmcia_socket *s = p_dev->socket; |
1a8d4663 DB |
395 | config_t *c; |
396 | pccard_io_map iomap; | |
397 | ||
1a8d4663 | 398 | if (!(s->state & SOCKET_PRESENT)) |
d598de02 | 399 | return -ENODEV; |
1a8d4663 | 400 | |
de6405e9 | 401 | if (req->IntType & INT_CARDBUS) { |
d50dbec3 | 402 | dev_dbg(&s->dev, "IntType may not be INT_CARDBUS\n"); |
de6405e9 DB |
403 | return -EINVAL; |
404 | } | |
94a819f8 DB |
405 | |
406 | mutex_lock(&s->ops_mutex); | |
dbb22f0d | 407 | c = p_dev->function_config; |
6d9a299f | 408 | if (c->state & CONFIG_LOCKED) { |
94a819f8 | 409 | mutex_unlock(&s->ops_mutex); |
6d9a299f | 410 | dev_dbg(&s->dev, "Configuration is locked\n"); |
943f70f1 | 411 | return -EACCES; |
6d9a299f | 412 | } |
1a8d4663 DB |
413 | |
414 | /* Do power control. We don't allow changes in Vcc. */ | |
70294b46 | 415 | s->socket.Vpp = req->Vpp; |
d8b0a49d | 416 | if (s->ops->set_socket(s, &s->socket)) { |
9e86749c | 417 | mutex_unlock(&s->ops_mutex); |
d8b0a49d DB |
418 | dev_printk(KERN_WARNING, &s->dev, |
419 | "Unable to set socket state\n"); | |
420 | return -EINVAL; | |
421 | } | |
1a8d4663 | 422 | |
1a8d4663 DB |
423 | /* Pick memory or I/O card, DMA mode, interrupt */ |
424 | c->IntType = req->IntType; | |
425 | c->Attributes = req->Attributes; | |
426 | if (req->IntType & INT_MEMORY_AND_IO) | |
427 | s->socket.flags |= SS_IOCARD; | |
428 | if (req->IntType & INT_ZOOMED_VIDEO) | |
429 | s->socket.flags |= SS_ZVCARD | SS_IOCARD; | |
430 | if (req->Attributes & CONF_ENABLE_DMA) | |
431 | s->socket.flags |= SS_DMA_MODE; | |
432 | if (req->Attributes & CONF_ENABLE_SPKR) | |
433 | s->socket.flags |= SS_SPKR_ENA; | |
434 | if (req->Attributes & CONF_ENABLE_IRQ) | |
6f840afb | 435 | s->socket.io_irq = s->pcmcia_irq; |
1a8d4663 DB |
436 | else |
437 | s->socket.io_irq = 0; | |
438 | s->ops->set_socket(s, &s->socket); | |
439 | s->lock_count++; | |
440 | ||
441 | /* Set up CIS configuration registers */ | |
442 | base = c->ConfigBase = req->ConfigBase; | |
1ae9c7d8 | 443 | c->CardValues = req->Present; |
1a8d4663 DB |
444 | if (req->Present & PRESENT_COPY) { |
445 | c->Copy = req->Copy; | |
446 | pcmcia_write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy); | |
447 | } | |
448 | if (req->Present & PRESENT_OPTION) { | |
449 | if (s->functions == 1) { | |
450 | c->Option = req->ConfigIndex & COR_CONFIG_MASK; | |
451 | } else { | |
452 | c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK; | |
453 | c->Option |= COR_FUNC_ENA|COR_IREQ_ENA; | |
454 | if (req->Present & PRESENT_IOBASE_0) | |
455 | c->Option |= COR_ADDR_DECODE; | |
456 | } | |
a7debe78 DB |
457 | if ((req->Attributes & CONF_ENABLE_IRQ) && |
458 | !(req->Attributes & CONF_ENABLE_PULSE_IRQ)) | |
459 | c->Option |= COR_LEVEL_REQ; | |
1a8d4663 DB |
460 | pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option); |
461 | mdelay(40); | |
462 | } | |
463 | if (req->Present & PRESENT_STATUS) { | |
464 | c->Status = req->Status; | |
465 | pcmcia_write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status); | |
466 | } | |
467 | if (req->Present & PRESENT_PIN_REPLACE) { | |
468 | c->Pin = req->Pin; | |
469 | pcmcia_write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin); | |
470 | } | |
471 | if (req->Present & PRESENT_EXT_STATUS) { | |
472 | c->ExtStatus = req->ExtStatus; | |
473 | pcmcia_write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus); | |
474 | } | |
475 | if (req->Present & PRESENT_IOBASE_0) { | |
476 | u_char b = c->io.BasePort1 & 0xff; | |
477 | pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b); | |
478 | b = (c->io.BasePort1 >> 8) & 0xff; | |
479 | pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b); | |
480 | } | |
481 | if (req->Present & PRESENT_IOSIZE) { | |
482 | u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1; | |
483 | pcmcia_write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b); | |
484 | } | |
485 | ||
486 | /* Configure I/O windows */ | |
487 | if (c->state & CONFIG_IO_REQ) { | |
488 | iomap.speed = io_speed; | |
489 | for (i = 0; i < MAX_IO_WIN; i++) | |
c7d00693 | 490 | if (s->io[i].res) { |
1a8d4663 DB |
491 | iomap.map = i; |
492 | iomap.flags = MAP_ACTIVE; | |
c7d00693 | 493 | switch (s->io[i].res->flags & IO_DATA_PATH_WIDTH) { |
1a8d4663 DB |
494 | case IO_DATA_PATH_WIDTH_16: |
495 | iomap.flags |= MAP_16BIT; break; | |
496 | case IO_DATA_PATH_WIDTH_AUTO: | |
497 | iomap.flags |= MAP_AUTOSZ; break; | |
498 | default: | |
499 | break; | |
500 | } | |
c7d00693 DB |
501 | iomap.start = s->io[i].res->start; |
502 | iomap.stop = s->io[i].res->end; | |
1a8d4663 DB |
503 | s->ops->set_io_map(s, &iomap); |
504 | s->io[i].Config++; | |
505 | } | |
506 | } | |
507 | ||
508 | c->state |= CONFIG_LOCKED; | |
e2d40963 | 509 | p_dev->_locked = 1; |
059f667d | 510 | mutex_unlock(&s->ops_mutex); |
4c89e88b | 511 | return 0; |
1a8d4663 DB |
512 | } /* pcmcia_request_configuration */ |
513 | EXPORT_SYMBOL(pcmcia_request_configuration); | |
514 | ||
515 | ||
516 | /** pcmcia_request_io | |
517 | * | |
518 | * Request_io() reserves ranges of port addresses for a socket. | |
519 | * I have not implemented range sharing or alias addressing. | |
520 | */ | |
2bc5a9bd | 521 | int pcmcia_request_io(struct pcmcia_device *p_dev, io_req_t *req) |
1a8d4663 | 522 | { |
2bc5a9bd | 523 | struct pcmcia_socket *s = p_dev->socket; |
1a8d4663 | 524 | config_t *c; |
94a819f8 DB |
525 | int ret = -EINVAL; |
526 | ||
527 | mutex_lock(&s->ops_mutex); | |
1a8d4663 | 528 | |
6d9a299f DB |
529 | if (!(s->state & SOCKET_PRESENT)) { |
530 | dev_dbg(&s->dev, "No card present\n"); | |
94a819f8 | 531 | goto out; |
6d9a299f | 532 | } |
1a8d4663 | 533 | |
1a8d4663 | 534 | if (!req) |
94a819f8 DB |
535 | goto out; |
536 | ||
dbb22f0d | 537 | c = p_dev->function_config; |
6d9a299f DB |
538 | if (c->state & CONFIG_LOCKED) { |
539 | dev_dbg(&s->dev, "Configuration is locked\n"); | |
94a819f8 | 540 | goto out; |
6d9a299f | 541 | } |
f958095e | 542 | if (c->state & CONFIG_IO_REQ) { |
d50dbec3 | 543 | dev_dbg(&s->dev, "IO already configured\n"); |
94a819f8 | 544 | goto out; |
f958095e | 545 | } |
610e2374 | 546 | if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)) { |
d50dbec3 | 547 | dev_dbg(&s->dev, "bad attribute setting for IO region 1\n"); |
94a819f8 | 548 | goto out; |
610e2374 | 549 | } |
1a8d4663 | 550 | if ((req->NumPorts2 > 0) && |
610e2374 | 551 | (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))) { |
d50dbec3 | 552 | dev_dbg(&s->dev, "bad attribute setting for IO region 2\n"); |
94a819f8 | 553 | goto out; |
610e2374 | 554 | } |
1a8d4663 | 555 | |
d50dbec3 | 556 | dev_dbg(&s->dev, "trying to allocate resource 1\n"); |
94a819f8 DB |
557 | ret = alloc_io_space(s, req->Attributes1, &req->BasePort1, |
558 | req->NumPorts1, req->IOAddrLines); | |
559 | if (ret) { | |
d50dbec3 | 560 | dev_dbg(&s->dev, "allocation of resource 1 failed\n"); |
94a819f8 | 561 | goto out; |
f958095e | 562 | } |
1a8d4663 DB |
563 | |
564 | if (req->NumPorts2) { | |
d50dbec3 | 565 | dev_dbg(&s->dev, "trying to allocate resource 2\n"); |
94a819f8 DB |
566 | ret = alloc_io_space(s, req->Attributes2, &req->BasePort2, |
567 | req->NumPorts2, req->IOAddrLines); | |
568 | if (ret) { | |
d50dbec3 | 569 | dev_dbg(&s->dev, "allocation of resource 2 failed\n"); |
1a8d4663 | 570 | release_io_space(s, req->BasePort1, req->NumPorts1); |
94a819f8 | 571 | goto out; |
1a8d4663 DB |
572 | } |
573 | } | |
574 | ||
575 | c->io = *req; | |
576 | c->state |= CONFIG_IO_REQ; | |
e2d40963 | 577 | p_dev->_io = 1; |
94a819f8 DB |
578 | dev_dbg(&s->dev, "allocating resources succeeded: %d\n", ret); |
579 | ||
580 | out: | |
581 | mutex_unlock(&s->ops_mutex); | |
582 | ||
583 | return ret; | |
1a8d4663 DB |
584 | } /* pcmcia_request_io */ |
585 | EXPORT_SYMBOL(pcmcia_request_io); | |
586 | ||
587 | ||
eb14120f DB |
588 | /** |
589 | * pcmcia_request_irq() - attempt to request a IRQ for a PCMCIA device | |
1a8d4663 | 590 | * |
eb14120f DB |
591 | * pcmcia_request_irq() is a wrapper around request_irq which will allow |
592 | * the PCMCIA core to clean up the registration in pcmcia_disable_device(). | |
593 | * Drivers are free to use request_irq() directly, but then they need to | |
594 | * call free_irq themselfves, too. Also, only IRQF_SHARED capable IRQ | |
595 | * handlers are allowed. | |
1a8d4663 | 596 | */ |
eb14120f DB |
597 | int __must_check pcmcia_request_irq(struct pcmcia_device *p_dev, |
598 | irq_handler_t handler) | |
1a8d4663 | 599 | { |
eb14120f | 600 | int ret; |
1a8d4663 | 601 | |
eb14120f DB |
602 | if (!p_dev->irq) |
603 | return -EINVAL; | |
94a819f8 | 604 | |
eb14120f DB |
605 | ret = request_irq(p_dev->irq, handler, IRQF_SHARED, |
606 | p_dev->devname, p_dev->priv); | |
607 | if (!ret) | |
608 | p_dev->_irq = 1; | |
1a8d4663 | 609 | |
eb14120f DB |
610 | return ret; |
611 | } | |
612 | EXPORT_SYMBOL(pcmcia_request_irq); | |
6f0f38c4 | 613 | |
1a8d4663 | 614 | |
eb14120f DB |
615 | /** |
616 | * pcmcia_request_exclusive_irq() - attempt to request an exclusive IRQ first | |
617 | * | |
618 | * pcmcia_request_exclusive_irq() is a wrapper around request_irq which | |
619 | * attempts first to request an exclusive IRQ. If it fails, it also accepts | |
620 | * a shared IRQ, but prints out a warning. PCMCIA drivers should allow for | |
621 | * IRQ sharing and either use request_irq directly (then they need to call | |
622 | * free_irq themselves, too), or the pcmcia_request_irq() function. | |
623 | */ | |
624 | int __must_check | |
b19a7275 DB |
625 | __pcmcia_request_exclusive_irq(struct pcmcia_device *p_dev, |
626 | irq_handler_t handler) | |
eb14120f DB |
627 | { |
628 | int ret; | |
1a8d4663 | 629 | |
eb14120f DB |
630 | if (!p_dev->irq) |
631 | return -EINVAL; | |
1a8d4663 | 632 | |
eb14120f DB |
633 | ret = request_irq(p_dev->irq, handler, 0, p_dev->devname, p_dev->priv); |
634 | if (ret) { | |
635 | ret = pcmcia_request_irq(p_dev, handler); | |
636 | dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: " | |
637 | "request for exclusive IRQ could not be fulfilled.\n"); | |
638 | dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver " | |
639 | "needs updating to supported shared IRQ lines.\n"); | |
640 | } | |
641 | if (ret) | |
642 | dev_printk(KERN_INFO, &p_dev->dev, "request_irq() failed\n"); | |
643 | else | |
644 | p_dev->_irq = 1; | |
1a8d4663 | 645 | |
94a819f8 | 646 | return ret; |
eb14120f | 647 | } /* pcmcia_request_exclusive_irq */ |
b19a7275 | 648 | EXPORT_SYMBOL(__pcmcia_request_exclusive_irq); |
1a8d4663 DB |
649 | |
650 | ||
6f0f38c4 DB |
651 | #ifdef CONFIG_PCMCIA_PROBE |
652 | ||
653 | /* mask of IRQs already reserved by other cards, we should avoid using them */ | |
654 | static u8 pcmcia_used_irq[NR_IRQS]; | |
655 | ||
656 | static irqreturn_t test_action(int cpl, void *dev_id) | |
657 | { | |
658 | return IRQ_NONE; | |
659 | } | |
660 | ||
661 | /** | |
662 | * pcmcia_setup_isa_irq() - determine whether an ISA IRQ can be used | |
663 | * @p_dev - the associated PCMCIA device | |
664 | * | |
665 | * locking note: must be called with ops_mutex locked. | |
666 | */ | |
667 | static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type) | |
668 | { | |
669 | struct pcmcia_socket *s = p_dev->socket; | |
670 | unsigned int try, irq; | |
671 | u32 mask = s->irq_mask; | |
672 | int ret = -ENODEV; | |
673 | ||
674 | for (try = 0; try < 64; try++) { | |
675 | irq = try % 32; | |
676 | ||
677 | /* marked as available by driver, not blocked by userspace? */ | |
678 | if (!((mask >> irq) & 1)) | |
679 | continue; | |
680 | ||
681 | /* avoid an IRQ which is already used by another PCMCIA card */ | |
682 | if ((try < 32) && pcmcia_used_irq[irq]) | |
683 | continue; | |
684 | ||
685 | /* register the correct driver, if possible, to check whether | |
686 | * registering a dummy handle works, i.e. if the IRQ isn't | |
687 | * marked as used by the kernel resource management core */ | |
688 | ret = request_irq(irq, test_action, type, p_dev->devname, | |
689 | p_dev); | |
690 | if (!ret) { | |
691 | free_irq(irq, p_dev); | |
eb14120f | 692 | p_dev->irq = s->pcmcia_irq = irq; |
6f0f38c4 DB |
693 | pcmcia_used_irq[irq]++; |
694 | break; | |
695 | } | |
696 | } | |
697 | ||
698 | return ret; | |
699 | } | |
700 | ||
701 | void pcmcia_cleanup_irq(struct pcmcia_socket *s) | |
702 | { | |
6f840afb DB |
703 | pcmcia_used_irq[s->pcmcia_irq]--; |
704 | s->pcmcia_irq = 0; | |
6f0f38c4 DB |
705 | } |
706 | ||
707 | #else /* CONFIG_PCMCIA_PROBE */ | |
708 | ||
709 | static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type) | |
710 | { | |
711 | return -EINVAL; | |
712 | } | |
713 | ||
714 | void pcmcia_cleanup_irq(struct pcmcia_socket *s) | |
715 | { | |
6f840afb | 716 | s->pcmcia_irq = 0; |
6f0f38c4 DB |
717 | return; |
718 | } | |
719 | ||
720 | #endif /* CONFIG_PCMCIA_PROBE */ | |
721 | ||
722 | ||
723 | /** | |
724 | * pcmcia_setup_irq() - determine IRQ to be used for device | |
725 | * @p_dev - the associated PCMCIA device | |
726 | * | |
727 | * locking note: must be called with ops_mutex locked. | |
728 | */ | |
729 | int pcmcia_setup_irq(struct pcmcia_device *p_dev) | |
730 | { | |
731 | struct pcmcia_socket *s = p_dev->socket; | |
732 | ||
eb14120f | 733 | if (p_dev->irq) |
6f0f38c4 DB |
734 | return 0; |
735 | ||
736 | /* already assigned? */ | |
6f840afb | 737 | if (s->pcmcia_irq) { |
eb14120f | 738 | p_dev->irq = s->pcmcia_irq; |
6f0f38c4 DB |
739 | return 0; |
740 | } | |
741 | ||
742 | /* prefer an exclusive ISA irq */ | |
743 | if (!pcmcia_setup_isa_irq(p_dev, 0)) | |
744 | return 0; | |
745 | ||
746 | /* but accept a shared ISA irq */ | |
747 | if (!pcmcia_setup_isa_irq(p_dev, IRQF_SHARED)) | |
748 | return 0; | |
749 | ||
750 | /* but use the PCI irq otherwise */ | |
751 | if (s->pci_irq) { | |
eb14120f | 752 | p_dev->irq = s->pcmcia_irq = s->pci_irq; |
6f0f38c4 DB |
753 | return 0; |
754 | } | |
755 | ||
756 | return -EINVAL; | |
757 | } | |
758 | ||
759 | ||
1a8d4663 DB |
760 | /** pcmcia_request_window |
761 | * | |
762 | * Request_window() establishes a mapping between card memory space | |
763 | * and system memory space. | |
764 | */ | |
6838b03f | 765 | int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_handle_t *wh) |
1a8d4663 | 766 | { |
6838b03f | 767 | struct pcmcia_socket *s = p_dev->socket; |
82f88e36 | 768 | pccard_mem_map *win; |
1a8d4663 DB |
769 | u_long align; |
770 | int w; | |
771 | ||
6d9a299f DB |
772 | if (!(s->state & SOCKET_PRESENT)) { |
773 | dev_dbg(&s->dev, "No card present\n"); | |
3939c1ef | 774 | return -ENODEV; |
6d9a299f | 775 | } |
610e2374 | 776 | if (req->Attributes & (WIN_PAGED | WIN_SHARED)) { |
d50dbec3 | 777 | dev_dbg(&s->dev, "bad attribute setting for iomem region\n"); |
610e2374 DB |
778 | return -EINVAL; |
779 | } | |
1a8d4663 DB |
780 | |
781 | /* Window size defaults to smallest available */ | |
782 | if (req->Size == 0) | |
783 | req->Size = s->map_size; | |
784 | align = (((s->features & SS_CAP_MEM_ALIGN) || | |
785 | (req->Attributes & WIN_STRICT_ALIGN)) ? | |
786 | req->Size : s->map_size); | |
69ba4433 | 787 | if (req->Size & (s->map_size-1)) { |
d50dbec3 | 788 | dev_dbg(&s->dev, "invalid map size\n"); |
69ba4433 DB |
789 | return -EINVAL; |
790 | } | |
1a8d4663 | 791 | if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) || |
69ba4433 | 792 | (req->Base & (align-1))) { |
d50dbec3 | 793 | dev_dbg(&s->dev, "invalid base address\n"); |
69ba4433 DB |
794 | return -EINVAL; |
795 | } | |
1a8d4663 DB |
796 | if (req->Base) |
797 | align = 0; | |
798 | ||
799 | /* Allocate system memory window */ | |
800 | for (w = 0; w < MAX_WIN; w++) | |
9fea84f4 DB |
801 | if (!(s->state & SOCKET_WIN_REQ(w))) |
802 | break; | |
f958095e | 803 | if (w == MAX_WIN) { |
d50dbec3 | 804 | dev_dbg(&s->dev, "all windows are used already\n"); |
f958095e DB |
805 | return -EINVAL; |
806 | } | |
1a8d4663 | 807 | |
6b8e087b | 808 | mutex_lock(&s->ops_mutex); |
1a8d4663 | 809 | win = &s->win[w]; |
1a8d4663 DB |
810 | |
811 | if (!(s->features & SS_CAP_STATIC_MAP)) { | |
82f88e36 | 812 | win->res = pcmcia_find_mem_region(req->Base, req->Size, align, |
1a8d4663 | 813 | (req->Attributes & WIN_MAP_BELOW_1MB), s); |
82f88e36 | 814 | if (!win->res) { |
d50dbec3 | 815 | dev_dbg(&s->dev, "allocating mem region failed\n"); |
6b8e087b | 816 | mutex_unlock(&s->ops_mutex); |
f958095e DB |
817 | return -EINVAL; |
818 | } | |
1a8d4663 | 819 | } |
6838b03f | 820 | p_dev->_win |= CLIENT_WIN_REQ(w); |
1a8d4663 DB |
821 | |
822 | /* Configure the socket controller */ | |
82f88e36 DB |
823 | win->map = w+1; |
824 | win->flags = 0; | |
825 | win->speed = req->AccessSpeed; | |
1a8d4663 | 826 | if (req->Attributes & WIN_MEMORY_TYPE) |
82f88e36 | 827 | win->flags |= MAP_ATTRIB; |
1a8d4663 | 828 | if (req->Attributes & WIN_ENABLE) |
82f88e36 | 829 | win->flags |= MAP_ACTIVE; |
1a8d4663 | 830 | if (req->Attributes & WIN_DATA_WIDTH_16) |
82f88e36 | 831 | win->flags |= MAP_16BIT; |
1a8d4663 | 832 | if (req->Attributes & WIN_USE_WAIT) |
82f88e36 DB |
833 | win->flags |= MAP_USE_WAIT; |
834 | win->card_start = 0; | |
6b8e087b | 835 | |
82f88e36 | 836 | if (s->ops->set_mem_map(s, win) != 0) { |
d50dbec3 | 837 | dev_dbg(&s->dev, "failed to set memory mapping\n"); |
6b8e087b | 838 | mutex_unlock(&s->ops_mutex); |
926c5402 DB |
839 | return -EIO; |
840 | } | |
1a8d4663 DB |
841 | s->state |= SOCKET_WIN_REQ(w); |
842 | ||
843 | /* Return window handle */ | |
9fea84f4 | 844 | if (s->features & SS_CAP_STATIC_MAP) |
82f88e36 | 845 | req->Base = win->static_start; |
9fea84f4 | 846 | else |
82f88e36 | 847 | req->Base = win->res->start; |
9fea84f4 | 848 | |
6b8e087b | 849 | mutex_unlock(&s->ops_mutex); |
0bdf9b3d | 850 | *wh = w + 1; |
1a8d4663 | 851 | |
4c89e88b | 852 | return 0; |
1a8d4663 DB |
853 | } /* pcmcia_request_window */ |
854 | EXPORT_SYMBOL(pcmcia_request_window); | |
5f2a71fc | 855 | |
9fea84f4 DB |
856 | void pcmcia_disable_device(struct pcmcia_device *p_dev) |
857 | { | |
5f2a71fc | 858 | pcmcia_release_configuration(p_dev); |
fd238232 | 859 | pcmcia_release_io(p_dev, &p_dev->io); |
418c5278 | 860 | if (p_dev->_irq) { |
eb14120f | 861 | free_irq(p_dev->irq, p_dev->priv); |
418c5278 PM |
862 | p_dev->_irq = 0; |
863 | } | |
c1ac0228 | 864 | if (p_dev->win) |
f5560da5 | 865 | pcmcia_release_window(p_dev, p_dev->win); |
5f2a71fc DB |
866 | } |
867 | EXPORT_SYMBOL(pcmcia_disable_device); |