Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit a0aab14322a74ab5665704c6155bf48fbc38f445

Authored by Dominik Brodowski
1 parent 90ff87008d
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

[PATCH] pcmcia: do not set dev_node to NULL too early 

If we set dev_node to NULL too early, some drivers which used this to
determine whether unregister_netdev() needs to be called fail when removing
a PCMCIA card.

Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>

Showing 2 changed files with 2 additions and 2 deletions Inline Diff

1 /* 1 /*
2 * ds.c -- 16-bit PCMCIA core support 2 * ds.c -- 16-bit PCMCIA core support
3 * 3 *
4 * This program is free software; you can redistribute it and/or modify 4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as 5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation. 6 * published by the Free Software Foundation.
7 * 7 *
8 * The initial developer of the original code is David A. Hinds 8 * The initial developer of the original code is David A. Hinds
9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
11 * 11 *
12 * (C) 1999 David A. Hinds 12 * (C) 1999 David A. Hinds
13 * (C) 2003 - 2006 Dominik Brodowski 13 * (C) 2003 - 2006 Dominik Brodowski
14 */ 14 */
15 15
16 #include <linux/kernel.h> 16 #include <linux/kernel.h>
17 #include <linux/module.h> 17 #include <linux/module.h>
18 #include <linux/init.h> 18 #include <linux/init.h>
19 #include <linux/errno.h> 19 #include <linux/errno.h>
20 #include <linux/list.h> 20 #include <linux/list.h>
21 #include <linux/delay.h> 21 #include <linux/delay.h>
22 #include <linux/workqueue.h> 22 #include <linux/workqueue.h>
23 #include <linux/crc32.h> 23 #include <linux/crc32.h>
24 #include <linux/firmware.h> 24 #include <linux/firmware.h>
25 #include <linux/kref.h> 25 #include <linux/kref.h>
26 26
27 #define IN_CARD_SERVICES 27 #define IN_CARD_SERVICES
28 #include <pcmcia/cs_types.h> 28 #include <pcmcia/cs_types.h>
29 #include <pcmcia/cs.h> 29 #include <pcmcia/cs.h>
30 #include <pcmcia/cistpl.h> 30 #include <pcmcia/cistpl.h>
31 #include <pcmcia/ds.h> 31 #include <pcmcia/ds.h>
32 #include <pcmcia/ss.h> 32 #include <pcmcia/ss.h>
33 33
34 #include "cs_internal.h" 34 #include "cs_internal.h"
35 #include "ds_internal.h" 35 #include "ds_internal.h"
36 36
37 /*====================================================================*/ 37 /*====================================================================*/
38 38
39 /* Module parameters */ 39 /* Module parameters */
40 40
41 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 41 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
42 MODULE_DESCRIPTION("PCMCIA Driver Services"); 42 MODULE_DESCRIPTION("PCMCIA Driver Services");
43 MODULE_LICENSE("GPL"); 43 MODULE_LICENSE("GPL");
44 44
45 #ifdef DEBUG 45 #ifdef DEBUG
46 int ds_pc_debug; 46 int ds_pc_debug;
47 47
48 module_param_named(pc_debug, ds_pc_debug, int, 0644); 48 module_param_named(pc_debug, ds_pc_debug, int, 0644);
49 49
50 #define ds_dbg(lvl, fmt, arg...) do { \ 50 #define ds_dbg(lvl, fmt, arg...) do { \
51 if (ds_pc_debug > (lvl)) \ 51 if (ds_pc_debug > (lvl)) \
52 printk(KERN_DEBUG "ds: " fmt , ## arg); \ 52 printk(KERN_DEBUG "ds: " fmt , ## arg); \
53 } while (0) 53 } while (0)
54 #else 54 #else
55 #define ds_dbg(lvl, fmt, arg...) do { } while (0) 55 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
56 #endif 56 #endif
57 57
58 spinlock_t pcmcia_dev_list_lock; 58 spinlock_t pcmcia_dev_list_lock;
59 59
60 /*====================================================================*/ 60 /*====================================================================*/
61 61
62 /* code which was in cs.c before */ 62 /* code which was in cs.c before */
63 63
64 /* String tables for error messages */ 64 /* String tables for error messages */
65 65
66 typedef struct lookup_t { 66 typedef struct lookup_t {
67 int key; 67 int key;
68 char *msg; 68 char *msg;
69 } lookup_t; 69 } lookup_t;
70 70
71 static const lookup_t error_table[] = { 71 static const lookup_t error_table[] = {
72 { CS_SUCCESS, "Operation succeeded" }, 72 { CS_SUCCESS, "Operation succeeded" },
73 { CS_BAD_ADAPTER, "Bad adapter" }, 73 { CS_BAD_ADAPTER, "Bad adapter" },
74 { CS_BAD_ATTRIBUTE, "Bad attribute", }, 74 { CS_BAD_ATTRIBUTE, "Bad attribute", },
75 { CS_BAD_BASE, "Bad base address" }, 75 { CS_BAD_BASE, "Bad base address" },
76 { CS_BAD_EDC, "Bad EDC" }, 76 { CS_BAD_EDC, "Bad EDC" },
77 { CS_BAD_IRQ, "Bad IRQ" }, 77 { CS_BAD_IRQ, "Bad IRQ" },
78 { CS_BAD_OFFSET, "Bad offset" }, 78 { CS_BAD_OFFSET, "Bad offset" },
79 { CS_BAD_PAGE, "Bad page number" }, 79 { CS_BAD_PAGE, "Bad page number" },
80 { CS_READ_FAILURE, "Read failure" }, 80 { CS_READ_FAILURE, "Read failure" },
81 { CS_BAD_SIZE, "Bad size" }, 81 { CS_BAD_SIZE, "Bad size" },
82 { CS_BAD_SOCKET, "Bad socket" }, 82 { CS_BAD_SOCKET, "Bad socket" },
83 { CS_BAD_TYPE, "Bad type" }, 83 { CS_BAD_TYPE, "Bad type" },
84 { CS_BAD_VCC, "Bad Vcc" }, 84 { CS_BAD_VCC, "Bad Vcc" },
85 { CS_BAD_VPP, "Bad Vpp" }, 85 { CS_BAD_VPP, "Bad Vpp" },
86 { CS_BAD_WINDOW, "Bad window" }, 86 { CS_BAD_WINDOW, "Bad window" },
87 { CS_WRITE_FAILURE, "Write failure" }, 87 { CS_WRITE_FAILURE, "Write failure" },
88 { CS_NO_CARD, "No card present" }, 88 { CS_NO_CARD, "No card present" },
89 { CS_UNSUPPORTED_FUNCTION, "Usupported function" }, 89 { CS_UNSUPPORTED_FUNCTION, "Usupported function" },
90 { CS_UNSUPPORTED_MODE, "Unsupported mode" }, 90 { CS_UNSUPPORTED_MODE, "Unsupported mode" },
91 { CS_BAD_SPEED, "Bad speed" }, 91 { CS_BAD_SPEED, "Bad speed" },
92 { CS_BUSY, "Resource busy" }, 92 { CS_BUSY, "Resource busy" },
93 { CS_GENERAL_FAILURE, "General failure" }, 93 { CS_GENERAL_FAILURE, "General failure" },
94 { CS_WRITE_PROTECTED, "Write protected" }, 94 { CS_WRITE_PROTECTED, "Write protected" },
95 { CS_BAD_ARG_LENGTH, "Bad argument length" }, 95 { CS_BAD_ARG_LENGTH, "Bad argument length" },
96 { CS_BAD_ARGS, "Bad arguments" }, 96 { CS_BAD_ARGS, "Bad arguments" },
97 { CS_CONFIGURATION_LOCKED, "Configuration locked" }, 97 { CS_CONFIGURATION_LOCKED, "Configuration locked" },
98 { CS_IN_USE, "Resource in use" }, 98 { CS_IN_USE, "Resource in use" },
99 { CS_NO_MORE_ITEMS, "No more items" }, 99 { CS_NO_MORE_ITEMS, "No more items" },
100 { CS_OUT_OF_RESOURCE, "Out of resource" }, 100 { CS_OUT_OF_RESOURCE, "Out of resource" },
101 { CS_BAD_HANDLE, "Bad handle" }, 101 { CS_BAD_HANDLE, "Bad handle" },
102 { CS_BAD_TUPLE, "Bad CIS tuple" } 102 { CS_BAD_TUPLE, "Bad CIS tuple" }
103 }; 103 };
104 104
105 105
106 static const lookup_t service_table[] = { 106 static const lookup_t service_table[] = {
107 { AccessConfigurationRegister, "AccessConfigurationRegister" }, 107 { AccessConfigurationRegister, "AccessConfigurationRegister" },
108 { AddSocketServices, "AddSocketServices" }, 108 { AddSocketServices, "AddSocketServices" },
109 { AdjustResourceInfo, "AdjustResourceInfo" }, 109 { AdjustResourceInfo, "AdjustResourceInfo" },
110 { CheckEraseQueue, "CheckEraseQueue" }, 110 { CheckEraseQueue, "CheckEraseQueue" },
111 { CloseMemory, "CloseMemory" }, 111 { CloseMemory, "CloseMemory" },
112 { DeregisterClient, "DeregisterClient" }, 112 { DeregisterClient, "DeregisterClient" },
113 { DeregisterEraseQueue, "DeregisterEraseQueue" }, 113 { DeregisterEraseQueue, "DeregisterEraseQueue" },
114 { GetCardServicesInfo, "GetCardServicesInfo" }, 114 { GetCardServicesInfo, "GetCardServicesInfo" },
115 { GetClientInfo, "GetClientInfo" }, 115 { GetClientInfo, "GetClientInfo" },
116 { GetConfigurationInfo, "GetConfigurationInfo" }, 116 { GetConfigurationInfo, "GetConfigurationInfo" },
117 { GetEventMask, "GetEventMask" }, 117 { GetEventMask, "GetEventMask" },
118 { GetFirstClient, "GetFirstClient" }, 118 { GetFirstClient, "GetFirstClient" },
119 { GetFirstRegion, "GetFirstRegion" }, 119 { GetFirstRegion, "GetFirstRegion" },
120 { GetFirstTuple, "GetFirstTuple" }, 120 { GetFirstTuple, "GetFirstTuple" },
121 { GetNextClient, "GetNextClient" }, 121 { GetNextClient, "GetNextClient" },
122 { GetNextRegion, "GetNextRegion" }, 122 { GetNextRegion, "GetNextRegion" },
123 { GetNextTuple, "GetNextTuple" }, 123 { GetNextTuple, "GetNextTuple" },
124 { GetStatus, "GetStatus" }, 124 { GetStatus, "GetStatus" },
125 { GetTupleData, "GetTupleData" }, 125 { GetTupleData, "GetTupleData" },
126 { MapMemPage, "MapMemPage" }, 126 { MapMemPage, "MapMemPage" },
127 { ModifyConfiguration, "ModifyConfiguration" }, 127 { ModifyConfiguration, "ModifyConfiguration" },
128 { ModifyWindow, "ModifyWindow" }, 128 { ModifyWindow, "ModifyWindow" },
129 { OpenMemory, "OpenMemory" }, 129 { OpenMemory, "OpenMemory" },
130 { ParseTuple, "ParseTuple" }, 130 { ParseTuple, "ParseTuple" },
131 { ReadMemory, "ReadMemory" }, 131 { ReadMemory, "ReadMemory" },
132 { RegisterClient, "RegisterClient" }, 132 { RegisterClient, "RegisterClient" },
133 { RegisterEraseQueue, "RegisterEraseQueue" }, 133 { RegisterEraseQueue, "RegisterEraseQueue" },
134 { RegisterMTD, "RegisterMTD" }, 134 { RegisterMTD, "RegisterMTD" },
135 { ReleaseConfiguration, "ReleaseConfiguration" }, 135 { ReleaseConfiguration, "ReleaseConfiguration" },
136 { ReleaseIO, "ReleaseIO" }, 136 { ReleaseIO, "ReleaseIO" },
137 { ReleaseIRQ, "ReleaseIRQ" }, 137 { ReleaseIRQ, "ReleaseIRQ" },
138 { ReleaseWindow, "ReleaseWindow" }, 138 { ReleaseWindow, "ReleaseWindow" },
139 { RequestConfiguration, "RequestConfiguration" }, 139 { RequestConfiguration, "RequestConfiguration" },
140 { RequestIO, "RequestIO" }, 140 { RequestIO, "RequestIO" },
141 { RequestIRQ, "RequestIRQ" }, 141 { RequestIRQ, "RequestIRQ" },
142 { RequestSocketMask, "RequestSocketMask" }, 142 { RequestSocketMask, "RequestSocketMask" },
143 { RequestWindow, "RequestWindow" }, 143 { RequestWindow, "RequestWindow" },
144 { ResetCard, "ResetCard" }, 144 { ResetCard, "ResetCard" },
145 { SetEventMask, "SetEventMask" }, 145 { SetEventMask, "SetEventMask" },
146 { ValidateCIS, "ValidateCIS" }, 146 { ValidateCIS, "ValidateCIS" },
147 { WriteMemory, "WriteMemory" }, 147 { WriteMemory, "WriteMemory" },
148 { BindDevice, "BindDevice" }, 148 { BindDevice, "BindDevice" },
149 { BindMTD, "BindMTD" }, 149 { BindMTD, "BindMTD" },
150 { ReportError, "ReportError" }, 150 { ReportError, "ReportError" },
151 { SuspendCard, "SuspendCard" }, 151 { SuspendCard, "SuspendCard" },
152 { ResumeCard, "ResumeCard" }, 152 { ResumeCard, "ResumeCard" },
153 { EjectCard, "EjectCard" }, 153 { EjectCard, "EjectCard" },
154 { InsertCard, "InsertCard" }, 154 { InsertCard, "InsertCard" },
155 { ReplaceCIS, "ReplaceCIS" } 155 { ReplaceCIS, "ReplaceCIS" }
156 }; 156 };
157 157
158 158
159 static int pcmcia_report_error(struct pcmcia_device *p_dev, error_info_t *err) 159 static int pcmcia_report_error(struct pcmcia_device *p_dev, error_info_t *err)
160 { 160 {
161 int i; 161 int i;
162 char *serv; 162 char *serv;
163 163
164 if (!p_dev) 164 if (!p_dev)
165 printk(KERN_NOTICE); 165 printk(KERN_NOTICE);
166 else 166 else
167 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id); 167 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id);
168 168
169 for (i = 0; i < ARRAY_SIZE(service_table); i++) 169 for (i = 0; i < ARRAY_SIZE(service_table); i++)
170 if (service_table[i].key == err->func) 170 if (service_table[i].key == err->func)
171 break; 171 break;
172 if (i < ARRAY_SIZE(service_table)) 172 if (i < ARRAY_SIZE(service_table))
173 serv = service_table[i].msg; 173 serv = service_table[i].msg;
174 else 174 else
175 serv = "Unknown service number"; 175 serv = "Unknown service number";
176 176
177 for (i = 0; i < ARRAY_SIZE(error_table); i++) 177 for (i = 0; i < ARRAY_SIZE(error_table); i++)
178 if (error_table[i].key == err->retcode) 178 if (error_table[i].key == err->retcode)
179 break; 179 break;
180 if (i < ARRAY_SIZE(error_table)) 180 if (i < ARRAY_SIZE(error_table))
181 printk("%s: %s\n", serv, error_table[i].msg); 181 printk("%s: %s\n", serv, error_table[i].msg);
182 else 182 else
183 printk("%s: Unknown error code %#x\n", serv, err->retcode); 183 printk("%s: Unknown error code %#x\n", serv, err->retcode);
184 184
185 return CS_SUCCESS; 185 return CS_SUCCESS;
186 } /* report_error */ 186 } /* report_error */
187 187
188 /* end of code which was in cs.c before */ 188 /* end of code which was in cs.c before */
189 189
190 /*======================================================================*/ 190 /*======================================================================*/
191 191
192 void cs_error(struct pcmcia_device *p_dev, int func, int ret) 192 void cs_error(struct pcmcia_device *p_dev, int func, int ret)
193 { 193 {
194 error_info_t err = { func, ret }; 194 error_info_t err = { func, ret };
195 pcmcia_report_error(p_dev, &err); 195 pcmcia_report_error(p_dev, &err);
196 } 196 }
197 EXPORT_SYMBOL(cs_error); 197 EXPORT_SYMBOL(cs_error);
198 198
199 199
200 static void pcmcia_check_driver(struct pcmcia_driver *p_drv) 200 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
201 { 201 {
202 struct pcmcia_device_id *did = p_drv->id_table; 202 struct pcmcia_device_id *did = p_drv->id_table;
203 unsigned int i; 203 unsigned int i;
204 u32 hash; 204 u32 hash;
205 205
206 if (!p_drv->probe || !p_drv->remove) 206 if (!p_drv->probe || !p_drv->remove)
207 printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback " 207 printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "
208 "function\n", p_drv->drv.name); 208 "function\n", p_drv->drv.name);
209 209
210 while (did && did->match_flags) { 210 while (did && did->match_flags) {
211 for (i=0; i<4; i++) { 211 for (i=0; i<4; i++) {
212 if (!did->prod_id[i]) 212 if (!did->prod_id[i])
213 continue; 213 continue;
214 214
215 hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i])); 215 hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
216 if (hash == did->prod_id_hash[i]) 216 if (hash == did->prod_id_hash[i])
217 continue; 217 continue;
218 218
219 printk(KERN_DEBUG "pcmcia: %s: invalid hash for " 219 printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
220 "product string \"%s\": is 0x%x, should " 220 "product string \"%s\": is 0x%x, should "
221 "be 0x%x\n", p_drv->drv.name, did->prod_id[i], 221 "be 0x%x\n", p_drv->drv.name, did->prod_id[i],
222 did->prod_id_hash[i], hash); 222 did->prod_id_hash[i], hash);
223 printk(KERN_DEBUG "pcmcia: see " 223 printk(KERN_DEBUG "pcmcia: see "
224 "Documentation/pcmcia/devicetable.txt for " 224 "Documentation/pcmcia/devicetable.txt for "
225 "details\n"); 225 "details\n");
226 } 226 }
227 did++; 227 did++;
228 } 228 }
229 229
230 return; 230 return;
231 } 231 }
232 232
233 233
234 #ifdef CONFIG_PCMCIA_LOAD_CIS 234 #ifdef CONFIG_PCMCIA_LOAD_CIS
235 235
236 /** 236 /**
237 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken 237 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
238 * @dev - the pcmcia device which needs a CIS override 238 * @dev - the pcmcia device which needs a CIS override
239 * @filename - requested filename in /lib/firmware/ 239 * @filename - requested filename in /lib/firmware/
240 * 240 *
241 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if 241 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
242 * the one provided by the card is broken. The firmware files reside in 242 * the one provided by the card is broken. The firmware files reside in
243 * /lib/firmware/ in userspace. 243 * /lib/firmware/ in userspace.
244 */ 244 */
245 static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) 245 static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
246 { 246 {
247 struct pcmcia_socket *s = dev->socket; 247 struct pcmcia_socket *s = dev->socket;
248 const struct firmware *fw; 248 const struct firmware *fw;
249 char path[20]; 249 char path[20];
250 int ret=-ENOMEM; 250 int ret=-ENOMEM;
251 cisdump_t *cis; 251 cisdump_t *cis;
252 252
253 if (!filename) 253 if (!filename)
254 return -EINVAL; 254 return -EINVAL;
255 255
256 ds_dbg(1, "trying to load firmware %s\n", filename); 256 ds_dbg(1, "trying to load firmware %s\n", filename);
257 257
258 if (strlen(filename) > 14) 258 if (strlen(filename) > 14)
259 return -EINVAL; 259 return -EINVAL;
260 260
261 snprintf(path, 20, "%s", filename); 261 snprintf(path, 20, "%s", filename);
262 262
263 if (request_firmware(&fw, path, &dev->dev) == 0) { 263 if (request_firmware(&fw, path, &dev->dev) == 0) {
264 if (fw->size >= CISTPL_MAX_CIS_SIZE) 264 if (fw->size >= CISTPL_MAX_CIS_SIZE)
265 goto release; 265 goto release;
266 266
267 cis = kzalloc(sizeof(cisdump_t), GFP_KERNEL); 267 cis = kzalloc(sizeof(cisdump_t), GFP_KERNEL);
268 if (!cis) 268 if (!cis)
269 goto release; 269 goto release;
270 270
271 cis->Length = fw->size + 1; 271 cis->Length = fw->size + 1;
272 memcpy(cis->Data, fw->data, fw->size); 272 memcpy(cis->Data, fw->data, fw->size);
273 273
274 if (!pcmcia_replace_cis(s, cis)) 274 if (!pcmcia_replace_cis(s, cis))
275 ret = 0; 275 ret = 0;
276 } 276 }
277 release: 277 release:
278 release_firmware(fw); 278 release_firmware(fw);
279 279
280 return (ret); 280 return (ret);
281 } 281 }
282 282
283 #else /* !CONFIG_PCMCIA_LOAD_CIS */ 283 #else /* !CONFIG_PCMCIA_LOAD_CIS */
284 284
285 static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) 285 static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
286 { 286 {
287 return -ENODEV; 287 return -ENODEV;
288 } 288 }
289 289
290 #endif 290 #endif
291 291
292 292
293 /*======================================================================*/ 293 /*======================================================================*/
294 294
295 295
296 /** 296 /**
297 * pcmcia_register_driver - register a PCMCIA driver with the bus core 297 * pcmcia_register_driver - register a PCMCIA driver with the bus core
298 * 298 *
299 * Registers a PCMCIA driver with the PCMCIA bus core. 299 * Registers a PCMCIA driver with the PCMCIA bus core.
300 */ 300 */
301 static int pcmcia_device_probe(struct device *dev); 301 static int pcmcia_device_probe(struct device *dev);
302 static int pcmcia_device_remove(struct device * dev); 302 static int pcmcia_device_remove(struct device * dev);
303 303
304 int pcmcia_register_driver(struct pcmcia_driver *driver) 304 int pcmcia_register_driver(struct pcmcia_driver *driver)
305 { 305 {
306 if (!driver) 306 if (!driver)
307 return -EINVAL; 307 return -EINVAL;
308 308
309 pcmcia_check_driver(driver); 309 pcmcia_check_driver(driver);
310 310
311 /* initialize common fields */ 311 /* initialize common fields */
312 driver->drv.bus = &pcmcia_bus_type; 312 driver->drv.bus = &pcmcia_bus_type;
313 driver->drv.owner = driver->owner; 313 driver->drv.owner = driver->owner;
314 314
315 return driver_register(&driver->drv); 315 return driver_register(&driver->drv);
316 } 316 }
317 EXPORT_SYMBOL(pcmcia_register_driver); 317 EXPORT_SYMBOL(pcmcia_register_driver);
318 318
319 /** 319 /**
320 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core 320 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
321 */ 321 */
322 void pcmcia_unregister_driver(struct pcmcia_driver *driver) 322 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
323 { 323 {
324 driver_unregister(&driver->drv); 324 driver_unregister(&driver->drv);
325 } 325 }
326 EXPORT_SYMBOL(pcmcia_unregister_driver); 326 EXPORT_SYMBOL(pcmcia_unregister_driver);
327 327
328 328
329 /* pcmcia_device handling */ 329 /* pcmcia_device handling */
330 330
331 struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev) 331 struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
332 { 332 {
333 struct device *tmp_dev; 333 struct device *tmp_dev;
334 tmp_dev = get_device(&p_dev->dev); 334 tmp_dev = get_device(&p_dev->dev);
335 if (!tmp_dev) 335 if (!tmp_dev)
336 return NULL; 336 return NULL;
337 return to_pcmcia_dev(tmp_dev); 337 return to_pcmcia_dev(tmp_dev);
338 } 338 }
339 339
340 void pcmcia_put_dev(struct pcmcia_device *p_dev) 340 void pcmcia_put_dev(struct pcmcia_device *p_dev)
341 { 341 {
342 if (p_dev) 342 if (p_dev)
343 put_device(&p_dev->dev); 343 put_device(&p_dev->dev);
344 } 344 }
345 345
346 static void pcmcia_release_function(struct kref *ref) 346 static void pcmcia_release_function(struct kref *ref)
347 { 347 {
348 struct config_t *c = container_of(ref, struct config_t, ref); 348 struct config_t *c = container_of(ref, struct config_t, ref);
349 kfree(c); 349 kfree(c);
350 } 350 }
351 351
352 static void pcmcia_release_dev(struct device *dev) 352 static void pcmcia_release_dev(struct device *dev)
353 { 353 {
354 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 354 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
355 ds_dbg(1, "releasing dev %p\n", p_dev); 355 ds_dbg(1, "releasing dev %p\n", p_dev);
356 pcmcia_put_socket(p_dev->socket); 356 pcmcia_put_socket(p_dev->socket);
357 kfree(p_dev->devname); 357 kfree(p_dev->devname);
358 kref_put(&p_dev->function_config->ref, pcmcia_release_function); 358 kref_put(&p_dev->function_config->ref, pcmcia_release_function);
359 kfree(p_dev); 359 kfree(p_dev);
360 } 360 }
361 361
362 static void pcmcia_add_pseudo_device(struct pcmcia_socket *s) 362 static void pcmcia_add_pseudo_device(struct pcmcia_socket *s)
363 { 363 {
364 if (!s->pcmcia_state.device_add_pending) { 364 if (!s->pcmcia_state.device_add_pending) {
365 s->pcmcia_state.device_add_pending = 1; 365 s->pcmcia_state.device_add_pending = 1;
366 schedule_work(&s->device_add); 366 schedule_work(&s->device_add);
367 } 367 }
368 return; 368 return;
369 } 369 }
370 370
371 static int pcmcia_device_probe(struct device * dev) 371 static int pcmcia_device_probe(struct device * dev)
372 { 372 {
373 struct pcmcia_device *p_dev; 373 struct pcmcia_device *p_dev;
374 struct pcmcia_driver *p_drv; 374 struct pcmcia_driver *p_drv;
375 struct pcmcia_device_id *did; 375 struct pcmcia_device_id *did;
376 struct pcmcia_socket *s; 376 struct pcmcia_socket *s;
377 int ret = 0; 377 int ret = 0;
378 378
379 dev = get_device(dev); 379 dev = get_device(dev);
380 if (!dev) 380 if (!dev)
381 return -ENODEV; 381 return -ENODEV;
382 382
383 p_dev = to_pcmcia_dev(dev); 383 p_dev = to_pcmcia_dev(dev);
384 p_drv = to_pcmcia_drv(dev->driver); 384 p_drv = to_pcmcia_drv(dev->driver);
385 s = p_dev->socket; 385 s = p_dev->socket;
386 386
387 if ((!p_drv->probe) || (!p_dev->function_config) || 387 if ((!p_drv->probe) || (!p_dev->function_config) ||
388 (!try_module_get(p_drv->owner))) { 388 (!try_module_get(p_drv->owner))) {
389 ret = -EINVAL; 389 ret = -EINVAL;
390 goto put_dev; 390 goto put_dev;
391 } 391 }
392 392
393 ret = p_drv->probe(p_dev); 393 ret = p_drv->probe(p_dev);
394 if (ret) 394 if (ret)
395 goto put_module; 395 goto put_module;
396 396
397 /* handle pseudo multifunction devices: 397 /* handle pseudo multifunction devices:
398 * there are at most two pseudo multifunction devices. 398 * there are at most two pseudo multifunction devices.
399 * if we're matching against the first, schedule a 399 * if we're matching against the first, schedule a
400 * call which will then check whether there are two 400 * call which will then check whether there are two
401 * pseudo devices, and if not, add the second one. 401 * pseudo devices, and if not, add the second one.
402 */ 402 */
403 did = (struct pcmcia_device_id *) p_dev->dev.driver_data; 403 did = (struct pcmcia_device_id *) p_dev->dev.driver_data;
404 if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && 404 if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) &&
405 (p_dev->socket->device_count == 1) && (p_dev->device_no == 0)) 405 (p_dev->socket->device_count == 1) && (p_dev->device_no == 0))
406 pcmcia_add_pseudo_device(p_dev->socket); 406 pcmcia_add_pseudo_device(p_dev->socket);
407 407
408 put_module: 408 put_module:
409 if (ret) 409 if (ret)
410 module_put(p_drv->owner); 410 module_put(p_drv->owner);
411 put_dev: 411 put_dev:
412 if (ret) 412 if (ret)
413 put_device(dev); 413 put_device(dev);
414 return (ret); 414 return (ret);
415 } 415 }
416 416
417 417
418 /* 418 /*
419 * Removes a PCMCIA card from the device tree and socket list. 419 * Removes a PCMCIA card from the device tree and socket list.
420 */ 420 */
421 static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover) 421 static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover)
422 { 422 {
423 struct pcmcia_device *p_dev; 423 struct pcmcia_device *p_dev;
424 struct pcmcia_device *tmp; 424 struct pcmcia_device *tmp;
425 unsigned long flags; 425 unsigned long flags;
426 426
427 ds_dbg(2, "unbind_request(%d)\n", s->sock); 427 ds_dbg(2, "unbind_request(%d)\n", s->sock);
428 428
429 429
430 if (!leftover) 430 if (!leftover)
431 s->device_count = 0; 431 s->device_count = 0;
432 else 432 else
433 s->device_count = 1; 433 s->device_count = 1;
434 434
435 /* unregister all pcmcia_devices registered with this socket, except leftover */ 435 /* unregister all pcmcia_devices registered with this socket, except leftover */
436 list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) { 436 list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) {
437 if (p_dev == leftover) 437 if (p_dev == leftover)
438 continue; 438 continue;
439 439
440 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 440 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
441 list_del(&p_dev->socket_device_list); 441 list_del(&p_dev->socket_device_list);
442 p_dev->_removed=1; 442 p_dev->_removed=1;
443 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 443 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
444 444
445 device_unregister(&p_dev->dev); 445 device_unregister(&p_dev->dev);
446 } 446 }
447 447
448 return; 448 return;
449 } 449 }
450 450
451 451
452 static int pcmcia_device_remove(struct device * dev) 452 static int pcmcia_device_remove(struct device * dev)
453 { 453 {
454 struct pcmcia_device *p_dev; 454 struct pcmcia_device *p_dev;
455 struct pcmcia_driver *p_drv; 455 struct pcmcia_driver *p_drv;
456 struct pcmcia_device_id *did; 456 struct pcmcia_device_id *did;
457 int i; 457 int i;
458 458
459 p_dev = to_pcmcia_dev(dev); 459 p_dev = to_pcmcia_dev(dev);
460 p_drv = to_pcmcia_drv(dev->driver); 460 p_drv = to_pcmcia_drv(dev->driver);
461 461
462 /* If we're removing the primary module driving a 462 /* If we're removing the primary module driving a
463 * pseudo multi-function card, we need to unbind 463 * pseudo multi-function card, we need to unbind
464 * all devices 464 * all devices
465 */ 465 */
466 did = (struct pcmcia_device_id *) p_dev->dev.driver_data; 466 did = (struct pcmcia_device_id *) p_dev->dev.driver_data;
467 if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && 467 if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) &&
468 (p_dev->socket->device_count != 0) && 468 (p_dev->socket->device_count != 0) &&
469 (p_dev->device_no == 0)) 469 (p_dev->device_no == 0))
470 pcmcia_card_remove(p_dev->socket, p_dev); 470 pcmcia_card_remove(p_dev->socket, p_dev);
471 471
472 /* detach the "instance" */ 472 /* detach the "instance" */
473 if (!p_drv) 473 if (!p_drv)
474 return 0; 474 return 0;
475 475
476 if (p_drv->remove) 476 if (p_drv->remove)
477 p_drv->remove(p_dev); 477 p_drv->remove(p_dev);
478 478
479 p_dev->dev_node = NULL;
480
479 /* check for proper unloading */ 481 /* check for proper unloading */
480 if (p_dev->_irq || p_dev->_io || p_dev->_locked) 482 if (p_dev->_irq || p_dev->_io || p_dev->_locked)
481 printk(KERN_INFO "pcmcia: driver %s did not release config properly\n", 483 printk(KERN_INFO "pcmcia: driver %s did not release config properly\n",
482 p_drv->drv.name); 484 p_drv->drv.name);
483 485
484 for (i = 0; i < MAX_WIN; i++) 486 for (i = 0; i < MAX_WIN; i++)
485 if (p_dev->_win & CLIENT_WIN_REQ(i)) 487 if (p_dev->_win & CLIENT_WIN_REQ(i))
486 printk(KERN_INFO "pcmcia: driver %s did not release windows properly\n", 488 printk(KERN_INFO "pcmcia: driver %s did not release windows properly\n",
487 p_drv->drv.name); 489 p_drv->drv.name);
488 490
489 /* references from pcmcia_probe_device */ 491 /* references from pcmcia_probe_device */
490 pcmcia_put_dev(p_dev); 492 pcmcia_put_dev(p_dev);
491 module_put(p_drv->owner); 493 module_put(p_drv->owner);
492 494
493 return 0; 495 return 0;
494 } 496 }
495 497
496 498
497 /* 499 /*
498 * pcmcia_device_query -- determine information about a pcmcia device 500 * pcmcia_device_query -- determine information about a pcmcia device
499 */ 501 */
500 static int pcmcia_device_query(struct pcmcia_device *p_dev) 502 static int pcmcia_device_query(struct pcmcia_device *p_dev)
501 { 503 {
502 cistpl_manfid_t manf_id; 504 cistpl_manfid_t manf_id;
503 cistpl_funcid_t func_id; 505 cistpl_funcid_t func_id;
504 cistpl_vers_1_t *vers1; 506 cistpl_vers_1_t *vers1;
505 unsigned int i; 507 unsigned int i;
506 508
507 vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL); 509 vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);
508 if (!vers1) 510 if (!vers1)
509 return -ENOMEM; 511 return -ENOMEM;
510 512
511 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 513 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
512 CISTPL_MANFID, &manf_id)) { 514 CISTPL_MANFID, &manf_id)) {
513 p_dev->manf_id = manf_id.manf; 515 p_dev->manf_id = manf_id.manf;
514 p_dev->card_id = manf_id.card; 516 p_dev->card_id = manf_id.card;
515 p_dev->has_manf_id = 1; 517 p_dev->has_manf_id = 1;
516 p_dev->has_card_id = 1; 518 p_dev->has_card_id = 1;
517 } 519 }
518 520
519 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 521 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
520 CISTPL_FUNCID, &func_id)) { 522 CISTPL_FUNCID, &func_id)) {
521 p_dev->func_id = func_id.func; 523 p_dev->func_id = func_id.func;
522 p_dev->has_func_id = 1; 524 p_dev->has_func_id = 1;
523 } else { 525 } else {
524 /* rule of thumb: cards with no FUNCID, but with 526 /* rule of thumb: cards with no FUNCID, but with
525 * common memory device geometry information, are 527 * common memory device geometry information, are
526 * probably memory cards (from pcmcia-cs) */ 528 * probably memory cards (from pcmcia-cs) */
527 cistpl_device_geo_t *devgeo; 529 cistpl_device_geo_t *devgeo;
528 530
529 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL); 531 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);
530 if (!devgeo) { 532 if (!devgeo) {
531 kfree(vers1); 533 kfree(vers1);
532 return -ENOMEM; 534 return -ENOMEM;
533 } 535 }
534 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 536 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
535 CISTPL_DEVICE_GEO, devgeo)) { 537 CISTPL_DEVICE_GEO, devgeo)) {
536 ds_dbg(0, "mem device geometry probably means " 538 ds_dbg(0, "mem device geometry probably means "
537 "FUNCID_MEMORY\n"); 539 "FUNCID_MEMORY\n");
538 p_dev->func_id = CISTPL_FUNCID_MEMORY; 540 p_dev->func_id = CISTPL_FUNCID_MEMORY;
539 p_dev->has_func_id = 1; 541 p_dev->has_func_id = 1;
540 } 542 }
541 kfree(devgeo); 543 kfree(devgeo);
542 } 544 }
543 545
544 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1, 546 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
545 vers1)) { 547 vers1)) {
546 for (i=0; i < vers1->ns; i++) { 548 for (i=0; i < vers1->ns; i++) {
547 char *tmp; 549 char *tmp;
548 unsigned int length; 550 unsigned int length;
549 551
550 tmp = vers1->str + vers1->ofs[i]; 552 tmp = vers1->str + vers1->ofs[i];
551 553
552 length = strlen(tmp) + 1; 554 length = strlen(tmp) + 1;
553 if ((length < 2) || (length > 255)) 555 if ((length < 2) || (length > 255))
554 continue; 556 continue;
555 557
556 p_dev->prod_id[i] = kmalloc(sizeof(char) * length, 558 p_dev->prod_id[i] = kmalloc(sizeof(char) * length,
557 GFP_KERNEL); 559 GFP_KERNEL);
558 if (!p_dev->prod_id[i]) 560 if (!p_dev->prod_id[i])
559 continue; 561 continue;
560 562
561 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i], 563 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i],
562 tmp, length); 564 tmp, length);
563 } 565 }
564 } 566 }
565 567
566 kfree(vers1); 568 kfree(vers1);
567 return 0; 569 return 0;
568 } 570 }
569 571
570 572
571 /* device_add_lock is needed to avoid double registration by cardmgr and kernel. 573 /* device_add_lock is needed to avoid double registration by cardmgr and kernel.
572 * Serializes pcmcia_device_add; will most likely be removed in future. 574 * Serializes pcmcia_device_add; will most likely be removed in future.
573 * 575 *
574 * While it has the caveat that adding new PCMCIA devices inside(!) device_register() 576 * While it has the caveat that adding new PCMCIA devices inside(!) device_register()
575 * won't work, this doesn't matter much at the moment: the driver core doesn't 577 * won't work, this doesn't matter much at the moment: the driver core doesn't
576 * support it either. 578 * support it either.
577 */ 579 */
578 static DEFINE_MUTEX(device_add_lock); 580 static DEFINE_MUTEX(device_add_lock);
579 581
580 struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int function) 582 struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int function)
581 { 583 {
582 struct pcmcia_device *p_dev, *tmp_dev; 584 struct pcmcia_device *p_dev, *tmp_dev;
583 unsigned long flags; 585 unsigned long flags;
584 int bus_id_len; 586 int bus_id_len;
585 587
586 s = pcmcia_get_socket(s); 588 s = pcmcia_get_socket(s);
587 if (!s) 589 if (!s)
588 return NULL; 590 return NULL;
589 591
590 mutex_lock(&device_add_lock); 592 mutex_lock(&device_add_lock);
591 593
592 /* max of 2 devices per card */ 594 /* max of 2 devices per card */
593 if (s->device_count == 2) 595 if (s->device_count == 2)
594 goto err_put; 596 goto err_put;
595 597
596 p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL); 598 p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
597 if (!p_dev) 599 if (!p_dev)
598 goto err_put; 600 goto err_put;
599 601
600 p_dev->socket = s; 602 p_dev->socket = s;
601 p_dev->device_no = (s->device_count++); 603 p_dev->device_no = (s->device_count++);
602 p_dev->func = function; 604 p_dev->func = function;
603 if (s->functions <= function) 605 if (s->functions <= function)
604 s->functions = function + 1; 606 s->functions = function + 1;
605 607
606 p_dev->dev.bus = &pcmcia_bus_type; 608 p_dev->dev.bus = &pcmcia_bus_type;
607 p_dev->dev.parent = s->dev.dev; 609 p_dev->dev.parent = s->dev.dev;
608 p_dev->dev.release = pcmcia_release_dev; 610 p_dev->dev.release = pcmcia_release_dev;
609 bus_id_len = sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no); 611 bus_id_len = sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
610 612
611 p_dev->devname = kmalloc(6 + bus_id_len + 1, GFP_KERNEL); 613 p_dev->devname = kmalloc(6 + bus_id_len + 1, GFP_KERNEL);
612 if (!p_dev->devname) 614 if (!p_dev->devname)
613 goto err_free; 615 goto err_free;
614 sprintf (p_dev->devname, "pcmcia%s", p_dev->dev.bus_id); 616 sprintf (p_dev->devname, "pcmcia%s", p_dev->dev.bus_id);
615 617
616 /* compat */ 618 /* compat */
617 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 619 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
618 620
619 /* 621 /*
620 * p_dev->function_config must be the same for all card functions. 622 * p_dev->function_config must be the same for all card functions.
621 * Note that this is serialized by the device_add_lock, so that 623 * Note that this is serialized by the device_add_lock, so that
622 * only one such struct will be created. 624 * only one such struct will be created.
623 */ 625 */
624 list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list) 626 list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
625 if (p_dev->func == tmp_dev->func) { 627 if (p_dev->func == tmp_dev->func) {
626 p_dev->function_config = tmp_dev->function_config; 628 p_dev->function_config = tmp_dev->function_config;
627 kref_get(&p_dev->function_config->ref); 629 kref_get(&p_dev->function_config->ref);
628 } 630 }
629 631
630 /* Add to the list in pcmcia_bus_socket */ 632 /* Add to the list in pcmcia_bus_socket */
631 list_add(&p_dev->socket_device_list, &s->devices_list); 633 list_add(&p_dev->socket_device_list, &s->devices_list);
632 634
633 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 635 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
634 636
635 if (!p_dev->function_config) { 637 if (!p_dev->function_config) {
636 p_dev->function_config = kzalloc(sizeof(struct config_t), 638 p_dev->function_config = kzalloc(sizeof(struct config_t),
637 GFP_KERNEL); 639 GFP_KERNEL);
638 if (!p_dev->function_config) 640 if (!p_dev->function_config)
639 goto err_unreg; 641 goto err_unreg;
640 kref_init(&p_dev->function_config->ref); 642 kref_init(&p_dev->function_config->ref);
641 } 643 }
642 644
643 printk(KERN_NOTICE "pcmcia: registering new device %s\n", 645 printk(KERN_NOTICE "pcmcia: registering new device %s\n",
644 p_dev->devname); 646 p_dev->devname);
645 647
646 pcmcia_device_query(p_dev); 648 pcmcia_device_query(p_dev);
647 649
648 if (device_register(&p_dev->dev)) 650 if (device_register(&p_dev->dev))
649 goto err_unreg; 651 goto err_unreg;
650 652
651 mutex_unlock(&device_add_lock); 653 mutex_unlock(&device_add_lock);
652 654
653 return p_dev; 655 return p_dev;
654 656
655 err_unreg: 657 err_unreg:
656 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 658 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
657 list_del(&p_dev->socket_device_list); 659 list_del(&p_dev->socket_device_list);
658 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 660 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
659 661
660 err_free: 662 err_free:
661 kfree(p_dev->devname); 663 kfree(p_dev->devname);
662 kfree(p_dev); 664 kfree(p_dev);
663 s->device_count--; 665 s->device_count--;
664 err_put: 666 err_put:
665 mutex_unlock(&device_add_lock); 667 mutex_unlock(&device_add_lock);
666 pcmcia_put_socket(s); 668 pcmcia_put_socket(s);
667 669
668 return NULL; 670 return NULL;
669 } 671 }
670 672
671 673
672 static int pcmcia_card_add(struct pcmcia_socket *s) 674 static int pcmcia_card_add(struct pcmcia_socket *s)
673 { 675 {
674 cisinfo_t cisinfo; 676 cisinfo_t cisinfo;
675 cistpl_longlink_mfc_t mfc; 677 cistpl_longlink_mfc_t mfc;
676 unsigned int no_funcs, i; 678 unsigned int no_funcs, i;
677 int ret = 0; 679 int ret = 0;
678 680
679 if (!(s->resource_setup_done)) 681 if (!(s->resource_setup_done))
680 return -EAGAIN; /* try again, but later... */ 682 return -EAGAIN; /* try again, but later... */
681 683
682 if (pcmcia_validate_mem(s)) 684 if (pcmcia_validate_mem(s))
683 return -EAGAIN; /* try again, but later... */ 685 return -EAGAIN; /* try again, but later... */
684 686
685 ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo); 687 ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo);
686 if (ret || !cisinfo.Chains) { 688 if (ret || !cisinfo.Chains) {
687 ds_dbg(0, "invalid CIS or invalid resources\n"); 689 ds_dbg(0, "invalid CIS or invalid resources\n");
688 return -ENODEV; 690 return -ENODEV;
689 } 691 }
690 692
691 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) 693 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
692 no_funcs = mfc.nfn; 694 no_funcs = mfc.nfn;
693 else 695 else
694 no_funcs = 1; 696 no_funcs = 1;
695 697
696 for (i=0; i < no_funcs; i++) 698 for (i=0; i < no_funcs; i++)
697 pcmcia_device_add(s, i); 699 pcmcia_device_add(s, i);
698 700
699 return (ret); 701 return (ret);
700 } 702 }
701 703
702 704
703 static void pcmcia_delayed_add_pseudo_device(void *data) 705 static void pcmcia_delayed_add_pseudo_device(void *data)
704 { 706 {
705 struct pcmcia_socket *s = data; 707 struct pcmcia_socket *s = data;
706 pcmcia_device_add(s, 0); 708 pcmcia_device_add(s, 0);
707 s->pcmcia_state.device_add_pending = 0; 709 s->pcmcia_state.device_add_pending = 0;
708 } 710 }
709 711
710 static int pcmcia_requery(struct device *dev, void * _data) 712 static int pcmcia_requery(struct device *dev, void * _data)
711 { 713 {
712 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 714 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
713 if (!p_dev->dev.driver) 715 if (!p_dev->dev.driver)
714 pcmcia_device_query(p_dev); 716 pcmcia_device_query(p_dev);
715 717
716 return 0; 718 return 0;
717 } 719 }
718 720
719 static void pcmcia_bus_rescan(struct pcmcia_socket *skt) 721 static void pcmcia_bus_rescan(struct pcmcia_socket *skt)
720 { 722 {
721 int no_devices=0; 723 int no_devices=0;
722 unsigned long flags; 724 unsigned long flags;
723 725
724 /* must be called with skt_mutex held */ 726 /* must be called with skt_mutex held */
725 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 727 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
726 if (list_empty(&skt->devices_list)) 728 if (list_empty(&skt->devices_list))
727 no_devices=1; 729 no_devices=1;
728 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 730 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
729 731
730 /* if no devices were added for this socket yet because of 732 /* if no devices were added for this socket yet because of
731 * missing resource information or other trouble, we need to 733 * missing resource information or other trouble, we need to
732 * do this now. */ 734 * do this now. */
733 if (no_devices) { 735 if (no_devices) {
734 int ret = pcmcia_card_add(skt); 736 int ret = pcmcia_card_add(skt);
735 if (ret) 737 if (ret)
736 return; 738 return;
737 } 739 }
738 740
739 /* some device information might have changed because of a CIS 741 /* some device information might have changed because of a CIS
740 * update or because we can finally read it correctly... so 742 * update or because we can finally read it correctly... so
741 * determine it again, overwriting old values if necessary. */ 743 * determine it again, overwriting old values if necessary. */
742 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery); 744 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery);
743 745
744 /* we re-scan all devices, not just the ones connected to this 746 /* we re-scan all devices, not just the ones connected to this
745 * socket. This does not matter, though. */ 747 * socket. This does not matter, though. */
746 bus_rescan_devices(&pcmcia_bus_type); 748 bus_rescan_devices(&pcmcia_bus_type);
747 } 749 }
748 750
749 static inline int pcmcia_devmatch(struct pcmcia_device *dev, 751 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
750 struct pcmcia_device_id *did) 752 struct pcmcia_device_id *did)
751 { 753 {
752 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) { 754 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
753 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id)) 755 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
754 return 0; 756 return 0;
755 } 757 }
756 758
757 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) { 759 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
758 if ((!dev->has_card_id) || (dev->card_id != did->card_id)) 760 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
759 return 0; 761 return 0;
760 } 762 }
761 763
762 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) { 764 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
763 if (dev->func != did->function) 765 if (dev->func != did->function)
764 return 0; 766 return 0;
765 } 767 }
766 768
767 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) { 769 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
768 if (!dev->prod_id[0]) 770 if (!dev->prod_id[0])
769 return 0; 771 return 0;
770 if (strcmp(did->prod_id[0], dev->prod_id[0])) 772 if (strcmp(did->prod_id[0], dev->prod_id[0]))
771 return 0; 773 return 0;
772 } 774 }
773 775
774 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) { 776 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
775 if (!dev->prod_id[1]) 777 if (!dev->prod_id[1])
776 return 0; 778 return 0;
777 if (strcmp(did->prod_id[1], dev->prod_id[1])) 779 if (strcmp(did->prod_id[1], dev->prod_id[1]))
778 return 0; 780 return 0;
779 } 781 }
780 782
781 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) { 783 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
782 if (!dev->prod_id[2]) 784 if (!dev->prod_id[2])
783 return 0; 785 return 0;
784 if (strcmp(did->prod_id[2], dev->prod_id[2])) 786 if (strcmp(did->prod_id[2], dev->prod_id[2]))
785 return 0; 787 return 0;
786 } 788 }
787 789
788 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) { 790 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
789 if (!dev->prod_id[3]) 791 if (!dev->prod_id[3])
790 return 0; 792 return 0;
791 if (strcmp(did->prod_id[3], dev->prod_id[3])) 793 if (strcmp(did->prod_id[3], dev->prod_id[3]))
792 return 0; 794 return 0;
793 } 795 }
794 796
795 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) { 797 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
796 if (dev->device_no != did->device_no) 798 if (dev->device_no != did->device_no)
797 return 0; 799 return 0;
798 } 800 }
799 801
800 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) { 802 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
801 if ((!dev->has_func_id) || (dev->func_id != did->func_id)) 803 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
802 return 0; 804 return 0;
803 805
804 /* if this is a pseudo-multi-function device, 806 /* if this is a pseudo-multi-function device,
805 * we need explicit matches */ 807 * we need explicit matches */
806 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) 808 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO)
807 return 0; 809 return 0;
808 if (dev->device_no) 810 if (dev->device_no)
809 return 0; 811 return 0;
810 812
811 /* also, FUNC_ID matching needs to be activated by userspace 813 /* also, FUNC_ID matching needs to be activated by userspace
812 * after it has re-checked that there is no possible module 814 * after it has re-checked that there is no possible module
813 * with a prod_id/manf_id/card_id match. 815 * with a prod_id/manf_id/card_id match.
814 */ 816 */
815 if (!dev->allow_func_id_match) 817 if (!dev->allow_func_id_match)
816 return 0; 818 return 0;
817 } 819 }
818 820
819 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) { 821 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
820 if (!dev->socket->fake_cis) 822 if (!dev->socket->fake_cis)
821 pcmcia_load_firmware(dev, did->cisfile); 823 pcmcia_load_firmware(dev, did->cisfile);
822 824
823 if (!dev->socket->fake_cis) 825 if (!dev->socket->fake_cis)
824 return 0; 826 return 0;
825 } 827 }
826 828
827 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) { 829 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
828 int i; 830 int i;
829 for (i=0; i<4; i++) 831 for (i=0; i<4; i++)
830 if (dev->prod_id[i]) 832 if (dev->prod_id[i])
831 return 0; 833 return 0;
832 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id) 834 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
833 return 0; 835 return 0;
834 } 836 }
835 837
836 dev->dev.driver_data = (void *) did; 838 dev->dev.driver_data = (void *) did;
837 839
838 return 1; 840 return 1;
839 } 841 }
840 842
841 843
842 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) { 844 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) {
843 struct pcmcia_device * p_dev = to_pcmcia_dev(dev); 845 struct pcmcia_device * p_dev = to_pcmcia_dev(dev);
844 struct pcmcia_driver * p_drv = to_pcmcia_drv(drv); 846 struct pcmcia_driver * p_drv = to_pcmcia_drv(drv);
845 struct pcmcia_device_id *did = p_drv->id_table; 847 struct pcmcia_device_id *did = p_drv->id_table;
846 848
847 #ifdef CONFIG_PCMCIA_IOCTL 849 #ifdef CONFIG_PCMCIA_IOCTL
848 /* matching by cardmgr */ 850 /* matching by cardmgr */
849 if (p_dev->cardmgr == p_drv) 851 if (p_dev->cardmgr == p_drv)
850 return 1; 852 return 1;
851 #endif 853 #endif
852 854
853 while (did && did->match_flags) { 855 while (did && did->match_flags) {
854 if (pcmcia_devmatch(p_dev, did)) 856 if (pcmcia_devmatch(p_dev, did))
855 return 1; 857 return 1;
856 did++; 858 did++;
857 } 859 }
858 860
859 return 0; 861 return 0;
860 } 862 }
861 863
862 #ifdef CONFIG_HOTPLUG 864 #ifdef CONFIG_HOTPLUG
863 865
864 static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp, 866 static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp,
865 char *buffer, int buffer_size) 867 char *buffer, int buffer_size)
866 { 868 {
867 struct pcmcia_device *p_dev; 869 struct pcmcia_device *p_dev;
868 int i, length = 0; 870 int i, length = 0;
869 u32 hash[4] = { 0, 0, 0, 0}; 871 u32 hash[4] = { 0, 0, 0, 0};
870 872
871 if (!dev) 873 if (!dev)
872 return -ENODEV; 874 return -ENODEV;
873 875
874 p_dev = to_pcmcia_dev(dev); 876 p_dev = to_pcmcia_dev(dev);
875 877
876 /* calculate hashes */ 878 /* calculate hashes */
877 for (i=0; i<4; i++) { 879 for (i=0; i<4; i++) {
878 if (!p_dev->prod_id[i]) 880 if (!p_dev->prod_id[i])
879 continue; 881 continue;
880 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i])); 882 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
881 } 883 }
882 884
883 i = 0; 885 i = 0;
884 886
885 if (add_uevent_var(envp, num_envp, &i, 887 if (add_uevent_var(envp, num_envp, &i,
886 buffer, buffer_size, &length, 888 buffer, buffer_size, &length,
887 "SOCKET_NO=%u", 889 "SOCKET_NO=%u",
888 p_dev->socket->sock)) 890 p_dev->socket->sock))
889 return -ENOMEM; 891 return -ENOMEM;
890 892
891 if (add_uevent_var(envp, num_envp, &i, 893 if (add_uevent_var(envp, num_envp, &i,
892 buffer, buffer_size, &length, 894 buffer, buffer_size, &length,
893 "DEVICE_NO=%02X", 895 "DEVICE_NO=%02X",
894 p_dev->device_no)) 896 p_dev->device_no))
895 return -ENOMEM; 897 return -ENOMEM;
896 898
897 if (add_uevent_var(envp, num_envp, &i, 899 if (add_uevent_var(envp, num_envp, &i,
898 buffer, buffer_size, &length, 900 buffer, buffer_size, &length,
899 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 901 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
900 "pa%08Xpb%08Xpc%08Xpd%08X", 902 "pa%08Xpb%08Xpc%08Xpd%08X",
901 p_dev->has_manf_id ? p_dev->manf_id : 0, 903 p_dev->has_manf_id ? p_dev->manf_id : 0,
902 p_dev->has_card_id ? p_dev->card_id : 0, 904 p_dev->has_card_id ? p_dev->card_id : 0,
903 p_dev->has_func_id ? p_dev->func_id : 0, 905 p_dev->has_func_id ? p_dev->func_id : 0,
904 p_dev->func, 906 p_dev->func,
905 p_dev->device_no, 907 p_dev->device_no,
906 hash[0], 908 hash[0],
907 hash[1], 909 hash[1],
908 hash[2], 910 hash[2],
909 hash[3])) 911 hash[3]))
910 return -ENOMEM; 912 return -ENOMEM;
911 913
912 envp[i] = NULL; 914 envp[i] = NULL;
913 915
914 return 0; 916 return 0;
915 } 917 }
916 918
917 #else 919 #else
918 920
919 static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp, 921 static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp,
920 char *buffer, int buffer_size) 922 char *buffer, int buffer_size)
921 { 923 {
922 return -ENODEV; 924 return -ENODEV;
923 } 925 }
924 926
925 #endif 927 #endif
926 928
927 /************************ per-device sysfs output ***************************/ 929 /************************ per-device sysfs output ***************************/
928 930
929 #define pcmcia_device_attr(field, test, format) \ 931 #define pcmcia_device_attr(field, test, format) \
930 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 932 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \
931 { \ 933 { \
932 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 934 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
933 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \ 935 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \
934 } 936 }
935 937
936 #define pcmcia_device_stringattr(name, field) \ 938 #define pcmcia_device_stringattr(name, field) \
937 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 939 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
938 { \ 940 { \
939 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 941 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
940 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \ 942 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \
941 } 943 }
942 944
943 pcmcia_device_attr(func, socket, "0x%02x\n"); 945 pcmcia_device_attr(func, socket, "0x%02x\n");
944 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n"); 946 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
945 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n"); 947 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
946 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n"); 948 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
947 pcmcia_device_stringattr(prod_id1, prod_id[0]); 949 pcmcia_device_stringattr(prod_id1, prod_id[0]);
948 pcmcia_device_stringattr(prod_id2, prod_id[1]); 950 pcmcia_device_stringattr(prod_id2, prod_id[1]);
949 pcmcia_device_stringattr(prod_id3, prod_id[2]); 951 pcmcia_device_stringattr(prod_id3, prod_id[2]);
950 pcmcia_device_stringattr(prod_id4, prod_id[3]); 952 pcmcia_device_stringattr(prod_id4, prod_id[3]);
951 953
952 954
953 static ssize_t pcmcia_show_pm_state(struct device *dev, struct device_attribute *attr, char *buf) 955 static ssize_t pcmcia_show_pm_state(struct device *dev, struct device_attribute *attr, char *buf)
954 { 956 {
955 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 957 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
956 958
957 if (p_dev->suspended) 959 if (p_dev->suspended)
958 return sprintf(buf, "off\n"); 960 return sprintf(buf, "off\n");
959 else 961 else
960 return sprintf(buf, "on\n"); 962 return sprintf(buf, "on\n");
961 } 963 }
962 964
963 static ssize_t pcmcia_store_pm_state(struct device *dev, struct device_attribute *attr, 965 static ssize_t pcmcia_store_pm_state(struct device *dev, struct device_attribute *attr,
964 const char *buf, size_t count) 966 const char *buf, size_t count)
965 { 967 {
966 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 968 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
967 int ret = 0; 969 int ret = 0;
968 970
969 if (!count) 971 if (!count)
970 return -EINVAL; 972 return -EINVAL;
971 973
972 if ((!p_dev->suspended) && !strncmp(buf, "off", 3)) 974 if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
973 ret = dpm_runtime_suspend(dev, PMSG_SUSPEND); 975 ret = dpm_runtime_suspend(dev, PMSG_SUSPEND);
974 else if (p_dev->suspended && !strncmp(buf, "on", 2)) 976 else if (p_dev->suspended && !strncmp(buf, "on", 2))
975 dpm_runtime_resume(dev); 977 dpm_runtime_resume(dev);
976 978
977 return ret ? ret : count; 979 return ret ? ret : count;
978 } 980 }
979 981
980 982
981 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 983 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
982 { 984 {
983 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 985 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
984 int i; 986 int i;
985 u32 hash[4] = { 0, 0, 0, 0}; 987 u32 hash[4] = { 0, 0, 0, 0};
986 988
987 /* calculate hashes */ 989 /* calculate hashes */
988 for (i=0; i<4; i++) { 990 for (i=0; i<4; i++) {
989 if (!p_dev->prod_id[i]) 991 if (!p_dev->prod_id[i])
990 continue; 992 continue;
991 hash[i] = crc32(0,p_dev->prod_id[i],strlen(p_dev->prod_id[i])); 993 hash[i] = crc32(0,p_dev->prod_id[i],strlen(p_dev->prod_id[i]));
992 } 994 }
993 return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 995 return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
994 "pa%08Xpb%08Xpc%08Xpd%08X\n", 996 "pa%08Xpb%08Xpc%08Xpd%08X\n",
995 p_dev->has_manf_id ? p_dev->manf_id : 0, 997 p_dev->has_manf_id ? p_dev->manf_id : 0,
996 p_dev->has_card_id ? p_dev->card_id : 0, 998 p_dev->has_card_id ? p_dev->card_id : 0,
997 p_dev->has_func_id ? p_dev->func_id : 0, 999 p_dev->has_func_id ? p_dev->func_id : 0,
998 p_dev->func, p_dev->device_no, 1000 p_dev->func, p_dev->device_no,
999 hash[0], hash[1], hash[2], hash[3]); 1001 hash[0], hash[1], hash[2], hash[3]);
1000 } 1002 }
1001 1003
1002 static ssize_t pcmcia_store_allow_func_id_match(struct device *dev, 1004 static ssize_t pcmcia_store_allow_func_id_match(struct device *dev,
1003 struct device_attribute *attr, const char *buf, size_t count) 1005 struct device_attribute *attr, const char *buf, size_t count)
1004 { 1006 {
1005 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1007 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1006 1008
1007 if (!count) 1009 if (!count)
1008 return -EINVAL; 1010 return -EINVAL;
1009 1011
1010 mutex_lock(&p_dev->socket->skt_mutex); 1012 mutex_lock(&p_dev->socket->skt_mutex);
1011 p_dev->allow_func_id_match = 1; 1013 p_dev->allow_func_id_match = 1;
1012 mutex_unlock(&p_dev->socket->skt_mutex); 1014 mutex_unlock(&p_dev->socket->skt_mutex);
1013 1015
1014 bus_rescan_devices(&pcmcia_bus_type); 1016 bus_rescan_devices(&pcmcia_bus_type);
1015 1017
1016 return count; 1018 return count;
1017 } 1019 }
1018 1020
1019 static struct device_attribute pcmcia_dev_attrs[] = { 1021 static struct device_attribute pcmcia_dev_attrs[] = {
1020 __ATTR(function, 0444, func_show, NULL), 1022 __ATTR(function, 0444, func_show, NULL),
1021 __ATTR(pm_state, 0644, pcmcia_show_pm_state, pcmcia_store_pm_state), 1023 __ATTR(pm_state, 0644, pcmcia_show_pm_state, pcmcia_store_pm_state),
1022 __ATTR_RO(func_id), 1024 __ATTR_RO(func_id),
1023 __ATTR_RO(manf_id), 1025 __ATTR_RO(manf_id),
1024 __ATTR_RO(card_id), 1026 __ATTR_RO(card_id),
1025 __ATTR_RO(prod_id1), 1027 __ATTR_RO(prod_id1),
1026 __ATTR_RO(prod_id2), 1028 __ATTR_RO(prod_id2),
1027 __ATTR_RO(prod_id3), 1029 __ATTR_RO(prod_id3),
1028 __ATTR_RO(prod_id4), 1030 __ATTR_RO(prod_id4),
1029 __ATTR_RO(modalias), 1031 __ATTR_RO(modalias),
1030 __ATTR(allow_func_id_match, 0200, NULL, pcmcia_store_allow_func_id_match), 1032 __ATTR(allow_func_id_match, 0200, NULL, pcmcia_store_allow_func_id_match),
1031 __ATTR_NULL, 1033 __ATTR_NULL,
1032 }; 1034 };
1033 1035
1034 /* PM support, also needed for reset */ 1036 /* PM support, also needed for reset */
1035 1037
1036 static int pcmcia_dev_suspend(struct device * dev, pm_message_t state) 1038 static int pcmcia_dev_suspend(struct device * dev, pm_message_t state)
1037 { 1039 {
1038 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1040 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1039 struct pcmcia_driver *p_drv = NULL; 1041 struct pcmcia_driver *p_drv = NULL;
1040 int ret = 0; 1042 int ret = 0;
1041 1043
1042 if (dev->driver) 1044 if (dev->driver)
1043 p_drv = to_pcmcia_drv(dev->driver); 1045 p_drv = to_pcmcia_drv(dev->driver);
1044 1046
1045 if (!p_drv) 1047 if (!p_drv)
1046 goto out; 1048 goto out;
1047 1049
1048 if (p_drv->suspend) { 1050 if (p_drv->suspend) {
1049 ret = p_drv->suspend(p_dev); 1051 ret = p_drv->suspend(p_dev);
1050 if (ret) 1052 if (ret)
1051 goto out; 1053 goto out;
1052 } 1054 }
1053 1055
1054 if (p_dev->device_no == p_dev->func) 1056 if (p_dev->device_no == p_dev->func)
1055 pcmcia_release_configuration(p_dev); 1057 pcmcia_release_configuration(p_dev);
1056 1058
1057 out: 1059 out:
1058 if (!ret) 1060 if (!ret)
1059 p_dev->suspended = 1; 1061 p_dev->suspended = 1;
1060 return ret; 1062 return ret;
1061 } 1063 }
1062 1064
1063 1065
1064 static int pcmcia_dev_resume(struct device * dev) 1066 static int pcmcia_dev_resume(struct device * dev)
1065 { 1067 {
1066 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1068 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1067 struct pcmcia_driver *p_drv = NULL; 1069 struct pcmcia_driver *p_drv = NULL;
1068 int ret = 0; 1070 int ret = 0;
1069 1071
1070 if (dev->driver) 1072 if (dev->driver)
1071 p_drv = to_pcmcia_drv(dev->driver); 1073 p_drv = to_pcmcia_drv(dev->driver);
1072 1074
1073 if (!p_drv) 1075 if (!p_drv)
1074 goto out; 1076 goto out;
1075 1077
1076 if (p_dev->device_no == p_dev->func) { 1078 if (p_dev->device_no == p_dev->func) {
1077 ret = pcmcia_request_configuration(p_dev, &p_dev->conf); 1079 ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
1078 if (ret) 1080 if (ret)
1079 goto out; 1081 goto out;
1080 } 1082 }
1081 1083
1082 if (p_drv->resume) 1084 if (p_drv->resume)
1083 ret = p_drv->resume(p_dev); 1085 ret = p_drv->resume(p_dev);
1084 1086
1085 out: 1087 out:
1086 if (!ret) 1088 if (!ret)
1087 p_dev->suspended = 0; 1089 p_dev->suspended = 0;
1088 return ret; 1090 return ret;
1089 } 1091 }
1090 1092
1091 1093
1092 static int pcmcia_bus_suspend_callback(struct device *dev, void * _data) 1094 static int pcmcia_bus_suspend_callback(struct device *dev, void * _data)
1093 { 1095 {
1094 struct pcmcia_socket *skt = _data; 1096 struct pcmcia_socket *skt = _data;
1095 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1097 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1096 1098
1097 if (p_dev->socket != skt) 1099 if (p_dev->socket != skt)
1098 return 0; 1100 return 0;
1099 1101
1100 return dpm_runtime_suspend(dev, PMSG_SUSPEND); 1102 return dpm_runtime_suspend(dev, PMSG_SUSPEND);
1101 } 1103 }
1102 1104
1103 static int pcmcia_bus_resume_callback(struct device *dev, void * _data) 1105 static int pcmcia_bus_resume_callback(struct device *dev, void * _data)
1104 { 1106 {
1105 struct pcmcia_socket *skt = _data; 1107 struct pcmcia_socket *skt = _data;
1106 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1108 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1107 1109
1108 if (p_dev->socket != skt) 1110 if (p_dev->socket != skt)
1109 return 0; 1111 return 0;
1110 1112
1111 dpm_runtime_resume(dev); 1113 dpm_runtime_resume(dev);
1112 1114
1113 return 0; 1115 return 0;
1114 } 1116 }
1115 1117
1116 static int pcmcia_bus_resume(struct pcmcia_socket *skt) 1118 static int pcmcia_bus_resume(struct pcmcia_socket *skt)
1117 { 1119 {
1118 bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback); 1120 bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback);
1119 return 0; 1121 return 0;
1120 } 1122 }
1121 1123
1122 static int pcmcia_bus_suspend(struct pcmcia_socket *skt) 1124 static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
1123 { 1125 {
1124 if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt, 1126 if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt,
1125 pcmcia_bus_suspend_callback)) { 1127 pcmcia_bus_suspend_callback)) {
1126 pcmcia_bus_resume(skt); 1128 pcmcia_bus_resume(skt);
1127 return -EIO; 1129 return -EIO;
1128 } 1130 }
1129 return 0; 1131 return 0;
1130 } 1132 }
1131 1133
1132 1134
1133 /*====================================================================== 1135 /*======================================================================
1134 1136
1135 The card status event handler. 1137 The card status event handler.
1136 1138
1137 ======================================================================*/ 1139 ======================================================================*/
1138 1140
1139 /* Normally, the event is passed to individual drivers after 1141 /* Normally, the event is passed to individual drivers after
1140 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this 1142 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
1141 * is inversed to maintain historic compatibility. 1143 * is inversed to maintain historic compatibility.
1142 */ 1144 */
1143 1145
1144 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) 1146 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
1145 { 1147 {
1146 struct pcmcia_socket *s = pcmcia_get_socket(skt); 1148 struct pcmcia_socket *s = pcmcia_get_socket(skt);
1147 1149
1148 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n", 1150 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
1149 event, priority, skt); 1151 event, priority, skt);
1150 1152
1151 switch (event) { 1153 switch (event) {
1152 case CS_EVENT_CARD_REMOVAL: 1154 case CS_EVENT_CARD_REMOVAL:
1153 s->pcmcia_state.present = 0; 1155 s->pcmcia_state.present = 0;
1154 pcmcia_card_remove(skt, NULL); 1156 pcmcia_card_remove(skt, NULL);
1155 handle_event(skt, event); 1157 handle_event(skt, event);
1156 break; 1158 break;
1157 1159
1158 case CS_EVENT_CARD_INSERTION: 1160 case CS_EVENT_CARD_INSERTION:
1159 s->pcmcia_state.present = 1; 1161 s->pcmcia_state.present = 1;
1160 pcmcia_card_add(skt); 1162 pcmcia_card_add(skt);
1161 handle_event(skt, event); 1163 handle_event(skt, event);
1162 break; 1164 break;
1163 1165
1164 case CS_EVENT_EJECTION_REQUEST: 1166 case CS_EVENT_EJECTION_REQUEST:
1165 break; 1167 break;
1166 1168
1167 case CS_EVENT_PM_SUSPEND: 1169 case CS_EVENT_PM_SUSPEND:
1168 case CS_EVENT_PM_RESUME: 1170 case CS_EVENT_PM_RESUME:
1169 case CS_EVENT_RESET_PHYSICAL: 1171 case CS_EVENT_RESET_PHYSICAL:
1170 case CS_EVENT_CARD_RESET: 1172 case CS_EVENT_CARD_RESET:
1171 default: 1173 default:
1172 handle_event(skt, event); 1174 handle_event(skt, event);
1173 break; 1175 break;
1174 } 1176 }
1175 1177
1176 pcmcia_put_socket(s); 1178 pcmcia_put_socket(s);
1177 1179
1178 return 0; 1180 return 0;
1179 } /* ds_event */ 1181 } /* ds_event */
1180 1182
1181 1183
1182 struct pcmcia_device * pcmcia_dev_present(struct pcmcia_device *_p_dev) 1184 struct pcmcia_device * pcmcia_dev_present(struct pcmcia_device *_p_dev)
1183 { 1185 {
1184 struct pcmcia_device *p_dev; 1186 struct pcmcia_device *p_dev;
1185 struct pcmcia_device *ret = NULL; 1187 struct pcmcia_device *ret = NULL;
1186 1188
1187 p_dev = pcmcia_get_dev(_p_dev); 1189 p_dev = pcmcia_get_dev(_p_dev);
1188 if (!p_dev) 1190 if (!p_dev)
1189 return NULL; 1191 return NULL;
1190 1192
1191 if (!p_dev->socket->pcmcia_state.present) 1193 if (!p_dev->socket->pcmcia_state.present)
1192 goto out; 1194 goto out;
1193 1195
1194 if (p_dev->_removed) 1196 if (p_dev->_removed)
1195 goto out; 1197 goto out;
1196 1198
1197 if (p_dev->suspended) 1199 if (p_dev->suspended)
1198 goto out; 1200 goto out;
1199 1201
1200 ret = p_dev; 1202 ret = p_dev;
1201 out: 1203 out:
1202 pcmcia_put_dev(p_dev); 1204 pcmcia_put_dev(p_dev);
1203 return ret; 1205 return ret;
1204 } 1206 }
1205 EXPORT_SYMBOL(pcmcia_dev_present); 1207 EXPORT_SYMBOL(pcmcia_dev_present);
1206 1208
1207 1209
1208 static struct pcmcia_callback pcmcia_bus_callback = { 1210 static struct pcmcia_callback pcmcia_bus_callback = {
1209 .owner = THIS_MODULE, 1211 .owner = THIS_MODULE,
1210 .event = ds_event, 1212 .event = ds_event,
1211 .requery = pcmcia_bus_rescan, 1213 .requery = pcmcia_bus_rescan,
1212 .suspend = pcmcia_bus_suspend, 1214 .suspend = pcmcia_bus_suspend,
1213 .resume = pcmcia_bus_resume, 1215 .resume = pcmcia_bus_resume,
1214 }; 1216 };
1215 1217
1216 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev, 1218 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev,
1217 struct class_interface *class_intf) 1219 struct class_interface *class_intf)
1218 { 1220 {
1219 struct pcmcia_socket *socket = class_get_devdata(class_dev); 1221 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1220 int ret; 1222 int ret;
1221 1223
1222 socket = pcmcia_get_socket(socket); 1224 socket = pcmcia_get_socket(socket);
1223 if (!socket) { 1225 if (!socket) {
1224 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket); 1226 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1225 return -ENODEV; 1227 return -ENODEV;
1226 } 1228 }
1227 1229
1228 /* 1230 /*
1229 * Ugly. But we want to wait for the socket threads to have started up. 1231 * Ugly. But we want to wait for the socket threads to have started up.
1230 * We really should let the drivers themselves drive some of this.. 1232 * We really should let the drivers themselves drive some of this..
1231 */ 1233 */
1232 msleep(250); 1234 msleep(250);
1233 1235
1234 #ifdef CONFIG_PCMCIA_IOCTL 1236 #ifdef CONFIG_PCMCIA_IOCTL
1235 init_waitqueue_head(&socket->queue); 1237 init_waitqueue_head(&socket->queue);
1236 #endif 1238 #endif
1237 INIT_LIST_HEAD(&socket->devices_list); 1239 INIT_LIST_HEAD(&socket->devices_list);
1238 INIT_WORK(&socket->device_add, pcmcia_delayed_add_pseudo_device, socket); 1240 INIT_WORK(&socket->device_add, pcmcia_delayed_add_pseudo_device, socket);
1239 memset(&socket->pcmcia_state, 0, sizeof(u8)); 1241 memset(&socket->pcmcia_state, 0, sizeof(u8));
1240 socket->device_count = 0; 1242 socket->device_count = 0;
1241 1243
1242 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); 1244 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1243 if (ret) { 1245 if (ret) {
1244 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket); 1246 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1245 pcmcia_put_socket(socket); 1247 pcmcia_put_socket(socket);
1246 return (ret); 1248 return (ret);
1247 } 1249 }
1248 1250
1249 return 0; 1251 return 0;
1250 } 1252 }
1251 1253
1252 static void pcmcia_bus_remove_socket(struct class_device *class_dev, 1254 static void pcmcia_bus_remove_socket(struct class_device *class_dev,
1253 struct class_interface *class_intf) 1255 struct class_interface *class_intf)
1254 { 1256 {
1255 struct pcmcia_socket *socket = class_get_devdata(class_dev); 1257 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1256 1258
1257 if (!socket) 1259 if (!socket)
1258 return; 1260 return;
1259 1261
1260 socket->pcmcia_state.dead = 1; 1262 socket->pcmcia_state.dead = 1;
1261 pccard_register_pcmcia(socket, NULL); 1263 pccard_register_pcmcia(socket, NULL);
1262 1264
1263 pcmcia_put_socket(socket); 1265 pcmcia_put_socket(socket);
1264 1266
1265 return; 1267 return;
1266 } 1268 }
1267 1269
1268 1270
1269 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */ 1271 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1270 static struct class_interface pcmcia_bus_interface = { 1272 static struct class_interface pcmcia_bus_interface = {
1271 .class = &pcmcia_socket_class, 1273 .class = &pcmcia_socket_class,
1272 .add = &pcmcia_bus_add_socket, 1274 .add = &pcmcia_bus_add_socket,
1273 .remove = &pcmcia_bus_remove_socket, 1275 .remove = &pcmcia_bus_remove_socket,
1274 }; 1276 };
1275 1277
1276 1278
1277 struct bus_type pcmcia_bus_type = { 1279 struct bus_type pcmcia_bus_type = {
1278 .name = "pcmcia", 1280 .name = "pcmcia",
1279 .uevent = pcmcia_bus_uevent, 1281 .uevent = pcmcia_bus_uevent,
1280 .match = pcmcia_bus_match, 1282 .match = pcmcia_bus_match,
1281 .dev_attrs = pcmcia_dev_attrs, 1283 .dev_attrs = pcmcia_dev_attrs,
1282 .probe = pcmcia_device_probe, 1284 .probe = pcmcia_device_probe,
1283 .remove = pcmcia_device_remove, 1285 .remove = pcmcia_device_remove,
1284 .suspend = pcmcia_dev_suspend, 1286 .suspend = pcmcia_dev_suspend,
1285 .resume = pcmcia_dev_resume, 1287 .resume = pcmcia_dev_resume,
1286 }; 1288 };
1287 1289
1288 1290
1289 static int __init init_pcmcia_bus(void) 1291 static int __init init_pcmcia_bus(void)
1290 { 1292 {
1291 spin_lock_init(&pcmcia_dev_list_lock); 1293 spin_lock_init(&pcmcia_dev_list_lock);
1292 1294
1293 bus_register(&pcmcia_bus_type); 1295 bus_register(&pcmcia_bus_type);
1294 class_interface_register(&pcmcia_bus_interface); 1296 class_interface_register(&pcmcia_bus_interface);
1295 1297
1296 pcmcia_setup_ioctl(); 1298 pcmcia_setup_ioctl();
1297 1299
1298 return 0; 1300 return 0;
1299 } 1301 }
1300 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that 1302 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1301 * pcmcia_socket_class is already registered */ 1303 * pcmcia_socket_class is already registered */
1302 1304
1303 1305
1304 static void __exit exit_pcmcia_bus(void) 1306 static void __exit exit_pcmcia_bus(void)
1305 { 1307 {
1306 pcmcia_cleanup_ioctl(); 1308 pcmcia_cleanup_ioctl();
1307 1309
1308 class_interface_unregister(&pcmcia_bus_interface); 1310 class_interface_unregister(&pcmcia_bus_interface);
1309 1311
1310 bus_unregister(&pcmcia_bus_type); 1312 bus_unregister(&pcmcia_bus_type);
1311 } 1313 }
1312 module_exit(exit_pcmcia_bus); 1314 module_exit(exit_pcmcia_bus);
1313 1315
1314 1316
1315 MODULE_ALIAS("ds"); 1317 MODULE_ALIAS("ds");
1316 1318
drivers/pcmcia/pcmcia_resource.c
Diff comments   View file @ a0aab14
1 /* 1 /*
2 * PCMCIA 16-bit resource management functions 2 * PCMCIA 16-bit resource management functions
3 * 3 *
4 * The initial developer of the original code is David A. Hinds 4 * The initial developer of the original code is David A. Hinds
5 * <dahinds@users.sourceforge.net>. Portions created by 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. 6 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
7 * 7 *
8 * Copyright (C) 1999 David A. Hinds 8 * Copyright (C) 1999 David A. Hinds
9 * Copyright (C) 2004-2005 Dominik Brodowski 9 * Copyright (C) 2004-2005 Dominik Brodowski
10 * 10 *
11 * This program is free software; you can redistribute it and/or modify 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 12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation. 13 * published by the Free Software Foundation.
14 * 14 *
15 */ 15 */
16 16
17 #include <linux/module.h> 17 #include <linux/module.h>
18 #include <linux/kernel.h> 18 #include <linux/kernel.h>
19 #include <linux/interrupt.h> 19 #include <linux/interrupt.h>
20 #include <linux/delay.h> 20 #include <linux/delay.h>
21 #include <linux/pci.h> 21 #include <linux/pci.h>
22 #include <linux/device.h> 22 #include <linux/device.h>
23 23
24 #define IN_CARD_SERVICES 24 #define IN_CARD_SERVICES
25 #include <pcmcia/cs_types.h> 25 #include <pcmcia/cs_types.h>
26 #include <pcmcia/ss.h> 26 #include <pcmcia/ss.h>
27 #include <pcmcia/cs.h> 27 #include <pcmcia/cs.h>
28 #include <pcmcia/bulkmem.h> 28 #include <pcmcia/bulkmem.h>
29 #include <pcmcia/cistpl.h> 29 #include <pcmcia/cistpl.h>
30 #include <pcmcia/cisreg.h> 30 #include <pcmcia/cisreg.h>
31 #include <pcmcia/ds.h> 31 #include <pcmcia/ds.h>
32 32
33 #include "cs_internal.h" 33 #include "cs_internal.h"
34 #include "ds_internal.h" 34 #include "ds_internal.h"
35 35
36 36
37 /* Access speed for IO windows */ 37 /* Access speed for IO windows */
38 static int io_speed = 0; 38 static int io_speed = 0;
39 module_param(io_speed, int, 0444); 39 module_param(io_speed, int, 0444);
40 40
41 41
42 #ifdef CONFIG_PCMCIA_PROBE 42 #ifdef CONFIG_PCMCIA_PROBE
43 #include <asm/irq.h> 43 #include <asm/irq.h>
44 /* mask of IRQs already reserved by other cards, we should avoid using them */ 44 /* mask of IRQs already reserved by other cards, we should avoid using them */
45 static u8 pcmcia_used_irq[NR_IRQS]; 45 static u8 pcmcia_used_irq[NR_IRQS];
46 #endif 46 #endif
47 47
48 48
49 #ifdef DEBUG 49 #ifdef DEBUG
50 extern int ds_pc_debug; 50 extern int ds_pc_debug;
51 #define cs_socket_name(skt) ((skt)->dev.class_id) 51 #define cs_socket_name(skt) ((skt)->dev.class_id)
52 52
53 #define ds_dbg(skt, lvl, fmt, arg...) do { \ 53 #define ds_dbg(skt, lvl, fmt, arg...) do { \
54 if (ds_pc_debug >= lvl) \ 54 if (ds_pc_debug >= lvl) \
55 printk(KERN_DEBUG "pcmcia_resource: %s: " fmt, \ 55 printk(KERN_DEBUG "pcmcia_resource: %s: " fmt, \
56 cs_socket_name(skt) , ## arg); \ 56 cs_socket_name(skt) , ## arg); \
57 } while (0) 57 } while (0)
58 #else 58 #else
59 #define ds_dbg(lvl, fmt, arg...) do { } while (0) 59 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
60 #endif 60 #endif
61 61
62 62
63 63
64 /** alloc_io_space 64 /** alloc_io_space
65 * 65 *
66 * Special stuff for managing IO windows, because they are scarce 66 * Special stuff for managing IO windows, because they are scarce
67 */ 67 */
68 68
69 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base, 69 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
70 ioaddr_t num, u_int lines) 70 ioaddr_t num, u_int lines)
71 { 71 {
72 int i; 72 int i;
73 kio_addr_t try, align; 73 kio_addr_t try, align;
74 74
75 align = (*base) ? (lines ? 1<<lines : 0) : 1; 75 align = (*base) ? (lines ? 1<<lines : 0) : 1;
76 if (align && (align < num)) { 76 if (align && (align < num)) {
77 if (*base) { 77 if (*base) {
78 ds_dbg(s, 0, "odd IO request: num %#x align %#lx\n", 78 ds_dbg(s, 0, "odd IO request: num %#x align %#lx\n",
79 num, align); 79 num, align);
80 align = 0; 80 align = 0;
81 } else 81 } else
82 while (align && (align < num)) align <<= 1; 82 while (align && (align < num)) align <<= 1;
83 } 83 }
84 if (*base & ~(align-1)) { 84 if (*base & ~(align-1)) {
85 ds_dbg(s, 0, "odd IO request: base %#x align %#lx\n", 85 ds_dbg(s, 0, "odd IO request: base %#x align %#lx\n",
86 *base, align); 86 *base, align);
87 align = 0; 87 align = 0;
88 } 88 }
89 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) { 89 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
90 *base = s->io_offset | (*base & 0x0fff); 90 *base = s->io_offset | (*base & 0x0fff);
91 s->io[0].res->flags = (s->io[0].res->flags & ~IORESOURCE_BITS) | (attr & IORESOURCE_BITS); 91 s->io[0].res->flags = (s->io[0].res->flags & ~IORESOURCE_BITS) | (attr & IORESOURCE_BITS);
92 return 0; 92 return 0;
93 } 93 }
94 /* Check for an already-allocated window that must conflict with 94 /* Check for an already-allocated window that must conflict with
95 * what was asked for. It is a hack because it does not catch all 95 * what was asked for. It is a hack because it does not catch all
96 * potential conflicts, just the most obvious ones. 96 * potential conflicts, just the most obvious ones.
97 */ 97 */
98 for (i = 0; i < MAX_IO_WIN; i++) 98 for (i = 0; i < MAX_IO_WIN; i++)
99 if ((s->io[i].res) && 99 if ((s->io[i].res) &&
100 ((s->io[i].res->start & (align-1)) == *base)) 100 ((s->io[i].res->start & (align-1)) == *base))
101 return 1; 101 return 1;
102 for (i = 0; i < MAX_IO_WIN; i++) { 102 for (i = 0; i < MAX_IO_WIN; i++) {
103 if (!s->io[i].res) { 103 if (!s->io[i].res) {
104 s->io[i].res = pcmcia_find_io_region(*base, num, align, s); 104 s->io[i].res = pcmcia_find_io_region(*base, num, align, s);
105 if (s->io[i].res) { 105 if (s->io[i].res) {
106 *base = s->io[i].res->start; 106 *base = s->io[i].res->start;
107 s->io[i].res->flags = (s->io[i].res->flags & ~IORESOURCE_BITS) | (attr & IORESOURCE_BITS); 107 s->io[i].res->flags = (s->io[i].res->flags & ~IORESOURCE_BITS) | (attr & IORESOURCE_BITS);
108 s->io[i].InUse = num; 108 s->io[i].InUse = num;
109 break; 109 break;
110 } else 110 } else
111 return 1; 111 return 1;
112 } else if ((s->io[i].res->flags & IORESOURCE_BITS) != (attr & IORESOURCE_BITS)) 112 } else if ((s->io[i].res->flags & IORESOURCE_BITS) != (attr & IORESOURCE_BITS))
113 continue; 113 continue;
114 /* Try to extend top of window */ 114 /* Try to extend top of window */
115 try = s->io[i].res->end + 1; 115 try = s->io[i].res->end + 1;
116 if ((*base == 0) || (*base == try)) 116 if ((*base == 0) || (*base == try))
117 if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start, 117 if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start,
118 s->io[i].res->end + num, s) == 0) { 118 s->io[i].res->end + num, s) == 0) {
119 *base = try; 119 *base = try;
120 s->io[i].InUse += num; 120 s->io[i].InUse += num;
121 break; 121 break;
122 } 122 }
123 /* Try to extend bottom of window */ 123 /* Try to extend bottom of window */
124 try = s->io[i].res->start - num; 124 try = s->io[i].res->start - num;
125 if ((*base == 0) || (*base == try)) 125 if ((*base == 0) || (*base == try))
126 if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start - num, 126 if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start - num,
127 s->io[i].res->end, s) == 0) { 127 s->io[i].res->end, s) == 0) {
128 *base = try; 128 *base = try;
129 s->io[i].InUse += num; 129 s->io[i].InUse += num;
130 break; 130 break;
131 } 131 }
132 } 132 }
133 return (i == MAX_IO_WIN); 133 return (i == MAX_IO_WIN);
134 } /* alloc_io_space */ 134 } /* alloc_io_space */
135 135
136 136
137 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base, 137 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
138 ioaddr_t num) 138 ioaddr_t num)
139 { 139 {
140 int i; 140 int i;
141 141
142 for (i = 0; i < MAX_IO_WIN; i++) { 142 for (i = 0; i < MAX_IO_WIN; i++) {
143 if (!s->io[i].res) 143 if (!s->io[i].res)
144 continue; 144 continue;
145 if ((s->io[i].res->start <= base) && 145 if ((s->io[i].res->start <= base) &&
146 (s->io[i].res->end >= base+num-1)) { 146 (s->io[i].res->end >= base+num-1)) {
147 s->io[i].InUse -= num; 147 s->io[i].InUse -= num;
148 /* Free the window if no one else is using it */ 148 /* Free the window if no one else is using it */
149 if (s->io[i].InUse == 0) { 149 if (s->io[i].InUse == 0) {
150 release_resource(s->io[i].res); 150 release_resource(s->io[i].res);
151 kfree(s->io[i].res); 151 kfree(s->io[i].res);
152 s->io[i].res = NULL; 152 s->io[i].res = NULL;
153 } 153 }
154 } 154 }
155 } 155 }
156 } /* release_io_space */ 156 } /* release_io_space */
157 157
158 158
159 /** pccard_access_configuration_register 159 /** pccard_access_configuration_register
160 * 160 *
161 * Access_configuration_register() reads and writes configuration 161 * Access_configuration_register() reads and writes configuration
162 * registers in attribute memory. Memory window 0 is reserved for 162 * registers in attribute memory. Memory window 0 is reserved for
163 * this and the tuple reading services. 163 * this and the tuple reading services.
164 */ 164 */
165 165
166 int pcmcia_access_configuration_register(struct pcmcia_device *p_dev, 166 int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
167 conf_reg_t *reg) 167 conf_reg_t *reg)
168 { 168 {
169 struct pcmcia_socket *s; 169 struct pcmcia_socket *s;
170 config_t *c; 170 config_t *c;
171 int addr; 171 int addr;
172 u_char val; 172 u_char val;
173 173
174 if (!p_dev || !p_dev->function_config) 174 if (!p_dev || !p_dev->function_config)
175 return CS_NO_CARD; 175 return CS_NO_CARD;
176 176
177 s = p_dev->socket; 177 s = p_dev->socket;
178 c = p_dev->function_config; 178 c = p_dev->function_config;
179 179
180 if (!(c->state & CONFIG_LOCKED)) 180 if (!(c->state & CONFIG_LOCKED))
181 return CS_CONFIGURATION_LOCKED; 181 return CS_CONFIGURATION_LOCKED;
182 182
183 addr = (c->ConfigBase + reg->Offset) >> 1; 183 addr = (c->ConfigBase + reg->Offset) >> 1;
184 184
185 switch (reg->Action) { 185 switch (reg->Action) {
186 case CS_READ: 186 case CS_READ:
187 pcmcia_read_cis_mem(s, 1, addr, 1, &val); 187 pcmcia_read_cis_mem(s, 1, addr, 1, &val);
188 reg->Value = val; 188 reg->Value = val;
189 break; 189 break;
190 case CS_WRITE: 190 case CS_WRITE:
191 val = reg->Value; 191 val = reg->Value;
192 pcmcia_write_cis_mem(s, 1, addr, 1, &val); 192 pcmcia_write_cis_mem(s, 1, addr, 1, &val);
193 break; 193 break;
194 default: 194 default:
195 return CS_BAD_ARGS; 195 return CS_BAD_ARGS;
196 break; 196 break;
197 } 197 }
198 return CS_SUCCESS; 198 return CS_SUCCESS;
199 } /* pcmcia_access_configuration_register */ 199 } /* pcmcia_access_configuration_register */
200 EXPORT_SYMBOL(pcmcia_access_configuration_register); 200 EXPORT_SYMBOL(pcmcia_access_configuration_register);
201 201
202 202
203 int pccard_get_configuration_info(struct pcmcia_socket *s, 203 int pccard_get_configuration_info(struct pcmcia_socket *s,
204 struct pcmcia_device *p_dev, 204 struct pcmcia_device *p_dev,
205 config_info_t *config) 205 config_info_t *config)
206 { 206 {
207 config_t *c; 207 config_t *c;
208 208
209 if (!(s->state & SOCKET_PRESENT)) 209 if (!(s->state & SOCKET_PRESENT))
210 return CS_NO_CARD; 210 return CS_NO_CARD;
211 211
212 config->Function = p_dev->func; 212 config->Function = p_dev->func;
213 213
214 #ifdef CONFIG_CARDBUS 214 #ifdef CONFIG_CARDBUS
215 if (s->state & SOCKET_CARDBUS) { 215 if (s->state & SOCKET_CARDBUS) {
216 memset(config, 0, sizeof(config_info_t)); 216 memset(config, 0, sizeof(config_info_t));
217 config->Vcc = s->socket.Vcc; 217 config->Vcc = s->socket.Vcc;
218 config->Vpp1 = config->Vpp2 = s->socket.Vpp; 218 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
219 config->Option = s->cb_dev->subordinate->number; 219 config->Option = s->cb_dev->subordinate->number;
220 if (s->state & SOCKET_CARDBUS_CONFIG) { 220 if (s->state & SOCKET_CARDBUS_CONFIG) {
221 config->Attributes = CONF_VALID_CLIENT; 221 config->Attributes = CONF_VALID_CLIENT;
222 config->IntType = INT_CARDBUS; 222 config->IntType = INT_CARDBUS;
223 config->AssignedIRQ = s->irq.AssignedIRQ; 223 config->AssignedIRQ = s->irq.AssignedIRQ;
224 if (config->AssignedIRQ) 224 if (config->AssignedIRQ)
225 config->Attributes |= CONF_ENABLE_IRQ; 225 config->Attributes |= CONF_ENABLE_IRQ;
226 config->BasePort1 = s->io[0].res->start; 226 config->BasePort1 = s->io[0].res->start;
227 config->NumPorts1 = s->io[0].res->end - config->BasePort1 + 1; 227 config->NumPorts1 = s->io[0].res->end - config->BasePort1 + 1;
228 } 228 }
229 return CS_SUCCESS; 229 return CS_SUCCESS;
230 } 230 }
231 #endif 231 #endif
232 232
233 c = (p_dev) ? p_dev->function_config : NULL; 233 c = (p_dev) ? p_dev->function_config : NULL;
234 234
235 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) { 235 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
236 config->Attributes = 0; 236 config->Attributes = 0;
237 config->Vcc = s->socket.Vcc; 237 config->Vcc = s->socket.Vcc;
238 config->Vpp1 = config->Vpp2 = s->socket.Vpp; 238 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
239 return CS_SUCCESS; 239 return CS_SUCCESS;
240 } 240 }
241 241
242 /* !!! This is a hack !!! */ 242 /* !!! This is a hack !!! */
243 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t)); 243 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
244 config->Attributes |= CONF_VALID_CLIENT; 244 config->Attributes |= CONF_VALID_CLIENT;
245 config->CardValues = c->CardValues; 245 config->CardValues = c->CardValues;
246 config->IRQAttributes = c->irq.Attributes; 246 config->IRQAttributes = c->irq.Attributes;
247 config->AssignedIRQ = s->irq.AssignedIRQ; 247 config->AssignedIRQ = s->irq.AssignedIRQ;
248 config->BasePort1 = c->io.BasePort1; 248 config->BasePort1 = c->io.BasePort1;
249 config->NumPorts1 = c->io.NumPorts1; 249 config->NumPorts1 = c->io.NumPorts1;
250 config->Attributes1 = c->io.Attributes1; 250 config->Attributes1 = c->io.Attributes1;
251 config->BasePort2 = c->io.BasePort2; 251 config->BasePort2 = c->io.BasePort2;
252 config->NumPorts2 = c->io.NumPorts2; 252 config->NumPorts2 = c->io.NumPorts2;
253 config->Attributes2 = c->io.Attributes2; 253 config->Attributes2 = c->io.Attributes2;
254 config->IOAddrLines = c->io.IOAddrLines; 254 config->IOAddrLines = c->io.IOAddrLines;
255 255
256 return CS_SUCCESS; 256 return CS_SUCCESS;
257 } /* pccard_get_configuration_info */ 257 } /* pccard_get_configuration_info */
258 258
259 int pcmcia_get_configuration_info(struct pcmcia_device *p_dev, 259 int pcmcia_get_configuration_info(struct pcmcia_device *p_dev,
260 config_info_t *config) 260 config_info_t *config)
261 { 261 {
262 return pccard_get_configuration_info(p_dev->socket, p_dev, 262 return pccard_get_configuration_info(p_dev->socket, p_dev,
263 config); 263 config);
264 } 264 }
265 EXPORT_SYMBOL(pcmcia_get_configuration_info); 265 EXPORT_SYMBOL(pcmcia_get_configuration_info);
266 266
267 267
268 /** pcmcia_get_window 268 /** pcmcia_get_window
269 */ 269 */
270 int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, 270 int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle,
271 int idx, win_req_t *req) 271 int idx, win_req_t *req)
272 { 272 {
273 window_t *win; 273 window_t *win;
274 int w; 274 int w;
275 275
276 if (!s || !(s->state & SOCKET_PRESENT)) 276 if (!s || !(s->state & SOCKET_PRESENT))
277 return CS_NO_CARD; 277 return CS_NO_CARD;
278 for (w = idx; w < MAX_WIN; w++) 278 for (w = idx; w < MAX_WIN; w++)
279 if (s->state & SOCKET_WIN_REQ(w)) 279 if (s->state & SOCKET_WIN_REQ(w))
280 break; 280 break;
281 if (w == MAX_WIN) 281 if (w == MAX_WIN)
282 return CS_NO_MORE_ITEMS; 282 return CS_NO_MORE_ITEMS;
283 win = &s->win[w]; 283 win = &s->win[w];
284 req->Base = win->ctl.res->start; 284 req->Base = win->ctl.res->start;
285 req->Size = win->ctl.res->end - win->ctl.res->start + 1; 285 req->Size = win->ctl.res->end - win->ctl.res->start + 1;
286 req->AccessSpeed = win->ctl.speed; 286 req->AccessSpeed = win->ctl.speed;
287 req->Attributes = 0; 287 req->Attributes = 0;
288 if (win->ctl.flags & MAP_ATTRIB) 288 if (win->ctl.flags & MAP_ATTRIB)
289 req->Attributes |= WIN_MEMORY_TYPE_AM; 289 req->Attributes |= WIN_MEMORY_TYPE_AM;
290 if (win->ctl.flags & MAP_ACTIVE) 290 if (win->ctl.flags & MAP_ACTIVE)
291 req->Attributes |= WIN_ENABLE; 291 req->Attributes |= WIN_ENABLE;
292 if (win->ctl.flags & MAP_16BIT) 292 if (win->ctl.flags & MAP_16BIT)
293 req->Attributes |= WIN_DATA_WIDTH_16; 293 req->Attributes |= WIN_DATA_WIDTH_16;
294 if (win->ctl.flags & MAP_USE_WAIT) 294 if (win->ctl.flags & MAP_USE_WAIT)
295 req->Attributes |= WIN_USE_WAIT; 295 req->Attributes |= WIN_USE_WAIT;
296 *handle = win; 296 *handle = win;
297 return CS_SUCCESS; 297 return CS_SUCCESS;
298 } /* pcmcia_get_window */ 298 } /* pcmcia_get_window */
299 EXPORT_SYMBOL(pcmcia_get_window); 299 EXPORT_SYMBOL(pcmcia_get_window);
300 300
301 301
302 /** pccard_get_status 302 /** pccard_get_status
303 * 303 *
304 * Get the current socket state bits. We don't support the latched 304 * Get the current socket state bits. We don't support the latched
305 * SocketState yet: I haven't seen any point for it. 305 * SocketState yet: I haven't seen any point for it.
306 */ 306 */
307 307
308 int pccard_get_status(struct pcmcia_socket *s, struct pcmcia_device *p_dev, 308 int pccard_get_status(struct pcmcia_socket *s, struct pcmcia_device *p_dev,
309 cs_status_t *status) 309 cs_status_t *status)
310 { 310 {
311 config_t *c; 311 config_t *c;
312 int val; 312 int val;
313 313
314 s->ops->get_status(s, &val); 314 s->ops->get_status(s, &val);
315 status->CardState = status->SocketState = 0; 315 status->CardState = status->SocketState = 0;
316 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0; 316 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
317 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0; 317 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
318 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0; 318 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
319 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0; 319 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
320 if (s->state & SOCKET_SUSPEND) 320 if (s->state & SOCKET_SUSPEND)
321 status->CardState |= CS_EVENT_PM_SUSPEND; 321 status->CardState |= CS_EVENT_PM_SUSPEND;
322 if (!(s->state & SOCKET_PRESENT)) 322 if (!(s->state & SOCKET_PRESENT))
323 return CS_NO_CARD; 323 return CS_NO_CARD;
324 324
325 c = (p_dev) ? p_dev->function_config : NULL; 325 c = (p_dev) ? p_dev->function_config : NULL;
326 326
327 if ((c != NULL) && (c->state & CONFIG_LOCKED) && 327 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
328 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) { 328 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
329 u_char reg; 329 u_char reg;
330 if (c->CardValues & PRESENT_PIN_REPLACE) { 330 if (c->CardValues & PRESENT_PIN_REPLACE) {
331 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg); 331 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
332 status->CardState |= 332 status->CardState |=
333 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0; 333 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
334 status->CardState |= 334 status->CardState |=
335 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0; 335 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
336 status->CardState |= 336 status->CardState |=
337 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0; 337 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
338 status->CardState |= 338 status->CardState |=
339 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0; 339 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
340 } else { 340 } else {
341 /* No PRR? Then assume we're always ready */ 341 /* No PRR? Then assume we're always ready */
342 status->CardState |= CS_EVENT_READY_CHANGE; 342 status->CardState |= CS_EVENT_READY_CHANGE;
343 } 343 }
344 if (c->CardValues & PRESENT_EXT_STATUS) { 344 if (c->CardValues & PRESENT_EXT_STATUS) {
345 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg); 345 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
346 status->CardState |= 346 status->CardState |=
347 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0; 347 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
348 } 348 }
349 return CS_SUCCESS; 349 return CS_SUCCESS;
350 } 350 }
351 status->CardState |= 351 status->CardState |=
352 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0; 352 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
353 status->CardState |= 353 status->CardState |=
354 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0; 354 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
355 status->CardState |= 355 status->CardState |=
356 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0; 356 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
357 status->CardState |= 357 status->CardState |=
358 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0; 358 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
359 return CS_SUCCESS; 359 return CS_SUCCESS;
360 } /* pccard_get_status */ 360 } /* pccard_get_status */
361 361
362 int pcmcia_get_status(struct pcmcia_device *p_dev, cs_status_t *status) 362 int pcmcia_get_status(struct pcmcia_device *p_dev, cs_status_t *status)
363 { 363 {
364 return pccard_get_status(p_dev->socket, p_dev, status); 364 return pccard_get_status(p_dev->socket, p_dev, status);
365 } 365 }
366 EXPORT_SYMBOL(pcmcia_get_status); 366 EXPORT_SYMBOL(pcmcia_get_status);
367 367
368 368
369 369
370 /** pcmcia_get_mem_page 370 /** pcmcia_get_mem_page
371 * 371 *
372 * Change the card address of an already open memory window. 372 * Change the card address of an already open memory window.
373 */ 373 */
374 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req) 374 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
375 { 375 {
376 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 376 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
377 return CS_BAD_HANDLE; 377 return CS_BAD_HANDLE;
378 req->Page = 0; 378 req->Page = 0;
379 req->CardOffset = win->ctl.card_start; 379 req->CardOffset = win->ctl.card_start;
380 return CS_SUCCESS; 380 return CS_SUCCESS;
381 } /* pcmcia_get_mem_page */ 381 } /* pcmcia_get_mem_page */
382 EXPORT_SYMBOL(pcmcia_get_mem_page); 382 EXPORT_SYMBOL(pcmcia_get_mem_page);
383 383
384 384
385 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req) 385 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
386 { 386 {
387 struct pcmcia_socket *s; 387 struct pcmcia_socket *s;
388 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 388 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
389 return CS_BAD_HANDLE; 389 return CS_BAD_HANDLE;
390 if (req->Page != 0) 390 if (req->Page != 0)
391 return CS_BAD_PAGE; 391 return CS_BAD_PAGE;
392 s = win->sock; 392 s = win->sock;
393 win->ctl.card_start = req->CardOffset; 393 win->ctl.card_start = req->CardOffset;
394 if (s->ops->set_mem_map(s, &win->ctl) != 0) 394 if (s->ops->set_mem_map(s, &win->ctl) != 0)
395 return CS_BAD_OFFSET; 395 return CS_BAD_OFFSET;
396 return CS_SUCCESS; 396 return CS_SUCCESS;
397 } /* pcmcia_map_mem_page */ 397 } /* pcmcia_map_mem_page */
398 EXPORT_SYMBOL(pcmcia_map_mem_page); 398 EXPORT_SYMBOL(pcmcia_map_mem_page);
399 399
400 400
401 /** pcmcia_modify_configuration 401 /** pcmcia_modify_configuration
402 * 402 *
403 * Modify a locked socket configuration 403 * Modify a locked socket configuration
404 */ 404 */
405 int pcmcia_modify_configuration(struct pcmcia_device *p_dev, 405 int pcmcia_modify_configuration(struct pcmcia_device *p_dev,
406 modconf_t *mod) 406 modconf_t *mod)
407 { 407 {
408 struct pcmcia_socket *s; 408 struct pcmcia_socket *s;
409 config_t *c; 409 config_t *c;
410 410
411 s = p_dev->socket; 411 s = p_dev->socket;
412 c = p_dev->function_config; 412 c = p_dev->function_config;
413 413
414 if (!(s->state & SOCKET_PRESENT)) 414 if (!(s->state & SOCKET_PRESENT))
415 return CS_NO_CARD; 415 return CS_NO_CARD;
416 if (!(c->state & CONFIG_LOCKED)) 416 if (!(c->state & CONFIG_LOCKED))
417 return CS_CONFIGURATION_LOCKED; 417 return CS_CONFIGURATION_LOCKED;
418 418
419 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) { 419 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
420 if (mod->Attributes & CONF_ENABLE_IRQ) { 420 if (mod->Attributes & CONF_ENABLE_IRQ) {
421 c->Attributes |= CONF_ENABLE_IRQ; 421 c->Attributes |= CONF_ENABLE_IRQ;
422 s->socket.io_irq = s->irq.AssignedIRQ; 422 s->socket.io_irq = s->irq.AssignedIRQ;
423 } else { 423 } else {
424 c->Attributes &= ~CONF_ENABLE_IRQ; 424 c->Attributes &= ~CONF_ENABLE_IRQ;
425 s->socket.io_irq = 0; 425 s->socket.io_irq = 0;
426 } 426 }
427 s->ops->set_socket(s, &s->socket); 427 s->ops->set_socket(s, &s->socket);
428 } 428 }
429 429
430 if (mod->Attributes & CONF_VCC_CHANGE_VALID) 430 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
431 return CS_BAD_VCC; 431 return CS_BAD_VCC;
432 432
433 /* We only allow changing Vpp1 and Vpp2 to the same value */ 433 /* We only allow changing Vpp1 and Vpp2 to the same value */
434 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) && 434 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
435 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) { 435 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
436 if (mod->Vpp1 != mod->Vpp2) 436 if (mod->Vpp1 != mod->Vpp2)
437 return CS_BAD_VPP; 437 return CS_BAD_VPP;
438 s->socket.Vpp = mod->Vpp1; 438 s->socket.Vpp = mod->Vpp1;
439 if (s->ops->set_socket(s, &s->socket)) 439 if (s->ops->set_socket(s, &s->socket))
440 return CS_BAD_VPP; 440 return CS_BAD_VPP;
441 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) || 441 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
442 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) 442 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
443 return CS_BAD_VPP; 443 return CS_BAD_VPP;
444 444
445 if (mod->Attributes & CONF_IO_CHANGE_WIDTH) { 445 if (mod->Attributes & CONF_IO_CHANGE_WIDTH) {
446 pccard_io_map io_off = { 0, 0, 0, 0, 1 }; 446 pccard_io_map io_off = { 0, 0, 0, 0, 1 };
447 pccard_io_map io_on; 447 pccard_io_map io_on;
448 int i; 448 int i;
449 449
450 io_on.speed = io_speed; 450 io_on.speed = io_speed;
451 for (i = 0; i < MAX_IO_WIN; i++) { 451 for (i = 0; i < MAX_IO_WIN; i++) {
452 if (!s->io[i].res) 452 if (!s->io[i].res)
453 continue; 453 continue;
454 io_off.map = i; 454 io_off.map = i;
455 io_on.map = i; 455 io_on.map = i;
456 456
457 io_on.flags = MAP_ACTIVE | IO_DATA_PATH_WIDTH_8; 457 io_on.flags = MAP_ACTIVE | IO_DATA_PATH_WIDTH_8;
458 io_on.start = s->io[i].res->start; 458 io_on.start = s->io[i].res->start;
459 io_on.stop = s->io[i].res->end; 459 io_on.stop = s->io[i].res->end;
460 460
461 s->ops->set_io_map(s, &io_off); 461 s->ops->set_io_map(s, &io_off);
462 mdelay(40); 462 mdelay(40);
463 s->ops->set_io_map(s, &io_on); 463 s->ops->set_io_map(s, &io_on);
464 } 464 }
465 } 465 }
466 466
467 return CS_SUCCESS; 467 return CS_SUCCESS;
468 } /* modify_configuration */ 468 } /* modify_configuration */
469 EXPORT_SYMBOL(pcmcia_modify_configuration); 469 EXPORT_SYMBOL(pcmcia_modify_configuration);
470 470
471 471
472 int pcmcia_release_configuration(struct pcmcia_device *p_dev) 472 int pcmcia_release_configuration(struct pcmcia_device *p_dev)
473 { 473 {
474 pccard_io_map io = { 0, 0, 0, 0, 1 }; 474 pccard_io_map io = { 0, 0, 0, 0, 1 };
475 struct pcmcia_socket *s = p_dev->socket; 475 struct pcmcia_socket *s = p_dev->socket;
476 config_t *c = p_dev->function_config; 476 config_t *c = p_dev->function_config;
477 int i; 477 int i;
478 478
479 if (p_dev->_locked) { 479 if (p_dev->_locked) {
480 p_dev->_locked = 0; 480 p_dev->_locked = 0;
481 if (--(s->lock_count) == 0) { 481 if (--(s->lock_count) == 0) {
482 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */ 482 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
483 s->socket.Vpp = 0; 483 s->socket.Vpp = 0;
484 s->socket.io_irq = 0; 484 s->socket.io_irq = 0;
485 s->ops->set_socket(s, &s->socket); 485 s->ops->set_socket(s, &s->socket);
486 } 486 }
487 } 487 }
488 if (c->state & CONFIG_LOCKED) { 488 if (c->state & CONFIG_LOCKED) {
489 c->state &= ~CONFIG_LOCKED; 489 c->state &= ~CONFIG_LOCKED;
490 if (c->state & CONFIG_IO_REQ) 490 if (c->state & CONFIG_IO_REQ)
491 for (i = 0; i < MAX_IO_WIN; i++) { 491 for (i = 0; i < MAX_IO_WIN; i++) {
492 if (!s->io[i].res) 492 if (!s->io[i].res)
493 continue; 493 continue;
494 s->io[i].Config--; 494 s->io[i].Config--;
495 if (s->io[i].Config != 0) 495 if (s->io[i].Config != 0)
496 continue; 496 continue;
497 io.map = i; 497 io.map = i;
498 s->ops->set_io_map(s, &io); 498 s->ops->set_io_map(s, &io);
499 } 499 }
500 } 500 }
501 501
502 return CS_SUCCESS; 502 return CS_SUCCESS;
503 } /* pcmcia_release_configuration */ 503 } /* pcmcia_release_configuration */
504 504
505 505
506 /** pcmcia_release_io 506 /** pcmcia_release_io
507 * 507 *
508 * Release_io() releases the I/O ranges allocated by a client. This 508 * Release_io() releases the I/O ranges allocated by a client. This
509 * may be invoked some time after a card ejection has already dumped 509 * may be invoked some time after a card ejection has already dumped
510 * the actual socket configuration, so if the client is "stale", we 510 * the actual socket configuration, so if the client is "stale", we
511 * don't bother checking the port ranges against the current socket 511 * don't bother checking the port ranges against the current socket
512 * values. 512 * values.
513 */ 513 */
514 static int pcmcia_release_io(struct pcmcia_device *p_dev, io_req_t *req) 514 static int pcmcia_release_io(struct pcmcia_device *p_dev, io_req_t *req)
515 { 515 {
516 struct pcmcia_socket *s = p_dev->socket; 516 struct pcmcia_socket *s = p_dev->socket;
517 config_t *c = p_dev->function_config; 517 config_t *c = p_dev->function_config;
518 518
519 if (!p_dev->_io ) 519 if (!p_dev->_io )
520 return CS_BAD_HANDLE; 520 return CS_BAD_HANDLE;
521 521
522 p_dev->_io = 0; 522 p_dev->_io = 0;
523 523
524 if ((c->io.BasePort1 != req->BasePort1) || 524 if ((c->io.BasePort1 != req->BasePort1) ||
525 (c->io.NumPorts1 != req->NumPorts1) || 525 (c->io.NumPorts1 != req->NumPorts1) ||
526 (c->io.BasePort2 != req->BasePort2) || 526 (c->io.BasePort2 != req->BasePort2) ||
527 (c->io.NumPorts2 != req->NumPorts2)) 527 (c->io.NumPorts2 != req->NumPorts2))
528 return CS_BAD_ARGS; 528 return CS_BAD_ARGS;
529 529
530 c->state &= ~CONFIG_IO_REQ; 530 c->state &= ~CONFIG_IO_REQ;
531 531
532 release_io_space(s, req->BasePort1, req->NumPorts1); 532 release_io_space(s, req->BasePort1, req->NumPorts1);
533 if (req->NumPorts2) 533 if (req->NumPorts2)
534 release_io_space(s, req->BasePort2, req->NumPorts2); 534 release_io_space(s, req->BasePort2, req->NumPorts2);
535 535
536 return CS_SUCCESS; 536 return CS_SUCCESS;
537 } /* pcmcia_release_io */ 537 } /* pcmcia_release_io */
538 538
539 539
540 static int pcmcia_release_irq(struct pcmcia_device *p_dev, irq_req_t *req) 540 static int pcmcia_release_irq(struct pcmcia_device *p_dev, irq_req_t *req)
541 { 541 {
542 struct pcmcia_socket *s = p_dev->socket; 542 struct pcmcia_socket *s = p_dev->socket;
543 config_t *c= p_dev->function_config; 543 config_t *c= p_dev->function_config;
544 544
545 if (!p_dev->_irq) 545 if (!p_dev->_irq)
546 return CS_BAD_HANDLE; 546 return CS_BAD_HANDLE;
547 p_dev->_irq = 0; 547 p_dev->_irq = 0;
548 548
549 if (c->state & CONFIG_LOCKED) 549 if (c->state & CONFIG_LOCKED)
550 return CS_CONFIGURATION_LOCKED; 550 return CS_CONFIGURATION_LOCKED;
551 if (c->irq.Attributes != req->Attributes) 551 if (c->irq.Attributes != req->Attributes)
552 return CS_BAD_ATTRIBUTE; 552 return CS_BAD_ATTRIBUTE;
553 if (s->irq.AssignedIRQ != req->AssignedIRQ) 553 if (s->irq.AssignedIRQ != req->AssignedIRQ)
554 return CS_BAD_IRQ; 554 return CS_BAD_IRQ;
555 if (--s->irq.Config == 0) { 555 if (--s->irq.Config == 0) {
556 c->state &= ~CONFIG_IRQ_REQ; 556 c->state &= ~CONFIG_IRQ_REQ;
557 s->irq.AssignedIRQ = 0; 557 s->irq.AssignedIRQ = 0;
558 } 558 }
559 559
560 if (req->Attributes & IRQ_HANDLE_PRESENT) { 560 if (req->Attributes & IRQ_HANDLE_PRESENT) {
561 free_irq(req->AssignedIRQ, req->Instance); 561 free_irq(req->AssignedIRQ, req->Instance);
562 } 562 }
563 563
564 #ifdef CONFIG_PCMCIA_PROBE 564 #ifdef CONFIG_PCMCIA_PROBE
565 pcmcia_used_irq[req->AssignedIRQ]--; 565 pcmcia_used_irq[req->AssignedIRQ]--;
566 #endif 566 #endif
567 567
568 return CS_SUCCESS; 568 return CS_SUCCESS;
569 } /* pcmcia_release_irq */ 569 } /* pcmcia_release_irq */
570 570
571 571
572 int pcmcia_release_window(window_handle_t win) 572 int pcmcia_release_window(window_handle_t win)
573 { 573 {
574 struct pcmcia_socket *s; 574 struct pcmcia_socket *s;
575 575
576 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 576 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
577 return CS_BAD_HANDLE; 577 return CS_BAD_HANDLE;
578 s = win->sock; 578 s = win->sock;
579 if (!(win->handle->_win & CLIENT_WIN_REQ(win->index))) 579 if (!(win->handle->_win & CLIENT_WIN_REQ(win->index)))
580 return CS_BAD_HANDLE; 580 return CS_BAD_HANDLE;
581 581
582 /* Shut down memory window */ 582 /* Shut down memory window */
583 win->ctl.flags &= ~MAP_ACTIVE; 583 win->ctl.flags &= ~MAP_ACTIVE;
584 s->ops->set_mem_map(s, &win->ctl); 584 s->ops->set_mem_map(s, &win->ctl);
585 s->state &= ~SOCKET_WIN_REQ(win->index); 585 s->state &= ~SOCKET_WIN_REQ(win->index);
586 586
587 /* Release system memory */ 587 /* Release system memory */
588 if (win->ctl.res) { 588 if (win->ctl.res) {
589 release_resource(win->ctl.res); 589 release_resource(win->ctl.res);
590 kfree(win->ctl.res); 590 kfree(win->ctl.res);
591 win->ctl.res = NULL; 591 win->ctl.res = NULL;
592 } 592 }
593 win->handle->_win &= ~CLIENT_WIN_REQ(win->index); 593 win->handle->_win &= ~CLIENT_WIN_REQ(win->index);
594 594
595 win->magic = 0; 595 win->magic = 0;
596 596
597 return CS_SUCCESS; 597 return CS_SUCCESS;
598 } /* pcmcia_release_window */ 598 } /* pcmcia_release_window */
599 EXPORT_SYMBOL(pcmcia_release_window); 599 EXPORT_SYMBOL(pcmcia_release_window);
600 600
601 601
602 int pcmcia_request_configuration(struct pcmcia_device *p_dev, 602 int pcmcia_request_configuration(struct pcmcia_device *p_dev,
603 config_req_t *req) 603 config_req_t *req)
604 { 604 {
605 int i; 605 int i;
606 u_int base; 606 u_int base;
607 struct pcmcia_socket *s = p_dev->socket; 607 struct pcmcia_socket *s = p_dev->socket;
608 config_t *c; 608 config_t *c;
609 pccard_io_map iomap; 609 pccard_io_map iomap;
610 610
611 if (!(s->state & SOCKET_PRESENT)) 611 if (!(s->state & SOCKET_PRESENT))
612 return CS_NO_CARD; 612 return CS_NO_CARD;
613 613
614 if (req->IntType & INT_CARDBUS) 614 if (req->IntType & INT_CARDBUS)
615 return CS_UNSUPPORTED_MODE; 615 return CS_UNSUPPORTED_MODE;
616 c = p_dev->function_config; 616 c = p_dev->function_config;
617 if (c->state & CONFIG_LOCKED) 617 if (c->state & CONFIG_LOCKED)
618 return CS_CONFIGURATION_LOCKED; 618 return CS_CONFIGURATION_LOCKED;
619 619
620 /* Do power control. We don't allow changes in Vcc. */ 620 /* Do power control. We don't allow changes in Vcc. */
621 s->socket.Vpp = req->Vpp; 621 s->socket.Vpp = req->Vpp;
622 if (s->ops->set_socket(s, &s->socket)) 622 if (s->ops->set_socket(s, &s->socket))
623 return CS_BAD_VPP; 623 return CS_BAD_VPP;
624 624
625 /* Pick memory or I/O card, DMA mode, interrupt */ 625 /* Pick memory or I/O card, DMA mode, interrupt */
626 c->IntType = req->IntType; 626 c->IntType = req->IntType;
627 c->Attributes = req->Attributes; 627 c->Attributes = req->Attributes;
628 if (req->IntType & INT_MEMORY_AND_IO) 628 if (req->IntType & INT_MEMORY_AND_IO)
629 s->socket.flags |= SS_IOCARD; 629 s->socket.flags |= SS_IOCARD;
630 if (req->IntType & INT_ZOOMED_VIDEO) 630 if (req->IntType & INT_ZOOMED_VIDEO)
631 s->socket.flags |= SS_ZVCARD | SS_IOCARD; 631 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
632 if (req->Attributes & CONF_ENABLE_DMA) 632 if (req->Attributes & CONF_ENABLE_DMA)
633 s->socket.flags |= SS_DMA_MODE; 633 s->socket.flags |= SS_DMA_MODE;
634 if (req->Attributes & CONF_ENABLE_SPKR) 634 if (req->Attributes & CONF_ENABLE_SPKR)
635 s->socket.flags |= SS_SPKR_ENA; 635 s->socket.flags |= SS_SPKR_ENA;
636 if (req->Attributes & CONF_ENABLE_IRQ) 636 if (req->Attributes & CONF_ENABLE_IRQ)
637 s->socket.io_irq = s->irq.AssignedIRQ; 637 s->socket.io_irq = s->irq.AssignedIRQ;
638 else 638 else
639 s->socket.io_irq = 0; 639 s->socket.io_irq = 0;
640 s->ops->set_socket(s, &s->socket); 640 s->ops->set_socket(s, &s->socket);
641 s->lock_count++; 641 s->lock_count++;
642 642
643 /* Set up CIS configuration registers */ 643 /* Set up CIS configuration registers */
644 base = c->ConfigBase = req->ConfigBase; 644 base = c->ConfigBase = req->ConfigBase;
645 c->CardValues = req->Present; 645 c->CardValues = req->Present;
646 if (req->Present & PRESENT_COPY) { 646 if (req->Present & PRESENT_COPY) {
647 c->Copy = req->Copy; 647 c->Copy = req->Copy;
648 pcmcia_write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy); 648 pcmcia_write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
649 } 649 }
650 if (req->Present & PRESENT_OPTION) { 650 if (req->Present & PRESENT_OPTION) {
651 if (s->functions == 1) { 651 if (s->functions == 1) {
652 c->Option = req->ConfigIndex & COR_CONFIG_MASK; 652 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
653 } else { 653 } else {
654 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK; 654 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
655 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA; 655 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
656 if (req->Present & PRESENT_IOBASE_0) 656 if (req->Present & PRESENT_IOBASE_0)
657 c->Option |= COR_ADDR_DECODE; 657 c->Option |= COR_ADDR_DECODE;
658 } 658 }
659 if (c->state & CONFIG_IRQ_REQ) 659 if (c->state & CONFIG_IRQ_REQ)
660 if (!(c->irq.Attributes & IRQ_FORCED_PULSE)) 660 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
661 c->Option |= COR_LEVEL_REQ; 661 c->Option |= COR_LEVEL_REQ;
662 pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option); 662 pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
663 mdelay(40); 663 mdelay(40);
664 } 664 }
665 if (req->Present & PRESENT_STATUS) { 665 if (req->Present & PRESENT_STATUS) {
666 c->Status = req->Status; 666 c->Status = req->Status;
667 pcmcia_write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status); 667 pcmcia_write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
668 } 668 }
669 if (req->Present & PRESENT_PIN_REPLACE) { 669 if (req->Present & PRESENT_PIN_REPLACE) {
670 c->Pin = req->Pin; 670 c->Pin = req->Pin;
671 pcmcia_write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin); 671 pcmcia_write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
672 } 672 }
673 if (req->Present & PRESENT_EXT_STATUS) { 673 if (req->Present & PRESENT_EXT_STATUS) {
674 c->ExtStatus = req->ExtStatus; 674 c->ExtStatus = req->ExtStatus;
675 pcmcia_write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus); 675 pcmcia_write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
676 } 676 }
677 if (req->Present & PRESENT_IOBASE_0) { 677 if (req->Present & PRESENT_IOBASE_0) {
678 u_char b = c->io.BasePort1 & 0xff; 678 u_char b = c->io.BasePort1 & 0xff;
679 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b); 679 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
680 b = (c->io.BasePort1 >> 8) & 0xff; 680 b = (c->io.BasePort1 >> 8) & 0xff;
681 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b); 681 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
682 } 682 }
683 if (req->Present & PRESENT_IOSIZE) { 683 if (req->Present & PRESENT_IOSIZE) {
684 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1; 684 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
685 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b); 685 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
686 } 686 }
687 687
688 /* Configure I/O windows */ 688 /* Configure I/O windows */
689 if (c->state & CONFIG_IO_REQ) { 689 if (c->state & CONFIG_IO_REQ) {
690 iomap.speed = io_speed; 690 iomap.speed = io_speed;
691 for (i = 0; i < MAX_IO_WIN; i++) 691 for (i = 0; i < MAX_IO_WIN; i++)
692 if (s->io[i].res) { 692 if (s->io[i].res) {
693 iomap.map = i; 693 iomap.map = i;
694 iomap.flags = MAP_ACTIVE; 694 iomap.flags = MAP_ACTIVE;
695 switch (s->io[i].res->flags & IO_DATA_PATH_WIDTH) { 695 switch (s->io[i].res->flags & IO_DATA_PATH_WIDTH) {
696 case IO_DATA_PATH_WIDTH_16: 696 case IO_DATA_PATH_WIDTH_16:
697 iomap.flags |= MAP_16BIT; break; 697 iomap.flags |= MAP_16BIT; break;
698 case IO_DATA_PATH_WIDTH_AUTO: 698 case IO_DATA_PATH_WIDTH_AUTO:
699 iomap.flags |= MAP_AUTOSZ; break; 699 iomap.flags |= MAP_AUTOSZ; break;
700 default: 700 default:
701 break; 701 break;
702 } 702 }
703 iomap.start = s->io[i].res->start; 703 iomap.start = s->io[i].res->start;
704 iomap.stop = s->io[i].res->end; 704 iomap.stop = s->io[i].res->end;
705 s->ops->set_io_map(s, &iomap); 705 s->ops->set_io_map(s, &iomap);
706 s->io[i].Config++; 706 s->io[i].Config++;
707 } 707 }
708 } 708 }
709 709
710 c->state |= CONFIG_LOCKED; 710 c->state |= CONFIG_LOCKED;
711 p_dev->_locked = 1; 711 p_dev->_locked = 1;
712 return CS_SUCCESS; 712 return CS_SUCCESS;
713 } /* pcmcia_request_configuration */ 713 } /* pcmcia_request_configuration */
714 EXPORT_SYMBOL(pcmcia_request_configuration); 714 EXPORT_SYMBOL(pcmcia_request_configuration);
715 715
716 716
717 /** pcmcia_request_io 717 /** pcmcia_request_io
718 * 718 *
719 * Request_io() reserves ranges of port addresses for a socket. 719 * Request_io() reserves ranges of port addresses for a socket.
720 * I have not implemented range sharing or alias addressing. 720 * I have not implemented range sharing or alias addressing.
721 */ 721 */
722 int pcmcia_request_io(struct pcmcia_device *p_dev, io_req_t *req) 722 int pcmcia_request_io(struct pcmcia_device *p_dev, io_req_t *req)
723 { 723 {
724 struct pcmcia_socket *s = p_dev->socket; 724 struct pcmcia_socket *s = p_dev->socket;
725 config_t *c; 725 config_t *c;
726 726
727 if (!(s->state & SOCKET_PRESENT)) 727 if (!(s->state & SOCKET_PRESENT))
728 return CS_NO_CARD; 728 return CS_NO_CARD;
729 729
730 if (!req) 730 if (!req)
731 return CS_UNSUPPORTED_MODE; 731 return CS_UNSUPPORTED_MODE;
732 c = p_dev->function_config; 732 c = p_dev->function_config;
733 if (c->state & CONFIG_LOCKED) 733 if (c->state & CONFIG_LOCKED)
734 return CS_CONFIGURATION_LOCKED; 734 return CS_CONFIGURATION_LOCKED;
735 if (c->state & CONFIG_IO_REQ) 735 if (c->state & CONFIG_IO_REQ)
736 return CS_IN_USE; 736 return CS_IN_USE;
737 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)) 737 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
738 return CS_BAD_ATTRIBUTE; 738 return CS_BAD_ATTRIBUTE;
739 if ((req->NumPorts2 > 0) && 739 if ((req->NumPorts2 > 0) &&
740 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))) 740 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
741 return CS_BAD_ATTRIBUTE; 741 return CS_BAD_ATTRIBUTE;
742 742
743 if (alloc_io_space(s, req->Attributes1, &req->BasePort1, 743 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
744 req->NumPorts1, req->IOAddrLines)) 744 req->NumPorts1, req->IOAddrLines))
745 return CS_IN_USE; 745 return CS_IN_USE;
746 746
747 if (req->NumPorts2) { 747 if (req->NumPorts2) {
748 if (alloc_io_space(s, req->Attributes2, &req->BasePort2, 748 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
749 req->NumPorts2, req->IOAddrLines)) { 749 req->NumPorts2, req->IOAddrLines)) {
750 release_io_space(s, req->BasePort1, req->NumPorts1); 750 release_io_space(s, req->BasePort1, req->NumPorts1);
751 return CS_IN_USE; 751 return CS_IN_USE;
752 } 752 }
753 } 753 }
754 754
755 c->io = *req; 755 c->io = *req;
756 c->state |= CONFIG_IO_REQ; 756 c->state |= CONFIG_IO_REQ;
757 p_dev->_io = 1; 757 p_dev->_io = 1;
758 return CS_SUCCESS; 758 return CS_SUCCESS;
759 } /* pcmcia_request_io */ 759 } /* pcmcia_request_io */
760 EXPORT_SYMBOL(pcmcia_request_io); 760 EXPORT_SYMBOL(pcmcia_request_io);
761 761
762 762
763 /** pcmcia_request_irq 763 /** pcmcia_request_irq
764 * 764 *
765 * Request_irq() reserves an irq for this client. 765 * Request_irq() reserves an irq for this client.
766 * 766 *
767 * Also, since Linux only reserves irq's when they are actually 767 * Also, since Linux only reserves irq's when they are actually
768 * hooked, we don't guarantee that an irq will still be available 768 * hooked, we don't guarantee that an irq will still be available
769 * when the configuration is locked. Now that I think about it, 769 * when the configuration is locked. Now that I think about it,
770 * there might be a way to fix this using a dummy handler. 770 * there might be a way to fix this using a dummy handler.
771 */ 771 */
772 772
773 #ifdef CONFIG_PCMCIA_PROBE 773 #ifdef CONFIG_PCMCIA_PROBE
774 static irqreturn_t test_action(int cpl, void *dev_id, struct pt_regs *regs) 774 static irqreturn_t test_action(int cpl, void *dev_id, struct pt_regs *regs)
775 { 775 {
776 return IRQ_NONE; 776 return IRQ_NONE;
777 } 777 }
778 #endif 778 #endif
779 779
780 int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req) 780 int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req)
781 { 781 {
782 struct pcmcia_socket *s = p_dev->socket; 782 struct pcmcia_socket *s = p_dev->socket;
783 config_t *c; 783 config_t *c;
784 int ret = CS_IN_USE, irq = 0; 784 int ret = CS_IN_USE, irq = 0;
785 785
786 if (!(s->state & SOCKET_PRESENT)) 786 if (!(s->state & SOCKET_PRESENT))
787 return CS_NO_CARD; 787 return CS_NO_CARD;
788 c = p_dev->function_config; 788 c = p_dev->function_config;
789 if (c->state & CONFIG_LOCKED) 789 if (c->state & CONFIG_LOCKED)
790 return CS_CONFIGURATION_LOCKED; 790 return CS_CONFIGURATION_LOCKED;
791 if (c->state & CONFIG_IRQ_REQ) 791 if (c->state & CONFIG_IRQ_REQ)
792 return CS_IN_USE; 792 return CS_IN_USE;
793 793
794 #ifdef CONFIG_PCMCIA_PROBE 794 #ifdef CONFIG_PCMCIA_PROBE
795 if (s->irq.AssignedIRQ != 0) { 795 if (s->irq.AssignedIRQ != 0) {
796 /* If the interrupt is already assigned, it must be the same */ 796 /* If the interrupt is already assigned, it must be the same */
797 irq = s->irq.AssignedIRQ; 797 irq = s->irq.AssignedIRQ;
798 } else { 798 } else {
799 int try; 799 int try;
800 u32 mask = s->irq_mask; 800 u32 mask = s->irq_mask;
801 void *data = &p_dev->dev.driver; /* something unique to this device */ 801 void *data = &p_dev->dev.driver; /* something unique to this device */
802 802
803 for (try = 0; try < 64; try++) { 803 for (try = 0; try < 64; try++) {
804 irq = try % 32; 804 irq = try % 32;
805 805
806 /* marked as available by driver, and not blocked by userspace? */ 806 /* marked as available by driver, and not blocked by userspace? */
807 if (!((mask >> irq) & 1)) 807 if (!((mask >> irq) & 1))
808 continue; 808 continue;
809 809
810 /* avoid an IRQ which is already used by a PCMCIA card */ 810 /* avoid an IRQ which is already used by a PCMCIA card */
811 if ((try < 32) && pcmcia_used_irq[irq]) 811 if ((try < 32) && pcmcia_used_irq[irq])
812 continue; 812 continue;
813 813
814 /* register the correct driver, if possible, of check whether 814 /* register the correct driver, if possible, of check whether
815 * registering a dummy handle works, i.e. if the IRQ isn't 815 * registering a dummy handle works, i.e. if the IRQ isn't
816 * marked as used by the kernel resource management core */ 816 * marked as used by the kernel resource management core */
817 ret = request_irq(irq, 817 ret = request_irq(irq,
818 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Handler : test_action, 818 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Handler : test_action,
819 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) || 819 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
820 (s->functions > 1) || 820 (s->functions > 1) ||
821 (irq == s->pci_irq)) ? SA_SHIRQ : 0, 821 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
822 p_dev->devname, 822 p_dev->devname,
823 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data); 823 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data);
824 if (!ret) { 824 if (!ret) {
825 if (!(req->Attributes & IRQ_HANDLE_PRESENT)) 825 if (!(req->Attributes & IRQ_HANDLE_PRESENT))
826 free_irq(irq, data); 826 free_irq(irq, data);
827 break; 827 break;
828 } 828 }
829 } 829 }
830 } 830 }
831 #endif 831 #endif
832 /* only assign PCI irq if no IRQ already assigned */ 832 /* only assign PCI irq if no IRQ already assigned */
833 if (ret && !s->irq.AssignedIRQ) { 833 if (ret && !s->irq.AssignedIRQ) {
834 if (!s->pci_irq) 834 if (!s->pci_irq)
835 return ret; 835 return ret;
836 irq = s->pci_irq; 836 irq = s->pci_irq;
837 } 837 }
838 838
839 if (ret && req->Attributes & IRQ_HANDLE_PRESENT) { 839 if (ret && req->Attributes & IRQ_HANDLE_PRESENT) {
840 if (request_irq(irq, req->Handler, 840 if (request_irq(irq, req->Handler,
841 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) || 841 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
842 (s->functions > 1) || 842 (s->functions > 1) ||
843 (irq == s->pci_irq)) ? SA_SHIRQ : 0, 843 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
844 p_dev->devname, req->Instance)) 844 p_dev->devname, req->Instance))
845 return CS_IN_USE; 845 return CS_IN_USE;
846 } 846 }
847 847
848 c->irq.Attributes = req->Attributes; 848 c->irq.Attributes = req->Attributes;
849 s->irq.AssignedIRQ = req->AssignedIRQ = irq; 849 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
850 s->irq.Config++; 850 s->irq.Config++;
851 851
852 c->state |= CONFIG_IRQ_REQ; 852 c->state |= CONFIG_IRQ_REQ;
853 p_dev->_irq = 1; 853 p_dev->_irq = 1;
854 854
855 #ifdef CONFIG_PCMCIA_PROBE 855 #ifdef CONFIG_PCMCIA_PROBE
856 pcmcia_used_irq[irq]++; 856 pcmcia_used_irq[irq]++;
857 #endif 857 #endif
858 858
859 return CS_SUCCESS; 859 return CS_SUCCESS;
860 } /* pcmcia_request_irq */ 860 } /* pcmcia_request_irq */
861 EXPORT_SYMBOL(pcmcia_request_irq); 861 EXPORT_SYMBOL(pcmcia_request_irq);
862 862
863 863
864 /** pcmcia_request_window 864 /** pcmcia_request_window
865 * 865 *
866 * Request_window() establishes a mapping between card memory space 866 * Request_window() establishes a mapping between card memory space
867 * and system memory space. 867 * and system memory space.
868 */ 868 */
869 int pcmcia_request_window(struct pcmcia_device **p_dev, win_req_t *req, window_handle_t *wh) 869 int pcmcia_request_window(struct pcmcia_device **p_dev, win_req_t *req, window_handle_t *wh)
870 { 870 {
871 struct pcmcia_socket *s = (*p_dev)->socket; 871 struct pcmcia_socket *s = (*p_dev)->socket;
872 window_t *win; 872 window_t *win;
873 u_long align; 873 u_long align;
874 int w; 874 int w;
875 875
876 if (!(s->state & SOCKET_PRESENT)) 876 if (!(s->state & SOCKET_PRESENT))
877 return CS_NO_CARD; 877 return CS_NO_CARD;
878 if (req->Attributes & (WIN_PAGED | WIN_SHARED)) 878 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
879 return CS_BAD_ATTRIBUTE; 879 return CS_BAD_ATTRIBUTE;
880 880
881 /* Window size defaults to smallest available */ 881 /* Window size defaults to smallest available */
882 if (req->Size == 0) 882 if (req->Size == 0)
883 req->Size = s->map_size; 883 req->Size = s->map_size;
884 align = (((s->features & SS_CAP_MEM_ALIGN) || 884 align = (((s->features & SS_CAP_MEM_ALIGN) ||
885 (req->Attributes & WIN_STRICT_ALIGN)) ? 885 (req->Attributes & WIN_STRICT_ALIGN)) ?
886 req->Size : s->map_size); 886 req->Size : s->map_size);
887 if (req->Size & (s->map_size-1)) 887 if (req->Size & (s->map_size-1))
888 return CS_BAD_SIZE; 888 return CS_BAD_SIZE;
889 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) || 889 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
890 (req->Base & (align-1))) 890 (req->Base & (align-1)))
891 return CS_BAD_BASE; 891 return CS_BAD_BASE;
892 if (req->Base) 892 if (req->Base)
893 align = 0; 893 align = 0;
894 894
895 /* Allocate system memory window */ 895 /* Allocate system memory window */
896 for (w = 0; w < MAX_WIN; w++) 896 for (w = 0; w < MAX_WIN; w++)
897 if (!(s->state & SOCKET_WIN_REQ(w))) break; 897 if (!(s->state & SOCKET_WIN_REQ(w))) break;
898 if (w == MAX_WIN) 898 if (w == MAX_WIN)
899 return CS_OUT_OF_RESOURCE; 899 return CS_OUT_OF_RESOURCE;
900 900
901 win = &s->win[w]; 901 win = &s->win[w];
902 win->magic = WINDOW_MAGIC; 902 win->magic = WINDOW_MAGIC;
903 win->index = w; 903 win->index = w;
904 win->handle = *p_dev; 904 win->handle = *p_dev;
905 win->sock = s; 905 win->sock = s;
906 906
907 if (!(s->features & SS_CAP_STATIC_MAP)) { 907 if (!(s->features & SS_CAP_STATIC_MAP)) {
908 win->ctl.res = pcmcia_find_mem_region(req->Base, req->Size, align, 908 win->ctl.res = pcmcia_find_mem_region(req->Base, req->Size, align,
909 (req->Attributes & WIN_MAP_BELOW_1MB), s); 909 (req->Attributes & WIN_MAP_BELOW_1MB), s);
910 if (!win->ctl.res) 910 if (!win->ctl.res)
911 return CS_IN_USE; 911 return CS_IN_USE;
912 } 912 }
913 (*p_dev)->_win |= CLIENT_WIN_REQ(w); 913 (*p_dev)->_win |= CLIENT_WIN_REQ(w);
914 914
915 /* Configure the socket controller */ 915 /* Configure the socket controller */
916 win->ctl.map = w+1; 916 win->ctl.map = w+1;
917 win->ctl.flags = 0; 917 win->ctl.flags = 0;
918 win->ctl.speed = req->AccessSpeed; 918 win->ctl.speed = req->AccessSpeed;
919 if (req->Attributes & WIN_MEMORY_TYPE) 919 if (req->Attributes & WIN_MEMORY_TYPE)
920 win->ctl.flags |= MAP_ATTRIB; 920 win->ctl.flags |= MAP_ATTRIB;
921 if (req->Attributes & WIN_ENABLE) 921 if (req->Attributes & WIN_ENABLE)
922 win->ctl.flags |= MAP_ACTIVE; 922 win->ctl.flags |= MAP_ACTIVE;
923 if (req->Attributes & WIN_DATA_WIDTH_16) 923 if (req->Attributes & WIN_DATA_WIDTH_16)
924 win->ctl.flags |= MAP_16BIT; 924 win->ctl.flags |= MAP_16BIT;
925 if (req->Attributes & WIN_USE_WAIT) 925 if (req->Attributes & WIN_USE_WAIT)
926 win->ctl.flags |= MAP_USE_WAIT; 926 win->ctl.flags |= MAP_USE_WAIT;
927 win->ctl.card_start = 0; 927 win->ctl.card_start = 0;
928 if (s->ops->set_mem_map(s, &win->ctl) != 0) 928 if (s->ops->set_mem_map(s, &win->ctl) != 0)
929 return CS_BAD_ARGS; 929 return CS_BAD_ARGS;
930 s->state |= SOCKET_WIN_REQ(w); 930 s->state |= SOCKET_WIN_REQ(w);
931 931
932 /* Return window handle */ 932 /* Return window handle */
933 if (s->features & SS_CAP_STATIC_MAP) { 933 if (s->features & SS_CAP_STATIC_MAP) {
934 req->Base = win->ctl.static_start; 934 req->Base = win->ctl.static_start;
935 } else { 935 } else {
936 req->Base = win->ctl.res->start; 936 req->Base = win->ctl.res->start;
937 } 937 }
938 *wh = win; 938 *wh = win;
939 939
940 return CS_SUCCESS; 940 return CS_SUCCESS;
941 } /* pcmcia_request_window */ 941 } /* pcmcia_request_window */
942 EXPORT_SYMBOL(pcmcia_request_window); 942 EXPORT_SYMBOL(pcmcia_request_window);
943 943
944 void pcmcia_disable_device(struct pcmcia_device *p_dev) { 944 void pcmcia_disable_device(struct pcmcia_device *p_dev) {
945 pcmcia_release_configuration(p_dev); 945 pcmcia_release_configuration(p_dev);
946 pcmcia_release_io(p_dev, &p_dev->io); 946 pcmcia_release_io(p_dev, &p_dev->io);
947 pcmcia_release_irq(p_dev, &p_dev->irq); 947 pcmcia_release_irq(p_dev, &p_dev->irq);
948 if (&p_dev->win) 948 if (&p_dev->win)
949 pcmcia_release_window(p_dev->win); 949 pcmcia_release_window(p_dev->win);
950
951 p_dev->dev_node = NULL;
952 } 950 }
953 EXPORT_SYMBOL(pcmcia_disable_device); 951 EXPORT_SYMBOL(pcmcia_disable_device);
954 952