projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
pcmcia: do not meddle with already assigned resources
[GitHub/mt8127/android_kernel_alcatel_ttab.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
322void destroy_cis_cache(struct pcmcia_socket *s)
323{
324 struct list_head *l, *n;
325
326 list_for_each_safe(l, n, &s->cis_cache) {
327 struct cis_cache_entry *cis = list_entry(l, struct cis_cache_entry, node);
328
329 list_del(&cis->node);
330 kfree(cis);
331 }
332
333 /*
334 * If there was a fake CIS, destroy that as well.
335 */
6044ec88
JJ		 336 kfree(s->fake_cis);
337 s->fake_cis = NULL;
1da177e4
LT		 338}
339EXPORT_SYMBOL(destroy_cis_cache);
340
341/*======================================================================
342
343 This verifies if the CIS of a card matches what is in the CIS
344 cache.
9fea84f4 345
1da177e4
LT		 346======================================================================*/
347
348int verify_cis_cache(struct pcmcia_socket *s)
349{
350 struct cis_cache_entry *cis;
351 char *buf;
352
353 buf = kmalloc(256, GFP_KERNEL);
e689597f 354 if (buf == NULL) {
1168386a
DB		 355 dev_printk(KERN_WARNING, &s->dev,
356 "no memory for verifying CIS\n");
357 return -ENOMEM;
e689597f 358 }
1da177e4
LT		 359 list_for_each_entry(cis, &s->cis_cache, node) {
360 int len = cis->len;
361
362 if (len > 256)
363 len = 256;
364#ifdef CONFIG_CARDBUS
365 if (s->state & SOCKET_CARDBUS)
366 read_cb_mem(s, cis->attr, cis->addr, len, buf);
367 else
368#endif
e6ea0b9e 369 pcmcia_read_cis_mem(s, cis->attr, cis->addr, len, buf);
1da177e4
LT		 370
371 if (memcmp(buf, cis->cache, len) != 0) {
372 kfree(buf);
373 return -1;
374 }
375 }
376 kfree(buf);
377 return 0;
378}
379
380/*======================================================================
381
382 For really bad cards, we provide a facility for uploading a
383 replacement CIS.
9fea84f4 384
1da177e4
LT		 385======================================================================*/
386
53efec95
DB		 387int pcmcia_replace_cis(struct pcmcia_socket *s,
388 const u8 *data, const size_t len)
1da177e4 389{
1168386a
DB		 390 if (len > CISTPL_MAX_CIS_SIZE) {
391 dev_printk(KERN_WARNING, &s->dev, "replacement CIS too big\n");
392 return -EINVAL;
393 }
394 kfree(s->fake_cis);
395 s->fake_cis = kmalloc(len, GFP_KERNEL);
396 if (s->fake_cis == NULL) {
397 dev_printk(KERN_WARNING, &s->dev, "no memory to replace CIS\n");
398 return -ENOMEM;
399 }
400 s->fake_cis_len = len;
401 memcpy(s->fake_cis, data, len);
402 return 0;
1da177e4 403}
33519ddd 404EXPORT_SYMBOL(pcmcia_replace_cis);
1da177e4
LT		 405
406/*======================================================================
407
408 The high-level CIS tuple services
9fea84f4 409
1da177e4
LT		 410======================================================================*/
411
412typedef struct tuple_flags {
413 u_int link_space:4;
414 u_int has_link:1;
415 u_int mfc_fn:3;
416 u_int space:4;
417} tuple_flags;
418
419#define LINK_SPACE(f) (((tuple_flags *)(&(f)))->link_space)
420#define HAS_LINK(f) (((tuple_flags *)(&(f)))->has_link)
421#define MFC_FN(f) (((tuple_flags *)(&(f)))->mfc_fn)
422#define SPACE(f) (((tuple_flags *)(&(f)))->space)
423
1da177e4
LT		 424int pccard_get_first_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple)
425{
426 if (!s)
ffb8da20 427 return -EINVAL;
1da177e4 428 if (!(s->state & SOCKET_PRESENT))
3939c1ef 429 return -ENODEV;
1da177e4
LT		 430 tuple->TupleLink = tuple->Flags = 0;
431#ifdef CONFIG_CARDBUS
432 if (s->state & SOCKET_CARDBUS) {
433 struct pci_dev *dev = s->cb_dev;
434 u_int ptr;
435 pci_bus_read_config_dword(dev->subordinate, 0, PCI_CARDBUS_CIS, &ptr);
436 tuple->CISOffset = ptr & ~7;
437 SPACE(tuple->Flags) = (ptr & 7);
438 } else
439#endif
440 {
441 /* Assume presence of a LONGLINK_C to address 0 */
442 tuple->CISOffset = tuple->LinkOffset = 0;
443 SPACE(tuple->Flags) = HAS_LINK(tuple->Flags) = 1;
444 }
445 if (!(s->state & SOCKET_CARDBUS) && (s->functions > 1) &&
446 !(tuple->Attributes & TUPLE_RETURN_COMMON)) {
447 cisdata_t req = tuple->DesiredTuple;
448 tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
4c89e88b 449 if (pccard_get_next_tuple(s, function, tuple) == 0) {
1da177e4 450 tuple->DesiredTuple = CISTPL_LINKTARGET;
4c89e88b 451 if (pccard_get_next_tuple(s, function, tuple) != 0)
635d19be 452 return -ENOSPC;
1da177e4
LT		 453 } else
454 tuple->CISOffset = tuple->TupleLink = 0;
455 tuple->DesiredTuple = req;
456 }
457 return pccard_get_next_tuple(s, function, tuple);
458}
459EXPORT_SYMBOL(pccard_get_first_tuple);
460
461static int follow_link(struct pcmcia_socket *s, tuple_t *tuple)
462{
463 u_char link[5];
464 u_int ofs;
465
466 if (MFC_FN(tuple->Flags)) {
467 /* Get indirect link from the MFC tuple */
468 read_cis_cache(s, LINK_SPACE(tuple->Flags),
469 tuple->LinkOffset, 5, link);
6b1e6f63 470 ofs = get_unaligned_le32(link + 1);
1da177e4
LT		 471 SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR);
472 /* Move to the next indirect link */
473 tuple->LinkOffset += 5;
474 MFC_FN(tuple->Flags)--;
475 } else if (HAS_LINK(tuple->Flags)) {
476 ofs = tuple->LinkOffset;
477 SPACE(tuple->Flags) = LINK_SPACE(tuple->Flags);
478 HAS_LINK(tuple->Flags) = 0;
479 } else {
480 return -1;
481 }
482 if (!(s->state & SOCKET_CARDBUS) && SPACE(tuple->Flags)) {
483 /* This is ugly, but a common CIS error is to code the long
484 link offset incorrectly, so we check the right spot... */
485 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link);
486 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) &&
487 (strncmp(link+2, "CIS", 3) == 0))
488 return ofs;
489 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5);
490 /* Then, we try the wrong spot... */
491 ofs = ofs >> 1;
492 }
493 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link);
494 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) &&
495 (strncmp(link+2, "CIS", 3) == 0))
496 return ofs;
497 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5);
498 return -1;
499}
500
501int pccard_get_next_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple)
502{
503 u_char link[2], tmp;
504 int ofs, i, attr;
505
506 if (!s)
ffb8da20 507 return -EINVAL;
1da177e4 508 if (!(s->state & SOCKET_PRESENT))
3939c1ef 509 return -ENODEV;
1da177e4
LT		 510
511 link[1] = tuple->TupleLink;
512 ofs = tuple->CISOffset + tuple->TupleLink;
513 attr = SPACE(tuple->Flags);
514
515 for (i = 0; i < MAX_TUPLES; i++) {
516 if (link[1] == 0xff) {
517 link[0] = CISTPL_END;
518 } else {
519 read_cis_cache(s, attr, ofs, 2, link);
520 if (link[0] == CISTPL_NULL) {
521 ofs++; continue;
522 }
523 }
9fea84f4 524
1da177e4
LT		 525 /* End of chain? Follow long link if possible */
526 if (link[0] == CISTPL_END) {
9fea84f4
DB		 527 ofs = follow_link(s, tuple);
528 if (ofs < 0)
635d19be 529 return -ENOSPC;
1da177e4
LT		 530 attr = SPACE(tuple->Flags);
531 read_cis_cache(s, attr, ofs, 2, link);
532 }
533
534 /* Is this a link tuple? Make a note of it */
535 if ((link[0] == CISTPL_LONGLINK_A) ||
536 (link[0] == CISTPL_LONGLINK_C) ||
537 (link[0] == CISTPL_LONGLINK_MFC) ||
538 (link[0] == CISTPL_LINKTARGET) ||
539 (link[0] == CISTPL_INDIRECT) ||
540 (link[0] == CISTPL_NO_LINK)) {
541 switch (link[0]) {
542 case CISTPL_LONGLINK_A:
543 HAS_LINK(tuple->Flags) = 1;
544 LINK_SPACE(tuple->Flags) = attr | IS_ATTR;
545 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset);
546 break;
547 case CISTPL_LONGLINK_C:
548 HAS_LINK(tuple->Flags) = 1;
549 LINK_SPACE(tuple->Flags) = attr & ~IS_ATTR;
550 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset);
551 break;
552 case CISTPL_INDIRECT:
553 HAS_LINK(tuple->Flags) = 1;
554 LINK_SPACE(tuple->Flags) = IS_ATTR | IS_INDIRECT;
555 tuple->LinkOffset = 0;
556 break;
557 case CISTPL_LONGLINK_MFC:
558 tuple->LinkOffset = ofs + 3;
559 LINK_SPACE(tuple->Flags) = attr;
560 if (function == BIND_FN_ALL) {
561 /* Follow all the MFC links */
562 read_cis_cache(s, attr, ofs+2, 1, &tmp);
563 MFC_FN(tuple->Flags) = tmp;
564 } else {
565 /* Follow exactly one of the links */
566 MFC_FN(tuple->Flags) = 1;
567 tuple->LinkOffset += function * 5;
568 }
569 break;
570 case CISTPL_NO_LINK:
571 HAS_LINK(tuple->Flags) = 0;
572 break;
573 }
574 if ((tuple->Attributes & TUPLE_RETURN_LINK) &&
575 (tuple->DesiredTuple == RETURN_FIRST_TUPLE))
576 break;
577 } else
578 if (tuple->DesiredTuple == RETURN_FIRST_TUPLE)
579 break;
9fea84f4 580
1da177e4
LT		 581 if (link[0] == tuple->DesiredTuple)
582 break;
583 ofs += link[1] + 2;
584 }
585 if (i == MAX_TUPLES) {
d50dbec3 586 dev_dbg(&s->dev, "cs: overrun in pcmcia_get_next_tuple\n");
635d19be 587 return -ENOSPC;
1da177e4 588 }
9fea84f4 589
1da177e4
LT		 590 tuple->TupleCode = link[0];
591 tuple->TupleLink = link[1];
592 tuple->CISOffset = ofs + 2;
4c89e88b 593 return 0;
1da177e4
LT		 594}
595EXPORT_SYMBOL(pccard_get_next_tuple);
596
597/*====================================================================*/
598
599#define _MIN(a, b) (((a) < (b)) ? (a) : (b))
600
601int pccard_get_tuple_data(struct pcmcia_socket *s, tuple_t *tuple)
602{
603 u_int len;
604
605 if (!s)
ffb8da20 606 return -EINVAL;
1da177e4
LT		 607
608 if (tuple->TupleLink < tuple->TupleOffset)
635d19be 609 return -ENOSPC;
1da177e4
LT		 610 len = tuple->TupleLink - tuple->TupleOffset;
611 tuple->TupleDataLen = tuple->TupleLink;
612 if (len == 0)
4c89e88b 613 return 0;
1da177e4
LT		 614 read_cis_cache(s, SPACE(tuple->Flags),
615 tuple->CISOffset + tuple->TupleOffset,
616 _MIN(len, tuple->TupleDataMax), tuple->TupleData);
4c89e88b 617 return 0;
1da177e4
LT		 618}
619EXPORT_SYMBOL(pccard_get_tuple_data);
620
621
622/*======================================================================
623
624 Parsing routines for individual tuples
9fea84f4 625
1da177e4
LT		 626======================================================================*/
627
628static int parse_device(tuple_t *tuple, cistpl_device_t *device)
629{
630 int i;
631 u_char scale;
632 u_char *p, *q;
633
634 p = (u_char *)tuple->TupleData;
635 q = p + tuple->TupleDataLen;
636
637 device->ndev = 0;
638 for (i = 0; i < CISTPL_MAX_DEVICES; i++) {
9fea84f4
DB		 639
640 if (*p == 0xff)
641 break;
1da177e4
LT		 642 device->dev[i].type = (*p >> 4);
643 device->dev[i].wp = (*p & 0x08) ? 1 : 0;
644 switch (*p & 0x07) {
9fea84f4
DB		 645 case 0:
646 device->dev[i].speed = 0;
647 break;
648 case 1:
649 device->dev[i].speed = 250;
650 break;
651 case 2:
652 device->dev[i].speed = 200;
653 break;
654 case 3:
655 device->dev[i].speed = 150;
656 break;
657 case 4:
658 device->dev[i].speed = 100;
659 break;
1da177e4 660 case 7:
3f9c5f4c
DB		 661 if (++p == q)
662 return -EINVAL;
9fea84f4
DB		 663 device->dev[i].speed = SPEED_CVT(*p);
664 while (*p & 0x80)
665 if (++p == q)
666 return -EINVAL;
667 break;
1da177e4 668 default:
9fea84f4 669 return -EINVAL;
1da177e4
LT		 670 }
671
3f9c5f4c
DB		 672 if (++p == q)
673 return -EINVAL;
674 if (*p == 0xff)
675 break;
1da177e4 676 scale = *p & 7;
3f9c5f4c
DB		 677 if (scale == 7)
678 return -EINVAL;
1da177e4
LT		 679 device->dev[i].size = ((*p >> 3) + 1) * (512 << (scale*2));
680 device->ndev++;
3f9c5f4c
DB		 681 if (++p == q)
682 break;
1da177e4 683 }
9fea84f4 684
4c89e88b 685 return 0;
1da177e4
LT		 686}
687
688/*====================================================================*/
689
690static int parse_checksum(tuple_t *tuple, cistpl_checksum_t *csum)
691{
692 u_char *p;
693 if (tuple->TupleDataLen < 5)
3f9c5f4c 694 return -EINVAL;
dc0cf6a2 695 p = (u_char *) tuple->TupleData;
6b1e6f63
HH		 696 csum->addr = tuple->CISOffset + get_unaligned_le16(p) - 2;
697 csum->len = get_unaligned_le16(p + 2);
dc0cf6a2 698 csum->sum = *(p + 4);
4c89e88b 699 return 0;
1da177e4
LT		 700}
701
702/*====================================================================*/
703
704static int parse_longlink(tuple_t *tuple, cistpl_longlink_t *link)
705{
706 if (tuple->TupleDataLen < 4)
3f9c5f4c 707 return -EINVAL;
6b1e6f63 708 link->addr = get_unaligned_le32(tuple->TupleData);
4c89e88b 709 return 0;
1da177e4
LT		 710}
711
712/*====================================================================*/
713
714static int parse_longlink_mfc(tuple_t *tuple,
715 cistpl_longlink_mfc_t *link)
716{
717 u_char *p;
718 int i;
9fea84f4 719
1da177e4 720 p = (u_char *)tuple->TupleData;
9fea84f4 721
1da177e4
LT		 722 link->nfn = *p; p++;
723 if (tuple->TupleDataLen <= link->nfn*5)
3f9c5f4c 724 return -EINVAL;
1da177e4
LT		 725 for (i = 0; i < link->nfn; i++) {
726 link->fn[i].space = *p; p++;
6b1e6f63 727 link->fn[i].addr = get_unaligned_le32(p);
dc0cf6a2 728 p += 4;
1da177e4 729 }
4c89e88b 730 return 0;
1da177e4
LT		 731}
732
733/*====================================================================*/
734
735static int parse_strings(u_char *p, u_char *q, int max,
736 char *s, u_char *ofs, u_char *found)
737{
738 int i, j, ns;
739
3f9c5f4c
DB		 740 if (p == q)
741 return -EINVAL;
1da177e4
LT		 742 ns = 0; j = 0;
743 for (i = 0; i < max; i++) {
3f9c5f4c
DB		 744 if (*p == 0xff)
745 break;
1da177e4
LT		 746 ofs[i] = j;
747 ns++;
748 for (;;) {
749 s[j++] = (*p == 0xff) ? '\0' : *p;
9fea84f4
DB		 750 if ((*p == '\0') || (*p == 0xff))
751 break;
3f9c5f4c
DB		 752 if (++p == q)
753 return -EINVAL;
1da177e4 754 }
9fea84f4
DB		 755 if ((*p == 0xff) || (++p == q))
756 break;
1da177e4
LT		 757 }
758 if (found) {
759 *found = ns;
4c89e88b 760 return 0;
1da177e4 761 } else {
3f9c5f4c 762 return (ns == max) ? 0 : -EINVAL;
1da177e4
LT		 763 }
764}
765
766/*====================================================================*/
767
768static int parse_vers_1(tuple_t *tuple, cistpl_vers_1_t *vers_1)
769{
770 u_char *p, *q;
9fea84f4 771
1da177e4
LT		 772 p = (u_char *)tuple->TupleData;
773 q = p + tuple->TupleDataLen;
9fea84f4 774
1da177e4
LT		 775 vers_1->major = *p; p++;
776 vers_1->minor = *p; p++;
3f9c5f4c
DB		 777 if (p >= q)
778 return -EINVAL;
1da177e4
LT		 779
780 return parse_strings(p, q, CISTPL_VERS_1_MAX_PROD_STRINGS,
781 vers_1->str, vers_1->ofs, &vers_1->ns);
782}
783
784/*====================================================================*/
785
786static int parse_altstr(tuple_t *tuple, cistpl_altstr_t *altstr)
787{
788 u_char *p, *q;
9fea84f4 789
1da177e4
LT		 790 p = (u_char *)tuple->TupleData;
791 q = p + tuple->TupleDataLen;
9fea84f4 792
1da177e4
LT		 793 return parse_strings(p, q, CISTPL_MAX_ALTSTR_STRINGS,
794 altstr->str, altstr->ofs, &altstr->ns);
795}
796
797/*====================================================================*/
798
799static int parse_jedec(tuple_t *tuple, cistpl_jedec_t *jedec)
800{
801 u_char *p, *q;
802 int nid;
803
804 p = (u_char *)tuple->TupleData;
805 q = p + tuple->TupleDataLen;
806
807 for (nid = 0; nid < CISTPL_MAX_DEVICES; nid++) {
9fea84f4
DB		 808 if (p > q-2)
809 break;
1da177e4
LT		 810 jedec->id[nid].mfr = p[0];
811 jedec->id[nid].info = p[1];
812 p += 2;
813 }
814 jedec->nid = nid;
4c89e88b 815 return 0;
1da177e4
LT		 816}
817
818/*====================================================================*/
819
820static int parse_manfid(tuple_t *tuple, cistpl_manfid_t *m)
821{
1da177e4 822 if (tuple->TupleDataLen < 4)
3f9c5f4c 823 return -EINVAL;
6b1e6f63
HH		 824 m->manf = get_unaligned_le16(tuple->TupleData);
825 m->card = get_unaligned_le16(tuple->TupleData + 2);
4c89e88b 826 return 0;
1da177e4
LT		 827}
828
829/*====================================================================*/
830
831static int parse_funcid(tuple_t *tuple, cistpl_funcid_t *f)
832{
833 u_char *p;
834 if (tuple->TupleDataLen < 2)
3f9c5f4c 835 return -EINVAL;
1da177e4
LT		 836 p = (u_char *)tuple->TupleData;
837 f->func = p[0];
838 f->sysinit = p[1];
4c89e88b 839 return 0;
1da177e4
LT		 840}
841
842/*====================================================================*/
843
844static int parse_funce(tuple_t *tuple, cistpl_funce_t *f)
845{
846 u_char *p;
847 int i;
848 if (tuple->TupleDataLen < 1)
3f9c5f4c 849 return -EINVAL;
1da177e4
LT		 850 p = (u_char *)tuple->TupleData;
851 f->type = p[0];
852 for (i = 1; i < tuple->TupleDataLen; i++)
853 f->data[i-1] = p[i];
4c89e88b 854 return 0;
1da177e4
LT		 855}
856
857/*====================================================================*/
858
859static int parse_config(tuple_t *tuple, cistpl_config_t *config)
860{
861 int rasz, rmsz, i;
862 u_char *p;
863
864 p = (u_char *)tuple->TupleData;
865 rasz = *p & 0x03;
866 rmsz = (*p & 0x3c) >> 2;
867 if (tuple->TupleDataLen < rasz+rmsz+4)
3f9c5f4c 868 return -EINVAL;
1da177e4
LT		 869 config->last_idx = *(++p);
870 p++;
871 config->base = 0;
872 for (i = 0; i <= rasz; i++)
873 config->base += p[i] << (8*i);
874 p += rasz+1;
875 for (i = 0; i < 4; i++)
876 config->rmask[i] = 0;
877 for (i = 0; i <= rmsz; i++)
878 config->rmask[i>>2] += p[i] << (8*(i%4));
879 config->subtuples = tuple->TupleDataLen - (rasz+rmsz+4);
4c89e88b 880 return 0;
1da177e4
LT		 881}
882
883/*======================================================================
884
885 The following routines are all used to parse the nightmarish
886 config table entries.
9fea84f4 887
1da177e4
LT		 888======================================================================*/
889
890static u_char *parse_power(u_char *p, u_char *q,
891 cistpl_power_t *pwr)
892{
893 int i;
894 u_int scale;
895
9fea84f4
DB		 896 if (p == q)
897 return NULL;
1da177e4
LT		 898 pwr->present = *p;
899 pwr->flags = 0;
900 p++;
901 for (i = 0; i < 7; i++)
902 if (pwr->present & (1<<i)) {
9fea84f4
DB		 903 if (p == q)
904 return NULL;
1da177e4
LT		 905 pwr->param[i] = POWER_CVT(*p);
906 scale = POWER_SCALE(*p);
907 while (*p & 0x80) {
9fea84f4
DB		 908 if (++p == q)
909 return NULL;
1da177e4
LT		 910 if ((*p & 0x7f) < 100)
911 pwr->param[i] += (*p & 0x7f) * scale / 100;
912 else if (*p == 0x7d)
913 pwr->flags |= CISTPL_POWER_HIGHZ_OK;
914 else if (*p == 0x7e)
915 pwr->param[i] = 0;
916 else if (*p == 0x7f)
917 pwr->flags |= CISTPL_POWER_HIGHZ_REQ;
918 else
919 return NULL;
920 }
921 p++;
922 }
923 return p;
924}
925
926/*====================================================================*/
927
928static u_char *parse_timing(u_char *p, u_char *q,
929 cistpl_timing_t *timing)
930{
931 u_char scale;
932
9fea84f4
DB		 933 if (p == q)
934 return NULL;
1da177e4
LT		 935 scale = *p;
936 if ((scale & 3) != 3) {
9fea84f4
DB		 937 if (++p == q)
938 return NULL;
1da177e4
LT		 939 timing->wait = SPEED_CVT(*p);
940 timing->waitscale = exponent[scale & 3];
941 } else
942 timing->wait = 0;
943 scale >>= 2;
944 if ((scale & 7) != 7) {
9fea84f4
DB		 945 if (++p == q)
946 return NULL;
1da177e4
LT		 947 timing->ready = SPEED_CVT(*p);
948 timing->rdyscale = exponent[scale & 7];
949 } else
950 timing->ready = 0;
951 scale >>= 3;
952 if (scale != 7) {
9fea84f4
DB		 953 if (++p == q)
954 return NULL;
1da177e4
LT		 955 timing->reserved = SPEED_CVT(*p);
956 timing->rsvscale = exponent[scale];
957 } else
958 timing->reserved = 0;
959 p++;
960 return p;
961}
962
963/*====================================================================*/
964
965static u_char *parse_io(u_char *p, u_char *q, cistpl_io_t *io)
966{
967 int i, j, bsz, lsz;
968
9fea84f4
DB		 969 if (p == q)
970 return NULL;
1da177e4
LT		 971 io->flags = *p;
972
973 if (!(*p & 0x80)) {
974 io->nwin = 1;
975 io->win[0].base = 0;
976 io->win[0].len = (1 << (io->flags & CISTPL_IO_LINES_MASK));
977 return p+1;
978 }
9fea84f4
DB		 979
980 if (++p == q)
981 return NULL;
1da177e4
LT		 982 io->nwin = (*p & 0x0f) + 1;
983 bsz = (*p & 0x30) >> 4;
9fea84f4
DB		 984 if (bsz == 3)
985 bsz++;
1da177e4 986 lsz = (*p & 0xc0) >> 6;
9fea84f4
DB		 987 if (lsz == 3)
988 lsz++;
1da177e4 989 p++;
9fea84f4 990
1da177e4
LT		 991 for (i = 0; i < io->nwin; i++) {
992 io->win[i].base = 0;
993 io->win[i].len = 1;
994 for (j = 0; j < bsz; j++, p++) {
9fea84f4
DB		 995 if (p == q)
996 return NULL;
1da177e4
LT		 997 io->win[i].base += *p << (j*8);
998 }
999 for (j = 0; j < lsz; j++, p++) {
9fea84f4
DB		 1000 if (p == q)
1001 return NULL;
1da177e4
LT		 1002 io->win[i].len += *p << (j*8);
1003 }
1004 }
1005 return p;
1006}
1007
1008/*====================================================================*/
1009
1010static u_char *parse_mem(u_char *p, u_char *q, cistpl_mem_t *mem)
1011{
1012 int i, j, asz, lsz, has_ha;
1013 u_int len, ca, ha;
1014
9fea84f4
DB		 1015 if (p == q)
1016 return NULL;
1da177e4
LT		 1017
1018 mem->nwin = (*p & 0x07) + 1;
1019 lsz = (*p & 0x18) >> 3;
1020 asz = (*p & 0x60) >> 5;
1021 has_ha = (*p & 0x80);
9fea84f4
DB		 1022 if (++p == q)
1023 return NULL;
1024
1da177e4
LT		 1025 for (i = 0; i < mem->nwin; i++) {
1026 len = ca = ha = 0;
1027 for (j = 0; j < lsz; j++, p++) {
9fea84f4
DB		 1028 if (p == q)
1029 return NULL;
1da177e4
LT		 1030 len += *p << (j*8);
1031 }
1032 for (j = 0; j < asz; j++, p++) {
9fea84f4
DB		 1033 if (p == q)
1034 return NULL;
1da177e4
LT		 1035 ca += *p << (j*8);
1036 }
1037 if (has_ha)
1038 for (j = 0; j < asz; j++, p++) {
9fea84f4
DB		 1039 if (p == q)
1040 return NULL;
1da177e4
LT		 1041 ha += *p << (j*8);
1042 }
1043 mem->win[i].len = len << 8;
1044 mem->win[i].card_addr = ca << 8;
1045 mem->win[i].host_addr = ha << 8;
1046 }
1047 return p;
1048}
1049
1050/*====================================================================*/
1051
1052static u_char *parse_irq(u_char *p, u_char *q, cistpl_irq_t *irq)
1053{
3f9c5f4c
DB		 1054 if (p == q)
1055 return NULL;
1da177e4
LT		 1056 irq->IRQInfo1 = *p; p++;
1057 if (irq->IRQInfo1 & IRQ_INFO2_VALID) {
3f9c5f4c
DB		 1058 if (p+2 > q)
1059 return NULL;
1da177e4
LT		 1060 irq->IRQInfo2 = (p[1]<<8) + p[0];
1061 p += 2;
1062 }
1063 return p;
1064}
1065
1066/*====================================================================*/
1067
1068static int parse_cftable_entry(tuple_t *tuple,
1069 cistpl_cftable_entry_t *entry)
1070{
1071 u_char *p, *q, features;
1072
1073 p = tuple->TupleData;
1074 q = p + tuple->TupleDataLen;
1075 entry->index = *p & 0x3f;
1076 entry->flags = 0;
1077 if (*p & 0x40)
1078 entry->flags |= CISTPL_CFTABLE_DEFAULT;
1079 if (*p & 0x80) {
3f9c5f4c
DB		 1080 if (++p == q)
1081 return -EINVAL;
1da177e4
LT		 1082 if (*p & 0x10)
1083 entry->flags |= CISTPL_CFTABLE_BVDS;
1084 if (*p & 0x20)
1085 entry->flags |= CISTPL_CFTABLE_WP;
1086 if (*p & 0x40)
1087 entry->flags |= CISTPL_CFTABLE_RDYBSY;
1088 if (*p & 0x80)
1089 entry->flags |= CISTPL_CFTABLE_MWAIT;
1090 entry->interface = *p & 0x0f;
1091 } else
1092 entry->interface = 0;
1093
1094 /* Process optional features */
3f9c5f4c
DB		 1095 if (++p == q)
1096 return -EINVAL;
1da177e4
LT		 1097 features = *p; p++;
1098
1099 /* Power options */
1100 if ((features & 3) > 0) {
1101 p = parse_power(p, q, &entry->vcc);
3f9c5f4c
DB		 1102 if (p == NULL)
1103 return -EINVAL;
1da177e4
LT		 1104 } else
1105 entry->vcc.present = 0;
1106 if ((features & 3) > 1) {
1107 p = parse_power(p, q, &entry->vpp1);
3f9c5f4c
DB		 1108 if (p == NULL)
1109 return -EINVAL;
1da177e4
LT		 1110 } else
1111 entry->vpp1.present = 0;
1112 if ((features & 3) > 2) {
1113 p = parse_power(p, q, &entry->vpp2);
3f9c5f4c
DB		 1114 if (p == NULL)
1115 return -EINVAL;
1da177e4
LT		 1116 } else
1117 entry->vpp2.present = 0;
1118
1119 /* Timing options */
1120 if (features & 0x04) {
1121 p = parse_timing(p, q, &entry->timing);
3f9c5f4c
DB		 1122 if (p == NULL)
1123 return -EINVAL;
1da177e4
LT		 1124 } else {
1125 entry->timing.wait = 0;
1126 entry->timing.ready = 0;
1127 entry->timing.reserved = 0;
1128 }
9fea84f4 1129
1da177e4
LT		 1130 /* I/O window options */
1131 if (features & 0x08) {
1132 p = parse_io(p, q, &entry->io);
3f9c5f4c
DB		 1133 if (p == NULL)
1134 return -EINVAL;
1da177e4
LT		 1135 } else
1136 entry->io.nwin = 0;
9fea84f4 1137
1da177e4
LT		 1138 /* Interrupt options */
1139 if (features & 0x10) {
1140 p = parse_irq(p, q, &entry->irq);
3f9c5f4c
DB		 1141 if (p == NULL)
1142 return -EINVAL;
1da177e4
LT		 1143 } else
1144 entry->irq.IRQInfo1 = 0;
1145
1146 switch (features & 0x60) {
1147 case 0x00:
1148 entry->mem.nwin = 0;
1149 break;
1150 case 0x20:
1151 entry->mem.nwin = 1;
6b1e6f63 1152 entry->mem.win[0].len = get_unaligned_le16(p) << 8;
1da177e4
LT		 1153 entry->mem.win[0].card_addr = 0;
1154 entry->mem.win[0].host_addr = 0;
1155 p += 2;
3f9c5f4c
DB		 1156 if (p > q)
1157 return -EINVAL;
1da177e4
LT		 1158 break;
1159 case 0x40:
1160 entry->mem.nwin = 1;
6b1e6f63
HH		 1161 entry->mem.win[0].len = get_unaligned_le16(p) << 8;
1162 entry->mem.win[0].card_addr = get_unaligned_le16(p + 2) << 8;
1da177e4
LT		 1163 entry->mem.win[0].host_addr = 0;
1164 p += 4;
3f9c5f4c
DB		 1165 if (p > q)
1166 return -EINVAL;
1da177e4
LT		 1167 break;
1168 case 0x60:
1169 p = parse_mem(p, q, &entry->mem);
3f9c5f4c
DB		 1170 if (p == NULL)
1171 return -EINVAL;
1da177e4
LT		 1172 break;
1173 }
1174
1175 /* Misc features */
1176 if (features & 0x80) {
3f9c5f4c
DB		 1177 if (p == q)
1178 return -EINVAL;
1da177e4
LT		 1179 entry->flags |= (*p << 8);
1180 while (*p & 0x80)
3f9c5f4c
DB		 1181 if (++p == q)
1182 return -EINVAL;
1da177e4
LT		 1183 p++;
1184 }
1185
1186 entry->subtuples = q-p;
9fea84f4 1187
4c89e88b 1188 return 0;
1da177e4
LT		 1189}
1190
1191/*====================================================================*/
1192
1193#ifdef CONFIG_CARDBUS
1194
1195static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar)
1196{
1197 u_char *p;
1198 if (tuple->TupleDataLen < 6)
3f9c5f4c 1199 return -EINVAL;
1da177e4
LT		 1200 p = (u_char *)tuple->TupleData;
1201 bar->attr = *p;
1202 p += 2;
6b1e6f63 1203 bar->size = get_unaligned_le32(p);
4c89e88b 1204 return 0;
1da177e4
LT		 1205}
1206
1207static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config)
1208{
1209 u_char *p;
9fea84f4 1210
1da177e4
LT		 1211 p = (u_char *)tuple->TupleData;
1212 if ((*p != 3) || (tuple->TupleDataLen < 6))
3f9c5f4c 1213 return -EINVAL;
1da177e4
LT		 1214 config->last_idx = *(++p);
1215 p++;
6b1e6f63 1216 config->base = get_unaligned_le32(p);
1da177e4 1217 config->subtuples = tuple->TupleDataLen - 6;
4c89e88b 1218 return 0;
1da177e4
LT		 1219}
1220
1221static int parse_cftable_entry_cb(tuple_t *tuple,
1222 cistpl_cftable_entry_cb_t *entry)
1223{
1224 u_char *p, *q, features;
1225
1226 p = tuple->TupleData;
1227 q = p + tuple->TupleDataLen;
1228 entry->index = *p & 0x3f;
1229 entry->flags = 0;
1230 if (*p & 0x40)
1231 entry->flags |= CISTPL_CFTABLE_DEFAULT;
1232
1233 /* Process optional features */
3f9c5f4c
DB		 1234 if (++p == q)
1235 return -EINVAL;
1da177e4
LT		 1236 features = *p; p++;
1237
1238 /* Power options */
1239 if ((features & 3) > 0) {
1240 p = parse_power(p, q, &entry->vcc);
3f9c5f4c
DB		 1241 if (p == NULL)
1242 return -EINVAL;
1da177e4
LT		 1243 } else
1244 entry->vcc.present = 0;
1245 if ((features & 3) > 1) {
1246 p = parse_power(p, q, &entry->vpp1);
3f9c5f4c
DB		 1247 if (p == NULL)
1248 return -EINVAL;
1da177e4
LT		 1249 } else
1250 entry->vpp1.present = 0;
1251 if ((features & 3) > 2) {
1252 p = parse_power(p, q, &entry->vpp2);
3f9c5f4c
DB		 1253 if (p == NULL)
1254 return -EINVAL;
1da177e4
LT		 1255 } else
1256 entry->vpp2.present = 0;
1257
1258 /* I/O window options */
1259 if (features & 0x08) {
3f9c5f4c
DB		 1260 if (p == q)
1261 return -EINVAL;
1da177e4
LT		 1262 entry->io = *p; p++;
1263 } else
1264 entry->io = 0;
9fea84f4 1265
1da177e4
LT		 1266 /* Interrupt options */
1267 if (features & 0x10) {
1268 p = parse_irq(p, q, &entry->irq);
3f9c5f4c
DB		 1269 if (p == NULL)
1270 return -EINVAL;
1da177e4
LT		 1271 } else
1272 entry->irq.IRQInfo1 = 0;
1273
1274 if (features & 0x20) {
3f9c5f4c
DB		 1275 if (p == q)
1276 return -EINVAL;
1da177e4
LT		 1277 entry->mem = *p; p++;
1278 } else
1279 entry->mem = 0;
1280
1281 /* Misc features */
1282 if (features & 0x80) {
3f9c5f4c
DB		 1283 if (p == q)
1284 return -EINVAL;
1da177e4
LT		 1285 entry->flags |= (*p << 8);
1286 if (*p & 0x80) {
3f9c5f4c
DB		 1287 if (++p == q)
1288 return -EINVAL;
1da177e4
LT		 1289 entry->flags |= (*p << 16);
1290 }
1291 while (*p & 0x80)
3f9c5f4c
DB		 1292 if (++p == q)
1293 return -EINVAL;
1da177e4
LT		 1294 p++;
1295 }
1296
1297 entry->subtuples = q-p;
9fea84f4 1298
4c89e88b 1299 return 0;
1da177e4
LT		 1300}
1301
1302#endif
1303
1304/*====================================================================*/
1305
1306static int parse_device_geo(tuple_t *tuple, cistpl_device_geo_t *geo)
1307{
1308 u_char *p, *q;
1309 int n;
1310
1311 p = (u_char *)tuple->TupleData;
1312 q = p + tuple->TupleDataLen;
1313
1314 for (n = 0; n < CISTPL_MAX_DEVICES; n++) {
9fea84f4
DB		 1315 if (p > q-6)
1316 break;
1da177e4
LT		 1317 geo->geo[n].buswidth = p[0];
1318 geo->geo[n].erase_block = 1 << (p[1]-1);
1319 geo->geo[n].read_block = 1 << (p[2]-1);
1320 geo->geo[n].write_block = 1 << (p[3]-1);
1321 geo->geo[n].partition = 1 << (p[4]-1);
1322 geo->geo[n].interleave = 1 << (p[5]-1);
1323 p += 6;
1324 }
1325 geo->ngeo = n;
4c89e88b 1326 return 0;
1da177e4
LT		 1327}
1328
1329/*====================================================================*/
1330
1331static int parse_vers_2(tuple_t *tuple, cistpl_vers_2_t *v2)
1332{
1333 u_char *p, *q;
1334
1335 if (tuple->TupleDataLen < 10)
3f9c5f4c 1336 return -EINVAL;
9fea84f4 1337
1da177e4
LT		 1338 p = tuple->TupleData;
1339 q = p + tuple->TupleDataLen;
1340
1341 v2->vers = p[0];
1342 v2->comply = p[1];
9fea84f4 1343 v2->dindex = get_unaligned_le16(p + 2);
1da177e4
LT		 1344 v2->vspec8 = p[6];
1345 v2->vspec9 = p[7];
1346 v2->nhdr = p[8];
1347 p += 9;
1348 return parse_strings(p, q, 2, v2->str, &v2->vendor, NULL);
1349}
1350
1351/*====================================================================*/
1352
1353static int parse_org(tuple_t *tuple, cistpl_org_t *org)
1354{
1355 u_char *p, *q;
1356 int i;
9fea84f4 1357
1da177e4
LT		 1358 p = tuple->TupleData;
1359 q = p + tuple->TupleDataLen;
3f9c5f4c
DB		 1360 if (p == q)
1361 return -EINVAL;
1da177e4 1362 org->data_org = *p;
3f9c5f4c
DB		 1363 if (++p == q)
1364 return -EINVAL;
1da177e4
LT		 1365 for (i = 0; i < 30; i++) {
1366 org->desc[i] = *p;
9fea84f4
DB		 1367 if (*p == '\0')
1368 break;
3f9c5f4c
DB		 1369 if (++p == q)
1370 return -EINVAL;
1da177e4 1371 }
4c89e88b 1372 return 0;
1da177e4
LT		 1373}
1374
1375/*====================================================================*/
1376
1377static int parse_format(tuple_t *tuple, cistpl_format_t *fmt)
1378{
1379 u_char *p;
1380
1381 if (tuple->TupleDataLen < 10)
3f9c5f4c 1382 return -EINVAL;
1da177e4
LT		 1383
1384 p = tuple->TupleData;
1385
1386 fmt->type = p[0];
1387 fmt->edc = p[1];
6b1e6f63
HH		 1388 fmt->offset = get_unaligned_le32(p + 2);
1389 fmt->length = get_unaligned_le32(p + 6);
1da177e4 1390
4c89e88b 1391 return 0;
1da177e4
LT		 1392}
1393
1394/*====================================================================*/
1395
2f3061eb 1396int pcmcia_parse_tuple(tuple_t *tuple, cisparse_t *parse)
1da177e4 1397{
4c89e88b 1398 int ret = 0;
9fea84f4 1399
1da177e4 1400 if (tuple->TupleDataLen > tuple->TupleDataMax)
3f9c5f4c 1401 return -EINVAL;
1da177e4
LT		 1402 switch (tuple->TupleCode) {
1403 case CISTPL_DEVICE:
1404 case CISTPL_DEVICE_A:
1405 ret = parse_device(tuple, &parse->device);
1406 break;
1407#ifdef CONFIG_CARDBUS
1408 case CISTPL_BAR:
1409 ret = parse_bar(tuple, &parse->bar);
1410 break;
1411 case CISTPL_CONFIG_CB:
1412 ret = parse_config_cb(tuple, &parse->config);
1413 break;
1414 case CISTPL_CFTABLE_ENTRY_CB:
1415 ret = parse_cftable_entry_cb(tuple, &parse->cftable_entry_cb);
1416 break;
1417#endif
1418 case CISTPL_CHECKSUM:
1419 ret = parse_checksum(tuple, &parse->checksum);
1420 break;
1421 case CISTPL_LONGLINK_A:
1422 case CISTPL_LONGLINK_C:
1423 ret = parse_longlink(tuple, &parse->longlink);
1424 break;
1425 case CISTPL_LONGLINK_MFC:
1426 ret = parse_longlink_mfc(tuple, &parse->longlink_mfc);
1427 break;
1428 case CISTPL_VERS_1:
1429 ret = parse_vers_1(tuple, &parse->version_1);
1430 break;
1431 case CISTPL_ALTSTR:
1432 ret = parse_altstr(tuple, &parse->altstr);
1433 break;
1434 case CISTPL_JEDEC_A:
1435 case CISTPL_JEDEC_C:
1436 ret = parse_jedec(tuple, &parse->jedec);
1437 break;
1438 case CISTPL_MANFID:
1439 ret = parse_manfid(tuple, &parse->manfid);
1440 break;
1441 case CISTPL_FUNCID:
1442 ret = parse_funcid(tuple, &parse->funcid);
1443 break;
1444 case CISTPL_FUNCE:
1445 ret = parse_funce(tuple, &parse->funce);
1446 break;
1447 case CISTPL_CONFIG:
1448 ret = parse_config(tuple, &parse->config);
1449 break;
1450 case CISTPL_CFTABLE_ENTRY:
1451 ret = parse_cftable_entry(tuple, &parse->cftable_entry);
1452 break;
1453 case CISTPL_DEVICE_GEO:
1454 case CISTPL_DEVICE_GEO_A:
1455 ret = parse_device_geo(tuple, &parse->device_geo);
1456 break;
1457 case CISTPL_VERS_2:
1458 ret = parse_vers_2(tuple, &parse->vers_2);
1459 break;
1460 case CISTPL_ORG:
1461 ret = parse_org(tuple, &parse->org);
1462 break;
1463 case CISTPL_FORMAT:
1464 case CISTPL_FORMAT_A:
1465 ret = parse_format(tuple, &parse->format);
1466 break;
1467 case CISTPL_NO_LINK:
1468 case CISTPL_LINKTARGET:
4c89e88b 1469 ret = 0;
1da177e4
LT		 1470 break;
1471 default:
de6405e9 1472 ret = -EINVAL;
1da177e4
LT		 1473 break;
1474 }
3f9c5f4c 1475 if (ret)
d50dbec3 1476 pr_debug("parse_tuple failed %d\n", ret);
1da177e4
LT		 1477 return ret;
1478}
2f3061eb 1479EXPORT_SYMBOL(pcmcia_parse_tuple);
1da177e4
LT		 1480
1481/*======================================================================
1482
1483 This is used internally by Card Services to look up CIS stuff.
9fea84f4 1484
1da177e4
LT		 1485======================================================================*/
1486
1487int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, cisdata_t code, void *parse)
1488{
1489 tuple_t tuple;
1490 cisdata_t *buf;
1491 int ret;
1492
1493 buf = kmalloc(256, GFP_KERNEL);
1168386a
DB		 1494 if (buf == NULL) {
1495 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n");
1496 return -ENOMEM;
1497 }
1da177e4 1498 tuple.DesiredTuple = code;
84897fc0
DB		 1499 tuple.Attributes = 0;
1500 if (function == BIND_FN_ALL)
1501 tuple.Attributes = TUPLE_RETURN_COMMON;
1da177e4 1502 ret = pccard_get_first_tuple(s, function, &tuple);
4c89e88b
DB		 1503 if (ret != 0)
1504 goto done;
1da177e4
LT		 1505 tuple.TupleData = buf;
1506 tuple.TupleOffset = 0;
1507 tuple.TupleDataMax = 255;
1508 ret = pccard_get_tuple_data(s, &tuple);
4c89e88b
DB		 1509 if (ret != 0)
1510 goto done;
2f3061eb 1511 ret = pcmcia_parse_tuple(&tuple, parse);
1da177e4
LT		 1512done:
1513 kfree(buf);
1514 return ret;
1515}
1516EXPORT_SYMBOL(pccard_read_tuple);
1517
91284224
DB		 1518
1519/**
1520 * pccard_loop_tuple() - loop over tuples in the CIS
1521 * @s: the struct pcmcia_socket where the card is inserted
1522 * @function: the device function we loop for
1523 * @code: which CIS code shall we look for?
1524 * @parse: buffer where the tuple shall be parsed (or NULL, if no parse)
1525 * @priv_data: private data to be passed to the loop_tuple function.
1526 * @loop_tuple: function to call for each CIS entry of type @function. IT
1527 * gets passed the raw tuple, the paresed tuple (if @parse is
1528 * set) and @priv_data.
1529 *
1530 * pccard_loop_tuple() loops over all CIS entries of type @function, and
1531 * calls the @loop_tuple function for each entry. If the call to @loop_tuple
1532 * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
1533 */
1534int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function,
1535 cisdata_t code, cisparse_t *parse, void *priv_data,
1536 int (*loop_tuple) (tuple_t *tuple,
1537 cisparse_t *parse,
1538 void *priv_data))
1539{
1540 tuple_t tuple;
1541 cisdata_t *buf;
1542 int ret;
1543
1544 buf = kzalloc(256, GFP_KERNEL);
1545 if (buf == NULL) {
1546 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n");
1547 return -ENOMEM;
1548 }
1549
1550 tuple.TupleData = buf;
1551 tuple.TupleDataMax = 255;
1552 tuple.TupleOffset = 0;
1553 tuple.DesiredTuple = code;
1554 tuple.Attributes = 0;
1555
1556 ret = pccard_get_first_tuple(s, function, &tuple);
1557 while (!ret) {
1558 if (pccard_get_tuple_data(s, &tuple))
1559 goto next_entry;
1560
1561 if (parse)
1562 if (pcmcia_parse_tuple(&tuple, parse))
1563 goto next_entry;
1564
1565 ret = loop_tuple(&tuple, parse, priv_data);
1566 if (!ret)
1567 break;
1568
1569next_entry:
1570 ret = pccard_get_next_tuple(s, function, &tuple);
1571 }
1572
1573 kfree(buf);
1574 return ret;
1575}
1576EXPORT_SYMBOL(pccard_loop_tuple);
1577
1578
1da177e4
LT		 1579/*======================================================================
1580
1581 This tries to determine if a card has a sensible CIS. It returns
1582 the number of tuples in the CIS, or 0 if the CIS looks bad. The
1583 checks include making sure several critical tuples are present and
1584 valid; seeing if the total number of tuples is reasonable; and
1585 looking for tuples that use reserved codes.
9fea84f4 1586
1da177e4
LT		 1587======================================================================*/
1588
84897fc0 1589int pccard_validate_cis(struct pcmcia_socket *s, unsigned int *info)
1da177e4
LT		 1590{
1591 tuple_t *tuple;
1592 cisparse_t *p;
c5081d5f 1593 unsigned int count = 0;
1da177e4
LT		 1594 int ret, reserved, dev_ok = 0, ident_ok = 0;
1595
1596 if (!s)
ffb8da20 1597 return -EINVAL;
1da177e4
LT		 1598
1599 tuple = kmalloc(sizeof(*tuple), GFP_KERNEL);
1168386a
DB		 1600 if (tuple == NULL) {
1601 dev_printk(KERN_WARNING, &s->dev, "no memory to validate CIS\n");
1602 return -ENOMEM;
1603 }
1da177e4
LT		 1604 p = kmalloc(sizeof(*p), GFP_KERNEL);
1605 if (p == NULL) {
1168386a
DB		 1606 kfree(tuple);
1607 dev_printk(KERN_WARNING, &s->dev, "no memory to validate CIS\n");
1608 return -ENOMEM;
1da177e4
LT		 1609 }
1610
c5081d5f 1611 count = reserved = 0;
1da177e4
LT		 1612 tuple->DesiredTuple = RETURN_FIRST_TUPLE;
1613 tuple->Attributes = TUPLE_RETURN_COMMON;
84897fc0 1614 ret = pccard_get_first_tuple(s, BIND_FN_ALL, tuple);
4c89e88b 1615 if (ret != 0)
1da177e4
LT		 1616 goto done;
1617
1618 /* First tuple should be DEVICE; we should really have either that
1619 or a CFTABLE_ENTRY of some sort */
1620 if ((tuple->TupleCode == CISTPL_DEVICE) ||
84897fc0
DB		 1621 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY, p) == 0) ||
1622 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY_CB, p) == 0))
1da177e4
LT		 1623 dev_ok++;
1624
1625 /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2
1626 tuple, for card identification. Certain old D-Link and Linksys
1627 cards have only a broken VERS_2 tuple; hence the bogus test. */
84897fc0
DB		 1628 if ((pccard_read_tuple(s, BIND_FN_ALL, CISTPL_MANFID, p) == 0) ||
1629 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_1, p) == 0) ||
1630 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_2, p) != -ENOSPC))
1da177e4
LT		 1631 ident_ok++;
1632
1633 if (!dev_ok && !ident_ok)
1634 goto done;
1635
c5081d5f 1636 for (count = 1; count < MAX_TUPLES; count++) {
84897fc0 1637 ret = pccard_get_next_tuple(s, BIND_FN_ALL, tuple);
4c89e88b
DB		 1638 if (ret != 0)
1639 break;
1da177e4
LT		 1640 if (((tuple->TupleCode > 0x23) && (tuple->TupleCode < 0x40)) ||
1641 ((tuple->TupleCode > 0x47) && (tuple->TupleCode < 0x80)) ||
1642 ((tuple->TupleCode > 0x90) && (tuple->TupleCode < 0xff)))
1643 reserved++;
1644 }
002b90a1 1645 if ((count == MAX_TUPLES) || (reserved > 5) ||
c5081d5f
DB		 1646 ((!dev_ok || !ident_ok) && (count > 10)))
1647 count = 0;
1da177e4
LT		 1648
1649done:
c5081d5f
DB		 1650 if (info)
1651 *info = count;
1da177e4
LT		 1652 kfree(tuple);
1653 kfree(p);
4c89e88b 1654 return 0;
1da177e4
LT		 1655}
1656EXPORT_SYMBOL(pccard_validate_cis);
kernel source for telekom puls (alcatel/mediatek)