开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
cistpl.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：40k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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