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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sdla_x25.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：151k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

sdla_x25.c：源码内容
  1. /*****************************************************************************
  2. * sdla_x25.c WANPIPE(tm) Multiprotocol WAN Link Driver.  X.25 module.
  3. *
  4. * Author: Nenad Corbic <ncorbic@sangoma.com>
  5. *
  6. * Copyright: (c) 1995-2001 Sangoma Technologies Inc.
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License
  10. * as published by the Free Software Foundation; either version
  11. * 2 of the License, or (at your option) any later version.
  12. * ============================================================================
  13. * Apr 03, 2001  Nenad Corbic  o Fixed the rx_skb=NULL bug in x25 in rx_intr().
  14. * Dec 26, 2000  Nenad Corbic  o Added a new polling routine, that uses
  15. *                                  a kernel timer (more efficient).
  16. * Dec 25, 2000  Nenad Corbic  o Updated for 2.4.X kernel
  17. * Jul 26, 2000  Nenad Corbic  o Increased the local packet buffering
  18. *     for API to 4096+header_size. 
  19. * Jul 17, 2000  Nenad Corbic  o Fixed the x25 startup bug. Enable 
  20. *     communications only after all interfaces
  21. *     come up.  HIGH SVC/PVC is used to calculate
  22. *     the number of channels.
  23. *                                  Enable protocol only after all interfaces
  24. *                                  are enabled.
  25. * Jul 10, 2000 Nenad Corbic  o Fixed the M_BIT bug. 
  26. * Apr 25, 2000  Nenad Corbic  o Pass Modem messages to the API.
  27. *                                  Disable idle timeout in X25 API.
  28. * Apr 14, 2000  Nenad Corbic  o Fixed: Large LCN number support.
  29. *                                  Maximum LCN number is 4095.
  30. *                                  Maximum number of X25 channels is 255.
  31. * Apr 06, 2000  Nenad Corbic  o Added SMP Support.
  32. * Mar 29, 2000  Nenad Corbic  o Added support for S514 PCI Card
  33. * Mar 23, 2000  Nenad Corbic  o Improved task queue, BH handling.
  34. * Mar 14, 2000  Nenad Corbic    o Updated Protocol Violation handling
  35. *                                  routines.  Bug Fix.
  36. * Mar 10, 2000  Nenad Corbic  o Bug Fix: corrupted mbox recovery.
  37. * Mar 09, 2000  Nenad Corbic     o Fixed the auto HDLC bug.
  38. * Mar 08, 2000 Nenad Corbic     o Fixed LAPB HDLC startup problems.
  39. *                                  Application must bring the link up 
  40. *                                  before tx/rx, and bring the 
  41. *                                  link down on close().
  42. * Mar 06, 2000 Nenad Corbic  o Added an option for logging call setup 
  43. *                                  information. 
  44. * Feb 29, 2000  Nenad Corbic   o Added support for LAPB HDLC API
  45. * Feb 25, 2000  Nenad Corbic     o Fixed the modem failure handling.
  46. *                                  No Modem OOB message will be passed 
  47. *                                  to the user.
  48. * Feb 21, 2000  Nenad Corbic   o Added Xpipemon Debug Support
  49. * Dec 30, 1999  Nenad Corbic  o Socket based X25API 
  50. * Sep 17, 1998 Jaspreet Singh  o Updates for 2.2.X  kernel
  51. * Mar 15, 1998 Alan Cox  o 2.1.x porting
  52. * Dec 19, 1997 Jaspreet Singh  o Added multi-channel IPX support
  53. * Nov 27, 1997 Jaspreet Singh  o Added protection against enabling of irqs
  54. *    when they are disabled.
  55. * Nov 17, 1997  Farhan Thawar    o Added IPX support
  56. *  o Changed if_send() to now buffer packets when
  57. *    the board is busy
  58. *  o Removed queueing of packets via the polling
  59. *    routing
  60. *  o Changed if_send() critical flags to properly
  61. *    handle race conditions
  62. * Nov 06, 1997  Farhan Thawar    o Added support for SVC timeouts
  63. *  o Changed PVC encapsulation to ETH_P_IP
  64. * Jul 21, 1997  Jaspreet Singh  o Fixed freeing up of buffers using kfree()
  65. *    when packets are received.
  66. * Mar 11, 1997  Farhan Thawar   Version 3.1.1
  67. *                                o added support for V35
  68. *                                o changed if_send() to return 0 if
  69. *                                  wandev.critical() is true
  70. *                                o free socket buffer in if_send() if
  71. *                                  returning 0
  72. *                                o added support for single '@' address to
  73. *                                  accept all incoming calls
  74. *                                o fixed bug in set_chan_state() to disconnect
  75. * Jan 15, 1997 Gene Kozin Version 3.1.0
  76. *  o implemented exec() entry point
  77. * Jan 07, 1997 Gene Kozin Initial version.
  78. *****************************************************************************/
  80. /*======================================================
  81.  *  Includes 
  82.  *=====================================================*/
  84. #include <linux/module.h>
  85. #include <linux/version.h>
  86. #include <linux/kernel.h> /* printk(), and other useful stuff */
  87. #include <linux/stddef.h> /* offsetof(), etc. */
  88. #include <linux/errno.h> /* return codes */
  89. #include <linux/string.h> /* inline memset(), etc. */
  90. #include <linux/ctype.h>
  91. #include <linux/slab.h> /* kmalloc(), kfree() */
  92. #include <linux/wanrouter.h> /* WAN router definitions */
  93. #include <linux/wanpipe.h> /* WANPIPE common user API definitions */
  94. #include <asm/byteorder.h> /* htons(), etc. */
  95. #include <asm/atomic.h>
  96. #include <linux/delay.h> /* Experimental delay */
  98. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  99.  #include <asm/uaccess.h>
  100. #else
  101.  #include <asm/segment.h>
  102.  #include <net/route.h>
  103. #endif
  105. #include <linux/if.h>
  106. #include <linux/if_arp.h>
  107. #include <linux/sdla_x25.h> /* X.25 firmware API definitions */
  108. #include <linux/if_wanpipe_common.h>
  109. #include <linux/if_wanpipe.h>
  112. /*======================================================
  113.  *  Defines & Macros 
  114.  *=====================================================*/
  117. #define CMD_OK 0 /* normal firmware return code */
  118. #define CMD_TIMEOUT 0xFF /* firmware command timed out */
  119. #define MAX_CMD_RETRY 10 /* max number of firmware retries */
  121. #define X25_CHAN_MTU 4096 /* unfragmented logical channel MTU */
  122. #define X25_HRDHDR_SZ 7 /* max encapsulation header size */
  123. #define X25_CONCT_TMOUT (90*HZ) /* link connection timeout */
  124. #define X25_RECON_TMOUT (10*HZ) /* link connection timeout */
  125. #define CONNECT_TIMEOUT (90*HZ) /* link connection timeout */
  126. #define HOLD_DOWN_TIME (30*HZ) /* link hold down time */
  127. #define MAX_BH_BUFF 10
  128. #define M_BIT 0x01
  130. //#define PRINT_DEBUG 1
  131. #ifdef PRINT_DEBUG
  132. #define DBG_PRINTK(format, a...) printk(format, ## a)
  133. #else
  134. #define DBG_PRINTK(format, a...)
  135. #endif  
  137. #define TMR_INT_ENABLED_POLL_ACTIVE      0x01
  138. #define TMR_INT_ENABLED_POLL_CONNECT_ON  0x02
  139. #define TMR_INT_ENABLED_POLL_CONNECT_OFF 0x04
  140. #define TMR_INT_ENABLED_POLL_DISCONNECT  0x08
  141. #define TMR_INT_ENABLED_CMD_EXEC  0x10
  142. #define TMR_INT_ENABLED_UPDATE  0x20
  143. #define TMR_INT_ENABLED_UDP_PKT  0x40
  145. #define MAX_X25_ADDR_SIZE 16
  146. #define MAX_X25_DATA_SIZE  129
  147. #define MAX_X25_FACL_SIZE 110
  149. #define TRY_CMD_AGAIN 2
  150. #define DELAY_RESULT    1
  151. #define RETURN_RESULT   0
  153. #define DCD(x) (x & 0x03 ? "HIGH" : "LOW")
  154. #define CTS(x) (x & 0x05 ? "HIGH" : "LOW")
  157. /* Driver will not write log messages about 
  158.  * modem status if defined.*/
  159. #define MODEM_NOT_LOG 1
  161. /*==================================================== 
  162.  *  For IPXWAN 
  163.  *===================================================*/
  165. #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
  168. /*====================================================
  169.  *           MEMORY DEBUGGING FUNCTION
  170.  *====================================================
  172. #define KMEM_SAFETYZONE 8
  174. static void * dbg_kmalloc(unsigned int size, int prio, int line) {
  175. int i = 0;
  176. void * v = kmalloc(size+sizeof(unsigned int)+2*KMEM_SAFETYZONE*8,prio);
  177. char * c1 = v;
  178. c1 += sizeof(unsigned int);
  179. *((unsigned int *)v) = size;
  181. for (i = 0; i < KMEM_SAFETYZONE; i++) {
  182. c1[0] = 'D'; c1[1] = 'E'; c1[2] = 'A'; c1[3] = 'D';
  183. c1[4] = 'B'; c1[5] = 'E'; c1[6] = 'E'; c1[7] = 'F';
  184. c1 += 8;
  185. }
  186. c1 += size;
  187. for (i = 0; i < KMEM_SAFETYZONE; i++) {
  188. c1[0] = 'M'; c1[1] = 'U'; c1[2] = 'N'; c1[3] = 'G';
  189. c1[4] = 'W'; c1[5] = 'A'; c1[6] = 'L'; c1[7] = 'L';
  190. c1 += 8;
  191. }
  192. v = ((char *)v) + sizeof(unsigned int) + KMEM_SAFETYZONE*8;
  193. printk(KERN_INFO "line %d  kmalloc(%d,%d) = %pn",line,size,prio,v);
  194. return v;
  195. }
  196. static void dbg_kfree(void * v, int line) {
  197. unsigned int * sp = (unsigned int *)(((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8));
  198. unsigned int size = *sp;
  199. char * c1 = ((char *)v) - KMEM_SAFETYZONE*8;
  200. int i = 0;
  201. for (i = 0; i < KMEM_SAFETYZONE; i++) {
  202. if (   c1[0] != 'D' || c1[1] != 'E' || c1[2] != 'A' || c1[3] != 'D'
  203.     || c1[4] != 'B' || c1[5] != 'E' || c1[6] != 'E' || c1[7] != 'F') {
  204. printk(KERN_INFO "kmalloced block at %p has been corrupted (underrun)!n",v);
  205. printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2xn", i*8,
  206.                 c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
  207. }
  208. c1 += 8;
  209. }
  210. c1 += size;
  211. for (i = 0; i < KMEM_SAFETYZONE; i++) {
  212. if (   c1[0] != 'M' || c1[1] != 'U' || c1[2] != 'N' || c1[3] != 'G'
  213.     || c1[4] != 'W' || c1[5] != 'A' || c1[6] != 'L' || c1[7] != 'L'
  214.    ) {
  215. printk(KERN_INFO "kmalloced block at %p has been corrupted (overrun):n",v);
  216. printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2xn", i*8,
  217.                 c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
  218. }
  219. c1 += 8;
  220. }
  221. printk(KERN_INFO "line %d  kfree(%p)n",line,v);
  222. v = ((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8);
  223. kfree(v);
  224. }
  226. #define kmalloc(x,y) dbg_kmalloc(x,y,__LINE__)
  227. #define kfree(x) dbg_kfree(x,__LINE__)
  229. ==============================================================*/
  233. /*===============================================
  234.  *  Data Structures 
  235.  *===============================================*/
  238. /*========================================================
  239.  * Name:  x25_channel
  240.  *
  241.  * Purpose: To hold private informaton for each  
  242.  *              logical channel.
  243.  *
  244.  * Rationale:   Per-channel debugging is possible if each 
  245.  *              channel has its own private area.
  246.  *
  247.  * Assumptions:
  248.  *
  249.  * Description: This is an extention of the 'netdevice_t' 
  250.  *              we create for each network interface to keep 
  251.  *              the rest of X.25 channel-specific data. 
  252.  *
  253.  * Construct: Typedef
  254.  */
  255. typedef struct x25_channel
  256. {
  257. wanpipe_common_t common; /* common area for x25api and socket */
  258. char name[WAN_IFNAME_SZ+1]; /* interface name, ASCIIZ */
  259. char addr[WAN_ADDRESS_SZ+1]; /* media address, ASCIIZ */
  260. unsigned tx_pkt_size;
  261. unsigned short protocol; /* ethertype, 0 - multiplexed */
  262. char drop_sequence; /* mark sequence for dropping */
  263. unsigned long state_tick; /* time of the last state change */
  264. unsigned idle_timeout; /* sec, before disconnecting */
  265. unsigned long i_timeout_sofar;  /* # of sec's we've been idle */
  266. unsigned hold_timeout; /* sec, before re-connecting */
  267. unsigned long tick_counter; /* counter for transmit time out */
  268. char devtint; /* Weather we should dev_tint() */
  269. struct sk_buff* rx_skb; /* receive socket buffer */
  270. struct sk_buff* tx_skb; /* transmit socket buffer */
  272. bh_data_t *bh_head;      /* Circular buffer for x25api_bh */
  273. unsigned long  tq_working;
  274. volatile int  bh_write;
  275. volatile int  bh_read;
  276. atomic_t  bh_buff_used;
  278. sdla_t* card; /* -> owner */
  279. netdevice_t *dev; /* -> bound devce */
  281. int ch_idx;
  282. unsigned char enable_IPX;
  283. unsigned long network_number;
  284. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  285. struct net_device_stats ifstats; /* interface statistics */
  286. #else
  287. struct enet_statistics ifstats;
  288. #endif
  289. unsigned short transmit_length;
  290. unsigned short tx_offset;
  291. char transmit_buffer[X25_CHAN_MTU+sizeof(x25api_hdr_t)];
  293. if_send_stat_t   if_send_stat;
  294.         rx_intr_stat_t   rx_intr_stat;
  295.         pipe_mgmt_stat_t pipe_mgmt_stat;    
  297. unsigned long router_start_time; /* Router start time in seconds */
  298. unsigned long router_up_time;
  300. } x25_channel_t;
  302. /* FIXME Take this out */
  304. #ifdef NEX_OLD_CALL_INFO
  305. typedef struct x25_call_info
  306. {
  307. char dest[17]; PACKED;/* ASCIIZ destination address */
  308. char src[17]; PACKED;/* ASCIIZ source address */
  309. char nuser; PACKED;/* number of user data bytes */
  310. unsigned char user[127]; PACKED;/* user data */
  311. char nfacil; PACKED;/* number of facilities */
  312. struct
  313. {
  314. unsigned char code;     PACKED;
  315. unsigned char parm;     PACKED;
  316. } facil[64];         /* facilities */
  317. } x25_call_info_t;
  318. #else
  319. typedef struct x25_call_info
  320. {
  321. char dest[MAX_X25_ADDR_SIZE] PACKED;/* ASCIIZ destination address */
  322. char src[MAX_X25_ADDR_SIZE] PACKED;/* ASCIIZ source address */
  323. unsigned char nuser PACKED;
  324. unsigned char user[MAX_X25_DATA_SIZE] PACKED;/* user data */
  325. unsigned char nfacil PACKED;
  326. unsigned char facil[MAX_X25_FACL_SIZE] PACKED;
  327. unsigned short lcn              PACKED;
  328. } x25_call_info_t;
  329. #endif
  332.   
  333. /*===============================================
  334.  * Private Function Prototypes
  335.  *==============================================*/
  338. /*================================================= 
  339.  * WAN link driver entry points. These are 
  340.  * called by the WAN router module.
  341.  */
  342. static int update (wan_device_t* wandev);
  343. static int new_if (wan_device_t* wandev, netdevice_t* dev,
  344. wanif_conf_t* conf);
  345. static int del_if (wan_device_t* wandev, netdevice_t* dev);
  346. static void disable_comm (sdla_t* card);
  347. static void disable_comm_shutdown(sdla_t *card);
  351. /*================================================= 
  352.  * WANPIPE-specific entry points 
  353.  */
  354. static int wpx_exec (struct sdla* card, void* u_cmd, void* u_data);
  355. static void x25api_bh (netdevice_t *);
  356. static int x25api_bh_cleanup (netdevice_t *);
  357. static int bh_enqueue (netdevice_t *, struct sk_buff *);
  360. /*=================================================  
  361.  *  Network device interface 
  362.  */
  363. static int if_init   (netdevice_t* dev);
  364. static int if_open   (netdevice_t* dev);
  365. static int if_close  (netdevice_t* dev);
  366. static int if_header (struct sk_buff* skb, netdevice_t* dev,
  367. unsigned short type, void* daddr, void* saddr, unsigned len);
  368. static int if_rebuild_hdr (struct sk_buff* skb);
  369. static int if_send (struct sk_buff* skb, netdevice_t* dev);
  370. static struct net_device_stats *if_stats (netdevice_t* dev);
  372. #ifdef LINUX_2_4
  373. static void if_tx_timeout (netdevice_t *dev);
  374. #endif
  376. /*=================================================  
  377.  *  Interrupt handlers 
  378.  */
  379. static void wpx_isr (sdla_t *);
  380. static void rx_intr (sdla_t *);
  381. static void tx_intr (sdla_t *);
  382. static void status_intr (sdla_t *);
  383. static void event_intr (sdla_t *);
  384. static void spur_intr (sdla_t *);
  385. static void timer_intr  (sdla_t *);
  387. static int tx_intr_send(sdla_t *, netdevice_t *);
  388. static netdevice_t * move_dev_to_next (sdla_t *, netdevice_t *);
  390. /*=================================================  
  391.  * Background polling routines 
  392.  */
  393. static void wpx_poll (sdla_t* card);
  394. static void poll_disconnected (sdla_t* card);
  395. static void poll_connecting (sdla_t* card);
  396. static void poll_active (sdla_t* card);
  397. static void trigger_x25_poll(sdla_t *card);
  398. static void x25_timer_routine(unsigned long data);
  402. /*=================================================  
  403.  * X.25 firmware interface functions 
  404.  */
  405. static int x25_get_version (sdla_t* card, char* str);
  406. static int x25_configure (sdla_t* card, TX25Config* conf);
  407. static int hdlc_configure (sdla_t* card, TX25Config* conf);
  408. static int set_hdlc_level (sdla_t* card);
  409. static int x25_get_err_stats (sdla_t* card);
  410. static int x25_get_stats (sdla_t* card);
  411. static int x25_set_intr_mode (sdla_t* card, int mode);
  412. static int x25_close_hdlc (sdla_t* card);
  413. static int x25_open_hdlc (sdla_t* card);
  414. static int x25_setup_hdlc (sdla_t* card);
  415. static int x25_set_dtr (sdla_t* card, int dtr);
  416. static int x25_get_chan_conf (sdla_t* card, x25_channel_t* chan);
  417. static int x25_place_call (sdla_t* card, x25_channel_t* chan);
  418. static int x25_accept_call (sdla_t* card, int lcn, int qdm);
  419. static int x25_clear_call (sdla_t* card, int lcn, int cause, int diagn);
  420. static int x25_send (sdla_t* card, int lcn, int qdm, int len, void* buf);
  421. static int x25_fetch_events (sdla_t* card);
  422. static int x25_error (sdla_t* card, int err, int cmd, int lcn);
  424. /*=================================================  
  425.  * X.25 asynchronous event handlers 
  426.  */
  427. static int incoming_call (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
  428. static int call_accepted (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
  429. static int call_cleared (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
  430. static int timeout_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
  431. static int restart_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
  434. /*=================================================  
  435.  * Miscellaneous functions 
  436.  */
  437. static int connect (sdla_t* card);
  438. static int disconnect (sdla_t* card);
  439. static netdevice_t* get_dev_by_lcn(wan_device_t* wandev, unsigned lcn);
  440. static int chan_connect (netdevice_t* dev);
  441. static int chan_disc (netdevice_t* dev);
  442. static void set_chan_state (netdevice_t* dev, int state);
  443. static int chan_send (netdevice_t* , void* , unsigned, unsigned char);
  444. static unsigned char bps_to_speed_code (unsigned long bps);
  445. static unsigned int dec_to_uint (unsigned char* str, int len);
  446. static unsigned int hex_to_uint (unsigned char*, int);
  447. static void parse_call_info (unsigned char*, x25_call_info_t*);
  448. static netdevice_t * find_channel(sdla_t *, unsigned);
  449. static void bind_lcn_to_dev (sdla_t *, netdevice_t *,unsigned);
  450. static void setup_for_delayed_transmit (netdevice_t*, void*, unsigned);
  453. /*=================================================  
  454.  *      X25 API Functions 
  455.  */
  456. static int wanpipe_pull_data_in_skb (sdla_t *, netdevice_t *, struct sk_buff **);
  457. static void timer_intr_exec(sdla_t *, unsigned char);
  458. static int execute_delayed_cmd (sdla_t*, netdevice_t *, mbox_cmd_t *,char);
  459. static int api_incoming_call (sdla_t*, TX25Mbox *, int);
  460. static int alloc_and_init_skb_buf (sdla_t *,struct sk_buff **, int);
  461. static void send_delayed_cmd_result(sdla_t *, netdevice_t *dev, TX25Mbox*);
  462. static int clear_confirm_event (sdla_t *, TX25Mbox*);
  463. static void send_oob_msg (sdla_t *, netdevice_t *, TX25Mbox *);
  464. static int timer_intr_cmd_exec(sdla_t *card);
  465. static void api_oob_event (sdla_t *card,TX25Mbox *mbox);
  466. static int check_bad_command (sdla_t *, netdevice_t *);
  467. static int channel_disconnect (sdla_t*, netdevice_t *);
  468. static void hdlc_link_down (sdla_t*);
  470. /*=================================================
  471.  *     XPIPEMON Functions
  472.  */
  473. static int process_udp_mgmt_pkt(sdla_t *);
  474. static int udp_pkt_type( struct sk_buff *, sdla_t*);
  475. static int reply_udp( unsigned char *, unsigned int); 
  476. static void init_x25_channel_struct( x25_channel_t *);
  477. static void init_global_statistics( sdla_t *);
  478. static int store_udp_mgmt_pkt(int, char, sdla_t*, netdevice_t *, struct sk_buff *, int);
  479. static unsigned short calc_checksum (char *, int);
  483. /*================================================= 
  484.  * IPX functions 
  485.  */
  486. static void switch_net_numbers(unsigned char *, unsigned long, unsigned char);
  487. static int handle_IPXWAN(unsigned char *, char *, unsigned char , 
  488.  unsigned long , unsigned short );
  490. extern void disable_irq(unsigned int);
  491. extern void enable_irq(unsigned int);
  493. static void S508_S514_lock(sdla_t *, unsigned long *);
  494. static void S508_S514_unlock(sdla_t *, unsigned long *);
  497. /*=================================================  
  498.  *  Global Variables 
  499.  *=================================================*/
  503. /*================================================= 
  504.  * Public Functions 
  505.  *=================================================*/
  510. /*===================================================================
  511.  * wpx_init: X.25 Protocol Initialization routine.
  512.  *
  513.  * Purpose: To initialize the protocol/firmware.
  514.  * 
  515.  * Rationale: This function is called by setup() function, in
  516.  *              sdlamain.c, to dynamically setup the x25 protocol.
  517.  * This is the first protocol specific function, which
  518.  *              executes once on startup.
  519.  *                
  520.  * Description: This procedure initializes the x25 firmware and
  521.  *     sets up the mailbox, transmit and receive buffer
  522.  *              pointers. It also initializes all debugging structures
  523.  *              and sets up the X25 environment.
  524.  *
  525.  * Sets up hardware options defined by user in [wanpipe#] 
  526.  * section of wanpipe#.conf configuration file. 
  527.  *
  528.  *  At this point adapter is completely initialized 
  529.  *       and X.25 firmware is running.
  530.  *   o read firmware version (to make sure it's alive)
  531.  *   o configure adapter
  532.  *   o initialize protocol-specific fields of the 
  533.  *                adapter data space.
  534.  *
  535.  * Called by: setup() function in sdlamain.c
  536.  *
  537.  * Assumptions: None
  538.  *
  539.  * Warnings: None
  540.  *
  541.  * Return:  0 o.k.
  542.  *   < 0 failure.
  543.  */
  545. int wpx_init (sdla_t* card, wandev_conf_t* conf)
  546. {
  547. union{
  548. char str[80];
  549. TX25Config cfg;
  550. } u;
  552. /* Verify configuration ID */
  553. if (conf->config_id != WANCONFIG_X25){
  554. printk(KERN_INFO "%s: invalid configuration ID %u!n",
  555. card->devname, conf->config_id)
  556. ;
  557. return -EINVAL;
  558. }
  560. /* Initialize protocol-specific fields */
  561. card->mbox  = (void*)(card->hw.dpmbase + X25_MBOX_OFFS);
  562. card->rxmb  = (void*)(card->hw.dpmbase + X25_RXMBOX_OFFS);
  563. card->flags = (void*)(card->hw.dpmbase + X25_STATUS_OFFS);
  565. /* Initialize for S514 Card */
  566. if(card->hw.type == SDLA_S514) {
  567. card->mbox += X25_MB_VECTOR;
  568. card->flags += X25_MB_VECTOR;
  569. card->rxmb += X25_MB_VECTOR;
  570. }
  573. /* Read firmware version.  Note that when adapter initializes, it
  574.  * clears the mailbox, so it may appear that the first command was
  575.  * executed successfully when in fact it was merely erased. To work
  576.  * around this, we execute the first command twice.
  577.  */
  578. if (x25_get_version(card, NULL) || x25_get_version(card, u.str))
  579. return -EIO;
  582. /* X25 firmware can run ether in X25 or LAPB HDLC mode.
  583.          * Check the user defined option and configure accordingly */
  584. if (conf->u.x25.LAPB_hdlc_only == WANOPT_YES){
  585. if (set_hdlc_level(card) != CMD_OK){
  586. return -EIO;
  587. }else{
  588. printk(KERN_INFO "%s: running LAP_B HDLC firmware v%sn",
  589. card->devname, u.str);
  590. }
  591. card->u.x.LAPB_hdlc = 1;
  592. }else{
  593. printk(KERN_INFO "%s: running X.25 firmware v%sn",
  594. card->devname, u.str);
  595. card->u.x.LAPB_hdlc = 0;
  596. }
  598. /* Configure adapter. Here we set resonable defaults, then parse
  599.  * device configuration structure and set configuration options.
  600.  * Most configuration options are verified and corrected (if
  601.  * necessary) since we can't rely on the adapter to do so.
  602.  */
  603. memset(&u.cfg, 0, sizeof(u.cfg));
  604. u.cfg.t1 = 3;
  605. u.cfg.n2 = 10;
  606. u.cfg.autoHdlc = 1; /* automatic HDLC connection */
  607. u.cfg.hdlcWindow = 7;
  608. u.cfg.pktWindow = 2;
  609. u.cfg.station = 1; /* DTE */
  610. u.cfg.options = 0x0090; /* disable D-bit pragmatics */
  611. u.cfg.ccittCompat = 1988;
  612. u.cfg.t10t20 = 30;
  613. u.cfg.t11t21 = 30;
  614. u.cfg.t12t22 = 30;
  615. u.cfg.t13t23 = 30;
  616. u.cfg.t16t26 = 30;
  617. u.cfg.t28 = 30;
  618. u.cfg.r10r20 = 5;
  619. u.cfg.r12r22 = 5;
  620. u.cfg.r13r23 = 5;
  621. u.cfg.responseOpt = 1; /* RR's after every packet */
  623. if (card->u.x.LAPB_hdlc){
  624. u.cfg.hdlcMTU = 1027;
  625. }
  627. if (conf->u.x25.x25_conf_opt){
  628. u.cfg.options = conf->u.x25.x25_conf_opt;
  629. }
  631. if (conf->clocking != WANOPT_EXTERNAL)
  632. u.cfg.baudRate = bps_to_speed_code(conf->bps);
  634. if (conf->station != WANOPT_DTE){
  635. u.cfg.station = 0; /* DCE mode */
  636. }
  638.         if (conf->interface != WANOPT_RS232 ){
  639.         u.cfg.hdlcOptions |= 0x80;      /* V35 mode */
  640. } 
  642. /* adjust MTU */
  643. if (!conf->mtu || (conf->mtu >= 1024))
  644. card->wandev.mtu = 1024;
  645. else if (conf->mtu >= 512)
  646. card->wandev.mtu = 512;
  647. else if (conf->mtu >= 256)
  648. card->wandev.mtu = 256;
  649. else if (conf->mtu >= 128)
  650. card->wandev.mtu = 128;
  651. else 
  652. card->wandev.mtu = 64;
  654. u.cfg.defPktSize = u.cfg.pktMTU = card->wandev.mtu;
  656. if (conf->u.x25.hi_pvc){
  657. card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, MAX_LCN_NUM);
  658. card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
  659. }
  661. if (conf->u.x25.hi_svc){
  662. card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, MAX_LCN_NUM);
  663. card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
  664. }
  666. /* Figure out the total number of channels to configure */
  667. card->u.x.num_of_ch = 0;
  668. if (card->u.x.hi_svc != 0){
  669. card->u.x.num_of_ch = (card->u.x.hi_svc - card->u.x.lo_svc) + 1;
  670. }
  671. if (card->u.x.hi_pvc != 0){
  672. card->u.x.num_of_ch += (card->u.x.hi_pvc - card->u.x.lo_pvc) + 1;
  673. }
  675. if (card->u.x.num_of_ch == 0){
  676. printk(KERN_INFO "%s: ERROR, Minimum number of PVC/SVC channels is 1 !n"
  677.  "%s: Please set the Lowest/Highest PVC/SVC values !n",
  678.  card->devname,card->devname);
  679. return -ECHRNG;
  680. }
  682. u.cfg.loPVC = card->u.x.lo_pvc;
  683. u.cfg.hiPVC = card->u.x.hi_pvc;
  684. u.cfg.loTwoWaySVC = card->u.x.lo_svc;
  685. u.cfg.hiTwoWaySVC = card->u.x.hi_svc;
  687. if (conf->u.x25.hdlc_window)
  688. u.cfg.hdlcWindow = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
  689. if (conf->u.x25.pkt_window)
  690. u.cfg.pktWindow = min_t(unsigned int, conf->u.x25.pkt_window, 7);
  692. if (conf->u.x25.t1)
  693. u.cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
  694. if (conf->u.x25.t2)
  695. u.cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 29);
  696. if (conf->u.x25.t4)
  697. u.cfg.t4 = min_t(unsigned int, conf->u.x25.t4, 240);
  698. if (conf->u.x25.n2)
  699. u.cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
  701. if (conf->u.x25.t10_t20)
  702. u.cfg.t10t20 = min_t(unsigned int, conf->u.x25.t10_t20,255);
  703. if (conf->u.x25.t11_t21)
  704. u.cfg.t11t21 = min_t(unsigned int, conf->u.x25.t11_t21,255);
  705. if (conf->u.x25.t12_t22)
  706. u.cfg.t12t22 = min_t(unsigned int, conf->u.x25.t12_t22,255);
  707. if (conf->u.x25.t13_t23)
  708. u.cfg.t13t23 = min_t(unsigned int, conf->u.x25.t13_t23,255);
  709. if (conf->u.x25.t16_t26)
  710. u.cfg.t16t26 = min_t(unsigned int, conf->u.x25.t16_t26, 255);
  711. if (conf->u.x25.t28)
  712. u.cfg.t28 = min_t(unsigned int, conf->u.x25.t28, 255);
  714. if (conf->u.x25.r10_r20)
  715. u.cfg.r10r20 = min_t(unsigned int, conf->u.x25.r10_r20,250);
  716. if (conf->u.x25.r12_r22)
  717. u.cfg.r12r22 = min_t(unsigned int, conf->u.x25.r12_r22,250);
  718. if (conf->u.x25.r13_r23)
  719. u.cfg.r13r23 = min_t(unsigned int, conf->u.x25.r13_r23,250);
  722. if (conf->u.x25.ccitt_compat)
  723. u.cfg.ccittCompat = conf->u.x25.ccitt_compat;
  725. /* initialize adapter */
  726. if (card->u.x.LAPB_hdlc){
  727. if (hdlc_configure(card, &u.cfg) != CMD_OK)
  728. return -EIO;
  729. }else{
  730. if (x25_configure(card, &u.cfg) != CMD_OK)
  731. return -EIO;
  732. }
  734. if ((x25_close_hdlc(card) != CMD_OK) || /* close HDLC link */
  735.     (x25_set_dtr(card, 0) != CMD_OK)) /* drop DTR */
  736. return -EIO;
  738. /* Initialize protocol-specific fields of adapter data space */
  739. card->wandev.bps = conf->bps;
  740. card->wandev.interface = conf->interface;
  741. card->wandev.clocking = conf->clocking;
  742. card->wandev.station = conf->station;
  743. card->isr = &wpx_isr;
  744. card->poll = NULL; //&wpx_poll;
  745. card->disable_comm = &disable_comm;
  746. card->exec = &wpx_exec;
  747. card->wandev.update = &update;
  748. card->wandev.new_if = &new_if;
  749. card->wandev.del_if = &del_if;
  751. /* WARNING: This function cannot exit with an error
  752.  *          after the change of state */
  753. card->wandev.state = WAN_DISCONNECTED;
  755. card->wandev.enable_tx_int = 0;
  756. card->irq_dis_if_send_count = 0;
  757.         card->irq_dis_poll_count = 0;
  758. card->u.x.tx_dev = NULL;
  759. card->u.x.no_dev = 0;
  762. /* Configure for S514 PCI Card */
  763. if (card->hw.type == SDLA_S514) {
  764. card->u.x.hdlc_buf_status = 
  765. (volatile unsigned char *)
  766. (card->hw.dpmbase + X25_MB_VECTOR+ X25_MISC_HDLC_BITS);
  767. }else{
  768. card->u.x.hdlc_buf_status = 
  769. (volatile unsigned char *)(card->hw.dpmbase + X25_MISC_HDLC_BITS); 
  770. }
  772. card->u.x.poll_device=NULL;
  773. card->wandev.udp_port = conf->udp_port;
  775. /* Enable or disable call setup logging */
  776. if (conf->u.x25.logging == WANOPT_YES){
  777. printk(KERN_INFO "%s: Enabling Call Logging.n",
  778. card->devname);
  779. card->u.x.logging = 1;
  780. }else{
  781. card->u.x.logging = 0;
  782. }
  784. /* Enable or disable modem status reporting */
  785. if (conf->u.x25.oob_on_modem == WANOPT_YES){
  786. printk(KERN_INFO "%s: Enabling OOB on Modem change.n",
  787. card->devname);
  788. card->u.x.oob_on_modem = 1;
  789. }else{
  790. card->u.x.oob_on_modem = 0;
  791. }
  793. init_global_statistics(card);
  795. #ifndef LINUX_2_4
  796. card->u.x.x25_poll_task.next = NULL;
  797. #endif
  798. card->u.x.x25_poll_task.sync=0;
  799. card->u.x.x25_poll_task.routine = (void*)(void*)wpx_poll;
  800. card->u.x.x25_poll_task.data = card;
  802. init_timer(&card->u.x.x25_timer);
  803. card->u.x.x25_timer.data = (unsigned long)card;
  804. card->u.x.x25_timer.function = x25_timer_routine;
  806. return 0;
  807. }
  809. /*=========================================================
  810.  * WAN Device Driver Entry Points 
  811.  *========================================================*/
  813. /*============================================================
  814.  * Name: update(),  Update device status & statistics.
  815.  *
  816.  * Purpose: To provide debugging and statitical
  817.  *              information to the /proc file system.
  818.  *              /proc/net/wanrouter/wanpipe#
  819.  *              
  820.  * Rationale: The /proc file system is used to collect
  821.  *              information about the kernel and drivers.
  822.  *              Using the /proc file system the user
  823.  *              can see exactly what the sangoma drivers are
  824.  *              doing. And in what state they are in. 
  825.  *                
  826.  * Description: Collect all driver statistical information
  827.  *              and pass it to the top laywer. 
  828.  *
  829.  * Since we have to execute a debugging command, 
  830.  *              to obtain firmware statitics, we trigger a 
  831.  *              UPDATE function within the timer interrtup.
  832.  *              We wait until the timer update is complete.
  833.  *              Once complete return the appropriate return
  834.  *              code to indicate that the update was successful.
  835.  *              
  836.  * Called by: device_stat() in wanmain.c
  837.  *
  838.  * Assumptions:
  839.  *
  840.  * Warnings: This function will degrade the performance
  841.  *              of the router, since it uses the mailbox. 
  842.  *
  843.  * Return:  0  OK
  844.  *  <0 Failed (or busy).
  845.  */
  847. static int update (wan_device_t* wandev)
  848. {
  849. volatile sdla_t* card;
  850. TX25Status* status;
  851. unsigned long timeout;
  853. /* sanity checks */
  854. if ((wandev == NULL) || (wandev->private == NULL))
  855. return -EFAULT;
  857. if (wandev->state == WAN_UNCONFIGURED)
  858. return -ENODEV;
  860. if (test_bit(SEND_CRIT, (void*)&wandev->critical))
  861. return -EAGAIN;
  863. if (!wandev->dev)
  864. return -ENODEV;
  866. card = wandev->private;
  867. status = card->flags;
  869. card->u.x.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
  870. status->imask |= INTR_ON_TIMER;
  871. timeout = jiffies;
  873. for (;;){
  874. if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_UPDATE)){
  875. break;
  876. }
  877. if ((jiffies-timeout) > 1*HZ){
  878. card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
  879. return -EAGAIN;
  880. }
  881. }
  882. return 0;
  883. }
  886. /*===================================================================
  887.  * Name: new_if
  888.  *
  889.  * Purpose: To allocate and initialize resources for a 
  890.  *              new logical channel.  
  891.  * 
  892.  * Rationale: A new channel can be added dynamically via
  893.  *              ioctl call.
  894.  *                
  895.  * Description: Allocate a private channel structure, x25_channel_t.
  896.  * Parse the user interface options from wanpipe#.conf 
  897.  * configuration file. 
  898.  * Bind the private are into the network device private
  899.  *              area pointer (dev->priv).
  900.  * Prepare the network device structure for registration.
  901.  *
  902.  * Called by: ROUTER_IFNEW Ioctl call, from wanrouter_ioctl() 
  903.  *              (wanmain.c)
  904.  *
  905.  * Assumptions: None
  906.  *
  907.  * Warnings: None
  908.  *
  909.  * Return:  0  Ok
  910.  * <0  Failed (channel will not be created)
  911.  */
  912. static int new_if (wan_device_t* wandev, netdevice_t* dev, wanif_conf_t* conf)
  913. {
  914. sdla_t* card = wandev->private;
  915. x25_channel_t* chan;
  916. int err = 0;
  918. if ((conf->name[0] == '') || (strlen(conf->name) > WAN_IFNAME_SZ)){
  919. printk(KERN_INFO "%s: invalid interface name!n",
  920. card->devname);
  921. return -EINVAL;
  922. }
  924. if(card->wandev.new_if_cnt++ > 0 && card->u.x.LAPB_hdlc) {
  925. printk(KERN_INFO "%s: Error: Running LAPB HDLC Mode !n",
  926. card->devname);
  927. printk(KERN_INFO 
  928. "%s: Maximum number of network interfaces must be one !n",
  929. card->devname);
  930. return -EEXIST;
  931. }
  933. /* allocate and initialize private data */
  934. chan = kmalloc(sizeof(x25_channel_t), GFP_ATOMIC);
  935. if (chan == NULL){
  936. return -ENOMEM;
  937. }
  939. memset(chan, 0, sizeof(x25_channel_t));
  941. /* Bug Fix: Seg Err on PVC startup
  942.  * It must be here since bind_lcn_to_dev expects 
  943.  * it bellow */
  944. dev->priv = chan;
  946. strcpy(chan->name, conf->name);
  947. chan->card = card;
  948. chan->dev = dev;
  949. chan->common.sk = NULL;
  950. chan->common.func = NULL;
  951. chan->common.rw_bind = 0;
  952. chan->tx_skb = chan->rx_skb = NULL;
  954. /* verify media address */
  955. if (conf->addr[0] == '@'){ /* SVC */
  956. chan->common.svc = 1;
  957. strncpy(chan->addr, &conf->addr[1], WAN_ADDRESS_SZ);
  959. /* Set channel timeouts (default if not specified) */
  960. chan->idle_timeout = (conf->idle_timeout) ? 
  961. conf->idle_timeout : 90;
  962. chan->hold_timeout = (conf->hold_timeout) ? 
  963. conf->hold_timeout : 10;
  965. }else if (is_digit(conf->addr[0])){ /* PVC */
  966. int lcn = dec_to_uint(conf->addr, 0);
  968. if ((lcn >= card->u.x.lo_pvc) && (lcn <= card->u.x.hi_pvc)){
  969. bind_lcn_to_dev (card, dev, lcn);
  970. }else{
  971. printk(KERN_ERR
  972. "%s: PVC %u is out of range on interface %s!n",
  973. wandev->name, lcn, chan->name);
  974. err = -EINVAL;
  975. }
  976. }else{
  977. printk(KERN_ERR
  978. "%s: invalid media address on interface %s!n",
  979. wandev->name, chan->name);
  980. err = -EINVAL;
  981. }
  983. if(strcmp(conf->usedby, "WANPIPE") == 0){
  984.                 printk(KERN_INFO "%s: Running in WANPIPE mode %sn",
  985. wandev->name, chan->name);
  986.                 chan->common.usedby = WANPIPE;
  987. chan->protocol = htons(ETH_P_IP);
  989.         }else if(strcmp(conf->usedby, "API") == 0){
  990. chan->common.usedby = API;
  991.                 printk(KERN_INFO "%s: Running in API mode %sn",
  992. wandev->name, chan->name);
  993. chan->protocol = htons(X25_PROT);
  994. }
  997. if (err){
  998. kfree(chan);
  999. dev->priv = NULL;
  1000. return err;
  1001. }
  1003. chan->enable_IPX = conf->enable_IPX;
  1005. if (chan->enable_IPX)
  1006. chan->protocol = htons(ETH_P_IPX);
  1008. if (conf->network_number)
  1009. chan->network_number = conf->network_number;
  1010. else
  1011. chan->network_number = 0xDEADBEEF;
  1013. /* prepare network device data space for registration */
  1014. #ifdef LINUX_2_4
  1015. strcpy(dev->name,chan->name);
  1016. #else
  1017. dev->name = (char *)kmalloc(strlen(chan->name) + 2, GFP_KERNEL); 
  1018. if(dev->name == NULL)
  1019. {
  1020. kfree(chan);
  1021. dev->priv = NULL;
  1022. return -ENOMEM;
  1023. }
  1024. sprintf(dev->name, "%s", chan->name);
  1025. #endif
  1026. dev->init = &if_init;
  1028. init_x25_channel_struct(chan);
  1030. return 0;
  1031. }
  1033. /*===================================================================
  1034.  * Name: del_if(),  Remove a logical channel.  
  1035.  *
  1036.  * Purpose: To dynamically remove a logical channel.
  1037.  * 
  1038.  * Rationale: Each logical channel should be dynamically
  1039.  *              removable. This functin is called by an 
  1040.  *              IOCTL_IFDEL ioctl call or shutdown(). 
  1041.  *                
  1042.  * Description: Do nothing.
  1043.  *
  1044.  * Called by: IOCTL_IFDEL : wanrouter_ioctl() from wanmain.c
  1045.  *              shutdown() from sdlamain.c
  1046.  *
  1047.  * Assumptions: 
  1048.  *
  1049.  * Warnings:
  1050.  *
  1051.  * Return:  0 Ok. Void function.
  1052.  */
  1054. //FIXME Del IF Should be taken out now.
  1056. static int del_if (wan_device_t* wandev, netdevice_t* dev)
  1057. {
  1058. return 0;
  1059. }
  1062. /*============================================================
  1063.  * Name: wpx_exec
  1064.  *
  1065.  * Description: Execute adapter interface command.
  1066.  *  This option is currently dissabled.
  1067.  *===========================================================*/
  1069. static int wpx_exec (struct sdla* card, void* u_cmd, void* u_data)
  1070. {
  1071.         return 0;
  1072. }
  1074. /*============================================================
  1075.  * Name: disable_comm
  1076.  *
  1077.  * Description: Disable communications during shutdown.
  1078.  *              Dont check return code because there is 
  1079.  *              nothing we can do about it.  
  1080.  *
  1081.  * Warning: Dev and private areas are gone at this point.
  1082.  *===========================================================*/
  1084. static void disable_comm(sdla_t* card)
  1085. {
  1086. disable_comm_shutdown(card);
  1087. del_timer(&card->u.x.x25_timer);
  1088. return;
  1089. }
  1092. /*============================================================
  1093.  * Network Device Interface 
  1094.  *===========================================================*/
  1096. /*===================================================================
  1097.  * Name: if_init(),   Netowrk Interface Initialization   
  1098.  *
  1099.  * Purpose: To initialize a network interface device structure.
  1100.  * 
  1101.  * Rationale: During network interface startup, the if_init
  1102.  *              is called by the kernel to initialize the
  1103.  *              netowrk device structure.  Thus a driver
  1104.  *              can customze a network device. 
  1105.  *                
  1106.  * Description: Initialize the netowrk device call back
  1107.  *              routines.  This is where we tell the kernel
  1108.  *              which function to use when it wants to send
  1109.  *              via our interface. 
  1110.  * Furthermore, we initialize the device flags, 
  1111.  *              MTU and physical address of the board.
  1112.  *
  1113.  * Called by: Kernel (/usr/src/linux/net/core/dev.c)
  1114.  *  (dev->init())
  1115.  *
  1116.  * Assumptions: None
  1117.  *
  1118.  * Warnings: None
  1119.  *
  1120.  * Return:  0  Ok : Void function.
  1121.  */
  1122. static int if_init (netdevice_t* dev)
  1123. {
  1124. x25_channel_t* chan = dev->priv;
  1125. sdla_t* card = chan->card;
  1126. wan_device_t* wandev = &card->wandev;
  1127. #ifdef LINUX_2_0
  1128. int i;
  1129. #endif
  1131. /* Initialize device driver entry points */
  1132. dev->open = &if_open;
  1133. dev->stop = &if_close;
  1134. dev->hard_header = &if_header;
  1135. dev->rebuild_header = &if_rebuild_hdr;
  1136. dev->hard_start_xmit = &if_send;
  1137. dev->get_stats = &if_stats;
  1139. #ifdef LINUX_2_4
  1140. dev->tx_timeout = &if_tx_timeout;
  1141. dev->watchdog_timeo = TX_TIMEOUT;
  1142. #endif
  1144. /* Initialize media-specific parameters */
  1145. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  1146. dev->type = ARPHRD_PPP; /* ARP h/w type */
  1147. #else
  1148.         dev->family             = AF_INET;      /* address family */
  1149.         dev->type               = ARPHRD_PPP;   /* no x25 type */
  1150. #endif
  1151. dev->flags |= IFF_POINTOPOINT;
  1152. dev->flags |= IFF_NOARP;
  1154. if (chan->common.usedby == API){
  1155. dev->mtu = X25_CHAN_MTU+sizeof(x25api_hdr_t);
  1156. }else{
  1157. dev->mtu = card->wandev.mtu; 
  1158. }
  1160. dev->hard_header_len = X25_HRDHDR_SZ; /* media header length */
  1161. dev->addr_len = 2; /* hardware address length */
  1163. if (!chan->common.svc){
  1164. *(unsigned short*)dev->dev_addr = htons(chan->common.lcn);
  1165. }
  1167. /* Initialize hardware parameters (just for reference) */
  1168. dev->irq = wandev->irq;
  1169. dev->dma = wandev->dma;
  1170. dev->base_addr = wandev->ioport;
  1171. dev->mem_start = (unsigned long)wandev->maddr;
  1172. dev->mem_end = wandev->maddr + wandev->msize - 1;
  1174.         /* Set transmit buffer queue length */
  1175.         dev->tx_queue_len = 100;
  1177. /* Initialize socket buffers */
  1178. #if !defined(LINUX_2_1) && !defined(LINUX_2_4)
  1179.         for (i = 0; i < DEV_NUMBUFFS; ++i)
  1180.                 skb_queue_head_init(&dev->buffs[i]);
  1181. #endif
  1182. /* FIXME Why are we doing this */
  1183. set_chan_state(dev, WAN_DISCONNECTED);
  1184. return 0;
  1185. }
  1188. /*===================================================================
  1189.  * Name: if_open(),   Open/Bring up the Netowrk Interface 
  1190.  *
  1191.  * Purpose: To bring up a network interface.
  1192.  * 
  1193.  * Rationale:
  1194.  *                
  1195.  * Description: Open network interface.
  1196.  *  o prevent module from unloading by incrementing use count
  1197.  *  o if link is disconnected then initiate connection
  1198.  *
  1199.  * Called by: Kernel (/usr/src/linux/net/core/dev.c)
  1200.  *  (dev->open())
  1201.  *
  1202.  * Assumptions: None
  1203.  *
  1204.  * Warnings: None
  1205.  *
  1206.  * Return:  0  Ok
  1207.  *  <0  Failur: Interface will not come up.
  1208.  */
  1210. static int if_open (netdevice_t* dev)
  1211. {
  1212. x25_channel_t* chan = dev->priv;
  1213. sdla_t* card = chan->card;
  1214. struct timeval tv;
  1215. unsigned long smp_flags;
  1217. if (is_dev_running(dev))
  1218. return -EBUSY;
  1220. chan->tq_working = 0;
  1222. /* Initialize the task queue */
  1223. #ifndef LINUX_2_4
  1224. chan->common.wanpipe_task.next = NULL;
  1225. #endif
  1226. chan->common.wanpipe_task.sync = 0;
  1227. chan->common.wanpipe_task.routine = (void *)(void *)x25api_bh;
  1228. chan->common.wanpipe_task.data = dev;
  1230. /* Allocate and initialize BH circular buffer */
  1231. /* Add 1 to MAX_BH_BUFF so we don't have test with (MAX_BH_BUFF-1) */
  1232. chan->bh_head = kmalloc((sizeof(bh_data_t)*(MAX_BH_BUFF+1)),GFP_ATOMIC);
  1234. if (chan->bh_head == NULL){
  1235. printk(KERN_INFO "%s: ERROR, failed to allocate memory ! BH_BUFFERS !n",
  1236. card->devname);
  1238. return -ENOBUFS;
  1239. }
  1240. memset(chan->bh_head,0,(sizeof(bh_data_t)*(MAX_BH_BUFF+1)));
  1241. atomic_set(&chan->bh_buff_used, 0);
  1243. /* Increment the number of interfaces */
  1244. ++card->u.x.no_dev;
  1246. wanpipe_open(card);
  1248. /* LAPB protocol only uses one interface, thus
  1249.  * start the protocol after it comes up. */
  1250. if (card->u.x.LAPB_hdlc){
  1251. if (card->open_cnt == 1){
  1252. TX25Status* status = card->flags;
  1253. S508_S514_lock(card, &smp_flags);
  1254. x25_set_intr_mode(card, INTR_ON_TIMER); 
  1255. status->imask &= ~INTR_ON_TIMER;
  1256. S508_S514_unlock(card, &smp_flags);
  1257. }
  1258. }else{
  1259. /* X25 can have multiple interfaces thus, start the 
  1260.  * protocol once all interfaces are up */
  1262. //FIXME: There is a bug here. If interface is
  1263. //brought down and up, it will try to enable comm.
  1264. if (card->open_cnt == card->u.x.num_of_ch){
  1266. S508_S514_lock(card, &smp_flags);
  1267. connect(card);
  1268. S508_S514_unlock(card, &smp_flags);
  1270. del_timer(&card->u.x.x25_timer);
  1271. card->u.x.x25_timer.expires=jiffies+HZ;
  1272. add_timer(&card->u.x.x25_timer);
  1273. }
  1274. }
  1275. /* Device is not up untill the we are in connected state */
  1276. do_gettimeofday( &tv );
  1277. chan->router_start_time = tv.tv_sec;
  1279. #ifdef LINUX_2_4
  1280. netif_start_queue(dev);
  1281. #else
  1282. dev->interrupt = 0;
  1283. dev->tbusy = 0;
  1284. dev->start = 1;
  1285. #endif
  1286. return 0;
  1287. }
  1289. /*===================================================================
  1290.  * Name: if_close(),   Close/Bring down the Netowrk Interface 
  1291.  *
  1292.  * Purpose: To bring down a network interface.
  1293.  * 
  1294.  * Rationale:
  1295.  *                
  1296.  * Description: Close network interface.
  1297.  *  o decrement use module use count
  1298.  *
  1299.  * Called by: Kernel (/usr/src/linux/net/core/dev.c)
  1300.  *  (dev->close())
  1301.  * ifconfig <name> down: will trigger the kernel
  1302.  *              which will call this function.
  1303.  *
  1304.  * Assumptions: None
  1305.  *
  1306.  * Warnings: None
  1307.  *
  1308.  * Return:  0  Ok
  1309.  *  <0  Failure: Interface will not exit properly.
  1310.  */
  1311. static int if_close (netdevice_t* dev)
  1312. {
  1313. x25_channel_t* chan = dev->priv;
  1314. sdla_t* card = chan->card;
  1315. unsigned long smp_flags;
  1317. stop_net_queue(dev);
  1318. #ifndef LINUX_2_4
  1319. dev->start=0;
  1320. #endif
  1322. if ((chan->common.state == WAN_CONNECTED) || 
  1323.     (chan->common.state == WAN_CONNECTING)){
  1324. S508_S514_lock(card, &smp_flags);
  1325. chan_disc(dev);
  1326. S508_S514_unlock(card, &smp_flags);
  1327. }
  1329. wanpipe_close(card);
  1331. S508_S514_lock(card, &smp_flags);
  1332. if (chan->bh_head){
  1333. int i;
  1334. struct sk_buff *skb;
  1336. for (i=0; i<(MAX_BH_BUFF+1); i++){
  1337. skb = ((bh_data_t *)&chan->bh_head[i])->skb;
  1338. if (skb != NULL){
  1339.                  wan_dev_kfree_skb(skb, FREE_READ);
  1340. }
  1341. }
  1342. kfree(chan->bh_head);
  1343. chan->bh_head=NULL;
  1344. }
  1345. S508_S514_unlock(card, &smp_flags);
  1347. /* If this is the last close, disconnect physical link */
  1348. if (!card->open_cnt){
  1349. S508_S514_lock(card, &smp_flags);
  1350. disconnect(card);
  1351. x25_set_intr_mode(card, 0);
  1352. S508_S514_unlock(card, &smp_flags);
  1353. }
  1355. /* Decrement the number of interfaces */
  1356. --card->u.x.no_dev;
  1357. return 0;
  1358. }
  1360. /*======================================================================
  1361.  *  Build media header.
  1362.  *  o encapsulate packet according to encapsulation type.
  1363.  *
  1364.  *  The trick here is to put packet type (Ethertype) into 'protocol' 
  1365.  *      field of the socket buffer, so that we don't forget it.  
  1366.  *      If encapsulation fails, set skb->protocol to 0 and discard 
  1367.  *      packet later.
  1368.  *
  1369.  *  Return: media header length.
  1370.  *======================================================================*/
  1372. static int if_header (struct sk_buff* skb, netdevice_t* dev,
  1373. unsigned short type, void* daddr, void* saddr, unsigned len)
  1374. {
  1375. x25_channel_t* chan = dev->priv;
  1376. int hdr_len = dev->hard_header_len;
  1378. skb->protocol = htons(type);
  1379. if (!chan->protocol){
  1380. hdr_len = wanrouter_encapsulate(skb, dev, type);
  1381. if (hdr_len < 0){
  1382. hdr_len = 0;
  1383. skb->protocol = htons(0);
  1384. }
  1385. }
  1386. return hdr_len;
  1387. }
  1389. /*===============================================================
  1390.  *  Re-build media header.
  1391.  *
  1392.  *  Return: 1 physical address resolved.
  1393.  * 0 physical address not resolved
  1394.  *==============================================================*/
  1396. static int if_rebuild_hdr (struct sk_buff* skb)
  1397. {
  1398. netdevice_t *dev = skb->dev; 
  1399. x25_channel_t* chan = dev->priv;
  1400. sdla_t* card = chan->card;
  1402. printk(KERN_INFO "%s: rebuild_header() called for interface %s!n",
  1403. card->devname, dev->name);
  1404. return 1;
  1405. }
  1408. #ifdef LINUX_2_4
  1409. /*============================================================================
  1410.  * Handle transmit timeout event from netif watchdog
  1411.  */
  1412. static void if_tx_timeout (netdevice_t *dev)
  1413. {
  1414.      x25_channel_t* chan = dev->priv;
  1415. sdla_t *card = chan->card;
  1417. /* If our device stays busy for at least 5 seconds then we will
  1418.  * kick start the device by making dev->tbusy = 0.  We expect
  1419.  * that our device never stays busy more than 5 seconds. So this                 
  1420.  * is only used as a last resort.
  1421.  */
  1423. ++chan->if_send_stat.if_send_tbusy_timeout;
  1424. printk (KERN_INFO "%s: Transmit timed out on %sn", 
  1425. card->devname, dev->name);
  1426. netif_wake_queue (dev);
  1427. }
  1428. #endif
  1431. /*=========================================================================
  1432.  *  Send a packet on a network interface.
  1433.  *  o set tbusy flag (marks start of the transmission).
  1434.  *  o check link state. If link is not up, then drop the packet.
  1435.  *  o check channel status. If it's down then initiate a call.
  1436.  *  o pass a packet to corresponding WAN device.
  1437.  *  o free socket buffer
  1438.  *
  1439.  *  Return: 0 complete (socket buffer must be freed)
  1440.  * non-0 packet may be re-transmitted (tbusy must be set)
  1441.  *
  1442.  *  Notes:
  1443.  *  1. This routine is called either by the protocol stack or by the "net
  1444.  *     bottom half" (with interrupts enabled).
  1445.  *  2. Setting tbusy flag will inhibit further transmit requests from the
  1446.  *     protocol stack and can be used for flow control with protocol layer.
  1447.  *
  1448.  *========================================================================*/
  1450. static int if_send (struct sk_buff* skb, netdevice_t* dev)
  1451. {
  1452. x25_channel_t* chan = dev->priv;
  1453. sdla_t* card = chan->card;
  1454. TX25Status* status = card->flags;
  1455. int udp_type;
  1456. unsigned long smp_flags=0;
  1458. ++chan->if_send_stat.if_send_entry;
  1460. #ifdef LINUX_2_4
  1461. netif_stop_queue(dev);
  1462. #endif
  1464. /* No need to check frame length, since socket code
  1465.          * will perform the check for us */
  1467. #ifndef LINUX_2_4
  1468. if (dev->tbusy){
  1469. netdevice_t *dev2;
  1471. ++chan->if_send_stat.if_send_tbusy;
  1472. if ((jiffies - chan->tick_counter) < (5*HZ)){
  1473. return 1;
  1474. }
  1475. printk(KERN_INFO "%s: Transmit time out %s!n",
  1476. card->devname, dev->name);
  1478. for( dev2 = card->wandev.dev; dev2; 
  1479.      dev2 = *((netdevice_t**)dev2->priv)){
  1481.          dev2->tbusy = 0;
  1482. }
  1483. ++chan->if_send_stat.if_send_tbusy_timeout;
  1484. }
  1485. #endif
  1487. chan->tick_counter = jiffies;
  1489. /* Critical region starts here */
  1490. S508_S514_lock(card, &smp_flags);
  1492. if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)){
  1493. printk(KERN_INFO "Hit critical in if_send()! %lxn",card->wandev.critical);
  1494. goto if_send_crit_exit;
  1495. }
  1497. udp_type = udp_pkt_type(skb, card);
  1499.         if(udp_type != UDP_INVALID_TYPE) {
  1501.                 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, dev, skb,
  1502.                         chan->common.lcn)) {
  1504.                         status->imask |= INTR_ON_TIMER;
  1505.                         if (udp_type == UDP_XPIPE_TYPE){
  1506.                                 chan->if_send_stat.if_send_PIPE_request++;
  1507. }
  1508.                 }
  1509. start_net_queue(dev);
  1510. clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
  1511. S508_S514_unlock(card, &smp_flags);
  1512. return 0;
  1513. }
  1515. if (chan->transmit_length){
  1516. //FIXME: This check doesn't make sense any more
  1517. if (chan->common.state != WAN_CONNECTED){
  1518. chan->transmit_length=0;
  1519. atomic_set(&chan->common.driver_busy,0);
  1520. }else{
  1521. stop_net_queue(dev);
  1522. ++card->u.x.tx_interrupts_pending;
  1523.         status->imask |= INTR_ON_TX_FRAME;
  1524. clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
  1525. S508_S514_unlock(card, &smp_flags);
  1526. return 1;
  1527. }
  1528. }
  1530. if (card->wandev.state != WAN_CONNECTED){
  1531. ++chan->ifstats.tx_dropped;
  1532. ++card->wandev.stats.tx_dropped;
  1533. ++chan->if_send_stat.if_send_wan_disconnected;
  1535. }else if ( chan->protocol && (chan->protocol != skb->protocol)){
  1536. printk(KERN_INFO
  1537. "%s: unsupported Ethertype 0x%04X on interface %s!n",
  1538. chan->name, htons(skb->protocol), dev->name);
  1540. printk(KERN_INFO "PROTO %Xn", htons(chan->protocol));
  1541. ++chan->ifstats.tx_errors;
  1542. ++chan->ifstats.tx_dropped;
  1543. ++card->wandev.stats.tx_dropped;
  1544. ++chan->if_send_stat.if_send_protocol_error;
  1546. }else switch (chan->common.state){
  1548. case WAN_DISCONNECTED:
  1549. /* Try to establish connection. If succeded, then start
  1550.  * transmission, else drop a packet.
  1551.  */
  1552. if (chan->common.usedby == API){
  1553. ++chan->ifstats.tx_dropped;
  1554. ++card->wandev.stats.tx_dropped;
  1555. break;
  1556. }else{
  1557. if (chan_connect(dev) != 0){
  1558. ++chan->ifstats.tx_dropped;
  1559. ++card->wandev.stats.tx_dropped;
  1560. break;
  1561. }
  1562. }
  1563. /* fall through */
  1565. case WAN_CONNECTED:
  1566. if( skb->protocol == htons(ETH_P_IPX)) {
  1567. if(chan->enable_IPX) {
  1568. switch_net_numbers( skb->data, 
  1569. chan->network_number, 0);
  1570. } else {
  1571. ++card->wandev.stats.tx_dropped;
  1572. ++chan->ifstats.tx_dropped;
  1573. ++chan->if_send_stat.if_send_protocol_error;
  1574. goto if_send_crit_exit;
  1575. }
  1576. }
  1577. /* We never drop here, if cannot send than, copy
  1578.                  * a packet into a transmit buffer 
  1579.                          */
  1580. chan_send(dev, skb->data, skb->len, 0);
  1581. break;
  1583. default:
  1584. ++chan->ifstats.tx_dropped;
  1585. ++card->wandev.stats.tx_dropped;
  1586. break;
  1587. }
  1590. if_send_crit_exit:
  1592.         wan_dev_kfree_skb(skb, FREE_WRITE);
  1594. start_net_queue(dev);
  1595. clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
  1596. S508_S514_unlock(card, &smp_flags);
  1597. return 0;
  1598. }
  1600. /*============================================================================
  1601.  * Setup so that a frame can be transmitted on the occurence of a transmit
  1602.  * interrupt.
  1603.  *===========================================================================*/
  1605. static void setup_for_delayed_transmit (netdevice_t* dev, void* buf,
  1606. unsigned len)
  1607. {
  1608.         x25_channel_t* chan = dev->priv;
  1609.         sdla_t* card = chan->card;
  1610. TX25Status* status = card->flags;
  1612. ++chan->if_send_stat.if_send_adptr_bfrs_full;
  1614.         if(chan->transmit_length) {
  1615.                 printk(KERN_INFO "%s: Error, transmit length set in delayed transmit!n",
  1616. card->devname);
  1617.                 return;
  1618.         }
  1620. if (chan->common.usedby == API){
  1621. if (len > X25_CHAN_MTU+sizeof(x25api_hdr_t)) {
  1622. ++chan->ifstats.tx_dropped;
  1623. ++card->wandev.stats.tx_dropped;
  1624. printk(KERN_INFO "%s: Length is too big for delayed transmitn",
  1625. card->devname);
  1626. return;
  1627. }
  1628. }else{
  1629. if (len > X25_MAX_DATA) {
  1630. ++chan->ifstats.tx_dropped;
  1631. ++card->wandev.stats.tx_dropped;
  1632. printk(KERN_INFO "%s: Length is too big for delayed transmitn",
  1633. card->devname);
  1634. return;
  1635. }
  1636. }
  1638.         chan->transmit_length = len;
  1639. atomic_set(&chan->common.driver_busy,1);
  1640.         memcpy(chan->transmit_buffer, buf, len);
  1642. ++chan->if_send_stat.if_send_tx_int_enabled;
  1644. /* Enable Transmit Interrupt */
  1645. ++card->u.x.tx_interrupts_pending;
  1646.         status->imask |= INTR_ON_TX_FRAME;
  1647. }
  1650. /*===============================================================
  1651.  * net_device_stats
  1652.  *
  1653.  *  Get ethernet-style interface statistics.
  1654.  *  Return a pointer to struct enet_statistics.
  1655.  *
  1656.  *==============================================================*/
  1657. static struct net_device_stats *if_stats (netdevice_t* dev)
  1658. {
  1659. x25_channel_t *chan = dev->priv;
  1661. if(chan == NULL)
  1662. return NULL;
  1664. return &chan->ifstats;
  1665. }
  1668. /*
  1669.  * Interrupt Handlers 
  1670.  */
  1672. /*
  1673.  * X.25 Interrupt Service Routine.
  1674.  */
  1676. static void wpx_isr (sdla_t* card)
  1677. {
  1678. TX25Status* status = card->flags;
  1680. card->in_isr = 1;
  1681. ++card->statistics.isr_entry;
  1683. if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
  1684. card->in_isr=0;
  1685. status->iflags = 0;
  1686. return;
  1687. }
  1689. if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)){
  1691.   printk(KERN_INFO "%s: wpx_isr: wandev.critical set to 0x%02lx, int type = 0x%02xn", 
  1692. card->devname, card->wandev.critical, status->iflags);
  1693. card->in_isr = 0;
  1694. status->iflags = 0;
  1695. return;
  1696. }
  1698. /* For all interrupts set the critical flag to CRITICAL_RX_INTR.
  1699.          * If the if_send routine is called with this flag set it will set
  1700.          * the enable transmit flag to 1. (for a delayed interrupt)
  1701.          */
  1702. switch (status->iflags){
  1704. case RX_INTR_PENDING: /* receive interrupt */
  1705. rx_intr(card);
  1706. break;
  1708. case TX_INTR_PENDING: /* transmit interrupt */
  1709. tx_intr(card);
  1710. break;
  1712. case MODEM_INTR_PENDING: /* modem status interrupt */
  1713. status_intr(card);
  1714. break;
  1716. case X25_ASY_TRANS_INTR_PENDING: /* network event interrupt */
  1717. event_intr(card);
  1718. break;
  1720. case TIMER_INTR_PENDING:
  1721. timer_intr(card);
  1722. break;
  1724. default: /* unwanted interrupt */
  1725. spur_intr(card);
  1726. }
  1728. card->in_isr = 0;
  1729. status->iflags = 0; /* clear interrupt condition */
  1730. }
  1732. /*
  1733.  *  Receive interrupt handler.
  1734.  *  This routine handles fragmented IP packets using M-bit according to the
  1735.  *  RFC1356.
  1736.  *  o map ligical channel number to network interface.
  1737.  *  o allocate socket buffer or append received packet to the existing one.
  1738.  *  o if M-bit is reset (i.e. it's the last packet in a sequence) then 
  1739.  *    decapsulate packet and pass socket buffer to the protocol stack.
  1740.  *
  1741.  *  Notes:
  1742.  *  1. When allocating a socket buffer, if M-bit is set then more data is
  1743.  *     coming and we have to allocate buffer for the maximum IP packet size
  1744.  *     expected on this channel.
  1745.  *  2. If something goes wrong and X.25 packet has to be dropped (e.g. no
  1746.  *     socket buffers available) the whole packet sequence must be discarded.
  1747.  */
  1749. static void rx_intr (sdla_t* card)
  1750. {
  1751. TX25Mbox* rxmb = card->rxmb;
  1752. unsigned lcn = rxmb->cmd.lcn;
  1753. netdevice_t* dev = find_channel(card,lcn);
  1754. x25_channel_t* chan;
  1755. struct sk_buff* skb=NULL;
  1757. if (dev == NULL){
  1758. /* Invalid channel, discard packet */
  1759. printk(KERN_INFO "%s: receiving on orphaned LCN %d!n",
  1760. card->devname, lcn);
  1761. return;
  1762. }
  1764. chan = dev->priv;
  1765. chan->i_timeout_sofar = jiffies;
  1768. /* Copy the data from the board, into an
  1769.          * skb buffer 
  1770.  */
  1771. if (wanpipe_pull_data_in_skb(card,dev,&skb)){
  1772. ++chan->ifstats.rx_dropped;
  1773. ++card->wandev.stats.rx_dropped;
  1774. ++chan->rx_intr_stat.rx_intr_no_socket;
  1775. ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
  1776. return;
  1777. }
  1779. dev->last_rx = jiffies; /* timestamp */
  1782. /* ------------ API ----------------*/
  1784. if (chan->common.usedby == API){
  1786. if (bh_enqueue(dev, skb)){
  1787. ++chan->ifstats.rx_dropped;
  1788. ++card->wandev.stats.rx_dropped;
  1789. ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
  1790. wan_dev_kfree_skb(skb, FREE_READ);
  1791. return;
  1792. }
  1794. ++chan->ifstats.rx_packets;
  1795. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  1796. chan->ifstats.rx_bytes += skb->len;
  1797. #endif
  1800. chan->rx_skb = NULL;
  1801. if (!test_and_set_bit(0, &chan->tq_working)){
  1802. wanpipe_queue_tq(&chan->common.wanpipe_task);
  1803. wanpipe_mark_bh();
  1804. }
  1805. return;
  1806. }
  1809. /* ------------- WANPIPE -------------------*/
  1811. /* set rx_skb to NULL so we won't access it later when kernel already owns it */
  1812. chan->rx_skb=NULL;
  1814. /* Decapsulate packet, if necessary */
  1815. if (!skb->protocol && !wanrouter_type_trans(skb, dev)){
  1816. /* can't decapsulate packet */
  1817.                 wan_dev_kfree_skb(skb, FREE_READ);
  1818. ++chan->ifstats.rx_errors;
  1819. ++chan->ifstats.rx_dropped;
  1820. ++card->wandev.stats.rx_dropped;
  1821. ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
  1823. }else{
  1824. if( handle_IPXWAN(skb->data, chan->name, 
  1825.   chan->enable_IPX, chan->network_number, 
  1826.   skb->protocol)){
  1828. if( chan->enable_IPX ){
  1829. if(chan_send(dev, skb->data, skb->len,0)){
  1830. chan->tx_skb = skb;
  1831. }else{
  1832.                                         wan_dev_kfree_skb(skb, FREE_WRITE);
  1833. ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
  1834. }
  1835. }else{
  1836. /* increment IPX packet dropped statistic */
  1837. ++chan->ifstats.rx_dropped;
  1838. ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
  1839. }
  1840. }else{
  1841. skb->mac.raw = skb->data;
  1842. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  1843. chan->ifstats.rx_bytes += skb->len;
  1844. #endif
  1845. ++chan->ifstats.rx_packets;
  1846. ++chan->rx_intr_stat.rx_intr_bfr_passed_to_stack;
  1847. netif_rx(skb);
  1848. }
  1849. }
  1851. return;
  1852. }
  1855. static int wanpipe_pull_data_in_skb (sdla_t *card, netdevice_t *dev, struct sk_buff **skb)
  1856. {
  1857. void *bufptr;
  1858. TX25Mbox* rxmb = card->rxmb;
  1859. unsigned len = rxmb->cmd.length; /* packet length */
  1860. unsigned qdm = rxmb->cmd.qdm; /* Q,D and M bits */
  1861. x25_channel_t *chan = dev->priv;
  1862. struct sk_buff *new_skb = *skb;
  1864. if (chan->common.usedby == WANPIPE){
  1865. if (chan->drop_sequence){
  1866. if (!(qdm & 0x01)){ 
  1867. chan->drop_sequence = 0;
  1868. }
  1869. return 1;
  1870. }
  1871. new_skb = chan->rx_skb;
  1872. }else{
  1873. /* Add on the API header to the received
  1874.                  * data 
  1875.  */
  1876. len += sizeof(x25api_hdr_t);
  1877. }
  1879. if (new_skb == NULL){
  1880. int bufsize;
  1882. if (chan->common.usedby == WANPIPE){
  1883. bufsize = (qdm & 0x01) ? dev->mtu : len;
  1884. }else{
  1885. bufsize = len;
  1886. }
  1888. /* Allocate new socket buffer */
  1889. new_skb = dev_alloc_skb(bufsize + dev->hard_header_len);
  1890. if (new_skb == NULL){
  1891. printk(KERN_INFO "%s: no socket buffers available!n",
  1892. card->devname);
  1893. chan->drop_sequence = 1; /* set flag */
  1894. ++chan->ifstats.rx_dropped;
  1895. return 1;
  1896. }
  1897. }
  1899. if (skb_tailroom(new_skb) < len){
  1900. /* No room for the packet. Call off the whole thing! */
  1901.                 wan_dev_kfree_skb(new_skb, FREE_READ);
  1902. if (chan->common.usedby == WANPIPE){
  1903. chan->rx_skb = NULL;
  1904. if (qdm & 0x01){ 
  1905. chan->drop_sequence = 1;
  1906. }
  1907. }
  1909. printk(KERN_INFO "%s: unexpectedly long packet sequence "
  1910. "on interface %s!n", card->devname, dev->name);
  1911. ++chan->ifstats.rx_length_errors;
  1912. return 1;
  1913. }
  1915. bufptr = skb_put(new_skb,len);
  1918. if (chan->common.usedby == API){
  1919. /* Fill in the x25api header 
  1920.  */
  1921. x25api_t * api_data = (x25api_t*)bufptr;
  1922. api_data->hdr.qdm = rxmb->cmd.qdm;
  1923. api_data->hdr.cause = rxmb->cmd.cause;
  1924. api_data->hdr.diagn = rxmb->cmd.diagn;
  1925. api_data->hdr.length = rxmb->cmd.length;
  1926. memcpy(api_data->data, rxmb->data, rxmb->cmd.length);
  1927. }else{
  1928. memcpy(bufptr, rxmb->data, len);
  1929. }
  1931. new_skb->dev = dev;
  1933. if (chan->common.usedby == API){
  1934. new_skb->mac.raw = new_skb->data;
  1935. new_skb->protocol = htons(X25_PROT);
  1936. new_skb->pkt_type = WAN_PACKET_DATA;
  1937. }else{
  1938. new_skb->protocol = chan->protocol;
  1939. chan->rx_skb = new_skb;
  1940. }
  1942. /* If qdm bit is set, more data is coming 
  1943.          * thus, exit and wait for more data before
  1944.          * sending the packet up. (Used by router only) 
  1945.  */
  1946. if ((qdm & 0x01) && (chan->common.usedby == WANPIPE)) 
  1947. return 1;
  1949. *skb = new_skb; 
  1951. return 0;
  1952. }
  1954. /*===============================================================
  1955.  * tx_intr
  1956.  *  
  1957.  *  Transmit interrupt handler.
  1958.  * For each dev, check that there is something to send.
  1959.  * If data available, transmit. 
  1960.  *
  1961.  *===============================================================*/
  1963. static void tx_intr (sdla_t* card)
  1964. {
  1965. netdevice_t *dev;
  1966. TX25Status* status = card->flags;
  1967. unsigned char more_to_tx=0;
  1968. x25_channel_t *chan=NULL;
  1969. int i=0;
  1971. if (card->u.x.tx_dev == NULL){
  1972. card->u.x.tx_dev = card->wandev.dev;
  1973. }
  1975. dev = card->u.x.tx_dev;
  1977. for (;;){
  1979. chan = dev->priv;
  1980. if (chan->transmit_length){
  1981. /* Device was set to transmit, check if the TX
  1982.                          * buffers are available 
  1983.  */
  1984. if (chan->common.state != WAN_CONNECTED){
  1985. chan->transmit_length = 0;
  1986. atomic_set(&chan->common.driver_busy,0);
  1987. chan->tx_offset=0;
  1988. if (is_queue_stopped(dev)){
  1989. if (chan->common.usedby == API){
  1990. start_net_queue(dev);
  1991. wakeup_sk_bh(dev);
  1992. }else{
  1993. wake_net_dev(dev);
  1994. }
  1995. }
  1996. dev = move_dev_to_next(card,dev);
  1997. break;
  1998. }
  2000. if ((status->cflags[chan->ch_idx] & 0x40 || card->u.x.LAPB_hdlc) && 
  2001.      (*card->u.x.hdlc_buf_status & 0x40) ){
  2002. /* Tx buffer available, we can send */
  2004. if (tx_intr_send(card, dev)){
  2005. more_to_tx=1;
  2006. }
  2008. /* If more than one interface present, move the
  2009.                                  * device pointer to the next interface, so on the 
  2010.                                  * next TX interrupt we will try sending from it. 
  2011.                                  */
  2012. dev = move_dev_to_next(card,dev);
  2013. break;
  2014. }else{
  2015. /* Tx buffers not available, but device set
  2016.                                  * the TX interrupt.  Set more_to_tx and try  
  2017.                                  * to transmit for other devices.
  2018.  */
  2019. more_to_tx=1;
  2020. dev = move_dev_to_next(card,dev);
  2021. }
  2023. }else{
  2024. /* This device was not set to transmit,
  2025.                          * go to next 
  2026.  */
  2027. dev = move_dev_to_next(card,dev);
  2028. }
  2030. if (++i == card->u.x.no_dev){
  2031. if (!more_to_tx){
  2032. DBG_PRINTK(KERN_INFO "%s: Nothing to Send in TX INTRn",
  2033. card->devname);
  2034. }
  2035. break;
  2036. }
  2038. } //End of FOR
  2040. card->u.x.tx_dev = dev;
  2042. if (!more_to_tx){
  2043. /* if any other interfaces have transmit interrupts pending, */
  2044. /* do not disable the global transmit interrupt */
  2045. if (!(--card->u.x.tx_interrupts_pending)){
  2046. status->imask &= ~INTR_ON_TX_FRAME;
  2047. }
  2048. }
  2049. return;
  2050. }
  2052. /*===============================================================
  2053.  * move_dev_to_next
  2054.  *  
  2055.  *
  2056.  *===============================================================*/
  2059. netdevice_t * move_dev_to_next (sdla_t *card, netdevice_t *dev)
  2060. {
  2061. if (card->u.x.no_dev != 1){
  2062. if (*((netdevice_t**)dev->priv) == NULL){
  2063. return card->wandev.dev;
  2064. }else{
  2065. return *((netdevice_t**)dev->priv);
  2066. }
  2067. }
  2068. return dev;
  2069. }
  2071. /*===============================================================
  2072.  *  tx_intr_send
  2073.  *  
  2074.  *
  2075.  *===============================================================*/
  2077. static int tx_intr_send(sdla_t *card, netdevice_t *dev)
  2078. {
  2079. x25_channel_t* chan = dev->priv; 
  2081. if (chan_send (dev,chan->transmit_buffer,chan->transmit_length,1)){
  2082.  
  2083.                 /* Packet was split up due to its size, do not disable
  2084.                  * tx_intr 
  2085.                  */
  2086. return 1;
  2087. }
  2089. chan->transmit_length=0;
  2090. atomic_set(&chan->common.driver_busy,0);
  2091. chan->tx_offset=0;
  2093. /* If we are in API mode, wakeup the 
  2094.          * sock BH handler, not the NET_BH */
  2095. if (is_queue_stopped(dev)){
  2096. if (chan->common.usedby == API){
  2097. start_net_queue(dev);
  2098. wakeup_sk_bh(dev);
  2099. }else{
  2100. wake_net_dev(dev);
  2101. }
  2102. }
  2103. return 0;
  2104. }
  2107. /*===============================================================
  2108.  * timer_intr
  2109.  *  
  2110.  *  Timer interrupt handler.
  2111.  * Check who called the timer interrupt and perform
  2112.  *      action accordingly.
  2113.  *
  2114.  *===============================================================*/
  2116. static void timer_intr (sdla_t *card)
  2117. {
  2118. TX25Status* status = card->flags;
  2120. if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC){
  2122. if (timer_intr_cmd_exec(card) == 0){
  2123. card->u.x.timer_int_enabled &=
  2124. ~TMR_INT_ENABLED_CMD_EXEC;
  2125. }
  2127. }else  if(card->u.x.timer_int_enabled & TMR_INT_ENABLED_UDP_PKT) {
  2129. if ((*card->u.x.hdlc_buf_status & 0x40) && 
  2130.     card->u.x.udp_type == UDP_XPIPE_TYPE){
  2132.                      if(process_udp_mgmt_pkt(card)) {
  2133.                 card->u.x.timer_int_enabled &= 
  2134. ~TMR_INT_ENABLED_UDP_PKT;
  2135. }
  2136. }
  2138. }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_ACTIVE) {
  2140. netdevice_t *dev = card->u.x.poll_device;
  2141. x25_channel_t *chan = NULL;
  2143. if (!dev){
  2144. card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_ACTIVE;
  2145. return;
  2146. }
  2147. chan = dev->priv;
  2149. printk(KERN_INFO 
  2150. "%s: Closing down Idle link %s on LCN %dn",
  2151. card->devname,chan->name,chan->common.lcn); 
  2152. chan->i_timeout_sofar = jiffies;
  2153. chan_disc(dev);
  2154.           card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_ACTIVE;
  2155. card->u.x.poll_device=NULL;
  2157. }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_CONNECT_ON) {
  2159. wanpipe_set_state(card, WAN_CONNECTED);
  2160. if (card->u.x.LAPB_hdlc){
  2161. netdevice_t *dev = card->wandev.dev;
  2162. set_chan_state(dev,WAN_CONNECTED);
  2163. send_delayed_cmd_result(card,dev,card->mbox);
  2164. }
  2166. /* 0x8F enable all interrupts */
  2167. x25_set_intr_mode(card, INTR_ON_RX_FRAME|
  2168. INTR_ON_TX_FRAME|
  2169. INTR_ON_MODEM_STATUS_CHANGE|
  2170. //INTR_ON_COMMAND_COMPLETE|
  2171. X25_ASY_TRANS_INTR_PENDING |
  2172. INTR_ON_TIMER |
  2173. DIRECT_RX_INTR_USAGE
  2174. ); 
  2176. status->imask &= ~INTR_ON_TX_FRAME; /* mask Tx interrupts */
  2177. card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_CONNECT_ON;
  2179. }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_CONNECT_OFF) {
  2181. //printk(KERN_INFO "Poll connect, Turning OFFn");
  2182. disconnect(card);
  2183. card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_CONNECT_OFF;
  2185. }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_DISCONNECT) {
  2187. //printk(KERN_INFO "POll disconnect, trying to connectn");
  2188. connect(card);
  2189. card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_DISCONNECT;
  2191. }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_UPDATE){
  2193. if (*card->u.x.hdlc_buf_status & 0x40){
  2194. x25_get_err_stats(card);
  2195. x25_get_stats(card);
  2196. card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
  2197. }
  2198. }
  2200. if(!card->u.x.timer_int_enabled){
  2201. //printk(KERN_INFO "Turning Timer Off n");
  2202.                 status->imask &= ~INTR_ON_TIMER;
  2203. }
  2204. }
  2206. /*====================================================================
  2207.  *  Modem status interrupt handler.
  2208.  *===================================================================*/
  2209. static void status_intr (sdla_t* card)
  2210. {
  2212. /* Added to avoid Modem status message flooding */
  2213. static TX25ModemStatus last_stat;
  2215. TX25Mbox* mbox = card->mbox;
  2216. TX25ModemStatus *modem_status;
  2217. netdevice_t *dev;
  2218. x25_channel_t *chan;
  2219. int err;
  2221. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2222. mbox->cmd.command = X25_READ_MODEM_STATUS;
  2223. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2224. if (err){ 
  2225. x25_error(card, err, X25_READ_MODEM_STATUS, 0);
  2226. }else{
  2228. modem_status = (TX25ModemStatus*)mbox->data;
  2230.             /* Check if the last status was the same
  2231.              * if it was, do NOT print message again */
  2233. if (last_stat.status != modem_status->status){
  2235.       printk(KERN_INFO "%s: Modem Status Change: DCD=%s, CTS=%sn",
  2236. card->devname,DCD(modem_status->status),CTS(modem_status->status));
  2238. last_stat.status = modem_status->status;
  2240. if (card->u.x.oob_on_modem){
  2242. mbox->cmd.pktType = mbox->cmd.command;
  2243. mbox->cmd.result = 0x08;
  2245. /* Send a OOB to all connected sockets */
  2246. for (dev = card->wandev.dev; dev; dev = *((netdevice_t**)dev->priv)){
  2247. chan=dev->priv;
  2248. if (chan->common.usedby == API){
  2249. send_oob_msg(card,dev,mbox);
  2250. }
  2251. }
  2253. /* The modem OOB message will probably kill the
  2254.  * the link. If we don't clear the flag here,
  2255.  * a deadlock could occur */ 
  2256. if (atomic_read(&card->u.x.command_busy)){
  2257. atomic_set(&card->u.x.command_busy,0);
  2258. }
  2259. }
  2260. }
  2261. }
  2263. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2264. mbox->cmd.command = X25_HDLC_LINK_STATUS;
  2265. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2266. if (err){ 
  2267. x25_error(card, err, X25_HDLC_LINK_STATUS, 0);
  2268. }
  2270. }
  2272. /*====================================================================
  2273.  *  Network event interrupt handler.
  2274.  *===================================================================*/
  2275. static void event_intr (sdla_t* card)
  2276. {
  2277. x25_fetch_events(card);
  2278. }
  2280. /*====================================================================
  2281.  *  Spurious interrupt handler.
  2282.  *  o print a warning
  2283.  *  o  
  2284.  *====================================================================*/
  2286. static void spur_intr (sdla_t* card)
  2287. {
  2288. printk(KERN_INFO "%s: spurious interrupt!n", card->devname);
  2289. }
  2292. /*
  2293.  * Background Polling Routines  
  2294.  */
  2296. /*====================================================================
  2297.  *  Main polling routine.
  2298.  *  This routine is repeatedly called by the WANPIPE 'thead' to allow for
  2299.  *  time-dependent housekeeping work.
  2300.  *
  2301.  *  Notes:
  2302.  *  1. This routine may be called on interrupt context with all interrupts
  2303.  *     enabled. Beware!
  2304.  *====================================================================*/
  2306. static void wpx_poll (sdla_t *card)
  2307. {
  2308. if (!card->wandev.dev){
  2309. goto wpx_poll_exit;
  2310. }
  2312. if (card->open_cnt != card->u.x.num_of_ch){
  2313. goto wpx_poll_exit;
  2314. }
  2316. if (test_bit(PERI_CRIT,&card->wandev.critical)){
  2317. goto wpx_poll_exit;
  2318. }
  2320. if (test_bit(SEND_CRIT,&card->wandev.critical)){
  2321. goto wpx_poll_exit;
  2322. }
  2324. switch(card->wandev.state){
  2325. case WAN_CONNECTED:
  2326. poll_active(card);
  2327. break;
  2329. case WAN_CONNECTING:
  2330. poll_connecting(card);
  2331. break;
  2333. case WAN_DISCONNECTED:
  2334. poll_disconnected(card);
  2335. break;
  2336. }
  2338. wpx_poll_exit:
  2339. clear_bit(POLL_CRIT,&card->wandev.critical);
  2340. return;
  2341. }
  2343. static void trigger_x25_poll(sdla_t *card)
  2344. {
  2345. #ifdef LINUX_2_4
  2346. schedule_task(&card->u.x.x25_poll_task);
  2347. #else
  2348. queue_task(&card->u.x.x25_poll_task, &tq_scheduler);
  2349. #endif
  2350. }
  2352. /*====================================================================
  2353.  *  Handle physical link establishment phase.
  2354.  *  o if connection timed out, disconnect the link.
  2355.  *===================================================================*/
  2357. static void poll_connecting (sdla_t* card)
  2358. {
  2359. volatile TX25Status* status = card->flags;
  2361. if (status->gflags & X25_HDLC_ABM){
  2363. timer_intr_exec (card, TMR_INT_ENABLED_POLL_CONNECT_ON);
  2365. }else if ((jiffies - card->state_tick) > CONNECT_TIMEOUT){
  2367. timer_intr_exec (card, TMR_INT_ENABLED_POLL_CONNECT_OFF);
  2369. }
  2370. }
  2372. /*====================================================================
  2373.  *  Handle physical link disconnected phase.
  2374.  *  o if hold-down timeout has expired and there are open interfaces, 
  2375.  * connect link.
  2376.  *===================================================================*/
  2378. static void poll_disconnected (sdla_t* card)
  2379. {
  2380. netdevice_t *dev; 
  2381. x25_channel_t *chan;
  2382. TX25Status* status = card->flags;
  2384. if (!card->u.x.LAPB_hdlc && card->open_cnt && 
  2385.     ((jiffies - card->state_tick) > HOLD_DOWN_TIME)){
  2386. timer_intr_exec(card, TMR_INT_ENABLED_POLL_DISCONNECT);
  2387. }
  2390. if ((dev=card->wandev.dev) == NULL)
  2391. return;
  2393. if ((chan=dev->priv) == NULL)
  2394. return;
  2396. if (chan->common.usedby == API && 
  2397.     atomic_read(&chan->common.command) && 
  2398.     card->u.x.LAPB_hdlc){
  2400. if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC)) 
  2401. card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
  2403. if (!(status->imask & INTR_ON_TIMER))
  2404. status->imask |= INTR_ON_TIMER;
  2405. }
  2407. }
  2409. /*====================================================================
  2410.  *  Handle active link phase.
  2411.  *  o fetch X.25 asynchronous events.
  2412.  *  o kick off transmission on all interfaces.
  2413.  *===================================================================*/
  2415. static void poll_active (sdla_t* card)
  2416. {
  2417. netdevice_t* dev;
  2418. TX25Status* status = card->flags;
  2420. for (dev = card->wandev.dev; dev; dev = *((netdevice_t**)dev->priv)){
  2421. x25_channel_t* chan = dev->priv;
  2423. /* If SVC has been idle long enough, close virtual circuit */
  2424. if ( chan->common.svc && 
  2425.      chan->common.state == WAN_CONNECTED &&
  2426.      chan->common.usedby == WANPIPE ){
  2428. if( (jiffies - chan->i_timeout_sofar) / HZ > chan->idle_timeout ){
  2429. /* Close svc */
  2430. card->u.x.poll_device=dev;
  2431. timer_intr_exec (card, TMR_INT_ENABLED_POLL_ACTIVE);
  2432. }
  2433. }
  2435. #ifdef PRINT_DEBUG
  2436. chan->ifstats.tx_compressed = atomic_read(&chan->common.command);
  2437. chan->ifstats.tx_errors = chan->common.state;
  2438. chan->ifstats.rx_fifo_errors = atomic_read(&card->u.x.command_busy);
  2439. ++chan->ifstats.tx_bytes;
  2441. chan->ifstats.rx_fifo_errors=atomic_read(&chan->common.disconnect);
  2442. chan->ifstats.multicast=atomic_read(&chan->bh_buff_used);
  2443. chan->ifstats.rx_length_errors=*card->u.x.hdlc_buf_status;
  2444. #endif
  2446. if (chan->common.usedby == API && 
  2447.     atomic_read(&chan->common.command) && 
  2448.             !card->u.x.LAPB_hdlc){
  2450. if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC)) 
  2451. card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
  2453. if (!(status->imask & INTR_ON_TIMER))
  2454. status->imask |= INTR_ON_TIMER;
  2455. }
  2457. if ((chan->common.usedby == API) && 
  2458.      atomic_read(&chan->common.disconnect)){
  2460. if (chan->common.state == WAN_DISCONNECTED){
  2461. atomic_set(&chan->common.disconnect,0);
  2462. return;
  2463. }
  2465. atomic_set(&chan->common.command,X25_CLEAR_CALL);
  2466. if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC)) 
  2467. card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
  2469. if (!(status->imask & INTR_ON_TIMER))
  2470. status->imask |= INTR_ON_TIMER;
  2471. }
  2472. }
  2473. }
  2475. static void timer_intr_exec(sdla_t *card, unsigned char TYPE)
  2476. {
  2477. TX25Status* status = card->flags;
  2478. card->u.x.timer_int_enabled |= TYPE;
  2479. if (!(status->imask & INTR_ON_TIMER))
  2480. status->imask |= INTR_ON_TIMER;
  2481. }
  2484. /*==================================================================== 
  2485.  * SDLA Firmware-Specific Functions 
  2486.  *
  2487.  *  Almost all X.25 commands can unexpetedly fail due to so called 'X.25
  2488.  *  asynchronous events' such as restart, interrupt, incoming call request,
  2489.  *  call clear request, etc.  They can't be ignored and have to be delt with
  2490.  *  immediately.  To tackle with this problem we execute each interface 
  2491.  *  command in a loop until good return code is received or maximum number 
  2492.  *  of retries is reached.  Each interface command returns non-zero return 
  2493.  *  code, an asynchronous event/error handler x25_error() is called.
  2494.  *====================================================================*/
  2496. /*====================================================================
  2497.  *  Read X.25 firmware version.
  2498.  * Put code version as ASCII string in str. 
  2499.  *===================================================================*/
  2501. static int x25_get_version (sdla_t* card, char* str)
  2502. {
  2503. TX25Mbox* mbox = card->mbox;
  2504.    int retry = MAX_CMD_RETRY;
  2505. int err;
  2507. do
  2508. {
  2509. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2510. mbox->cmd.command = X25_READ_CODE_VERSION;
  2511. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2512. } while (err && retry-- &&
  2513.  x25_error(card, err, X25_READ_CODE_VERSION, 0));
  2515. if (!err && str)
  2516. {
  2517. int len = mbox->cmd.length;
  2519. memcpy(str, mbox->data, len);
  2520. str[len] = '';
  2521. }
  2522. return err;
  2523. }
  2525. /*====================================================================
  2526.  *  Configure adapter.
  2527.  *===================================================================*/
  2529. static int x25_configure (sdla_t* card, TX25Config* conf)
  2530. {
  2531. TX25Mbox* mbox = card->mbox;
  2532.    int retry = MAX_CMD_RETRY;
  2533. int err;
  2535. do{
  2536. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2537. memcpy(mbox->data, (void*)conf, sizeof(TX25Config));
  2538. mbox->cmd.length  = sizeof(TX25Config);
  2539. mbox->cmd.command = X25_SET_CONFIGURATION;
  2540. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2541. } while (err && retry-- && x25_error(card, err, X25_SET_CONFIGURATION, 0));
  2542. return err;
  2543. }
  2545. /*====================================================================
  2546.  *  Configure adapter for HDLC only.
  2547.  *===================================================================*/
  2549. static int hdlc_configure (sdla_t* card, TX25Config* conf)
  2550. {
  2551. TX25Mbox* mbox = card->mbox;
  2552.    int retry = MAX_CMD_RETRY;
  2553. int err;
  2555. do{
  2556. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2557. memcpy(mbox->data, (void*)conf, sizeof(TX25Config));
  2558. mbox->cmd.length  = sizeof(TX25Config);
  2559. mbox->cmd.command = X25_HDLC_SET_CONFIG;
  2560. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2561. } while (err && retry-- && x25_error(card, err, X25_SET_CONFIGURATION, 0));
  2563. return err;
  2564. }
  2566. static int set_hdlc_level (sdla_t* card)
  2567. {
  2569. TX25Mbox* mbox = card->mbox;
  2570.    int retry = MAX_CMD_RETRY;
  2571. int err;
  2573. do{
  2574. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2575. mbox->cmd.command = SET_PROTOCOL_LEVEL;
  2576. mbox->cmd.length = 1;
  2577. mbox->data[0] = HDLC_LEVEL; //| DO_HDLC_LEVEL_ERROR_CHECKING; 
  2578. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2579. } while (err && retry-- && x25_error(card, err, SET_PROTOCOL_LEVEL, 0));
  2581. return err;
  2582. }
  2586. /*====================================================================
  2587.  * Get communications error statistics.
  2588.  *====================================================================*/
  2590. static int x25_get_err_stats (sdla_t* card)
  2591. {
  2592. TX25Mbox* mbox = card->mbox;
  2593.    int retry = MAX_CMD_RETRY;
  2594. int err;
  2596. do
  2597. {
  2598. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2599. mbox->cmd.command = X25_HDLC_READ_COMM_ERR;
  2600. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2601. } while (err && retry-- && x25_error(card, err, X25_HDLC_READ_COMM_ERR, 0));
  2603. if (!err)
  2604. {
  2605. THdlcCommErr* stats = (void*)mbox->data;
  2607. card->wandev.stats.rx_over_errors    = stats->rxOverrun;
  2608. card->wandev.stats.rx_crc_errors     = stats->rxBadCrc;
  2609. card->wandev.stats.rx_missed_errors  = stats->rxAborted;
  2610. card->wandev.stats.tx_aborted_errors = stats->txAborted;
  2611. }
  2612. return err;
  2613. }
  2615. /*====================================================================
  2616.  *  Get protocol statistics.
  2617.  *===================================================================*/
  2619. static int x25_get_stats (sdla_t* card)
  2620. {
  2621. TX25Mbox* mbox = card->mbox;
  2622.    int retry = MAX_CMD_RETRY;
  2623. int err;
  2625. do
  2626. {
  2627. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2628. mbox->cmd.command = X25_READ_STATISTICS;
  2629. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2630. } while (err && retry-- && x25_error(card, err, X25_READ_STATISTICS, 0)) ;
  2632. if (!err)
  2633. {
  2634. TX25Stats* stats = (void*)mbox->data;
  2636. card->wandev.stats.rx_packets = stats->rxData;
  2637. card->wandev.stats.tx_packets = stats->txData;
  2638. }
  2639. return err;
  2640. }
  2642. /*====================================================================
  2643.  *  Close HDLC link.
  2644.  *===================================================================*/
  2646. static int x25_close_hdlc (sdla_t* card)
  2647. {
  2648. TX25Mbox* mbox = card->mbox;
  2649.    int retry = MAX_CMD_RETRY;
  2650. int err;
  2652. do
  2653. {
  2654. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2655. mbox->cmd.command = X25_HDLC_LINK_CLOSE;
  2656. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2657. } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_CLOSE, 0));
  2659. return err;
  2660. }
  2663. /*====================================================================
  2664.  *  Open HDLC link.
  2665.  *===================================================================*/
  2667. static int x25_open_hdlc (sdla_t* card)
  2668. {
  2669. TX25Mbox* mbox = card->mbox;
  2670.    int retry = MAX_CMD_RETRY;
  2671. int err;
  2673. do
  2674. {
  2675. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2676. mbox->cmd.command = X25_HDLC_LINK_OPEN;
  2677. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2678. } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_OPEN, 0));
  2680. return err;
  2681. }
  2683. /*=====================================================================
  2684.  * Setup HDLC link.
  2685.  *====================================================================*/
  2686. static int x25_setup_hdlc (sdla_t* card)
  2687. {
  2688. TX25Mbox* mbox = card->mbox;
  2689.    int retry = MAX_CMD_RETRY;
  2690. int err;
  2692. do
  2693. {
  2694. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2695. mbox->cmd.command = X25_HDLC_LINK_SETUP;
  2696. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2697. } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_SETUP, 0));
  2699. return err;
  2700. }
  2702. /*====================================================================
  2703.  * Set (raise/drop) DTR.
  2704.  *===================================================================*/
  2706. static int x25_set_dtr (sdla_t* card, int dtr)
  2707. {
  2708. TX25Mbox* mbox = card->mbox;
  2709.    int retry = MAX_CMD_RETRY;
  2710. int err;
  2712. do
  2713. {
  2714. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2715. mbox->data[0] = 0;
  2716. mbox->data[2] = 0;
  2717. mbox->data[1] = dtr ? 0x02 : 0x01;
  2718. mbox->cmd.length  = 3;
  2719. mbox->cmd.command = X25_SET_GLOBAL_VARS;
  2720. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2721. } while (err && retry-- && x25_error(card, err, X25_SET_GLOBAL_VARS, 0));
  2723. return err;
  2724. }
  2726. /*====================================================================
  2727.  *  Set interrupt mode.
  2728.  *===================================================================*/
  2730. static int x25_set_intr_mode (sdla_t* card, int mode)
  2731. {
  2732. TX25Mbox* mbox = card->mbox;
  2733.    int retry = MAX_CMD_RETRY;
  2734. int err;
  2736. do
  2737. {
  2738. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2739. mbox->data[0] = mode;
  2740. if (card->hw.fwid == SFID_X25_508){
  2741. mbox->data[1] = card->hw.irq;
  2742. mbox->data[2] = 2;
  2743. mbox->cmd.length = 3;
  2744. }else {
  2745.   mbox->cmd.length  = 1;
  2746. }
  2747. mbox->cmd.command = X25_SET_INTERRUPT_MODE;
  2748. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2749. } while (err && retry-- && x25_error(card, err, X25_SET_INTERRUPT_MODE, 0));
  2751. return err;
  2752. }
  2754. /*====================================================================
  2755.  *  Read X.25 channel configuration.
  2756.  *===================================================================*/
  2758. static int x25_get_chan_conf (sdla_t* card, x25_channel_t* chan)
  2759. {
  2760. TX25Mbox* mbox = card->mbox;
  2761.    int retry = MAX_CMD_RETRY;
  2762. int lcn = chan->common.lcn;
  2763. int err;
  2765. do{
  2766. memset(&mbox->cmd, 0, sizeof(TX25Cmd));
  2767. mbox->cmd.lcn     = lcn;
  2768. mbox->cmd.command = X25_READ_CHANNEL_CONFIG;
  2769. err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
  2770. } while (err && retry-- && x25_error(card, err, X25_READ_CHANNEL_CONFIG, lcn));
  2772. if (!err)
  2773. {
  2774. TX25Status* status = card->flags;
  2776. /* calculate an offset into the array of status bytes */
  2777. if (card->u.x.hi_svc <= X25_MAX_CHAN){ 
  2779. chan->ch_idx = lcn - 1;
  2781. }else{
  2782. int offset;
  2784. /* FIX: Apr 14 2000 : Nenad Corbic
  2785.  * The data field was being compared to 0x1F using
  2786.                          * '&&' instead of '&'. 
  2787.  * This caused X25API to fail for LCNs greater than 255.
  2788.  */