projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
pcmcia: improve check for same card in slot after resume
[linux-2.6-block.git] / drivers / pcmcia / cistpl.c
CommitLineData
1da177e4
LT		 1/*
2 * cistpl.c -- 16-bit PCMCIA Card Information Structure parser
3 *
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
6 * published by the Free Software Foundation.
7 *
8 * The initial developer of the original code is 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.
11 *
12 * (C) 1999 David A. Hinds
13 */
14
1da177e4
LT		 15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/kernel.h>
18#include <linux/string.h>
19#include <linux/major.h>
20#include <linux/errno.h>
21#include <linux/timer.h>
22#include <linux/slab.h>
23#include <linux/mm.h>
1da177e4
LT		 24#include <linux/pci.h>
25#include <linux/ioport.h>
9fea84f4 26#include <linux/io.h>
1da177e4 27#include <asm/byteorder.h>
dc0cf6a2 28#include <asm/unaligned.h>
1da177e4
LT		 29
30#include <pcmcia/cs_types.h>
31#include <pcmcia/ss.h>
32#include <pcmcia/cs.h>
1da177e4
LT		 33#include <pcmcia/cisreg.h>
34#include <pcmcia/cistpl.h>
35#include "cs_internal.h"
36
37static const u_char mantissa[] = {
38 10, 12, 13, 15, 20, 25, 30, 35,
39 40, 45, 50, 55, 60, 70, 80, 90
40};
41
42static const u_int exponent[] = {
43 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
44};
45
46/* Convert an extended speed byte to a time in nanoseconds */
47#define SPEED_CVT(v) \
48 (mantissa[(((v)>>3)&15)-1] * exponent[(v)&7] / 10)
49/* Convert a power byte to a current in 0.1 microamps */
50#define POWER_CVT(v) \
51 (mantissa[((v)>>3)&15] * exponent[(v)&7] / 10)
52#define POWER_SCALE(v) (exponent[(v)&7])
53
54/* Upper limit on reasonable # of tuples */
55#define MAX_TUPLES 200
56
57/*====================================================================*/
58
59/* Parameters that can be set with 'insmod' */
60
37f77955
PM		 61/* 16-bit CIS? */
62static int cis_width;
63module_param(cis_width, int, 0444);
1da177e4
LT		 64
65void release_cis_mem(struct pcmcia_socket *s)
66{
67 if (s->cis_mem.flags & MAP_ACTIVE) {
68 s->cis_mem.flags &= ~MAP_ACTIVE;
69 s->ops->set_mem_map(s, &s->cis_mem);
70 if (s->cis_mem.res) {
71 release_resource(s->cis_mem.res);
72 kfree(s->cis_mem.res);
73 s->cis_mem.res = NULL;
74 }
75 iounmap(s->cis_virt);
76 s->cis_virt = NULL;
77 }
78}
79EXPORT_SYMBOL(release_cis_mem);
80
81/*
82 * Map the card memory at "card_offset" into virtual space.
83 * If flags & MAP_ATTRIB, map the attribute space, otherwise
84 * map the memory space.
85 */
86static void __iomem *
87set_cis_map(struct pcmcia_socket *s, unsigned int card_offset, unsigned int flags)
88{
2e5a3e79
DB		 89 pccard_mem_map *mem = &s->cis_mem;
90 int ret;
91
92 if (!(s->features & SS_CAP_STATIC_MAP) && (mem->res == NULL)) {
93 mem->res = pcmcia_find_mem_region(0, s->map_size, s->map_size, 0, s);
94 if (mem->res == NULL) {
2e55bf6b
DB		 95 dev_printk(KERN_NOTICE, &s->dev,
96 "cs: unable to map card memory!\n");
2e5a3e79
DB		 97 return NULL;
98 }
99 s->cis_virt = NULL;
1da177e4 100 }
2ad0a0a7 101
2e5a3e79
DB		 102 if (!(s->features & SS_CAP_STATIC_MAP) && (!s->cis_virt))
103 s->cis_virt = ioremap(mem->res->start, s->map_size);
104
105 mem->card_start = card_offset;
106 mem->flags = flags;
107
108 ret = s->ops->set_mem_map(s, mem);
109 if (ret) {
110 iounmap(s->cis_virt);
111 s->cis_virt = NULL;
112 return NULL;
113 }
114
115 if (s->features & SS_CAP_STATIC_MAP) {
116 if (s->cis_virt)
117 iounmap(s->cis_virt);
118 s->cis_virt = ioremap(mem->static_start, s->map_size);
119 }
120
121 return s->cis_virt;
1da177e4
LT		 122}
123
124/*======================================================================
125
126 Low-level functions to read and write CIS memory. I think the
127 write routine is only useful for writing one-byte registers.
9fea84f4 128
1da177e4
LT		 129======================================================================*/
130
131/* Bits in attr field */
132#define IS_ATTR 1
133#define IS_INDIRECT 8
134
e6ea0b9e 135int pcmcia_read_cis_mem(struct pcmcia_socket *s, int attr, u_int addr,
1da177e4
LT		 136 u_int len, void *ptr)
137{
138 void __iomem *sys, *end;
139 unsigned char *buf = ptr;
9fea84f4 140
d50dbec3 141 dev_dbg(&s->dev, "pcmcia_read_cis_mem(%d, %#x, %u)\n", attr, addr, len);
1da177e4
LT		 142
143 if (attr & IS_INDIRECT) {
144 /* Indirect accesses use a bunch of special registers at fixed
145 locations in common memory */
146 u_char flags = ICTRL0_COMMON|ICTRL0_AUTOINC|ICTRL0_BYTEGRAN;
147 if (attr & IS_ATTR) {
148 addr *= 2;
149 flags = ICTRL0_AUTOINC;
150 }
151
152 sys = set_cis_map(s, 0, MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0));
153 if (!sys) {
154 memset(ptr, 0xff, len);
155 return -1;
156 }
157
158 writeb(flags, sys+CISREG_ICTRL0);
159 writeb(addr & 0xff, sys+CISREG_IADDR0);
160 writeb((addr>>8) & 0xff, sys+CISREG_IADDR1);
161 writeb((addr>>16) & 0xff, sys+CISREG_IADDR2);
162 writeb((addr>>24) & 0xff, sys+CISREG_IADDR3);
163 for ( ; len > 0; len--, buf++)
164 *buf = readb(sys+CISREG_IDATA0);
165 } else {
166 u_int inc = 1, card_offset, flags;
167
168 flags = MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0);
169 if (attr) {
170 flags |= MAP_ATTRIB;
171 inc++;
172 addr *= 2;
173 }
174
175 card_offset = addr & ~(s->map_size-1);
176 while (len) {
177 sys = set_cis_map(s, card_offset, flags);
178 if (!sys) {
179 memset(ptr, 0xff, len);
180 return -1;
181 }
182 end = sys + s->map_size;
183 sys = sys + (addr & (s->map_size-1));
184 for ( ; len > 0; len--, buf++, sys += inc) {
185 if (sys == end)
186 break;
187 *buf = readb(sys);
188 }
189 card_offset += s->map_size;
190 addr = 0;
191 }
192 }
d50dbec3 193 dev_dbg(&s->dev, " %#2.2x %#2.2x %#2.2x %#2.2x ...\n",
1da177e4
LT		 194 *(u_char *)(ptr+0), *(u_char *)(ptr+1),
195 *(u_char *)(ptr+2), *(u_char *)(ptr+3));
196 return 0;
197}
1a8d4663
DB		 198EXPORT_SYMBOL(pcmcia_read_cis_mem);
199
1da177e4 200
e6ea0b9e 201void pcmcia_write_cis_mem(struct pcmcia_socket *s, int attr, u_int addr,
1da177e4
LT		 202 u_int len, void *ptr)
203{
204 void __iomem *sys, *end;
205 unsigned char *buf = ptr;
9fea84f4 206
d50dbec3 207 dev_dbg(&s->dev, "pcmcia_write_cis_mem(%d, %#x, %u)\n", attr, addr, len);
1da177e4
LT		 208
209 if (attr & IS_INDIRECT) {
210 /* Indirect accesses use a bunch of special registers at fixed
211 locations in common memory */
212 u_char flags = ICTRL0_COMMON|ICTRL0_AUTOINC|ICTRL0_BYTEGRAN;
213 if (attr & IS_ATTR) {
214 addr *= 2;
215 flags = ICTRL0_AUTOINC;
216 }
217
218 sys = set_cis_map(s, 0, MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0));
219 if (!sys)
220 return; /* FIXME: Error */
221
222 writeb(flags, sys+CISREG_ICTRL0);
223 writeb(addr & 0xff, sys+CISREG_IADDR0);
224 writeb((addr>>8) & 0xff, sys+CISREG_IADDR1);
225 writeb((addr>>16) & 0xff, sys+CISREG_IADDR2);
226 writeb((addr>>24) & 0xff, sys+CISREG_IADDR3);
227 for ( ; len > 0; len--, buf++)
228 writeb(*buf, sys+CISREG_IDATA0);
229 } else {
230 u_int inc = 1, card_offset, flags;
231
232 flags = MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0);
233 if (attr & IS_ATTR) {
234 flags |= MAP_ATTRIB;
235 inc++;
236 addr *= 2;
237 }
238
239 card_offset = addr & ~(s->map_size-1);
240 while (len) {
241 sys = set_cis_map(s, card_offset, flags);
242 if (!sys)
243 return; /* FIXME: error */
244
245 end = sys + s->map_size;
246 sys = sys + (addr & (s->map_size-1));
247 for ( ; len > 0; len--, buf++, sys += inc) {
248 if (sys == end)
249 break;
250 writeb(*buf, sys);
251 }
252 card_offset += s->map_size;
253 addr = 0;
254 }
255 }
256}
1a8d4663
DB		 257EXPORT_SYMBOL(pcmcia_write_cis_mem);
258
1da177e4
LT		 259
260/*======================================================================
261
262 This is a wrapper around read_cis_mem, with the same interface,
263 but which caches information, for cards whose CIS may not be
264 readable all the time.
9fea84f4 265
1da177e4
LT		 266======================================================================*/
267
268static void read_cis_cache(struct pcmcia_socket *s, int attr, u_int addr,
53efec95 269 size_t len, void *ptr)
1da177e4
LT		 270{
271 struct cis_cache_entry *cis;
272 int ret;
273
274 if (s->fake_cis) {
53efec95 275 if (s->fake_cis_len >= addr+len)
1da177e4
LT		 276 memcpy(ptr, s->fake_cis+addr, len);
277 else
278 memset(ptr, 0xff, len);
279 return;
280 }
281
282 list_for_each_entry(cis, &s->cis_cache, node) {
283 if (cis->addr == addr && cis->len == len && cis->attr == attr) {
284 memcpy(ptr, cis->cache, len);
285 return;
286 }
287 }
288
289#ifdef CONFIG_CARDBUS
290 if (s->state & SOCKET_CARDBUS)
291 ret = read_cb_mem(s, attr, addr, len, ptr);
292 else
293#endif
e6ea0b9e 294 ret = pcmcia_read_cis_mem(s, attr, addr, len, ptr);
1da177e4
LT		 295
296 if (ret == 0) {
297 /* Copy data into the cache */
298 cis = kmalloc(sizeof(struct cis_cache_entry) + len, GFP_KERNEL);
299 if (cis) {
300 cis->addr = addr;
301 cis->len = len;
302 cis->attr = attr;
303 memcpy(cis->cache, ptr, len);
304 list_add(&cis->node, &s->cis_cache);
305 }
306 }
307}
308
309static void
310remove_cis_cache(struct pcmcia_socket *s, int attr, u_int addr, u_int len)
311{
312 struct cis_cache_entry *cis;
313
314 list_for_each_entry(cis, &s->cis_cache, node)
315 if (cis->addr == addr && cis->len == len && cis->attr == attr) {
316 list_del(&cis->node);
317 kfree(cis);
318 break;
319 }
320}
321
904e3777
DB		 322/**
323 * destroy_cis_cache() - destroy the CIS cache
324 * @s: pcmcia_socket for which CIS cache shall be destroyed
325 *
326 * This destroys the CIS cache but keeps any fake CIS alive.
327 */
328
1da177e4
LT		 329void destroy_cis_cache(struct pcmcia_socket *s)
330{
331 struct list_head *l, *n;
904e3777 332 struct cis_cache_entry *cis;
1da177e4
LT		 333
334 list_for_each_safe(l, n, &s->cis_cache) {
904e3777 335 cis = list_entry(l, struct cis_cache_entry, node);
1da177e4
LT		 336 list_del(&cis->node);
337 kfree(cis);
338 }
1da177e4
LT		 339}
340EXPORT_SYMBOL(destroy_cis_cache);
341
342/*======================================================================
343
344 This verifies if the CIS of a card matches what is in the CIS
345 cache.
9fea84f4 346
1da177e4
LT		 347======================================================================*/
348
349int verify_cis_cache(struct pcmcia_socket *s)
350{
351 struct cis_cache_entry *cis;
352 char *buf;
353
354 buf = kmalloc(256, GFP_KERNEL);
e689597f 355 if (buf == NULL) {
1168386a
DB		 356 dev_printk(KERN_WARNING, &s->dev,
357 "no memory for verifying CIS\n");
358 return -ENOMEM;
e689597f 359 }
1da177e4
LT		 360 list_for_each_entry(cis, &s->cis_cache, node) {
361 int len = cis->len;
362
363 if (len > 256)
364 len = 256;
365#ifdef CONFIG_CARDBUS
366 if (s->state & SOCKET_CARDBUS)
367 read_cb_mem(s, cis->attr, cis->addr, len, buf);
368 else
369#endif
e6ea0b9e 370 pcmcia_read_cis_mem(s, cis->attr, cis->addr, len, buf);
1da177e4
LT		 371
372 if (memcmp(buf, cis->cache, len) != 0) {
373 kfree(buf);
374 return -1;
375 }
376 }
377 kfree(buf);
378 return 0;
379}
88b060d6 380EXPORT_SYMBOL(verify_cis_cache);
1da177e4
LT		 381
382/*======================================================================
383
384 For really bad cards, we provide a facility for uploading a
385 replacement CIS.
9fea84f4 386
1da177e4
LT		 387======================================================================*/
388
53efec95
DB		 389int pcmcia_replace_cis(struct pcmcia_socket *s,
390 const u8 *data, const size_t len)
1da177e4 391{
1168386a
DB		 392 if (len > CISTPL_MAX_CIS_SIZE) {
393 dev_printk(KERN_WARNING, &s->dev, "replacement CIS too big\n");
394 return -EINVAL;
395 }
396 kfree(s->fake_cis);
397 s->fake_cis = kmalloc(len, GFP_KERNEL);
398 if (s->fake_cis == NULL) {
399 dev_printk(KERN_WARNING, &s->dev, "no memory to replace CIS\n");
400 return -ENOMEM;
401 }
402 s->fake_cis_len = len;
403 memcpy(s->fake_cis, data, len);
404 return 0;
1da177e4 405}
33519ddd 406EXPORT_SYMBOL(pcmcia_replace_cis);
1da177e4
LT		 407
408/*======================================================================
409
410 The high-level CIS tuple services
9fea84f4 411
1da177e4
LT		 412======================================================================*/
413
414typedef struct tuple_flags {
415 u_int link_space:4;
416 u_int has_link:1;
417 u_int mfc_fn:3;
418 u_int space:4;
419} tuple_flags;
420
421#define LINK_SPACE(f) (((tuple_flags *)(&(f)))->link_space)
422#define HAS_LINK(f) (((tuple_flags *)(&(f)))->has_link)
423#define MFC_FN(f) (((tuple_flags *)(&(f)))->mfc_fn)
424#define SPACE(f) (((tuple_flags *)(&(f)))->space)
425
1da177e4
LT		 426int pccard_get_first_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple)
427{
428 if (!s)
ffb8da20 429 return -EINVAL;
1da177e4 430 if (!(s->state & SOCKET_PRESENT))
3939c1ef 431 return -ENODEV;
1da177e4
LT		 432 tuple->TupleLink = tuple->Flags = 0;
433#ifdef CONFIG_CARDBUS
434 if (s->state & SOCKET_CARDBUS) {
435 struct pci_dev *dev = s->cb_dev;
436 u_int ptr;
437 pci_bus_read_config_dword(dev->subordinate, 0, PCI_CARDBUS_CIS, &ptr);
438 tuple->CISOffset = ptr & ~7;
439 SPACE(tuple->Flags) = (ptr & 7);
440 } else
441#endif
442 {
443 /* Assume presence of a LONGLINK_C to address 0 */
444 tuple->CISOffset = tuple->LinkOffset = 0;
445 SPACE(tuple->Flags) = HAS_LINK(tuple->Flags) = 1;
446 }
447 if (!(s->state & SOCKET_CARDBUS) && (s->functions > 1) &&
448 !(tuple->Attributes & TUPLE_RETURN_COMMON)) {
449 cisdata_t req = tuple->DesiredTuple;
450 tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
4c89e88b 451 if (pccard_get_next_tuple(s, function, tuple) == 0) {
1da177e4 452 tuple->DesiredTuple = CISTPL_LINKTARGET;
4c89e88b 453 if (pccard_get_next_tuple(s, function, tuple) != 0)
635d19be 454 return -ENOSPC;
1da177e4
LT		 455 } else
456 tuple->CISOffset = tuple->TupleLink = 0;
457 tuple->DesiredTuple = req;
458 }
459 return pccard_get_next_tuple(s, function, tuple);
460}
461EXPORT_SYMBOL(pccard_get_first_tuple);
462
463static int follow_link(struct pcmcia_socket *s, tuple_t *tuple)
464{
465 u_char link[5];
466 u_int ofs;
467
468 if (MFC_FN(tuple->Flags)) {
469 /* Get indirect link from the MFC tuple */
470 read_cis_cache(s, LINK_SPACE(tuple->Flags),
471 tuple->LinkOffset, 5, link);
6b1e6f63 472 ofs = get_unaligned_le32(link + 1);
1da177e4
LT		 473 SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR);
474 /* Move to the next indirect link */
475 tuple->LinkOffset += 5;
476 MFC_FN(tuple->Flags)--;
477 } else if (HAS_LINK(tuple->Flags)) {
478 ofs = tuple->LinkOffset;
479 SPACE(tuple->Flags) = LINK_SPACE(tuple->Flags);
480 HAS_LINK(tuple->Flags) = 0;
481 } else {
482 return -1;
483 }
484 if (!(s->state & SOCKET_CARDBUS) && SPACE(tuple->Flags)) {
485 /* This is ugly, but a common CIS error is to code the long
486 link offset incorrectly, so we check the right spot... */
487 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link);
488 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) &&
489 (strncmp(link+2, "CIS", 3) == 0))
490 return ofs;
491 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5);
492 /* Then, we try the wrong spot... */
493 ofs = ofs >> 1;
494 }
495 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link);
496 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) &&
497 (strncmp(link+2, "CIS", 3) == 0))
498 return ofs;
499 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5);
500 return -1;
501}
502
503int pccard_get_next_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple)
504{
505 u_char link[2], tmp;
506 int ofs, i, attr;
507
508 if (!s)
ffb8da20 509 return -EINVAL;
1da177e4 510 if (!(s->state & SOCKET_PRESENT))
3939c1ef 511 return -ENODEV;
1da177e4
LT		 512
513 link[1] = tuple->TupleLink;
514 ofs = tuple->CISOffset + tuple->TupleLink;
515 attr = SPACE(tuple->Flags);
516
517 for (i = 0; i < MAX_TUPLES; i++) {
518 if (link[1] == 0xff) {
519 link[0] = CISTPL_END;
520 } else {
521 read_cis_cache(s, attr, ofs, 2, link);
522 if (link[0] == CISTPL_NULL) {
523 ofs++; continue;
524 }
525 }
9fea84f4 526
1da177e4
LT		 527 /* End of chain? Follow long link if possible */
528 if (link[0] == CISTPL_END) {
9fea84f4
DB		 529 ofs = follow_link(s, tuple);
530 if (ofs < 0)
635d19be 531 return -ENOSPC;
1da177e4
LT		 532 attr = SPACE(tuple->Flags);
533 read_cis_cache(s, attr, ofs, 2, link);
534 }
535
536 /* Is this a link tuple? Make a note of it */
537 if ((link[0] == CISTPL_LONGLINK_A) ||
538 (link[0] == CISTPL_LONGLINK_C) ||
539 (link[0] == CISTPL_LONGLINK_MFC) ||
540 (link[0] == CISTPL_LINKTARGET) ||
541 (link[0] == CISTPL_INDIRECT) ||
542 (link[0] == CISTPL_NO_LINK)) {
543 switch (link[0]) {
544 case CISTPL_LONGLINK_A:
545 HAS_LINK(tuple->Flags) = 1;
546 LINK_SPACE(tuple->Flags) = attr | IS_ATTR;
547 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset);
548 break;
549 case CISTPL_LONGLINK_C:
550 HAS_LINK(tuple->Flags) = 1;
551 LINK_SPACE(tuple->Flags) = attr & ~IS_ATTR;
552 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset);
553 break;
554 case CISTPL_INDIRECT:
555 HAS_LINK(tuple->Flags) = 1;
556 LINK_SPACE(tuple->Flags) = IS_ATTR | IS_INDIRECT;
557 tuple->LinkOffset = 0;
558 break;
559 case CISTPL_LONGLINK_MFC:
560 tuple->LinkOffset = ofs + 3;
561 LINK_SPACE(tuple->Flags) = attr;
562 if (function == BIND_FN_ALL) {
563 /* Follow all the MFC links */
564 read_cis_cache(s, attr, ofs+2, 1, &tmp);
565 MFC_FN(tuple->Flags) = tmp;
566 } else {
567 /* Follow exactly one of the links */
568 MFC_FN(tuple->Flags) = 1;
569 tuple->LinkOffset += function * 5;
570 }
571 break;
572 case CISTPL_NO_LINK:
573 HAS_LINK(tuple->Flags) = 0;
574 break;
575 }
576 if ((tuple->Attributes & TUPLE_RETURN_LINK) &&
577 (tuple->DesiredTuple == RETURN_FIRST_TUPLE))
578 break;
579 } else
580 if (tuple->DesiredTuple == RETURN_FIRST_TUPLE)
581 break;
9fea84f4 582
1da177e4
LT		 583 if (link[0] == tuple->DesiredTuple)
584 break;
585 ofs += link[1] + 2;
586 }
587 if (i == MAX_TUPLES) {
d50dbec3 588 dev_dbg(&s->dev, "cs: overrun in pcmcia_get_next_tuple\n");
635d19be 589 return -ENOSPC;
1da177e4 590 }
9fea84f4 591
1da177e4
LT		 592 tuple->TupleCode = link[0];
593 tuple->TupleLink = link[1];
594 tuple->CISOffset = ofs + 2;
4c89e88b 595 return 0;
1da177e4
LT		 596}
597EXPORT_SYMBOL(pccard_get_next_tuple);
598
599/*====================================================================*/
600
601#define _MIN(a, b) (((a) < (b)) ? (a) : (b))
602
603int pccard_get_tuple_data(struct pcmcia_socket *s, tuple_t *tuple)
604{
605 u_int len;
606
607 if (!s)
ffb8da20 608 return -EINVAL;
1da177e4
LT		 609
610 if (tuple->TupleLink < tuple->TupleOffset)
635d19be 611 return -ENOSPC;
1da177e4
LT		 612 len = tuple->TupleLink - tuple->TupleOffset;
613 tuple->TupleDataLen = tuple->TupleLink;
614 if (len == 0)
4c89e88b 615 return 0;
1da177e4
LT		 616 read_cis_cache(s, SPACE(tuple->Flags),
617 tuple->CISOffset + tuple->TupleOffset,
618 _MIN(len, tuple->TupleDataMax), tuple->TupleData);
4c89e88b 619 return 0;
1da177e4
LT		 620}
621EXPORT_SYMBOL(pccard_get_tuple_data);
622
623
624/*======================================================================
625
626 Parsing routines for individual tuples
9fea84f4 627
1da177e4
LT		 628======================================================================*/
629
630static int parse_device(tuple_t *tuple, cistpl_device_t *device)
631{
632 int i;
633 u_char scale;
634 u_char *p, *q;
635
636 p = (u_char *)tuple->TupleData;
637 q = p + tuple->TupleDataLen;
638
639 device->ndev = 0;
640 for (i = 0; i < CISTPL_MAX_DEVICES; i++) {
9fea84f4
DB		 641
642 if (*p == 0xff)
643 break;
1da177e4
LT		 644 device->dev[i].type = (*p >> 4);
645 device->dev[i].wp = (*p & 0x08) ? 1 : 0;
646 switch (*p & 0x07) {
9fea84f4
DB		 647 case 0:
648 device->dev[i].speed = 0;
649 break;
650 case 1:
651 device->dev[i].speed = 250;
652 break;
653 case 2:
654 device->dev[i].speed = 200;
655 break;
656 case 3:
657 device->dev[i].speed = 150;
658 break;
659 case 4:
660 device->dev[i].speed = 100;
661 break;
1da177e4 662 case 7:
3f9c5f4c
DB		 663 if (++p == q)
664 return -EINVAL;
9fea84f4
DB		 665 device->dev[i].speed = SPEED_CVT(*p);
666 while (*p & 0x80)
667 if (++p == q)
668 return -EINVAL;
669 break;
1da177e4 670 default:
9fea84f4 671 return -EINVAL;
1da177e4
LT		 672 }
673
3f9c5f4c
DB		 674 if (++p == q)
675 return -EINVAL;
676 if (*p == 0xff)
677 break;
1da177e4 678 scale = *p & 7;
3f9c5f4c
DB		 679 if (scale == 7)
680 return -EINVAL;
1da177e4
LT		 681 device->dev[i].size = ((*p >> 3) + 1) * (512 << (scale*2));
682 device->ndev++;
3f9c5f4c
DB		 683 if (++p == q)
684 break;
1da177e4 685 }
9fea84f4 686
4c89e88b 687 return 0;
1da177e4
LT		 688}
689
690/*====================================================================*/
691
692static int parse_checksum(tuple_t *tuple, cistpl_checksum_t *csum)
693{
694 u_char *p;
695 if (tuple->TupleDataLen < 5)
3f9c5f4c 696 return -EINVAL;
dc0cf6a2 697 p = (u_char *) tuple->TupleData;
6b1e6f63
HH		 698 csum->addr = tuple->CISOffset + get_unaligned_le16(p) - 2;
699 csum->len = get_unaligned_le16(p + 2);
dc0cf6a2 700 csum->sum = *(p + 4);
4c89e88b 701 return 0;
1da177e4
LT		 702}
703
704/*====================================================================*/
705
706static int parse_longlink(tuple_t *tuple, cistpl_longlink_t *link)
707{
708 if (tuple->TupleDataLen < 4)
3f9c5f4c 709 return -EINVAL;
6b1e6f63 710 link->addr = get_unaligned_le32(tuple->TupleData);
4c89e88b 711 return 0;
1da177e4
LT		 712}
713
714/*====================================================================*/
715
716static int parse_longlink_mfc(tuple_t *tuple,
717 cistpl_longlink_mfc_t *link)
718{
719 u_char *p;
720 int i;
9fea84f4 721
1da177e4 722 p = (u_char *)tuple->TupleData;
9fea84f4 723
1da177e4
LT		 724 link->nfn = *p; p++;
725 if (tuple->TupleDataLen <= link->nfn*5)
3f9c5f4c 726 return -EINVAL;
1da177e4
LT		 727 for (i = 0; i < link->nfn; i++) {
728 link->fn[i].space = *p; p++;
6b1e6f63 729 link->fn[i].addr = get_unaligned_le32(p);
dc0cf6a2 730 p += 4;
1da177e4 731 }
4c89e88b 732 return 0;
1da177e4
LT		 733}
734
735/*====================================================================*/
736
737static int parse_strings(u_char *p, u_char *q, int max,
738 char *s, u_char *ofs, u_char *found)
739{
740 int i, j, ns;
741
3f9c5f4c
DB		 742 if (p == q)
743 return -EINVAL;
1da177e4
LT		 744 ns = 0; j = 0;
745 for (i = 0; i < max; i++) {
3f9c5f4c
DB		 746 if (*p == 0xff)
747 break;
1da177e4
LT		 748 ofs[i] = j;
749 ns++;
750 for (;;) {
751 s[j++] = (*p == 0xff) ? '\0' : *p;
9fea84f4
DB		 752 if ((*p == '\0') || (*p == 0xff))
753 break;
3f9c5f4c
DB		 754 if (++p == q)
755 return -EINVAL;
1da177e4 756 }
9fea84f4
DB		 757 if ((*p == 0xff) || (++p == q))
758 break;
1da177e4
LT		 759 }
760 if (found) {
761 *found = ns;
4c89e88b 762 return 0;
1da177e4 763 } else {
3f9c5f4c 764 return (ns == max) ? 0 : -EINVAL;
1da177e4
LT		 765 }
766}
767
768/*====================================================================*/
769
770static int parse_vers_1(tuple_t *tuple, cistpl_vers_1_t *vers_1)
771{
772 u_char *p, *q;
9fea84f4 773
1da177e4
LT		 774 p = (u_char *)tuple->TupleData;
775 q = p + tuple->TupleDataLen;
9fea84f4 776
1da177e4
LT		 777 vers_1->major = *p; p++;
778 vers_1->minor = *p; p++;
3f9c5f4c
DB		 779 if (p >= q)
780 return -EINVAL;
1da177e4
LT		 781
782 return parse_strings(p, q, CISTPL_VERS_1_MAX_PROD_STRINGS,
783 vers_1->str, vers_1->ofs, &vers_1->ns);
784}
785
786/*====================================================================*/
787
788static int parse_altstr(tuple_t *tuple, cistpl_altstr_t *altstr)
789{
790 u_char *p, *q;
9fea84f4 791
1da177e4
LT		 792 p = (u_char *)tuple->TupleData;
793 q = p + tuple->TupleDataLen;
9fea84f4 794
1da177e4
LT		 795 return parse_strings(p, q, CISTPL_MAX_ALTSTR_STRINGS,
796 altstr->str, altstr->ofs, &altstr->ns);
797}
798
799/*====================================================================*/
800
801static int parse_jedec(tuple_t *tuple, cistpl_jedec_t *jedec)
802{
803 u_char *p, *q;
804 int nid;
805
806 p = (u_char *)tuple->TupleData;
807 q = p + tuple->TupleDataLen;
808
809 for (nid = 0; nid < CISTPL_MAX_DEVICES; nid++) {
9fea84f4
DB		 810 if (p > q-2)
811 break;
1da177e4
LT		 812 jedec->id[nid].mfr = p[0];
813 jedec->id[nid].info = p[1];
814 p += 2;
815 }
816 jedec->nid = nid;
4c89e88b 817 return 0;
1da177e4
LT		 818}
819
820/*====================================================================*/
821
822static int parse_manfid(tuple_t *tuple, cistpl_manfid_t *m)
823{
1da177e4 824 if (tuple->TupleDataLen < 4)
3f9c5f4c 825 return -EINVAL;
6b1e6f63
HH		 826 m->manf = get_unaligned_le16(tuple->TupleData);
827 m->card = get_unaligned_le16(tuple->TupleData + 2);
4c89e88b 828 return 0;
1da177e4
LT		 829}
830
831/*====================================================================*/
832
833static int parse_funcid(tuple_t *tuple, cistpl_funcid_t *f)
834{
835 u_char *p;
836 if (tuple->TupleDataLen < 2)
3f9c5f4c 837 return -EINVAL;
1da177e4
LT		 838 p = (u_char *)tuple->TupleData;
839 f->func = p[0];
840 f->sysinit = p[1];
4c89e88b 841 return 0;
1da177e4
LT		 842}
843
844/*====================================================================*/
845
846static int parse_funce(tuple_t *tuple, cistpl_funce_t *f)
847{
848 u_char *p;
849 int i;
850 if (tuple->TupleDataLen < 1)
3f9c5f4c 851 return -EINVAL;
1da177e4
LT		 852 p = (u_char *)tuple->TupleData;
853 f->type = p[0];
854 for (i = 1; i < tuple->TupleDataLen; i++)
855 f->data[i-1] = p[i];
4c89e88b 856 return 0;
1da177e4
LT		 857}
858
859/*====================================================================*/
860
861static int parse_config(tuple_t *tuple, cistpl_config_t *config)
862{
863 int rasz, rmsz, i;
864 u_char *p;
865
866 p = (u_char *)tuple->TupleData;
867 rasz = *p & 0x03;
868 rmsz = (*p & 0x3c) >> 2;
869 if (tuple->TupleDataLen < rasz+rmsz+4)
3f9c5f4c 870 return -EINVAL;
1da177e4
LT		 871 config->last_idx = *(++p);
872 p++;
873 config->base = 0;
874 for (i = 0; i <= rasz; i++)
875 config->base += p[i] << (8*i);
876 p += rasz+1;
877 for (i = 0; i < 4; i++)
878 config->rmask[i] = 0;
879 for (i = 0; i <= rmsz; i++)
880 config->rmask[i>>2] += p[i] << (8*(i%4));
881 config->subtuples = tuple->TupleDataLen - (rasz+rmsz+4);
4c89e88b 882 return 0;
1da177e4
LT		 883}
884
885/*======================================================================
886
887 The following routines are all used to parse the nightmarish
888 config table entries.
9fea84f4 889
1da177e4
LT		 890======================================================================*/
891
892static u_char *parse_power(u_char *p, u_char *q,
893 cistpl_power_t *pwr)
894{
895 int i;
896 u_int scale;
897
9fea84f4
DB		 898 if (p == q)
899 return NULL;
1da177e4
LT		 900 pwr->present = *p;
901 pwr->flags = 0;
902 p++;
903 for (i = 0; i < 7; i++)
904 if (pwr->present & (1<<i)) {
9fea84f4
DB		 905 if (p == q)
906 return NULL;
1da177e4
LT		 907 pwr->param[i] = POWER_CVT(*p);
908 scale = POWER_SCALE(*p);
909 while (*p & 0x80) {
9fea84f4
DB		 910 if (++p == q)
911 return NULL;
1da177e4
LT		 912 if ((*p & 0x7f) < 100)
913 pwr->param[i] += (*p & 0x7f) * scale / 100;
914 else if (*p == 0x7d)
915 pwr->flags |= CISTPL_POWER_HIGHZ_OK;
916 else if (*p == 0x7e)
917 pwr->param[i] = 0;
918 else if (*p == 0x7f)
919 pwr->flags |= CISTPL_POWER_HIGHZ_REQ;
920 else
921 return NULL;
922 }
923 p++;
924 }
925 return p;
926}
927
928/*====================================================================*/
929
930static u_char *parse_timing(u_char *p, u_char *q,
931 cistpl_timing_t *timing)
932{
933 u_char scale;
934
9fea84f4
DB		 935 if (p == q)
936 return NULL;
1da177e4
LT		 937 scale = *p;
938 if ((scale & 3) != 3) {
9fea84f4
DB		 939 if (++p == q)
940 return NULL;
1da177e4
LT		 941 timing->wait = SPEED_CVT(*p);
942 timing->waitscale = exponent[scale & 3];
943 } else
944 timing->wait = 0;
945 scale >>= 2;
946 if ((scale & 7) != 7) {
9fea84f4
DB		 947 if (++p == q)
948 return NULL;
1da177e4
LT		 949 timing->ready = SPEED_CVT(*p);
950 timing->rdyscale = exponent[scale & 7];
951 } else
952 timing->ready = 0;
953 scale >>= 3;
954 if (scale != 7) {
9fea84f4
DB		 955 if (++p == q)
956 return NULL;
1da177e4
LT		 957 timing->reserved = SPEED_CVT(*p);
958 timing->rsvscale = exponent[scale];
959 } else
960 timing->reserved = 0;
961 p++;
962 return p;
963}
964
965/*====================================================================*/
966
967static u_char *parse_io(u_char *p, u_char *q, cistpl_io_t *io)
968{
969 int i, j, bsz, lsz;
970
9fea84f4
DB		 971 if (p == q)
972 return NULL;
1da177e4
LT		 973 io->flags = *p;
974
975 if (!(*p & 0x80)) {
976 io->nwin = 1;
977 io->win[0].base = 0;
978 io->win[0].len = (1 << (io->flags & CISTPL_IO_LINES_MASK));
979 return p+1;
980 }
9fea84f4
DB		 981
982 if (++p == q)
983 return NULL;
1da177e4
LT		 984 io->nwin = (*p & 0x0f) + 1;
985 bsz = (*p & 0x30) >> 4;
9fea84f4
DB		 986 if (bsz == 3)
987 bsz++;
1da177e4 988 lsz = (*p & 0xc0) >> 6;
9fea84f4
DB		 989 if (lsz == 3)
990 lsz++;
1da177e4 991 p++;
9fea84f4 992
1da177e4
LT		 993 for (i = 0; i < io->nwin; i++) {
994 io->win[i].base = 0;
995 io->win[i].len = 1;
996 for (j = 0; j < bsz; j++, p++) {
9fea84f4
DB		 997 if (p == q)
998 return NULL;
1da177e4
LT		 999 io->win[i].base += *p << (j*8);
1000 }
1001 for (j = 0; j < lsz; j++, p++) {
9fea84f4
DB		 1002 if (p == q)
1003 return NULL;
1da177e4
LT		 1004 io->win[i].len += *p << (j*8);
1005 }
1006 }
1007 return p;
1008}
1009
1010/*====================================================================*/
1011
1012static u_char *parse_mem(u_char *p, u_char *q, cistpl_mem_t *mem)
1013{
1014 int i, j, asz, lsz, has_ha;
1015 u_int len, ca, ha;
1016
9fea84f4
DB		 1017 if (p == q)
1018 return NULL;
1da177e4
LT		 1019
1020 mem->nwin = (*p & 0x07) + 1;
1021 lsz = (*p & 0x18) >> 3;
1022 asz = (*p & 0x60) >> 5;
1023 has_ha = (*p & 0x80);
9fea84f4
DB		 1024 if (++p == q)
1025 return NULL;
1026
1da177e4
LT		 1027 for (i = 0; i < mem->nwin; i++) {
1028 len = ca = ha = 0;
1029 for (j = 0; j < lsz; j++, p++) {
9fea84f4
DB		 1030 if (p == q)
1031 return NULL;
1da177e4
LT		 1032 len += *p << (j*8);
1033 }
1034 for (j = 0; j < asz; j++, p++) {
9fea84f4
DB		 1035 if (p == q)
1036 return NULL;
1da177e4
LT		 1037 ca += *p << (j*8);
1038 }
1039 if (has_ha)
1040 for (j = 0; j < asz; j++, p++) {
9fea84f4
DB		 1041 if (p == q)
1042 return NULL;
1da177e4
LT		 1043 ha += *p << (j*8);
1044 }
1045 mem->win[i].len = len << 8;
1046 mem->win[i].card_addr = ca << 8;
1047 mem->win[i].host_addr = ha << 8;
1048 }
1049 return p;
1050}
1051
1052/*====================================================================*/
1053
1054static u_char *parse_irq(u_char *p, u_char *q, cistpl_irq_t *irq)
1055{
3f9c5f4c
DB		 1056 if (p == q)
1057 return NULL;
1da177e4
LT		 1058 irq->IRQInfo1 = *p; p++;
1059 if (irq->IRQInfo1 & IRQ_INFO2_VALID) {
3f9c5f4c
DB		 1060 if (p+2 > q)
1061 return NULL;
1da177e4
LT		 1062 irq->IRQInfo2 = (p[1]<<8) + p[0];
1063 p += 2;
1064 }
1065 return p;
1066}
1067
1068/*====================================================================*/
1069
1070static int parse_cftable_entry(tuple_t *tuple,
1071 cistpl_cftable_entry_t *entry)
1072{
1073 u_char *p, *q, features;
1074
1075 p = tuple->TupleData;
1076 q = p + tuple->TupleDataLen;
1077 entry->index = *p & 0x3f;
1078 entry->flags = 0;
1079 if (*p & 0x40)
1080 entry->flags |= CISTPL_CFTABLE_DEFAULT;
1081 if (*p & 0x80) {
3f9c5f4c
DB		 1082 if (++p == q)
1083 return -EINVAL;
1da177e4
LT		 1084 if (*p & 0x10)
1085 entry->flags |= CISTPL_CFTABLE_BVDS;
1086 if (*p & 0x20)
1087 entry->flags |= CISTPL_CFTABLE_WP;
1088 if (*p & 0x40)
1089 entry->flags |= CISTPL_CFTABLE_RDYBSY;
1090 if (*p & 0x80)
1091 entry->flags |= CISTPL_CFTABLE_MWAIT;
1092 entry->interface = *p & 0x0f;
1093 } else
1094 entry->interface = 0;
1095
1096 /* Process optional features */
3f9c5f4c
DB		 1097 if (++p == q)
1098 return -EINVAL;
1da177e4
LT		 1099 features = *p; p++;
1100
1101 /* Power options */
1102 if ((features & 3) > 0) {
1103 p = parse_power(p, q, &entry->vcc);
3f9c5f4c
DB		 1104 if (p == NULL)
1105 return -EINVAL;
1da177e4
LT		 1106 } else
1107 entry->vcc.present = 0;
1108 if ((features & 3) > 1) {
1109 p = parse_power(p, q, &entry->vpp1);
3f9c5f4c
DB		 1110 if (p == NULL)
1111 return -EINVAL;
1da177e4
LT		 1112 } else
1113 entry->vpp1.present = 0;
1114 if ((features & 3) > 2) {
1115 p = parse_power(p, q, &entry->vpp2);
3f9c5f4c
DB		 1116 if (p == NULL)
1117 return -EINVAL;
1da177e4
LT		 1118 } else
1119 entry->vpp2.present = 0;
1120
1121 /* Timing options */
1122 if (features & 0x04) {
1123 p = parse_timing(p, q, &entry->timing);
3f9c5f4c
DB		 1124 if (p == NULL)
1125 return -EINVAL;
1da177e4
LT		 1126 } else {
1127 entry->timing.wait = 0;
1128 entry->timing.ready = 0;
1129 entry->timing.reserved = 0;
1130 }
9fea84f4 1131
1da177e4
LT		 1132 /* I/O window options */
1133 if (features & 0x08) {
1134 p = parse_io(p, q, &entry->io);
3f9c5f4c
DB		 1135 if (p == NULL)
1136 return -EINVAL;
1da177e4
LT		 1137 } else
1138 entry->io.nwin = 0;
9fea84f4 1139
1da177e4
LT		 1140 /* Interrupt options */
1141 if (features & 0x10) {
1142 p = parse_irq(p, q, &entry->irq);
3f9c5f4c
DB		 1143 if (p == NULL)
1144 return -EINVAL;
1da177e4
LT		 1145 } else
1146 entry->irq.IRQInfo1 = 0;
1147
1148 switch (features & 0x60) {
1149 case 0x00:
1150 entry->mem.nwin = 0;
1151 break;
1152 case 0x20:
1153 entry->mem.nwin = 1;
6b1e6f63 1154 entry->mem.win[0].len = get_unaligned_le16(p) << 8;
1da177e4
LT		 1155 entry->mem.win[0].card_addr = 0;
1156 entry->mem.win[0].host_addr = 0;
1157 p += 2;
3f9c5f4c
DB		 1158 if (p > q)
1159 return -EINVAL;
1da177e4
LT		 1160 break;
1161 case 0x40:
1162 entry->mem.nwin = 1;
6b1e6f63
HH		 1163 entry->mem.win[0].len = get_unaligned_le16(p) << 8;
1164 entry->mem.win[0].card_addr = get_unaligned_le16(p + 2) << 8;
1da177e4
LT		 1165 entry->mem.win[0].host_addr = 0;
1166 p += 4;
3f9c5f4c
DB		 1167 if (p > q)
1168 return -EINVAL;
1da177e4
LT		 1169 break;
1170 case 0x60:
1171 p = parse_mem(p, q, &entry->mem);
3f9c5f4c
DB		 1172 if (p == NULL)
1173 return -EINVAL;
1da177e4
LT		 1174 break;
1175 }
1176
1177 /* Misc features */
1178 if (features & 0x80) {
3f9c5f4c
DB		 1179 if (p == q)
1180 return -EINVAL;
1da177e4
LT		 1181 entry->flags |= (*p << 8);
1182 while (*p & 0x80)
3f9c5f4c
DB		 1183 if (++p == q)
1184 return -EINVAL;
1da177e4
LT		 1185 p++;
1186 }
1187
1188 entry->subtuples = q-p;
9fea84f4 1189
4c89e88b 1190 return 0;
1da177e4
LT		 1191}
1192
1193/*====================================================================*/
1194
1195#ifdef CONFIG_CARDBUS
1196
1197static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar)
1198{
1199 u_char *p;
1200 if (tuple->TupleDataLen < 6)
3f9c5f4c 1201 return -EINVAL;
1da177e4
LT		 1202 p = (u_char *)tuple->TupleData;
1203 bar->attr = *p;
1204 p += 2;
6b1e6f63 1205 bar->size = get_unaligned_le32(p);
4c89e88b 1206 return 0;
1da177e4
LT		 1207}
1208
1209static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config)
1210{
1211 u_char *p;
9fea84f4 1212
1da177e4
LT		 1213 p = (u_char *)tuple->TupleData;
1214 if ((*p != 3) || (tuple->TupleDataLen < 6))
3f9c5f4c 1215 return -EINVAL;
1da177e4
LT		 1216 config->last_idx = *(++p);
1217 p++;
6b1e6f63 1218 config->base = get_unaligned_le32(p);
1da177e4 1219 config->subtuples = tuple->TupleDataLen - 6;
4c89e88b 1220 return 0;
1da177e4
LT		 1221}
1222
1223static int parse_cftable_entry_cb(tuple_t *tuple,
1224 cistpl_cftable_entry_cb_t *entry)
1225{
1226 u_char *p, *q, features;
1227
1228 p = tuple->TupleData;
1229 q = p + tuple->TupleDataLen;
1230 entry->index = *p & 0x3f;
1231 entry->flags = 0;
1232 if (*p & 0x40)
1233 entry->flags |= CISTPL_CFTABLE_DEFAULT;
1234
1235 /* Process optional features */
3f9c5f4c
DB		 1236 if (++p == q)
1237 return -EINVAL;
1da177e4
LT		 1238 features = *p; p++;
1239
1240 /* Power options */
1241 if ((features & 3) > 0) {
1242 p = parse_power(p, q, &entry->vcc);
3f9c5f4c
DB		 1243 if (p == NULL)
1244 return -EINVAL;
1da177e4
LT		 1245 } else
1246 entry->vcc.present = 0;
1247 if ((features & 3) > 1) {
1248 p = parse_power(p, q, &entry->vpp1);
3f9c5f4c
DB		 1249 if (p == NULL)
1250 return -EINVAL;
1da177e4
LT		 1251 } else
1252 entry->vpp1.present = 0;
1253 if ((features & 3) > 2) {
1254 p = parse_power(p, q, &entry->vpp2);
3f9c5f4c
DB		 1255 if (p == NULL)
1256 return -EINVAL;
1da177e4
LT		 1257 } else
1258 entry->vpp2.present = 0;
1259
1260 /* I/O window options */
1261 if (features & 0x08) {
3f9c5f4c
DB		 1262 if (p == q)
1263 return -EINVAL;
1da177e4
LT		 1264 entry->io = *p; p++;
1265 } else
1266 entry->io = 0;
9fea84f4 1267
1da177e4
LT		 1268 /* Interrupt options */
1269 if (features & 0x10) {
1270 p = parse_irq(p, q, &entry->irq);
3f9c5f4c
DB		 1271 if (p == NULL)
1272 return -EINVAL;
1da177e4
LT		 1273 } else
1274 entry->irq.IRQInfo1 = 0;
1275
1276 if (features & 0x20) {
3f9c5f4c
DB		 1277 if (p == q)
1278 return -EINVAL;
1da177e4
LT		 1279 entry->mem = *p; p++;
1280 } else
1281 entry->mem = 0;
1282
1283 /* Misc features */
1284 if (features & 0x80) {
3f9c5f4c
DB		 1285 if (p == q)
1286 return -EINVAL;
1da177e4
LT		 1287 entry->flags |= (*p << 8);
1288 if (*p & 0x80) {
3f9c5f4c
DB		 1289 if (++p == q)
1290 return -EINVAL;
1da177e4
LT		 1291 entry->flags |= (*p << 16);
1292 }
1293 while (*p & 0x80)
3f9c5f4c
DB		 1294 if (++p == q)
1295 return -EINVAL;
1da177e4
LT		 1296 p++;
1297 }
1298
1299 entry->subtuples = q-p;
9fea84f4 1300
4c89e88b 1301 return 0;
1da177e4
LT		 1302}
1303
1304#endif
1305
1306/*====================================================================*/
1307
1308static int parse_device_geo(tuple_t *tuple, cistpl_device_geo_t *geo)
1309{
1310 u_char *p, *q;
1311 int n;
1312
1313 p = (u_char *)tuple->TupleData;
1314 q = p + tuple->TupleDataLen;
1315
1316 for (n = 0; n < CISTPL_MAX_DEVICES; n++) {
9fea84f4
DB		 1317 if (p > q-6)
1318 break;
1da177e4
LT		 1319 geo->geo[n].buswidth = p[0];
1320 geo->geo[n].erase_block = 1 << (p[1]-1);
1321 geo->geo[n].read_block = 1 << (p[2]-1);
1322 geo->geo[n].write_block = 1 << (p[3]-1);
1323 geo->geo[n].partition = 1 << (p[4]-1);
1324 geo->geo[n].interleave = 1 << (p[5]-1);
1325 p += 6;
1326 }
1327 geo->ngeo = n;
4c89e88b 1328 return 0;
1da177e4
LT		 1329}
1330
1331/*====================================================================*/
1332
1333static int parse_vers_2(tuple_t *tuple, cistpl_vers_2_t *v2)
1334{
1335 u_char *p, *q;
1336
1337 if (tuple->TupleDataLen < 10)
3f9c5f4c 1338 return -EINVAL;
9fea84f4 1339
1da177e4
LT		 1340 p = tuple->TupleData;
1341 q = p + tuple->TupleDataLen;
1342
1343 v2->vers = p[0];
1344 v2->comply = p[1];
9fea84f4 1345 v2->dindex = get_unaligned_le16(p + 2);
1da177e4
LT		 1346 v2->vspec8 = p[6];
1347 v2->vspec9 = p[7];
1348 v2->nhdr = p[8];
1349 p += 9;
1350 return parse_strings(p, q, 2, v2->str, &v2->vendor, NULL);
1351}
1352
1353/*====================================================================*/
1354
1355static int parse_org(tuple_t *tuple, cistpl_org_t *org)
1356{
1357 u_char *p, *q;
1358 int i;
9fea84f4 1359
1da177e4
LT		 1360 p = tuple->TupleData;
1361 q = p + tuple->TupleDataLen;
3f9c5f4c
DB		 1362 if (p == q)
1363 return -EINVAL;
1da177e4 1364 org->data_org = *p;
3f9c5f4c
DB		 1365 if (++p == q)
1366 return -EINVAL;
1da177e4
LT		 1367 for (i = 0; i < 30; i++) {
1368 org->desc[i] = *p;
9fea84f4
DB		 1369 if (*p == '\0')
1370 break;
3f9c5f4c
DB		 1371 if (++p == q)
1372 return -EINVAL;
1da177e4 1373 }
4c89e88b 1374 return 0;
1da177e4
LT		 1375}
1376
1377/*====================================================================*/
1378
1379static int parse_format(tuple_t *tuple, cistpl_format_t *fmt)
1380{
1381 u_char *p;
1382
1383 if (tuple->TupleDataLen < 10)
3f9c5f4c 1384 return -EINVAL;
1da177e4
LT		 1385
1386 p = tuple->TupleData;
1387
1388 fmt->type = p[0];
1389 fmt->edc = p[1];
6b1e6f63
HH		 1390 fmt->offset = get_unaligned_le32(p + 2);
1391 fmt->length = get_unaligned_le32(p + 6);
1da177e4 1392
4c89e88b 1393 return 0;
1da177e4
LT		 1394}
1395
1396/*====================================================================*/
1397
2f3061eb 1398int pcmcia_parse_tuple(tuple_t *tuple, cisparse_t *parse)
1da177e4 1399{
4c89e88b 1400 int ret = 0;
9fea84f4 1401
1da177e4 1402 if (tuple->TupleDataLen > tuple->TupleDataMax)
3f9c5f4c 1403 return -EINVAL;
1da177e4
LT		 1404 switch (tuple->TupleCode) {
1405 case CISTPL_DEVICE:
1406 case CISTPL_DEVICE_A:
1407 ret = parse_device(tuple, &parse->device);
1408 break;
1409#ifdef CONFIG_CARDBUS
1410 case CISTPL_BAR:
1411 ret = parse_bar(tuple, &parse->bar);
1412 break;
1413 case CISTPL_CONFIG_CB:
1414 ret = parse_config_cb(tuple, &parse->config);
1415 break;
1416 case CISTPL_CFTABLE_ENTRY_CB:
1417 ret = parse_cftable_entry_cb(tuple, &parse->cftable_entry_cb);
1418 break;
1419#endif
1420 case CISTPL_CHECKSUM:
1421 ret = parse_checksum(tuple, &parse->checksum);
1422 break;
1423 case CISTPL_LONGLINK_A:
1424 case CISTPL_LONGLINK_C:
1425 ret = parse_longlink(tuple, &parse->longlink);
1426 break;
1427 case CISTPL_LONGLINK_MFC:
1428 ret = parse_longlink_mfc(tuple, &parse->longlink_mfc);
1429 break;
1430 case CISTPL_VERS_1:
1431 ret = parse_vers_1(tuple, &parse->version_1);
1432 break;
1433 case CISTPL_ALTSTR:
1434 ret = parse_altstr(tuple, &parse->altstr);
1435 break;
1436 case CISTPL_JEDEC_A:
1437 case CISTPL_JEDEC_C:
1438 ret = parse_jedec(tuple, &parse->jedec);
1439 break;
1440 case CISTPL_MANFID:
1441 ret = parse_manfid(tuple, &parse->manfid);
1442 break;
1443 case CISTPL_FUNCID:
1444 ret = parse_funcid(tuple, &parse->funcid);
1445 break;
1446 case CISTPL_FUNCE:
1447 ret = parse_funce(tuple, &parse->funce);
1448 break;
1449 case CISTPL_CONFIG:
1450 ret = parse_config(tuple, &parse->config);
1451 break;
1452 case CISTPL_CFTABLE_ENTRY:
1453 ret = parse_cftable_entry(tuple, &parse->cftable_entry);
1454 break;
1455 case CISTPL_DEVICE_GEO:
1456 case CISTPL_DEVICE_GEO_A:
1457 ret = parse_device_geo(tuple, &parse->device_geo);
1458 break;
1459 case CISTPL_VERS_2:
1460 ret = parse_vers_2(tuple, &parse->vers_2);
1461 break;
1462 case CISTPL_ORG:
1463 ret = parse_org(tuple, &parse->org);
1464 break;
1465 case CISTPL_FORMAT:
1466 case CISTPL_FORMAT_A:
1467 ret = parse_format(tuple, &parse->format);
1468 break;
1469 case CISTPL_NO_LINK:
1470 case CISTPL_LINKTARGET:
4c89e88b 1471 ret = 0;
1da177e4
LT		 1472 break;
1473 default:
de6405e9 1474 ret = -EINVAL;
1da177e4
LT		 1475 break;
1476 }
3f9c5f4c 1477 if (ret)
d50dbec3 1478 pr_debug("parse_tuple failed %d\n", ret);
1da177e4
LT		 1479 return ret;
1480}
2f3061eb 1481EXPORT_SYMBOL(pcmcia_parse_tuple);
1da177e4
LT		 1482
1483/*======================================================================
1484
1485 This is used internally by Card Services to look up CIS stuff.
9fea84f4 1486
1da177e4
LT		 1487======================================================================*/
1488
1489int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, cisdata_t code, void *parse)
1490{
1491 tuple_t tuple;
1492 cisdata_t *buf;
1493 int ret;
1494
1495 buf = kmalloc(256, GFP_KERNEL);
1168386a
DB		 1496 if (buf == NULL) {
1497 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n");
1498 return -ENOMEM;
1499 }
1da177e4 1500 tuple.DesiredTuple = code;
84897fc0
DB		 1501 tuple.Attributes = 0;
1502 if (function == BIND_FN_ALL)
1503 tuple.Attributes = TUPLE_RETURN_COMMON;
1da177e4 1504 ret = pccard_get_first_tuple(s, function, &tuple);
4c89e88b
DB		 1505 if (ret != 0)
1506 goto done;
1da177e4
LT		 1507 tuple.TupleData = buf;
1508 tuple.TupleOffset = 0;
1509 tuple.TupleDataMax = 255;
1510 ret = pccard_get_tuple_data(s, &tuple);
4c89e88b
DB		 1511 if (ret != 0)
1512 goto done;
2f3061eb 1513 ret = pcmcia_parse_tuple(&tuple, parse);
1da177e4
LT		 1514done:
1515 kfree(buf);
1516 return ret;
1517}
1518EXPORT_SYMBOL(pccard_read_tuple);
1519
91284224
DB		 1520
1521/**
1522 * pccard_loop_tuple() - loop over tuples in the CIS
1523 * @s: the struct pcmcia_socket where the card is inserted
1524 * @function: the device function we loop for
1525 * @code: which CIS code shall we look for?
1526 * @parse: buffer where the tuple shall be parsed (or NULL, if no parse)
1527 * @priv_data: private data to be passed to the loop_tuple function.
1528 * @loop_tuple: function to call for each CIS entry of type @function. IT
1529 * gets passed the raw tuple, the paresed tuple (if @parse is
1530 * set) and @priv_data.
1531 *
1532 * pccard_loop_tuple() loops over all CIS entries of type @function, and
1533 * calls the @loop_tuple function for each entry. If the call to @loop_tuple
1534 * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
1535 */
1536int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function,
1537 cisdata_t code, cisparse_t *parse, void *priv_data,
1538 int (*loop_tuple) (tuple_t *tuple,
1539 cisparse_t *parse,
1540 void *priv_data))
1541{
1542 tuple_t tuple;
1543 cisdata_t *buf;
1544 int ret;
1545
1546 buf = kzalloc(256, GFP_KERNEL);
1547 if (buf == NULL) {
1548 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n");
1549 return -ENOMEM;
1550 }
1551
1552 tuple.TupleData = buf;
1553 tuple.TupleDataMax = 255;
1554 tuple.TupleOffset = 0;
1555 tuple.DesiredTuple = code;
1556 tuple.Attributes = 0;
1557
1558 ret = pccard_get_first_tuple(s, function, &tuple);
1559 while (!ret) {
1560 if (pccard_get_tuple_data(s, &tuple))
1561 goto next_entry;
1562
1563 if (parse)
1564 if (pcmcia_parse_tuple(&tuple, parse))
1565 goto next_entry;
1566
1567 ret = loop_tuple(&tuple, parse, priv_data);
1568 if (!ret)
1569 break;
1570
1571next_entry:
1572 ret = pccard_get_next_tuple(s, function, &tuple);
1573 }
1574
1575 kfree(buf);
1576 return ret;
1577}
1578EXPORT_SYMBOL(pccard_loop_tuple);
1579
1580
f131ddc4
DB		 1581/**
1582 * pccard_validate_cis() - check whether card has a sensible CIS
1583 * @s: the struct pcmcia_socket we are to check
1584 * @info: returns the number of tuples in the (valid) CIS, or 0
1585 *
1586 * This tries to determine if a card has a sensible CIS. In @info, it
1587 * returns the number of tuples in the CIS, or 0 if the CIS looks bad. The
1588 * checks include making sure several critical tuples are present and
1589 * valid; seeing if the total number of tuples is reasonable; and
1590 * looking for tuples that use reserved codes.
1591 *
1592 * The function returns 0 on success.
1593 */
84897fc0 1594int pccard_validate_cis(struct pcmcia_socket *s, unsigned int *info)
1da177e4 1595{
f131ddc4
DB		 1596 tuple_t *tuple;
1597 cisparse_t *p;
1598 unsigned int count = 0;
1599 int ret, reserved, dev_ok = 0, ident_ok = 0;
1da177e4 1600
f131ddc4
DB		 1601 if (!s)
1602 return -EINVAL;
1da177e4 1603
f131ddc4
DB		 1604 /* We do not want to validate the CIS cache... */
1605 destroy_cis_cache(s);
904e3777 1606
f131ddc4
DB		 1607 tuple = kmalloc(sizeof(*tuple), GFP_KERNEL);
1608 if (tuple == NULL) {
1609 dev_warn(&s->dev, "no memory to validate CIS\n");
1610 return -ENOMEM;
1611 }
1612 p = kmalloc(sizeof(*p), GFP_KERNEL);
1613 if (p == NULL) {
1614 kfree(tuple);
1615 dev_warn(&s->dev, "no memory to validate CIS\n");
1616 return -ENOMEM;
1617 }
1da177e4 1618
f131ddc4
DB		 1619 count = reserved = 0;
1620 tuple->DesiredTuple = RETURN_FIRST_TUPLE;
1621 tuple->Attributes = TUPLE_RETURN_COMMON;
1622 ret = pccard_get_first_tuple(s, BIND_FN_ALL, tuple);
4c89e88b 1623 if (ret != 0)
f131ddc4
DB		 1624 goto done;
1625
1626 /* First tuple should be DEVICE; we should really have either that
1627 or a CFTABLE_ENTRY of some sort */
1628 if ((tuple->TupleCode == CISTPL_DEVICE) ||
1629 (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY, p)) ||
1630 (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY_CB, p)))
1631 dev_ok++;
1632
1633 /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2
1634 tuple, for card identification. Certain old D-Link and Linksys
1635 cards have only a broken VERS_2 tuple; hence the bogus test. */
1636 if ((pccard_read_tuple(s, BIND_FN_ALL, CISTPL_MANFID, p) == 0) ||
1637 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_1, p) == 0) ||
1638 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_2, p) != -ENOSPC))
1639 ident_ok++;
1640
1641 if (!dev_ok && !ident_ok)
1642 goto done;
1643
1644 for (count = 1; count < MAX_TUPLES; count++) {
1645 ret = pccard_get_next_tuple(s, BIND_FN_ALL, tuple);
1646 if (ret != 0)
1647 break;
1648 if (((tuple->TupleCode > 0x23) && (tuple->TupleCode < 0x40)) ||
1649 ((tuple->TupleCode > 0x47) && (tuple->TupleCode < 0x80)) ||
1650 ((tuple->TupleCode > 0x90) && (tuple->TupleCode < 0xff)))
1651 reserved++;
1652 }
1653 if ((count == MAX_TUPLES) || (reserved > 5) ||
1654 ((!dev_ok || !ident_ok) && (count > 10)))
1655 count = 0;
1656
1657 ret = 0;
1da177e4
LT		 1658
1659done:
f131ddc4
DB		 1660 /* invalidate CIS cache on failure */
1661 if (!dev_ok || !ident_ok || !count) {
1662 destroy_cis_cache(s);
1663 ret = -EIO;
1664 }
1665
1666 if (info)
1667 *info = count;
1668 kfree(tuple);
1669 kfree(p);
1670 return ret;
1da177e4
LT		 1671}
1672EXPORT_SYMBOL(pccard_validate_cis);
Linux 6.x block layer and io_uring tree(s)