drivers/pcmcia/cistpl.c

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