for new module-tag.py
[nozomi.git] / nozomi.c
1 /* nozomi.c  -- HSDPA driver Broadband Wireless Data Card - Globe Trotter
2 *
3 * Written by: Ulf Jakobsson,
4 *             Jan ï¿½erfeldt,
5 *             Stefan Thomasson,
6 *
7 * Maintained by: Paul Hardwick (p.hardwick@option.com)
8 *
9 * Patches:
10 *          Locking code changes for Vodafone by Sphere Systems Ltd,
11 *                              Andrew Bird (ajb@spheresystems.co.uk )
12 *                              & Phil Sanderson
13 *
14 * Source has been ported from an implementation made by Filip Aben @ Option
15 *
16 * --------------------------------------------------------------------------
17
18 Copyright (c) 2005,2006 Option Wireless Sweden AB
19 Copyright (c) 2006 Sphere Systems Ltd
20 Copyright (c) 2006 Option Wireless n/v
21 All rights Reserved.
22
23 This program is free software; you can redistribute it and/or modify
24 it under the terms of the GNU General Public License as published by
25 the Free Software Foundation; either version 2 of the License, or
26 (at your option) any later version.
27
28 This program is distributed in the hope that it will be useful,
29 but WITHOUT ANY WARRANTY; without even the implied warranty of
30 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
31 GNU General Public License for more details.
32
33 You should have received a copy of the GNU General Public License
34 along with this program; if not, write to the Free Software
35 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
36
37 * --------------------------------------------------------------------------
38 */
39
40 /* CHANGELOG
41 * Version 2.21alpha
42 * 17-Sept-2006 paul Hardwick
43 *       -Fixed unseen! bug in termio settings
44 *       -Removed more compile warnings
45 * Version 2.2alpha
46 * 10-Sept-2006 Paul Hardwick
47 *
48 * - A 2.6 kernel support version incorporating patches by GregKH
49 * - changes include:
50 * - module reference counting
51 * - improved device exit code
52 * - greater compliance to kernel guidelines
53 *
54 * - 2.4 kernels untested but included
55 * - Still supports 2.6.14 for Ubunto users.
56 * - Finally fixed compiler warnings
57
58 * Version 2.1
59 * 03-July-2006 Paul Hardwick
60 *
61 * - Stability Improvements. Incorporated spinlock wraps patch.
62 * - Updated for newer 2.6.14+ kernels (tty_buffer_request_room)
63 * - using __devexit macro for tty
64 *
65 *
66 * Version 2.0
67 * 08-feb-2006 15:34:10:Ulf
68 *
69 * -Fixed issue when not waking up line disipine layer, could probably result
70 * in better uplink performance for 2.4.
71 *
72 * -Fixed issue with big endian during initalization, now proper toggle flags
73 * are handled between preloader and maincode.
74 *
75 * -Fixed flow control issue.
76 *
77 * -Added support for setting DTR.
78 *
79 * -For 2.4 kernels, removing temporary buffer that's not needed.
80 *
81 * -Reading CTS only for modem port (only port that supports it).
82 *
83 * -Return 0 in write_room instead of netative value, it's not handled in
84 * upper layer.
85 *
86 * --------------------------------------------------------------------------
87 * Version 1.0
88 *
89 * First version of driver, only tested with card of type F32_2.
90 * Works fine with 2.4 and 2.6 kernels.
91 * Driver also support big endian architecture.
92 */
93
94 /* TODO
95 *
96 * See TODO file in this package
97 */
98
99 #include <linux/version.h>
100
101 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,14)
102 #define KERNEL_2_6_14
103 #endif
104 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)
105 #define KERNEL_2_6_18
106 #endif
107
108
109 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
110 #define KERNEL_2_6
111 #elif LINUX_VERSION_CODE > KERNEL_VERSION(2,4,0)
112 #define KERNEL_2_4
113 #endif
114
115 #include <linux/module.h>
116 #include <linux/pci.h>
117 #include <linux/ioport.h>
118 #include <linux/tty.h>
119 #include <linux/tty_driver.h>
120 #include <linux/tty_flip.h>
121 #include <linux/serial.h>
122 #include <linux/interrupt.h>
123 #include <linux/kmod.h>
124 #include <linux/proc_fs.h>
125 #include <linux/init.h>
126 #ifdef KERNEL_2_6
127 #include <linux/kfifo.h>
128 #else
129 #include "kfifo.h"
130 #endif
131 #include <asm/uaccess.h>
132
133 #ifdef KERNEL_2_4
134
135 #ifndef IRQ_NONE
136 #define IRQ_NONE
137 #endif
138
139 #ifndef IRQ_HANDLED
140 #define IRQ_HANDLED
141 typedef void irqreturn_t;
142 #endif
143
144 #endif
145
146 #ifndef CONFIG_PCI
147 #error "This driver needs PCI support to be available"
148 #endif
149
150 #define VERSION_STRING DRIVER_DESC " 2.21alpha (build date: " __DATE__ " " __TIME__ ")"
151
152 /*    Macros definitions */
153
154 /* Enable this to have a lot of debug printouts */
155 /* #define NOZOMI_DEBUG */
156
157 /* Default debug printout level */
158 #define NOZOMI_DEBUG_LEVEL 0x1
159
160 #define P_BUF_SIZE 128
161 #define NFO( _err_flag_, args...)                                            \
162   do{                                                                        \
163     char t_m_p_[P_BUF_SIZE];                                                 \
164       snprintf(t_m_p_, sizeof(t_m_p_), ##args);                              \
165       printk( _err_flag_ "[%d] %s(): %s\n", __LINE__, __FUNCTION__, t_m_p_); \
166 } while(0)
167
168 #define ERR(args...)  NFO( KERN_ERR, ##args)
169
170 #define D1(args...) D_(0x01, ##args)
171 #define D2(args...) D_(0x02, ##args)
172 #define D3(args...) D_(0x04, ##args)
173 #define D4(args...) D_(0x08, ##args)
174 #define D5(args...) D_(0x10, ##args)
175 #define D6(args...) D_(0x20, ##args)
176 #define D7(args...) D_(0x40, ##args)
177 #define D8(args...) D_(0x80, ##args)
178
179 #ifdef NOZOMI_DEBUG
180 #define D_(lvl, args...) D(lvl, ##args)
181   /* Do we need this settable at runtime? */
182 static int nzdebug = NOZOMI_DEBUG_LEVEL;
183
184 #define D(lvl, args...)  do{if(lvl & nzdebug) NFO(KERN_DEBUG, ##args );}while(0)
185 #define D_(lvl, args...) D(lvl, ##args)
186
187 /* These printouts are always printed */
188
189 #else
190 static const int nzdebug = 0;
191 #define D_(lvl, args...)
192 #endif
193
194 /* TODO: rewrite to optimize macros... */
195 #define SET_FCR(value__) \
196   do {  \
197     writew((value__), (dc->REG_FCR )); \
198 } while(0)
199
200 #define SET_IER(value__, mask__) \
201   do {  \
202     dc->ier_last_written = (dc->ier_last_written & ~mask__) | (value__ & mask__ );\
203     writew( dc->ier_last_written, (dc->REG_IER));\
204 } while(0)
205
206 #define GET_IER(read_val__) \
207   do {  \
208     (read_val__) = readw((dc->REG_IER));\
209 } while(0)
210
211 #define GET_IIR(read_val__) \
212   do {  \
213     (read_val__) = readw( (dc->REG_IIR));\
214 } while(0)
215
216 #define GET_MEM(value__, addr__, length__) \
217   do {  \
218 /*    read_mem32( (u32*) (value__), (u32) (addr__), (length__)); */\
219     read_mem32( (u32*) (value__), (addr__), (length__));\
220 } while(0)
221
222 #define GET_MEM_BUF(value__, addr__, length__) \
223   do {  \
224 /*    read_mem32_buf( (u32*) (value__), (u32) (addr__), (length__)); */\
225     read_mem32_buf( (u32*) (value__), (addr__), (length__));\
226 } while(0)
227
228 #define SET_MEM(addr__, value__, length__) \
229   do {  \
230   write_mem32( (addr__),  (u32*) (value__), (length__));\
231 } while(0)
232
233 #define SET_MEM_BUF(addr__, value__, length__) \
234   do {  \
235   write_mem32_buf( (addr__),  (u32*) (value__), (length__));\
236 } while(0)
237
238 #define TMP_BUF_MAX 256
239
240 #define DUMP(buf__,len__) \
241   do {  \
242     char tbuf[TMP_BUF_MAX]={0};\
243     if (len__>1) {\
244         snprintf(tbuf, len__ > TMP_BUF_MAX ? TMP_BUF_MAX : len__, "%s",buf__);\
245         if(tbuf[len__-2] == '\r') {\
246             tbuf[len__-2] = 'r';\
247         }\
248         D1( "SENDING: '%s' (%d+n)", tbuf, len__);\
249     } else {\
250         D1( "SENDING: '%s' (%d)", tbuf, len__);\
251     }\
252 } while(0)
253
254 #define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
255
256 /*    Defines */
257 #define NOZOMI_NAME     "nozomi"
258 #define NOZOMI_NAME_TTY "nozomi_tty"
259 #define DRIVER_DESC     "Nozomi driver"
260
261 #define NTTY_TTY_MAJOR                  241
262 #define NTTY_TTY_MINORS                 MAX_PORT
263 #define NTTY_FIFO_BUFFER_SIZE   8192
264
265 /* Must be power of 2 */
266 #define FIFO_BUFFER_SIZE_UL     8192
267
268 /* Size of tmp send buffer to card */
269 #define SEND_BUF_MAX    1024
270 #define RECEIVE_BUF_MAX 4
271
272 /* Our fake UART values */
273 #define MCR_DTR         0x01
274 #define MCR_RTS         0x02
275 #define MCR_LOOP        0x04
276 #define MSR_CTS         0x08
277 #define MSR_CD          0x10
278 #define MSR_RI          0x20
279 #define MSR_DSR         0x40
280
281 /* Define all types of vendors and devices to support */
282 #define VENDOR1          0x1931 /* Vendor Option */
283 #define DEVICE1          0x000c /* HSDPA card */
284
285 #define R_IIR            0x0000 /* Interrupt Identity Register */
286 #define R_FCR            0x0000 /* Flow Control Register */
287 #define R_IER            0x0004 /* Interrupt Enable Register */
288
289 #define CONFIG_MAGIC 0xEFEFFEFE
290 #define TOGGLE_VALID 0x0000
291
292 /* Definition of interrupt tokens */
293 #define MDM_DL1  0x0001
294 #define MDM_UL1  0x0002
295 #define MDM_DL2  0x0004
296 #define MDM_UL2  0x0008
297 #define DIAG_DL1 0x0010
298 #define DIAG_DL2 0x0020
299 #define DIAG_UL  0x0040
300 #define APP1_DL  0x0080
301 #define APP1_UL  0x0100
302 #define APP2_DL  0x0200
303 #define APP2_UL  0x0400
304 #define CTRL_DL  0x0800
305 #define CTRL_UL  0x1000
306 #define RESET    0x8000
307
308 #define MDM_DL  (MDM_DL1  | MDM_DL2)
309 #define MDM_UL  (MDM_UL1  | MDM_UL2)
310 #define DIAG_DL (DIAG_DL1 | DIAG_DL2)
311
312 /* modem signal definition */
313 #define CTRL_DSR 0x0001
314 #define CTRL_DCD 0x0002
315 #define CTRL_RI  0x0004
316 #define CTRL_CTS 0x0008
317
318 #define CTRL_DTR 0x0001
319 #define CTRL_RTS 0x0002
320
321 #define MAX_PORT 4
322 #define NOZOMI_MAX_PORTS 5
323
324 /*    Type definitions */
325
326 /* There are two types of nozomi cards, one with 2048 memory and with 8192 memory */
327 enum card_type {
328         F32_2 = 2048,           /* Has 512 bytes downlink and uplink * 2             -> 2048 */
329         F32_8 = 8192,           /* Has 3072 bytes downlink and 1024 bytes uplink * 2 -> 8192 */
330 };
331
332 /* Two different toggle channels exist */
333 enum channel_type {
334         CH_A = 0,
335         CH_B = 1,
336 };
337
338 /* Port definition for the card regarding flow control */
339 enum ctrl_port_type {
340         CTRL_CMD = 0x00,
341         CTRL_MDM = 0x01,
342         CTRL_DIAG = 0x02,
343         CTRL_APP1 = 0x03,
344         CTRL_APP2 = 0x04,
345         CTRL_ERROR = -1,
346 };
347
348 /* Ports that the nozomi has */
349 enum port_type {
350         PORT_MDM = 0,
351         PORT_DIAG = 1,
352         PORT_APP1 = 2,
353         PORT_APP2 = 3,
354         PORT_CTRL = 4,
355         PORT_ERROR = -1,
356 };
357
358 #ifdef __ARMEB__
359 /* Big endian */
360
361 typedef struct {
362         unsigned enabled:5;     /* Toggle fields are valid if enabled is 0, else A-channels
363                                    must always be used. */
364         unsigned diag_dl:1;
365         unsigned mdm_dl:1;
366         unsigned mdm_ul:1;
367 } __attribute__ ((packed)) toggles_t;
368
369 /* Configuration table to read at startup of card */
370 /* Is for now only needed during initialization phase */
371 typedef struct {
372         u32 signature;
373         u16 product_information;
374         u16 version;
375         u8 pad3[3];
376         toggles_t toggle;
377         u8 pad1[4];
378         u16 dl_mdm_len1;        /* If this is 64, it can hold 60 bytes + 4 that is length field */
379         u16 dl_start;
380
381         u16 dl_diag_len1;
382         u16 dl_mdm_len2;        /* If this is 64, it can hold 60 bytes + 4 that is length field */
383         u16 dl_app1_len;
384
385         u16 dl_diag_len2;
386         u16 dl_ctrl_len;
387         u16 dl_app2_len;
388         u8 pad2[16];
389         u16 ul_mdm_len1;
390         u16 ul_start;
391         u16 ul_diag_len;
392         u16 ul_mdm_len2;
393         u16 ul_app1_len;
394         u16 ul_app2_len;
395         u16 ul_ctrl_len;
396 } __attribute__ ((packed)) config_table_t;
397
398 /* This stores all control downlink flags */
399 typedef struct {
400         u8 port;
401         unsigned reserved:4;
402         unsigned CTS:1;
403         unsigned RI:1;
404         unsigned DCD:1;
405         unsigned DSR:1;
406 } __attribute__ ((packed)) ctrl_dl_t;
407
408 /* This stores all control uplink flags */
409 typedef struct {
410         u8 port;
411         unsigned reserved:6;
412         unsigned RTS:1;
413         unsigned DTR:1;
414 } __attribute__ ((packed)) ctrl_ul_t;
415
416 #else
417 /* Little endian */
418
419 /* This represents the toggle information */
420 typedef struct {
421         unsigned mdm_ul:1;
422         unsigned mdm_dl:1;
423         unsigned diag_dl:1;
424         unsigned enabled:5;     /* Toggle fields are valid if enabled is 0, else A-channels
425                                    must always be used. */
426 } __attribute__ ((packed)) toggles_t;
427
428 /* Configuration table to read at startup of card */
429 typedef struct {
430         u32 signature;
431         u16 version;
432         u16 product_information;
433         toggles_t toggle;
434         u8 pad1[7];
435         u16 dl_start;
436         u16 dl_mdm_len1;        /* If this is 64, it can hold 60 bytes + 4 that is length field */
437         u16 dl_mdm_len2;
438         u16 dl_diag_len1;
439         u16 dl_diag_len2;
440         u16 dl_app1_len;
441         u16 dl_app2_len;
442         u16 dl_ctrl_len;
443         u8 pad2[16];
444         u16 ul_start;
445         u16 ul_mdm_len2;
446         u16 ul_mdm_len1;
447         u16 ul_diag_len;
448         u16 ul_app1_len;
449         u16 ul_app2_len;
450         u16 ul_ctrl_len;
451 } __attribute__ ((packed)) config_table_t;
452
453 /* This stores all control downlink flags */
454 typedef struct {
455         unsigned DSR:1;
456         unsigned DCD:1;
457         unsigned RI:1;
458         unsigned CTS:1;
459         unsigned reserverd:4;
460         u8 port;
461 } __attribute__ ((packed)) ctrl_dl_t;
462
463 /* This stores all control uplink flags */
464 typedef struct {
465         unsigned DTR:1;
466         unsigned RTS:1;
467         unsigned reserved:6;
468         u8 port;
469 } __attribute__ ((packed)) ctrl_ul_t;
470 #endif
471
472 /* This holds all information that is needed regarding a port */
473 struct port {
474         u8 update_flow_control;
475         ctrl_ul_t ctrl_ul;
476         ctrl_dl_t ctrl_dl;
477         struct kfifo *fifo_ul;
478         void __iomem *dl_addr[2];
479         u32 dl_size[2];
480         u8 toggle_dl;
481         void __iomem *ul_addr[2];
482         u32 ul_size[2];
483         u8 toggle_ul;
484         u16 token_dl;
485
486         struct tty_struct *tty;
487         int tty_open_count;
488         struct semaphore tty_sem;
489         wait_queue_head_t tty_wait;
490         struct async_icount tty_icount;
491         int tty_index;
492         u32 rx_data, tx_data;
493         u8 tty_dont_flip;
494
495 };
496
497 /* Private data one for each card in the system */
498 typedef struct {
499         void __iomem *base_addr;
500         u8 closing;
501
502         /* Pointers to registers */
503         void __iomem *REG_IIR;
504         void __iomem *REG_FCR;
505         void __iomem *REG_IER;
506
507         u16 ier_last_written;
508         enum card_type card_type;
509         config_table_t config_table;    /* Configuration table */
510         struct pci_dev *pdev;
511         struct port port[NOZOMI_MAX_PORTS];
512         u8 *send_buf;
513
514         struct tty_driver *tty_driver;
515
516 #ifdef KERNEL_2_4
517         struct tty_struct *tty_table[NTTY_TTY_MINORS];
518         struct tq_struct tty_flip_queue;
519         s32 tty_refcount;
520 #endif
521 #ifdef KERNEL_2_6
522         struct workqueue_struct *tty_flip_wq;
523         struct work_struct tty_flip_wq_struct;
524 #endif
525
526         struct termios *tty_termios[NTTY_TTY_MINORS];
527         struct termios *tty_termios_locked[NTTY_TTY_MINORS];
528         spinlock_t spin_mutex;
529
530         u32 open_ttys;
531         struct proc_dir_entry *proc_entry;
532
533 } dc_t;
534
535 /* This is a data packet that is read or written to/from card */
536 typedef struct {
537         u32 size;               /* size is the length of the data buffer */
538         u8 *data;
539 } __attribute__ ((packed)) buf_t;
540
541 /*    Function declarations */
542 static int ntty_tty_init(dc_t * dc);
543 static void tty_flip_queue_function(void *tmp_dc);
544
545 /*    Global variables */
546 static struct pci_device_id nozomi_pci_tbl[] = {
547         {VENDOR1, DEVICE1},
548         {0,}
549 };
550
551 /* Used to store interrupt variables */
552 typedef struct {
553         u16 read_iir;           /* Holds current interrupt tokens */
554 } irq_t;
555
556 MODULE_DEVICE_TABLE(pci, nozomi_pci_tbl);
557
558 /* Representing the pci device of interest */
559 static int cards_found;
560 static dc_t *my_dev = NULL;
561 static irq_t my_irq;
562
563 static inline dc_t *get_dc_by_pdev(struct pci_dev *pdev)
564 {
565         return my_dev;
566 }
567
568 static inline dc_t *get_dc_by_index(s32 index)
569 {
570         return my_dev;
571 }
572
573 static inline s32 get_index(struct tty_struct *tty)
574 {
575 #ifdef KERNEL_2_6
576         return tty->index;
577 #else
578         return MINOR(tty->device) - tty->driver.minor_start;
579 #endif
580
581 }
582
583 static inline struct port *get_port_by_tty(struct tty_struct *tty)
584 {
585         return &my_dev->port[get_index(tty)];
586 }
587
588 static inline dc_t *get_dc_by_tty(struct tty_struct *tty)
589 {
590         return my_dev;
591 }
592
593 /* TODO: */
594 /* -Optimize */
595 /* -Rewrite cleaner */
596 //static void read_mem32(u32 *buf, u32 mem_addr_start, u32 size_bytes) {
597 static void read_mem32(u32 * buf, void __iomem * mem_addr_start, u32 size_bytes)
598 {
599         u32 i = 0;
600         u32 *ptr = (__force u32 *) mem_addr_start;
601         u16 *buf16;
602
603         /* 2 bytes */
604         if (size_bytes == 2) {
605                 buf16 = (u16 *) buf;
606                 *buf16 = readw((void __iomem *)ptr);
607                 return;
608         }
609
610         while (i < size_bytes) {
611                 if (size_bytes - i == 2) {
612                         /* Handle 2 bytes in the end */
613                         buf16 = (u16 *) buf;
614                         *(buf16) = readw((void __iomem *)ptr);
615                         i += 2;
616                 } else {
617                         /* Read 4 bytes */
618                         *(buf) = readl((void __iomem *)ptr);
619                         i += 4;
620                 }
621                 buf++;
622                 ptr++;
623         }
624 }
625
626 /* TODO: */
627 /* - Rewrite cleaner */
628 /* - merge with read_mem32() */
629 //static void read_mem32_buf(u32 *buf, u32 mem_addr_start, u32 size_bytes) {
630 static void read_mem32_buf(u32 * buf, void __iomem * mem_addr_start,
631                            u32 size_bytes)
632 {
633 #ifdef __ARMEB__
634         u32 i = 0;
635         u32 *ptr = (u32 *) mem_addr_start;
636         u16 *buf16;
637
638         /* 2 bytes */
639         if (size_bytes == 2) {
640                 buf16 = (u16 *) buf;
641                 *buf16 = __le16_to_cpu(readw(ptr));
642                 return;
643         }
644
645         while (i < size_bytes) {
646                 if (size_bytes - i == 2) {
647                         /* Handle 2 bytes in the end */
648                         buf16 = (u16 *) buf;
649                         *(buf16) = __le16_to_cpu(readw(ptr));
650                         i += 2;
651                 } else {
652                         /* Read 4 bytes */
653                         *(buf) = __le32_to_cpu(readl(ptr));
654                         i += 4;
655                 }
656                 buf++;
657                 ptr++;
658         }
659 #else
660         read_mem32(buf, mem_addr_start, size_bytes);
661 #endif
662 }
663
664 /* TODO: */
665 /* -Optimize */
666 /* -Rewrite cleaner */
667 //static u32 write_mem32(u32 mem_addr_start, u32 *buf, u32 size_bytes) {
668 static u32 write_mem32(void __iomem * mem_addr_start, u32 * buf, u32 size_bytes)
669 {
670         u32 i = 0;
671         u32 *ptr = (__force u32 *) mem_addr_start;
672         u16 *buf16;
673
674         /* 2 bytes */
675         if (size_bytes == 2) {
676                 buf16 = (u16 *) buf;
677                 writew(*buf16, (void __iomem *)ptr);
678                 return 2;
679         }
680
681         while (i < size_bytes) {
682                 if (size_bytes - i == 2) {
683                         /* 2 bytes */
684                         buf16 = (u16 *) buf;
685                         writew(*buf16, (void __iomem *)ptr);
686                         i += 2;
687                 } else {
688                         /* 4 bytes */
689                         writel(*buf, (void __iomem *)ptr);
690                         i += 4;
691                 }
692                 buf++;
693                 ptr++;
694         }
695         return size_bytes;
696 }
697
698 /* Todo: */
699 /* - Merge with write_mem32() */
700 //static u32 write_mem32_buf(u32 mem_addr_start, u32 *buf, u32 size_bytes) {
701 static u32 write_mem32_buf(void __iomem * mem_addr_start, u32 * buf,
702                            u32 size_bytes)
703 {
704 #ifdef __ARMEB__
705         u32 i = 0;
706         u32 *ptr = (u32 *) mem_addr_start;
707         u16 *buf16;
708
709         /* 2 bytes */
710         if (size_bytes == 2) {
711                 buf16 = (u16 *) buf;
712                 writew(__le16_to_cpu(*buf16), ptr);
713                 return 2;
714         }
715
716         while (i < size_bytes) {
717                 if (size_bytes - i == 2) {
718                         /* 2 bytes */
719                         buf16 = (u16 *) buf;
720                         writew(__le16_to_cpu(*buf16), ptr);
721                         i += 2;
722                 } else {
723                         /* 4 bytes */
724                         writel(__cpu_to_le32(*buf), ptr);
725                         i += 4;
726                 }
727                 buf++;
728                 ptr++;
729         }
730         return size_bytes;
731 #else
732         return write_mem32(mem_addr_start, buf, size_bytes);
733 #endif
734 }
735
736 /* Setup pointers to different channels and also setup buffer sizes. */
737 static void setup_memory(dc_t * dc)
738 {
739         void __iomem *offset = dc->base_addr + dc->config_table.dl_start;
740         /* The length reported is including the length field of 4 bytes, hence subtract with 4. */
741         u16 buff_offset = 4;
742
743         /* Modem port dl configuration */
744         dc->port[PORT_MDM].dl_addr[CH_A] = offset;
745         dc->port[PORT_MDM].dl_addr[CH_B] = (offset +=
746                                             dc->config_table.dl_mdm_len1);
747         dc->port[PORT_MDM].dl_size[CH_A] =
748             dc->config_table.dl_mdm_len1 - buff_offset;
749         dc->port[PORT_MDM].dl_size[CH_B] =
750             dc->config_table.dl_mdm_len2 - buff_offset;
751
752         /* Diag port dl configuration */
753         dc->port[PORT_DIAG].dl_addr[CH_A] = (offset +=
754                                              dc->config_table.dl_mdm_len2);
755         dc->port[PORT_DIAG].dl_size[CH_A] =
756             dc->config_table.dl_diag_len1 - buff_offset;
757         dc->port[PORT_DIAG].dl_addr[CH_B] = (offset +=
758                                              dc->config_table.dl_diag_len1);
759         dc->port[PORT_DIAG].dl_size[CH_B] =
760             dc->config_table.dl_diag_len2 - buff_offset;
761
762         /* App1 port dl configuration */
763         dc->port[PORT_APP1].dl_addr[CH_A] = (offset +=
764                                              dc->config_table.dl_diag_len2);
765         dc->port[PORT_APP1].dl_size[CH_A] =
766             dc->config_table.dl_app1_len - buff_offset;
767
768         /* App2 port dl configuration */
769         dc->port[PORT_APP2].dl_addr[CH_A] = (offset +=
770                                              dc->config_table.dl_app1_len);
771         dc->port[PORT_APP2].dl_size[CH_A] =
772             dc->config_table.dl_app2_len - buff_offset;
773
774         /* Ctrl dl configuration */
775         dc->port[PORT_CTRL].dl_addr[CH_A] = (offset +=
776                                              dc->config_table.dl_app2_len);
777         dc->port[PORT_CTRL].dl_size[CH_A] =
778             dc->config_table.dl_ctrl_len - buff_offset;
779
780         /* Modem Port ul configuration */
781         dc->port[PORT_MDM].ul_addr[CH_A] = (offset =
782                                             dc->base_addr +
783                                             dc->config_table.ul_start);
784         dc->port[PORT_MDM].ul_size[CH_A] =
785             dc->config_table.ul_mdm_len1 - buff_offset;
786         dc->port[PORT_MDM].ul_addr[CH_B] = (offset +=
787                                             dc->config_table.ul_mdm_len1);
788         dc->port[PORT_MDM].ul_size[CH_B] =
789             dc->config_table.ul_mdm_len2 - buff_offset;
790
791         /* Diag port ul configuration */
792         dc->port[PORT_DIAG].ul_addr[CH_A] = (offset +=
793                                              dc->config_table.ul_mdm_len2);
794         dc->port[PORT_DIAG].ul_size[CH_A] =
795             dc->config_table.ul_diag_len - buff_offset;
796
797         /* App1 port ul configuration */
798         dc->port[PORT_APP1].ul_addr[CH_A] = (offset +=
799                                              dc->config_table.ul_diag_len);
800         dc->port[PORT_APP1].ul_size[CH_A] =
801             dc->config_table.ul_app1_len - buff_offset;
802
803         /* App2 port ul configuration */
804         dc->port[PORT_APP2].ul_addr[CH_A] = (offset +=
805                                              dc->config_table.ul_app1_len);
806         dc->port[PORT_APP2].ul_size[CH_A] =
807             dc->config_table.ul_app2_len - buff_offset;
808
809         /* Ctrl ul configuration */
810         dc->port[PORT_CTRL].ul_addr[CH_A] = (offset +=
811                                              dc->config_table.ul_app2_len);
812         dc->port[PORT_CTRL].ul_size[CH_A] =
813             dc->config_table.ul_ctrl_len - buff_offset;
814 //    offset = dc->config_table.ul_start;
815 }
816
817 /* Dump config table under initalization phase */
818 #ifdef NOZOMI_DEBUG
819 static void dump_table(dc_t * dc)
820 {
821         D3("signature: 0x%08X", dc->config_table.signature);
822         D3("version: 0x%04X", dc->config_table.version);
823         D3("product_information: 0x%04X", dc->config_table.product_information);
824         D3("toggle enabled: %d", dc->config_table.toggle.enabled);
825         D3("toggle up_mdm: %d", dc->config_table.toggle.mdm_ul);
826         D3("toggle dl_mdm: %d", dc->config_table.toggle.mdm_dl);
827         D3("toggle dl_dbg: %d", dc->config_table.toggle.diag_dl);
828
829         D3("dl_start: 0x%04X", dc->config_table.dl_start);
830         D3("dl_mdm_len0: 0x%04X, %d", dc->config_table.dl_mdm_len1,
831            dc->config_table.dl_mdm_len1);
832         D3("dl_mdm_len1: 0x%04X, %d", dc->config_table.dl_mdm_len2,
833            dc->config_table.dl_mdm_len2);
834         D3("dl_diag_len0: 0x%04X, %d", dc->config_table.dl_diag_len1,
835            dc->config_table.dl_diag_len1);
836         D3("dl_diag_len1: 0x%04X, %d", dc->config_table.dl_diag_len2,
837            dc->config_table.dl_diag_len2);
838         D3("dl_app1_len: 0x%04X, %d", dc->config_table.dl_app1_len,
839            dc->config_table.dl_app1_len);
840         D3("dl_app2_len: 0x%04X, %d", dc->config_table.dl_app2_len,
841            dc->config_table.dl_app2_len);
842         D3("dl_ctrl_len: 0x%04X, %d", dc->config_table.dl_ctrl_len,
843            dc->config_table.dl_ctrl_len);
844         D3("ul_start: 0x%04X, %d", dc->config_table.ul_start,
845            dc->config_table.ul_start);
846         D3("ul_mdm_len[0]: 0x%04X, %d", dc->config_table.ul_mdm_len1,
847            dc->config_table.ul_mdm_len1);
848         D3("ul_mdm_len[1]: 0x%04X, %d", dc->config_table.ul_mdm_len2,
849            dc->config_table.ul_mdm_len2);
850         D3("ul_diag_len: 0x%04X, %d", dc->config_table.ul_diag_len,
851            dc->config_table.ul_diag_len);
852         D3("ul_app1_len: 0x%04X, %d", dc->config_table.ul_app1_len,
853            dc->config_table.ul_app1_len);
854         D3("ul_app2_len: 0x%04X, %d", dc->config_table.ul_app2_len,
855            dc->config_table.ul_app2_len);
856         D3("ul_ctrl_len: 0x%04X, %d", dc->config_table.ul_ctrl_len,
857            dc->config_table.ul_ctrl_len);
858 }
859 #endif
860
861 /* Read configuration table from card under intalization phase */
862 /* Returns 1 if ok, else 0 */
863 static int nozomi_read_config_table(dc_t * dc)
864 {
865
866         GET_MEM(&dc->config_table, dc->base_addr + 0, sizeof(config_table_t));
867
868         /* D1( "0x%08X == 0x%08X ", dc->config_table.signature, CONFIG_MAGIC); */
869
870         if (dc->config_table.signature != CONFIG_MAGIC) {
871                 dev_err(&dc->pdev->dev, "ConfigTable Bad! 0x%08X != 0x%08X\n",
872                         dc->config_table.signature, CONFIG_MAGIC);
873                 return 0;
874         }
875
876         if ((dc->config_table.version == 0)
877             || (dc->config_table.toggle.enabled == TOGGLE_VALID)) {
878                 int i;
879                 D1("Second phase, configuring card");
880
881                 setup_memory(dc);
882
883                 dc->port[PORT_MDM].toggle_ul = dc->config_table.toggle.mdm_ul;
884                 dc->port[PORT_MDM].toggle_dl = dc->config_table.toggle.mdm_dl;
885                 dc->port[PORT_DIAG].toggle_dl = dc->config_table.toggle.diag_dl;
886                 D1("toggle ports: MDM UL:%d MDM DL:%d, DIAG DL:%d",
887                    dc->port[PORT_MDM].toggle_ul,
888                    dc->port[PORT_MDM].toggle_dl, dc->port[PORT_DIAG].toggle_dl);
889
890 #ifdef NOZOMI_DEBUG
891                 dump_table(dc);
892 #endif
893                 for (i = PORT_MDM; i < MAX_PORT; i++) {
894                         dc->port[i].fifo_ul =
895                             kfifo_alloc(FIFO_BUFFER_SIZE_UL, GFP_ATOMIC, NULL);
896                         memset(&dc->port[i].ctrl_dl, 0, sizeof(ctrl_dl_t));
897                         memset(&dc->port[i].ctrl_ul, 0, sizeof(ctrl_ul_t));
898                 }
899
900                 /* Enable control channel */
901                 SET_IER(CTRL_DL, CTRL_DL);
902
903                 dev_info(&dc->pdev->dev, "Initialization OK!\n");
904                 return 1;
905         }
906
907         if ((dc->config_table.version > 0)
908             && (dc->config_table.toggle.enabled != TOGGLE_VALID)) {
909                 u32 offset = 0;
910                 D1("First phase: pushing upload buffers, clearing download");
911
912                 dev_info(&dc->pdev->dev, "Version of card: %d\n",
913                          dc->config_table.version);
914
915                 /* Here we should disable all I/O over F32. */
916                 setup_memory(dc);
917
918                 /* We should send ALL channel pair tokens back along with reset token */
919
920                 /* push upload modem buffers */
921                 SET_MEM(dc->port[PORT_MDM].ul_addr[CH_A], &offset, 4);
922                 SET_MEM(dc->port[PORT_MDM].ul_addr[CH_B], &offset, 4);
923
924                 SET_FCR(MDM_UL | DIAG_DL | MDM_DL);
925
926                 D1("First phase done");
927         }
928
929         return 1;
930 }
931
932 /* Enable uplink interrupts  */
933 static void enable_transmit_ul(enum port_type port, dc_t * dc)
934 {
935
936         switch (port) {
937         case PORT_MDM:
938                 SET_IER(MDM_UL, MDM_UL);
939                 break;
940         case PORT_DIAG:
941                 SET_IER(DIAG_UL, DIAG_UL);
942                 break;
943         case PORT_APP1:
944                 SET_IER(APP1_UL, APP1_UL);
945                 break;
946         case PORT_APP2:
947                 SET_IER(APP2_UL, APP2_UL);
948                 break;
949         case PORT_CTRL:
950                 SET_IER(CTRL_UL, CTRL_UL);
951                 break;
952         default:
953                 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
954                 break;
955         };
956 }
957
958 /* Disable uplink interrupts  */
959 static void disable_transmit_ul(enum port_type port, dc_t * dc)
960 {
961         switch (port) {
962         case PORT_MDM:
963                 SET_IER(0, MDM_UL);
964                 break;
965         case PORT_DIAG:
966                 SET_IER(0, DIAG_UL);
967                 break;
968         case PORT_APP1:
969                 SET_IER(0, APP1_UL);
970                 break;
971         case PORT_APP2:
972                 SET_IER(0, APP2_UL);
973                 break;
974         case PORT_CTRL:
975                 SET_IER(0, CTRL_UL);
976                 break;
977         default:
978                 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
979                 break;
980         };
981 }
982
983 /* Enable downlink interrupts */
984 static void enable_transmit_dl(enum port_type port, dc_t * dc)
985 {
986         switch (port) {
987         case PORT_MDM:
988                 SET_IER(MDM_DL, MDM_DL);
989                 break;
990         case PORT_DIAG:
991                 SET_IER(DIAG_DL, DIAG_DL);
992                 break;
993         case PORT_APP1:
994                 SET_IER(APP1_DL, APP1_DL);
995                 break;
996         case PORT_APP2:
997                 SET_IER(APP2_DL, APP2_DL);
998                 break;
999         case PORT_CTRL:
1000                 SET_IER(CTRL_DL, CTRL_DL);
1001                 break;
1002         default:
1003                 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
1004                 break;
1005         };
1006 }
1007
1008 /* Disable downlink interrupts */
1009 static void disable_transmit_dl(enum port_type port, dc_t * dc)
1010 {
1011         switch (port) {
1012         case PORT_MDM:
1013                 SET_IER(0, MDM_DL);
1014                 break;
1015         case PORT_DIAG:
1016                 SET_IER(0, DIAG_DL);
1017                 break;
1018         case PORT_APP1:
1019                 SET_IER(0, APP1_DL);
1020                 break;
1021         case PORT_APP2:
1022                 SET_IER(0, APP2_DL);
1023                 break;
1024         case PORT_CTRL:
1025                 SET_IER(0, CTRL_DL);
1026                 break;
1027         default:
1028                 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
1029                 break;
1030         };
1031 }
1032
1033 /* Return 1 - send buffer to card and ack. */
1034 /* Return 0 - don't ack, don't send buffer to card. */
1035 static int send_data(enum port_type index, dc_t * dc)
1036 {
1037         u32 size = 0;
1038         struct port *port = &dc->port[index];
1039         u8 toggle = port->toggle_ul;
1040         void __iomem *addr = port->ul_addr[toggle];
1041         u32 ul_size = port->ul_size[toggle];
1042         struct tty_struct *tty = port->tty;
1043
1044         if (index >= NTTY_TTY_MINORS) {
1045                 dev_err(&dc->pdev->dev, "Called with wrong index?\n");
1046                 return 0;
1047         }
1048
1049         /* Get data from tty and place in buf for now */
1050         size =
1051             __kfifo_get(port->fifo_ul, dc->send_buf,
1052                         ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX);
1053
1054         if (size == 0) {
1055                 D4("No more data to send, disable link:");
1056                 return 0;
1057         }
1058
1059         port->tx_data += size;
1060
1061         /* DUMP(buf, size); */
1062
1063         /* Write length + data */
1064         SET_MEM(addr, &size, 4);
1065         SET_MEM_BUF(addr + 4, dc->send_buf, size);
1066
1067         if (port->tty) {
1068                 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP))
1069                     && tty->ldisc.write_wakeup) {
1070                         tty->ldisc.write_wakeup(tty);
1071                 }
1072                 wake_up_interruptible(&tty->write_wait);
1073         }
1074
1075         return 1;
1076 }
1077
1078 /* If all data has been read, return 1, else 0 */
1079 static int receive_data(enum port_type index, dc_t * dc)
1080 {
1081         u8 buf[RECEIVE_BUF_MAX] = { 0 };
1082         int size;
1083         u32 offset = 4;
1084         struct port *port = &dc->port[index];
1085         u8 toggle = port->toggle_dl;
1086         void __iomem *addr = port->dl_addr[toggle];
1087         struct tty_struct *tty = port->tty;
1088         int i;
1089
1090         if (!tty) {
1091                 D1("tty not open for port: %d?", index);
1092                 return 1;
1093         }
1094
1095         GET_MEM(&size, addr, 4);
1096         /*  D1( "%d bytes port: %d", size, index); */
1097
1098         if (test_bit(TTY_THROTTLED, &tty->flags)) {
1099                 D1("No room in tty, don't read data, don't ack interrupt, disable interrupt");
1100
1101                 /* disable interrupt in downlink... */
1102                 disable_transmit_dl(index, dc);
1103 #ifdef KERNEL_2_4
1104                 schedule_task(&dc->tty_flip_queue);
1105 #endif
1106                 return 0;
1107         }
1108
1109         if (size == 0) {
1110                 dev_err(&dc->pdev->dev, "size == 0?\n");
1111                 return 1;
1112         }
1113
1114         while (size > 0) {
1115                 GET_MEM_BUF(buf, addr + offset, 4);
1116
1117                 i = 0;
1118                 while (i < 4 && size > 0) {
1119 #ifdef KERNEL_2_6_14
1120                         if (tty_buffer_request_room(tty, 1) < 1)
1121 #else
1122                         if (tty->flip.count >= TTY_FLIPBUF_SIZE)        //pre 2.6.14 kernels*/
1123 #endif
1124                         {
1125                                 tty_flip_buffer_push(tty);
1126                         }
1127                         tty_insert_flip_char(tty, buf[i], TTY_NORMAL);
1128                         port->rx_data++;
1129                         i++;
1130                         size--;
1131                 }
1132
1133                 offset += 4;
1134         }
1135
1136         tty_flip_buffer_push(tty);
1137
1138         return 1;
1139 }
1140
1141 /* Debug for interrupts */
1142 #ifdef NOZOMI_DEBUG
1143 static char *interrupt2str(u16 interrupt)
1144 {
1145         static char buf[TMP_BUF_MAX];
1146         char *p = buf;
1147
1148         interrupt & MDM_DL1 ? p += snprintf(p, TMP_BUF_MAX, "MDM_DL1 ") : 0;
1149         interrupt & MDM_DL2 ? p += snprintf(p, TMP_BUF_MAX, "MDM_DL2 ") : 0;
1150
1151         interrupt & MDM_UL1 ? p += snprintf(p, TMP_BUF_MAX, "MDM_UL1 ") : 0;
1152         interrupt & MDM_UL2 ? p += snprintf(p, TMP_BUF_MAX, "MDM_UL2 ") : 0;
1153
1154         interrupt & DIAG_DL1 ? p += snprintf(p, TMP_BUF_MAX, "DIAG_DL1 ") : 0;
1155         interrupt & DIAG_DL2 ? p += snprintf(p, TMP_BUF_MAX, "DIAG_DL2 ") : 0;
1156
1157         interrupt & DIAG_UL ? p += snprintf(p, TMP_BUF_MAX, "DIAG_UL ") : 0;
1158
1159         interrupt & APP1_DL ? p += snprintf(p, TMP_BUF_MAX, "APP1_DL ") : 0;
1160         interrupt & APP2_DL ? p += snprintf(p, TMP_BUF_MAX, "APP2_DL ") : 0;
1161
1162         interrupt & APP1_UL ? p += snprintf(p, TMP_BUF_MAX, "APP1_UL ") : 0;
1163         interrupt & APP2_UL ? p += snprintf(p, TMP_BUF_MAX, "APP2_UL ") : 0;
1164
1165         interrupt & CTRL_DL ? p += snprintf(p, TMP_BUF_MAX, "CTRL_DL ") : 0;
1166         interrupt & CTRL_UL ? p += snprintf(p, TMP_BUF_MAX, "CTRL_UL ") : 0;
1167
1168         interrupt & RESET ? p += snprintf(p, TMP_BUF_MAX, "RESET ") : 0;
1169
1170         return buf;
1171 }
1172 #endif
1173
1174 /* Receive flow control */
1175 /* Return 1 - If ok, else 0 */
1176 static int receive_flow_control(dc_t * dc, irq_t * m)
1177 {
1178         enum port_type port = PORT_MDM;
1179         ctrl_dl_t ctrl_dl;
1180         ctrl_dl_t old_ctrl;
1181         u16 enable_ier = 0;
1182
1183         GET_MEM(&ctrl_dl, dc->port[PORT_CTRL].dl_addr[CH_A], 2);
1184
1185         switch (ctrl_dl.port) {
1186         case CTRL_CMD:
1187                 D1("The Base Band sends this value as a response to a request for IMSI detach sent" " over the control channel uplink (see section 7.6.1).");
1188                 break;
1189         case CTRL_MDM:
1190                 port = PORT_MDM;
1191                 enable_ier = MDM_DL;
1192                 break;
1193         case CTRL_DIAG:
1194                 port = PORT_DIAG;
1195                 enable_ier = DIAG_DL;
1196                 break;
1197         case CTRL_APP1:
1198                 port = PORT_APP1;
1199                 enable_ier = APP1_DL;
1200                 break;
1201         case CTRL_APP2:
1202                 port = PORT_APP2;
1203                 enable_ier = APP2_DL;
1204                 break;
1205         default:
1206                 dev_err(&dc->pdev->dev,
1207                         "ERROR: flow control received for non-existing port\n");
1208                 return 0;
1209         };
1210
1211         D1("0x%04X->0x%04X", *((u16 *) & dc->port[port].ctrl_dl),
1212            *((u16 *) & ctrl_dl));
1213
1214         old_ctrl = dc->port[port].ctrl_dl;
1215         dc->port[port].ctrl_dl = ctrl_dl;
1216
1217         if (old_ctrl.CTS == 1 && ctrl_dl.CTS == 0) {
1218                 D1("Disable interrupt (0x%04X) on port: %d", enable_ier, port);
1219                 disable_transmit_ul(port, dc);
1220
1221         } else if (old_ctrl.CTS == 0 && ctrl_dl.CTS == 1) {
1222
1223                 if (__kfifo_len(dc->port[port].fifo_ul)) {
1224                         D1("Enable interrupt (0x%04X) on port: %d", enable_ier,
1225                            port);
1226                         D1("Data in buffer [%d], enable transmit! ",
1227                            __kfifo_len(dc->port[port].fifo_ul));
1228                         enable_transmit_ul(port, dc);
1229                 } else {
1230                         D1("No data in buffer...");
1231                 }
1232         }
1233
1234         if (*(u16 *) & old_ctrl == *(u16 *) & ctrl_dl) {
1235                 D1(" No change in mctrl");
1236                 return 1;
1237         }
1238         /* Update statistics */
1239         if (old_ctrl.CTS != ctrl_dl.CTS) {
1240                 dc->port[port].tty_icount.cts++;
1241         }
1242         if (old_ctrl.DSR != ctrl_dl.DSR) {
1243                 dc->port[port].tty_icount.dsr++;
1244         }
1245         if (old_ctrl.RI != ctrl_dl.RI) {
1246                 dc->port[port].tty_icount.rng++;
1247         }
1248         if (old_ctrl.DCD != ctrl_dl.DCD) {
1249                 dc->port[port].tty_icount.dcd++;
1250         }
1251         D1("port: %d DCD(%d), CTS(%d), RI(%d), DSR(%d)",
1252            port,
1253            dc->port[port].tty_icount.dcd, dc->port[port].tty_icount.cts,
1254            dc->port[port].tty_icount.rng, dc->port[port].tty_icount.dsr);
1255
1256         return 1;
1257 }
1258
1259 /* TODO:  */
1260 /* - return enum ctrl_port_type */
1261 static u8 port2ctrl(enum port_type port, dc_t * dc)
1262 {
1263         switch (port) {
1264         case PORT_MDM:
1265                 return CTRL_MDM;
1266         case PORT_DIAG:
1267                 return CTRL_DIAG;
1268         case PORT_APP1:
1269                 return CTRL_APP1;
1270         case PORT_APP2:
1271                 return CTRL_APP2;
1272         default:
1273                 dev_err(&dc->pdev->dev,
1274                         "ERROR: send flow control received for non-existing port\n");
1275         };
1276         return -1;
1277 }
1278
1279 /* Send flow control, can only update one channel at a time */
1280 /* Return 0 - If we have updated all flow control */
1281 /* Return 1 - If we need to update more flow control, ack current enable more */
1282 static int send_flow_control(dc_t * dc)
1283 {
1284         u32 i, more_flow_control_to_be_updated = 0;
1285         u16 *ctrl;
1286
1287         for (i = PORT_MDM; i < MAX_PORT; i++) {
1288                 if (dc->port[i].update_flow_control) {
1289                         if (more_flow_control_to_be_updated) {
1290                                 /* We have more flow control to be updated */
1291                                 return 1;
1292                         }
1293                         dc->port[i].ctrl_ul.port = port2ctrl(i, dc);
1294                         ctrl = (u16 *) & dc->port[i].ctrl_ul;
1295                         /* D1( "sending flow control 0x%04X for port %d, %d", (u16) *ctrl, i, dc->port[i].ctrl_ul.port ); */
1296                         SET_MEM(dc->port[PORT_CTRL].ul_addr[0], (u32 *) ctrl,
1297                                 2);
1298                         dc->port[i].update_flow_control = 0;
1299                         more_flow_control_to_be_updated = 1;
1300                 }
1301         }
1302         return 0;
1303 }
1304
1305 /* Handle donlink data, ports that are handled are modem and diagnostics */
1306 /* Return 1 - ok */
1307 /* Return 0 - toggle fields are out of sync */
1308 static int handle_data_dl(dc_t * dc, irq_t * m, enum port_type port,
1309                           u8 * toggle, u16 mask1, u16 mask2)
1310 {
1311
1312         if (*toggle == 0 && m->read_iir & mask1) {
1313                 if (receive_data(port, dc)) {
1314                         SET_FCR(mask1);
1315                         *toggle = !(*toggle);
1316                 }
1317
1318                 if (m->read_iir & mask2) {
1319                         if (receive_data(port, dc)) {
1320                                 SET_FCR(mask2);
1321                                 *toggle = !(*toggle);
1322                         }
1323                 }
1324         } else if (*toggle == 1 && m->read_iir & mask2) {
1325                 if (receive_data(port, dc)) {
1326                         SET_FCR(mask2);
1327                         *toggle = !(*toggle);
1328                 }
1329
1330                 if (m->read_iir & mask1) {
1331                         if (receive_data(port, dc)) {
1332                                 SET_FCR(mask1);
1333                                 *toggle = !(*toggle);
1334                         }
1335                 }
1336         } else {
1337                 ERR("port out of sync!, toggle:%d", *toggle);
1338                 return 0;
1339         }
1340         return 1;
1341 }
1342
1343 /* Handle uplink data, this is currently for the modem port */
1344 /* Return 1 - ok */
1345 /* Return 0 - toggle field are out of sync */
1346 static int handle_data_ul(dc_t * dc, irq_t * m, enum port_type port)
1347 {
1348
1349         u8 *toggle = &(dc->port[port].toggle_ul);
1350
1351         if (*toggle == 0 && m->read_iir & MDM_UL1) {
1352                 SET_IER(0, MDM_UL);
1353                 if (send_data(port, dc)) {
1354                         SET_FCR(MDM_UL1);
1355                         SET_IER(MDM_UL, MDM_UL);
1356                         *toggle = !*toggle;
1357                 }
1358
1359                 if (m->read_iir & MDM_UL2) {
1360                         SET_IER(0, MDM_UL);
1361                         if (send_data(port, dc)) {
1362                                 SET_FCR(MDM_UL2);
1363                                 SET_IER(MDM_UL, MDM_UL);
1364                                 *toggle = !*toggle;
1365                         }
1366                 }
1367
1368         } else if (*toggle == 1 && m->read_iir & MDM_UL2) {
1369                 SET_IER(0, MDM_UL);
1370                 if (send_data(port, dc)) {
1371                         SET_FCR(MDM_UL2);
1372                         SET_IER(MDM_UL, MDM_UL);
1373                         *toggle = !*toggle;
1374                 }
1375
1376                 if (m->read_iir & MDM_UL1) {
1377                         SET_IER(0, MDM_UL);
1378                         if (send_data(port, dc)) {
1379                                 SET_FCR(MDM_UL1);
1380                                 SET_IER(MDM_UL, MDM_UL);
1381                                 *toggle = !*toggle;
1382                         }
1383                 }
1384         } else {
1385                 SET_FCR(m->read_iir & MDM_UL);
1386                 ERR("port out of sync!");
1387                 return 0;
1388         }
1389         return 1;
1390 }
1391
1392 static irqreturn_t interrupt_handler(int irq, void *dev_id,
1393                                      struct pt_regs *regs)
1394 {
1395         dc_t *dc = NULL;
1396         irq_t *m = &my_irq;
1397
1398         if (my_dev && my_dev->pdev != dev_id) {
1399                 return IRQ_NONE;
1400         }
1401
1402         if (!(dc = get_dc_by_pdev(dev_id))) {
1403                 ERR("Could not find device context from pci_dev: %Xu",
1404                     (u32) dev_id);
1405                 return IRQ_NONE;
1406         }
1407
1408         GET_IIR(m->read_iir);
1409
1410         /* Just handle interrupt enabled in IER (by masking with dc->ier_last_written) */
1411         m->read_iir &= dc->ier_last_written;
1412
1413         if (m->read_iir == 0) {
1414                 return IRQ_NONE;
1415         }
1416
1417         if (dc == NULL) {
1418                 ERR("ERROR!!");
1419                 return IRQ_NONE;
1420         }
1421
1422         spin_lock(&dc->spin_mutex);
1423
1424         D4("%s irq:0x%04X, prev:0x%04X", interrupt2str(m->read_iir),
1425            m->read_iir, dc->ier_last_written);
1426
1427         if (m->read_iir & RESET) {
1428                 if (!nozomi_read_config_table(dc)) {
1429                         SET_IER(0, 0xFFFF);
1430                         ERR("ERR: Could not read status from card, we should disable interface");
1431                 } else {
1432                         SET_FCR(RESET);
1433                 }
1434                 goto exit_handler;      /* No more useful info if this was the reset interrupt. */
1435         }
1436         if (m->read_iir & CTRL_UL) {
1437                 D1("CTRL_UL");
1438                 SET_IER(0, CTRL_UL);
1439                 if (send_flow_control(dc)) {
1440                         SET_FCR(CTRL_UL);
1441                         SET_IER(CTRL_UL, CTRL_UL);
1442                 }
1443         }
1444         if (m->read_iir & CTRL_DL) {
1445                 receive_flow_control(dc, m);
1446                 SET_FCR(CTRL_DL);
1447         }
1448         if (m->read_iir & MDM_DL) {
1449                 if (!
1450                     (handle_data_dl
1451                      (dc, m, PORT_MDM, &(dc->port[PORT_MDM].toggle_dl), MDM_DL1,
1452                       MDM_DL2))) {
1453                         ERR("MDM_DL out of sync!");
1454                         goto exit_handler;
1455                 }
1456         }
1457         if (m->read_iir & MDM_UL) {
1458                 if (!handle_data_ul(dc, m, PORT_MDM)) {
1459                         ERR("MDM_UL out of sync!");
1460                         goto exit_handler;
1461                 }
1462         }
1463         if (m->read_iir & DIAG_DL) {
1464                 if (!
1465                     (handle_data_dl
1466                      (dc, m, PORT_DIAG, &(dc->port[PORT_DIAG].toggle_dl),
1467                       DIAG_DL1, DIAG_DL2))) {
1468                         ERR("DIAG_DL out of sync!");
1469                         goto exit_handler;
1470                 }
1471         }
1472         if (m->read_iir & DIAG_UL) {
1473                 SET_IER(0, DIAG_UL);
1474                 if (send_data(PORT_DIAG, dc)) {
1475                         SET_FCR(DIAG_UL);
1476                         SET_IER(DIAG_UL, DIAG_UL);
1477                 }
1478         }
1479         if (m->read_iir & APP1_DL) {
1480                 if (receive_data(PORT_APP1, dc)) {
1481                         SET_FCR(APP1_DL);
1482                 }
1483         }
1484         if (m->read_iir & APP1_UL) {
1485                 SET_IER(0, APP1_UL);
1486                 if (send_data(PORT_APP1, dc)) {
1487                         SET_FCR(APP1_UL);
1488                         SET_IER(APP1_UL, APP1_UL);
1489                 }
1490         }
1491         if (m->read_iir & APP2_DL) {
1492                 if (receive_data(PORT_APP2, dc)) {
1493                         SET_FCR(APP2_DL);
1494                 }
1495         }
1496         if (m->read_iir & APP2_UL) {
1497                 SET_IER(0, APP2_UL);
1498                 if (send_data(PORT_APP2, dc)) {
1499                         SET_FCR(APP2_UL);
1500                         SET_IER(APP2_UL, APP2_UL);
1501                 }
1502         }
1503
1504       exit_handler:
1505         spin_unlock(&dc->spin_mutex);
1506         return IRQ_HANDLED;
1507 }
1508
1509 /* Request a shared IRQ from system */
1510 static int nozomi_setup_interrupt(struct pci_dev *pdev)
1511 {
1512
1513         int rval = 0;
1514
1515         if ((rval =
1516              request_irq(pdev->irq, &interrupt_handler, SA_SHIRQ, NOZOMI_NAME,
1517                          pdev))) {
1518                 ERR("Cannot open because IRQ %d is already in use.", pdev->irq);
1519                 return rval;
1520         }
1521
1522         return rval;
1523 }
1524
1525 static void nozomi_get_card_type(dc_t * dc)
1526 {
1527         int i;
1528         u32 size = 0;
1529
1530         for (i = 0; i < 6; i++)
1531                 size += pci_resource_len(dc->pdev, i);
1532         /* Assume card type F32_8 if no match */
1533         dc->card_type = size == 2048 ? F32_2 : F32_8;
1534         dev_info(&dc->pdev->dev, "Card type is: %d\n", dc->card_type);
1535 }
1536
1537 static void nozomi_setup_private_data(dc_t * dc)
1538 {
1539         void __iomem *offset = dc->base_addr + dc->card_type / 2;
1540         int i;
1541
1542         dc->REG_FCR = (void __iomem *)(offset + R_FCR);
1543         dc->REG_IIR = (void __iomem *)(offset + R_IIR);
1544         dc->REG_IER = (void __iomem *)(offset + R_IER);
1545         dc->ier_last_written = 0;
1546         dc->closing = 0;
1547         dc->port[PORT_MDM].token_dl = MDM_DL;
1548         dc->port[PORT_DIAG].token_dl = DIAG_DL;
1549         dc->port[PORT_APP1].token_dl = APP1_DL;
1550         dc->port[PORT_APP2].token_dl = APP2_DL;
1551
1552         for (i = PORT_MDM; i < MAX_PORT; i++) {
1553                 dc->port[i].rx_data = dc->port[i].tx_data = 0;
1554                 dc->port[i].tty_dont_flip = 0;
1555         }
1556 }
1557
1558 static void tty_flip_queue_function(void *tmp_dc)
1559 {
1560         dc_t *dc = (dc_t *) tmp_dc;
1561         int i;
1562         unsigned long flags;
1563
1564         /* Enable interrupt for that port */
1565         for (i = 0; i < MAX_PORT; i++) {
1566                 if (dc->port[i].tty_dont_flip) {
1567                         D6("Enable for port: %d", i);
1568                         dc->port[i].tty_dont_flip = 0;
1569                         spin_lock_irqsave(&dc->spin_mutex, flags);
1570                         enable_transmit_dl(dc->port[i].tty_index, dc);
1571                         spin_unlock_irqrestore(&dc->spin_mutex, flags);
1572                 }
1573         }
1574 }
1575
1576 static int read_proc_card_type(char *buf, char **start, off_t offset, int len)
1577 {
1578         dc_t *dc = get_dc_by_index(0);
1579         len = 0;
1580
1581         len += sprintf(buf + len, "%d\n", dc->card_type);
1582         return len;
1583 }
1584
1585 static int read_proc_open_ttys(char *buf, char **start, off_t offset, int len)
1586 {
1587         dc_t *dc = get_dc_by_index(0);
1588         len = 0;
1589
1590         len += sprintf(buf + len, "%d\n", dc->open_ttys);
1591         return len;
1592 }
1593
1594 static int read_proc_version(char *buf, char **start, off_t offset, int len)
1595 {
1596         len = 0;
1597
1598         len += sprintf(buf + len, "%s\n", VERSION_STRING);
1599         return len;
1600 }
1601
1602 static int read_proc_rtx(char *buf, char **start, off_t offset, int len)
1603 {
1604         dc_t *dc = get_dc_by_index(0);
1605         int i;
1606
1607         len = 0;
1608
1609         for (i = PORT_MDM; i < MAX_PORT; i++) {
1610                 len +=
1611                     sprintf(buf + len, "noz%d rx: %d, tx: %d\n", i,
1612                             dc->port[i].rx_data, dc->port[i].tx_data);
1613         }
1614         return len;
1615 }
1616
1617 static void make_proc_dirs(void)
1618 {
1619         dc_t *dc = get_dc_by_index(0);
1620         dc->proc_entry = proc_mkdir("nozomi", &proc_root);
1621
1622         /* Register the read_proc */
1623         if (!create_proc_info_entry
1624             ("card_type", 0, dc->proc_entry, read_proc_card_type)) {
1625                 ERR("ERROR: failed to register read_procmem");
1626         }
1627         if (!create_proc_info_entry
1628             ("open_ttys", 0, dc->proc_entry, read_proc_open_ttys)) {
1629                 ERR("ERROR: failed to register read_procmem");
1630         }
1631         if (!create_proc_info_entry("rtx", 0, dc->proc_entry, read_proc_rtx)) {
1632                 ERR("ERROR: failed to register read_procmem");
1633         }
1634         if (!create_proc_info_entry
1635             ("version", 0, dc->proc_entry, read_proc_version)) {
1636                 ERR("ERROR: failed to register read_procmem");
1637         }
1638 }
1639
1640 static void remove_proc_dirs(void)
1641 {
1642         dc_t *dc = get_dc_by_index(0);
1643
1644         remove_proc_entry("card_type", dc->proc_entry);
1645         remove_proc_entry("open_ttys", dc->proc_entry);
1646         remove_proc_entry("rtx", dc->proc_entry);
1647         remove_proc_entry("version", dc->proc_entry);
1648         remove_proc_entry("nozomi", &proc_root);
1649 }
1650
1651 /* Allocate memory for one device */
1652 static int __devinit nozomi_card_init(struct pci_dev *pdev,
1653                                       const struct pci_device_id *ent)
1654 {
1655         int ret = -EIO;
1656         dc_t *dc = NULL;
1657
1658         cards_found++;
1659         dev_info(&pdev->dev, "Init, cards_found: %d\n", cards_found);
1660
1661         if (!(my_dev = kmalloc(sizeof(dc_t), GFP_KERNEL))) {
1662                 D1("Could not allocate memory");
1663                 return -EIO;
1664         }
1665
1666         memset(my_dev, 0, sizeof(dc_t));
1667
1668         if (cards_found > 1) {
1669                 dev_err(&pdev->dev, "This driver only supports 1 device\n");
1670                 return -ENODEV;
1671         }
1672
1673         my_dev->pdev = pdev;
1674         dc = my_dev;
1675
1676         /* Find out what card type it is */
1677         nozomi_get_card_type(dc);
1678
1679         if (pci_enable_device(dc->pdev)) {
1680                 dev_err(&pdev->dev, "Not possible to enable PCI Device\n");
1681                 return -ENODEV;
1682         }
1683         dc->base_addr = (void *)pci_resource_start(dc->pdev, 0);
1684         if (dc->base_addr == 0x0000) {
1685                 dev_err(&pdev->dev, "No I/O-Address for card detected\n");
1686                 ret = -ENODEV;
1687                 goto err_disable_device;
1688         }
1689         dc->base_addr = (void *)ioremap((int)dc->base_addr, dc->card_type);
1690         if (!dc->base_addr) {
1691                 dev_err(&pdev->dev, "No I/O-Address for card detected\n");
1692                 ret = -ENODEV;
1693                 goto err_disable_device;
1694         }
1695
1696         dc->open_ttys = 0;
1697
1698         nozomi_setup_private_data(dc);
1699
1700         if (pci_request_regions(dc->pdev, NOZOMI_NAME)) {
1701                 dev_err(&pdev->dev, "I/O address 0x%04x already in use\n",
1702                         (int) /* nozomi_private.io_addr */ 0);
1703                 ret = -EIO;
1704                 goto err_disable_regions;
1705         }
1706
1707         dc->send_buf = kmalloc(SEND_BUF_MAX, GFP_KERNEL);
1708         if (!dc->send_buf) {
1709                 dev_err(&pdev->dev, "Could not allocate send buffer?\n");
1710                 goto err_disable_regions;
1711         }
1712
1713         /* Disable all interrupts */
1714         SET_IER(0, 0xFFFF);
1715
1716         /* Setup interrupt handler */
1717         if (nozomi_setup_interrupt(dc->pdev)) {
1718                 ret = -EIO;
1719                 goto err_disable_regions;
1720         }
1721
1722         D1("base_addr: 0x%08X", dc->base_addr);
1723 #ifdef KERNEL_2_4
1724         dc->tty_flip_queue.list.next = NULL;
1725         dc->tty_flip_queue.list.prev = NULL;
1726         dc->tty_flip_queue.sync = 0;
1727         dc->tty_flip_queue.data = dc;
1728         dc->tty_flip_queue.routine = tty_flip_queue_function;
1729 #endif
1730 #ifdef KERNEL_2_6
1731         if (!(dc->tty_flip_wq = create_singlethread_workqueue(NOZOMI_NAME))) {
1732                 ERR("Could not create workqueue?");
1733                 BUG_ON(!dc->tty_flip_wq);
1734                 return -ENOMEM;
1735         }
1736 //      INIT_WORK(&dc->tty_flip_wq_struct, tty_flip_queue_function, dc);
1737         INIT_WORK(&dc->tty_flip_wq_struct, tty_flip_queue_function);
1738 #endif
1739         spin_lock_init(&dc->spin_mutex);
1740         make_proc_dirs();
1741         ntty_tty_init(dc);
1742         /* Enable  RESET interrupt. */
1743         SET_IER(RESET, 0xFFFF);
1744         return 0;
1745
1746       err_disable_regions:
1747         pci_release_regions(pdev);
1748         iounmap(dc->base_addr);
1749         dc->base_addr = NULL;
1750
1751       err_disable_device:
1752         pci_disable_device(pdev);
1753         kfree(my_dev);
1754         return ret;
1755 }
1756
1757 static void tty_do_close(dc_t * dc, struct port *port)
1758 {
1759
1760         unsigned long flags;
1761
1762         if (down_interruptible(&port->tty_sem)) {
1763                 return;
1764         }
1765         if (port->tty_open_count) {
1766                 dc->open_ttys--;
1767                 port->tty_open_count--;
1768         #ifdef KERNEL_2_4
1769                 MOD_DEC_USE_COUNT;
1770         #endif
1771                 if (port->tty_open_count == 0) {
1772                         D1("close: %d", port->token_dl);
1773                         spin_lock_irqsave(&dc->spin_mutex, flags);
1774                         SET_IER(0, port->token_dl);
1775                         spin_unlock_irqrestore(&dc->spin_mutex, flags);
1776                 }
1777         }
1778         up(&port->tty_sem);
1779 }
1780
1781 static void __devexit tty_exit(void)
1782 {
1783         dc_t *dc = my_dev;
1784         int i;
1785
1786         D1(" ");
1787         for (i = 0; i < NTTY_TTY_MINORS; i++) {
1788                 while (dc->port[i].tty_open_count)
1789                         tty_do_close(dc, &dc->port[i]);
1790                 dc->port[i].tty = NULL;
1791         }
1792 #ifdef KERNEL_2_6
1793         for (i = 0; i < NTTY_TTY_MINORS; ++i){
1794                 D1("Unregistering device");
1795                 tty_unregister_device(dc->tty_driver, i);
1796         }
1797 #endif
1798         D1("Unregistering driver");
1799         tty_unregister_driver(dc->tty_driver);
1800         put_tty_driver(dc->tty_driver);
1801 }
1802
1803 /* Deallocate memory for one device */
1804 static void __devexit nozomi_card_exit(struct pci_dev *pdev)
1805 {
1806         int i;
1807         ctrl_ul_t ctrl;
1808         dc_t *dc = get_dc_by_pdev(pdev);
1809
1810         /* Disable all interrupts */
1811         SET_IER(0, 0xFFFF);
1812
1813         /* Send 0x0001, command card to resend the reset token. */
1814         /* This is to get the reset when the module is reloaded. */
1815         ctrl.port = 0x00;
1816         ctrl.reserved = 0;
1817         ctrl.RTS = 0;
1818         ctrl.DTR = 1;
1819         D1("sending flow control 0x%04X", *((u16 *) & ctrl));
1820
1821         /* Setup dc->reg addresses to we can use defines here */
1822         nozomi_setup_private_data(dc);
1823         SET_MEM(dc->port[PORT_CTRL].ul_addr[0], (u32 *) & ctrl, 2);
1824         SET_FCR(CTRL_UL);       /* push the token to the card. */
1825
1826         D1("pci_release_regions");
1827         pci_release_regions(pdev);
1828
1829         if (dc->base_addr)
1830                 iounmap(dc->base_addr);
1831
1832         D1("pci_disable_device");
1833         pci_disable_device(pdev);
1834
1835         free_irq(pdev->irq, pdev);
1836
1837         for (i = PORT_MDM; i < MAX_PORT; i++) {
1838                 kfree(dc->port[i].fifo_ul);
1839         }
1840
1841         kfree(dc->send_buf);
1842
1843         tty_exit();
1844
1845         remove_proc_dirs();
1846
1847 #ifdef KERNEL_2_6
1848         destroy_workqueue(dc->tty_flip_wq);
1849 #endif
1850         if (my_dev) {
1851                 kfree(my_dev);
1852         }
1853
1854         cards_found--;
1855 }
1856
1857 static void set_rts(int index, int rts)
1858 {
1859         dc_t *dc = get_dc_by_index(index);
1860         dc->port[index].ctrl_ul.RTS = rts;
1861         dc->port[index].update_flow_control = 1;
1862         enable_transmit_ul(PORT_CTRL, dc);
1863 }
1864
1865 static void set_dtr(int index, int dtr)
1866 {
1867         dc_t *dc = get_dc_by_index(index);
1868         D1("SETTING DTR index: %d, dtr: %d", index, dtr);
1869         dc->port[index].ctrl_ul.DTR = dtr;
1870         dc->port[index].update_flow_control = 1;
1871         enable_transmit_ul(PORT_CTRL, dc);
1872 }
1873
1874 /* ---------------------------------------------------------------------------------------------------
1875   TTY code
1876   ---------------------------------------------------------------------------------------------------*/
1877
1878 /* Called when the userspace process opens the tty, /dev/noz*. */
1879 static int ntty_open(struct tty_struct *tty, struct file *file)
1880 {
1881
1882         s32 index = get_index(tty);
1883         struct port *port = get_port_by_tty(tty);
1884         dc_t *dc = get_dc_by_tty(tty);
1885         unsigned long flags;
1886
1887         if (down_interruptible(&port->tty_sem)) {
1888                 return -ERESTARTSYS;
1889         }
1890
1891         tty->low_latency = 1;
1892         tty->driver_data = port;
1893         port->tty = tty;
1894         port->tty_index = index;
1895         port->tty_open_count++;
1896         dc->open_ttys++;
1897 #ifdef KERNEL_2_4
1898         MOD_INC_USE_COUNT;
1899 #endif
1900         /* Enable interrupt downlink for channel */
1901         if (port->tty_open_count == 1) {
1902                 port->rx_data = port->tx_data = 0;
1903                 D1("open: %d", port->token_dl);
1904                 spin_lock_irqsave(&dc->spin_mutex, flags);
1905                 SET_IER(port->token_dl, port->token_dl);
1906                 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1907         }
1908
1909         up(&port->tty_sem);
1910         return 0;
1911 }
1912
1913 /* Called when the userspace process close the tty, /dev/noz*. */
1914 static void ntty_close(struct tty_struct *tty, struct file *file)
1915 {
1916         dc_t *dc = get_dc_by_tty(tty);
1917         tty_do_close(dc, (struct port *)tty->driver_data);
1918 }
1919
1920 /* called when the userspace process writes to the tty (/dev/noz*).  */
1921 /* Data is inserted into a fifo, which is then read and transfered to the modem. */
1922 #ifdef KERNEL_2_6
1923 static int ntty_write(struct tty_struct *tty, const u8 *buffer,
1924                       int count)
1925 {
1926 #else
1927 static s32 ntty_write(struct tty_struct *tty, s32 from_user, const u8 * buffer,
1928                       s32 count)
1929 {
1930 #endif
1931         int rval = -EINVAL;
1932         dc_t *dc = get_dc_by_tty(tty);
1933         struct port *port = (struct port *)tty->driver_data;
1934         unsigned long flags;
1935
1936         /* D1( "WRITEx: %d, index = %d", count, index); */
1937
1938         if (!port) {
1939                 return -ENODEV;
1940         }
1941
1942         if (down_trylock(&port->tty_sem)) {     // must test lock as tty layer wraps calls to this function with BKL
1943                 ERR("Would have deadlocked - return ERESTARTSYS");
1944                 return -ERESTARTSYS;
1945         }
1946
1947         if (!port->tty_open_count) {
1948                 D1(" ");
1949                 goto exit;
1950         }
1951 #ifdef KERNEL_2_4
1952         if (from_user) {
1953                 rval =
1954                     __kfifo_put_user(port->fifo_ul, (unsigned char *)buffer,
1955                                      count);
1956         } else {
1957                 rval =
1958                     __kfifo_put(port->fifo_ul, (unsigned char *)buffer, count);
1959         }
1960 #else
1961         rval = __kfifo_put(port->fifo_ul, (unsigned char *)buffer, count);
1962 #endif
1963
1964         /* notify card */
1965         if (dc == NULL) {
1966                 D1("No device context?");
1967                 goto exit;
1968         }
1969
1970         spin_lock_irqsave(&dc->spin_mutex, flags);
1971         // CTS is only valid on the modem channel
1972         if (port == &(dc->port[PORT_MDM])) {
1973                 if (port->ctrl_dl.CTS) {
1974                         D4("Enable interrupt");
1975                         enable_transmit_ul(port->tty_index, dc);
1976                 } else {
1977                         ERR("CTS not active on modem port?");
1978                 }
1979         } else {
1980                 enable_transmit_ul(port->tty_index, dc);
1981         }
1982         spin_unlock_irqrestore(&dc->spin_mutex, flags);
1983
1984       exit:
1985         up(&port->tty_sem);
1986         return rval;
1987 }
1988
1989 /* Calculate how much is left in device */
1990 /* This method is called by the upper tty layer. */
1991 /*   #according to sources N_TTY.c it expects a value >= 0 and does not check for negative values. */
1992 static int ntty_write_room(struct tty_struct *tty)
1993 {
1994         struct port *port = (struct port *)tty->driver_data;
1995         int room = 0;
1996         if (!port) {
1997                 return 0;
1998         }
1999         if (down_trylock(&port->tty_sem)) {
2000                 return 0;
2001         }
2002         if (port->tty_open_count) {
2003                 room = port->fifo_ul->size - __kfifo_len(port->fifo_ul);
2004         }
2005         up(&port->tty_sem);
2006         return room;
2007 }
2008
2009 /* Sets termios flags, called by the tty layer. */
2010 static void ntty_set_termios(struct tty_struct *tty,
2011                              struct termios *old_termios)
2012 {
2013         unsigned int cflag;
2014
2015         cflag = tty->termios->c_cflag;
2016
2017         if (old_termios) {
2018                 if ((cflag == old_termios->c_cflag) &&
2019                     (RELEVANT_IFLAG(tty->termios->c_iflag) ==
2020                      RELEVANT_IFLAG(old_termios->c_iflag))) {
2021                         D1(" - nothing to change...");
2022                         goto exit_termios;
2023                 }
2024         }
2025
2026         /* get the byte size */
2027         switch (cflag & CSIZE) {
2028         case CS5:
2029                 D1(" - data bits = 5");
2030                 break;
2031         case CS6:
2032                 D1(" - data bits = 6");
2033                 break;
2034         case CS7:
2035                 D1(" - data bits = 7");
2036                 break;
2037         default:
2038         case CS8:
2039                 D1(" - data bits = 8");
2040                 break;
2041         }
2042
2043         /* determine the parity */
2044         if (cflag & PARENB) {
2045                 if (cflag & PARODD) {
2046                         D1(" - parity = odd");
2047                 } else {
2048                         D1(" - parity = even");
2049                 }
2050         } else {
2051                 D1(" - parity = none");
2052         }
2053
2054         /* figure out the stop bits requested */
2055         if (cflag & CSTOPB) {
2056                 D1(" - stop bits = 2");
2057         } else {
2058                 D1(" - stop bits = 1");
2059         }
2060
2061         /* figure out the hardware flow control settings */
2062         if (cflag & CRTSCTS) {
2063                 D1(" - RTS/CTS is enabled");
2064         } else {
2065                 D1(" - RTS/CTS is disabled");
2066         }
2067
2068         /* determine software flow control */
2069         /* if we are implementing XON/XOFF, set the start and
2070          * stop character in the device */
2071         if (I_IXOFF(tty) || I_IXON(tty)) {
2072 #ifdef NOZOMI_DEBUG
2073                 unsigned char stop_char = STOP_CHAR(tty);
2074                 unsigned char start_char = START_CHAR(tty);
2075 #endif
2076                 /* if we are implementing INBOUND XON/XOFF */
2077                 if (I_IXOFF(tty)) {
2078                         D1(" - INBOUND XON/XOFF is enabled, "
2079                            "XON = %2x, XOFF = %2x", start_char, stop_char);
2080                 } else {
2081                         D1(" - INBOUND XON/XOFF is disabled");
2082                 }
2083
2084                 /* if we are implementing OUTBOUND XON/XOFF */
2085                 if (I_IXON(tty)) {
2086                         D1(" - OUTBOUND XON/XOFF is enabled, "
2087                            "XON = %2x, XOFF = %2x", start_char, stop_char);
2088                 } else {
2089                         D1(" - OUTBOUND XON/XOFF is disabled");
2090                 }
2091         }
2092
2093       exit_termios:
2094         return;
2095 }
2096
2097 /* Gets io control parameters */
2098 static int ntty_tiocmget(struct tty_struct *tty, struct file *file)
2099 {
2100         struct port *port = tty->driver_data;
2101         ctrl_dl_t *ctrl_dl = &port->ctrl_dl;
2102         ctrl_ul_t *ctrl_ul = &port->ctrl_ul;
2103
2104         return 0 | (ctrl_ul->RTS ? TIOCM_RTS : 0)
2105             | (ctrl_ul->DTR ? TIOCM_DTR : 0)
2106             | (ctrl_dl->DCD ? TIOCM_CAR : 0)
2107             | (ctrl_dl->RI ? TIOCM_RNG : 0)
2108             | (ctrl_dl->DSR ? TIOCM_DSR : 0)
2109             | (ctrl_dl->CTS ? TIOCM_CTS : 0);
2110 }
2111
2112 /* Sets io controls parameters */
2113 static int ntty_tiocmset(struct tty_struct *tty, struct file *file, u32 arg)
2114 {
2115         struct port *port = (struct port *)tty->driver_data;
2116
2117         set_rts(port->tty_index, (arg & TIOCM_RTS) ? 1 : 0);
2118         set_dtr(port->tty_index, (arg & TIOCM_DTR) ? 1 : 0);
2119
2120         return 0;
2121 }
2122
2123 static int ntty_ioctl_tiocmiwait(struct tty_struct *tty, struct file *file,
2124                                  unsigned int cmd, unsigned long arg)
2125 {
2126         struct port *port = (struct port *)tty->driver_data;
2127
2128         if (cmd == TIOCMIWAIT) {
2129                 DECLARE_WAITQUEUE(wait, current);
2130                 struct async_icount cnow;
2131                 struct async_icount cprev;
2132
2133                 cprev = port->tty_icount;
2134                 while (1) {
2135                         add_wait_queue(&port->tty_wait, &wait);
2136                         set_current_state(TASK_INTERRUPTIBLE);
2137                         schedule();
2138                         remove_wait_queue(&port->tty_wait, &wait);
2139
2140                         /* see if a signal woke us up */
2141                         if (signal_pending(current))
2142                                 return -ERESTARTSYS;
2143
2144                         cnow = port->tty_icount;
2145                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2146                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2147                                 return -EIO;    /* no change => error */
2148                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2149                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2150                             ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2151                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
2152                                 return 0;
2153                         }
2154                         cprev = cnow;
2155                 }
2156
2157         }
2158         return -ENOIOCTLCMD;
2159 }
2160
2161 static int ntty_ioctl_tiocgicount(struct tty_struct *tty, struct file *file,
2162                                   unsigned int cmd, void __user * arg)
2163 {
2164         struct port *port = (struct port *)tty->driver_data;
2165
2166         if (cmd == TIOCGICOUNT) {
2167                 struct async_icount cnow = port->tty_icount;
2168                 struct serial_icounter_struct icount;
2169
2170                 icount.cts = cnow.cts;
2171                 icount.dsr = cnow.dsr;
2172                 icount.rng = cnow.rng;
2173                 icount.dcd = cnow.dcd;
2174                 icount.rx = cnow.rx;
2175                 icount.tx = cnow.tx;
2176                 icount.frame = cnow.frame;
2177                 icount.overrun = cnow.overrun;
2178                 icount.parity = cnow.parity;
2179                 icount.brk = cnow.brk;
2180                 icount.buf_overrun = cnow.buf_overrun;
2181
2182                 if (copy_to_user(arg, &icount, sizeof(icount)))
2183                         return -EFAULT;
2184                 return 0;
2185         }
2186         return -ENOIOCTLCMD;
2187 }
2188
2189 static int ntty_ioctl(struct tty_struct *tty, struct file *file,
2190                       unsigned int cmd, unsigned long arg)
2191 {
2192         struct port *port = tty->driver_data;
2193         dc_t *dc = get_dc_by_tty(tty);
2194         unsigned long flags;
2195         int mask;
2196         int rval = -ENOIOCTLCMD;
2197
2198         D1("******** IOCTL, cmd: %d", cmd);
2199
2200         switch (cmd) {
2201         case TCGETS:
2202                 D1("IOCTL TCGETS ...");
2203                 rval = -ENOIOCTLCMD;
2204                 break;
2205         case TCSETS:
2206                 D1("IOCTL TCSETS ...");
2207                 rval = -ENOIOCTLCMD;
2208                 break;
2209         case TIOCMIWAIT:
2210                 rval = ntty_ioctl_tiocmiwait(tty, file, cmd, arg);
2211                 break;
2212         case TIOCGICOUNT:
2213                 rval =
2214                     ntty_ioctl_tiocgicount(tty, file, cmd, (void __user *)arg);
2215                 break;
2216         case TIOCMGET:
2217                 spin_lock_irqsave(&dc->spin_mutex, flags);
2218                 rval = ntty_tiocmget(tty, file);
2219                 spin_unlock_irqrestore(&dc->spin_mutex, flags);
2220                 break;
2221         case TIOCMSET:
2222                 rval = ntty_tiocmset(tty, file, arg);
2223                 break;
2224         case TIOCMBIC:
2225                 if (get_user(mask, (unsigned long __user *)arg))
2226                         return -EFAULT;
2227
2228                 spin_lock_irqsave(&dc->spin_mutex, flags);
2229                 if (mask & TIOCM_RTS)
2230                         set_rts(port->tty_index, 0);
2231                 if (mask & TIOCM_DTR)
2232                         set_dtr(port->tty_index, 0);
2233                 spin_unlock_irqrestore(&dc->spin_mutex, flags);
2234                 rval = 0;
2235                 break;
2236         case TIOCMBIS:
2237                 if (get_user(mask, (unsigned long __user *)arg))
2238                         return -EFAULT;
2239
2240                 spin_lock_irqsave(&dc->spin_mutex, flags);
2241                 if (mask & TIOCM_RTS)
2242                         set_rts(port->tty_index, 1);
2243                 if (mask & TIOCM_DTR)
2244                         set_dtr(port->tty_index, 1);
2245                 spin_unlock_irqrestore(&dc->spin_mutex, flags);
2246                 rval = 0;
2247                 break;
2248         case TCFLSH:
2249                 D1("IOCTL TCFLSH ...");
2250                 rval = -ENOIOCTLCMD;
2251                 break;
2252
2253         default:
2254                 D1("ERR: 0x%08X, %d", cmd, cmd);
2255                 break;
2256         };
2257
2258         return rval;
2259 }
2260
2261 /* Called by the upper tty layer when tty buffers are ready */
2262 /* to receive data again after a call to throttle. */
2263 static void ntty_unthrottle(struct tty_struct *tty)
2264 {
2265         struct port *port = (struct port *)tty->driver_data;
2266         dc_t *dc = get_dc_by_tty(tty);
2267         unsigned long flags;
2268
2269         D1("UNTHROTTLE");
2270         spin_lock_irqsave(&dc->spin_mutex, flags);
2271         enable_transmit_dl(port->tty_index, dc);
2272         set_rts(port->tty_index, 1);
2273
2274         spin_unlock_irqrestore(&dc->spin_mutex, flags);
2275 }
2276
2277 /* Called by the upper tty layer when the tty buffers are almost full. */
2278 /* The driver should stop send more data. */
2279 static void ntty_throttle(struct tty_struct *tty)
2280 {
2281         struct port *port = (struct port *)tty->driver_data;
2282         dc_t *dc = get_dc_by_tty(tty);
2283         unsigned long flags;
2284
2285         D1("THROTTLE");
2286         spin_lock_irqsave(&dc->spin_mutex, flags);
2287         set_rts(port->tty_index, 0);
2288         spin_unlock_irqrestore(&dc->spin_mutex, flags);
2289 }
2290
2291 static void ntty_put_char(struct tty_struct *tty, unsigned char c)
2292 {
2293         D2("PUT CHAR Function: %c", c);
2294 }
2295
2296 /* Returns number of chars in buffer, called by tty layer */
2297 static s32 ntty_chars_in_buffer(struct tty_struct *tty)
2298 {
2299         struct port *port = (struct port *)tty->driver_data;
2300         s32 rval;
2301
2302         if (!port) {
2303                 rval = -ENODEV;
2304                 goto exit_in_buffer;
2305         }
2306
2307         if (!port->tty_open_count) {
2308                 ERR("No tty open?");
2309                 rval = -ENODEV;
2310                 goto exit_in_buffer;
2311         }
2312
2313         rval = __kfifo_len(port->fifo_ul);
2314
2315       exit_in_buffer:
2316         return rval;
2317 }
2318
2319 static struct tty_operations tty_ops = {
2320         .ioctl = ntty_ioctl,
2321         .open = ntty_open,
2322         .close = ntty_close,
2323         .write = ntty_write,
2324         .write_room = ntty_write_room,
2325         .unthrottle = ntty_unthrottle,
2326         .throttle = ntty_throttle,
2327         .set_termios = ntty_set_termios,
2328         .chars_in_buffer = ntty_chars_in_buffer,
2329         .put_char = ntty_put_char,
2330 };
2331
2332 /* Initializes the tty */
2333 static int ntty_tty_init(dc_t * dc)
2334 {
2335         struct tty_driver *td;
2336         int rval;
2337         int i;
2338
2339         dc->tty_driver = alloc_tty_driver(NTTY_TTY_MINORS);
2340         if (!dc->tty_driver)
2341                 return -ENOMEM;
2342         td = dc->tty_driver;
2343         td->owner = THIS_MODULE;
2344         td->driver_name = NOZOMI_NAME_TTY;
2345         td->name = "noz";
2346         td->major = NTTY_TTY_MAJOR;
2347         td->type = TTY_DRIVER_TYPE_SERIAL;
2348         td->subtype = SERIAL_TYPE_NORMAL;
2349 #ifdef KERNEL_2_6_18
2350         td->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2351 #else
2352         td->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
2353 #endif
2354         td->init_termios = tty_std_termios;
2355         td->init_termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
2356
2357 #ifdef KERNEL_2_4
2358         td->table = dc->tty_table;
2359         td->refcount = &dc->tty_refcount;
2360 #endif
2361
2362         td->termios = dc->tty_termios;
2363         td->termios_locked = dc->tty_termios_locked;
2364         tty_set_operations(dc->tty_driver, &tty_ops);
2365
2366         rval = tty_register_driver(td);
2367         if (rval) {
2368                 dev_err(&dc->pdev->dev, "failed to register ntty tty driver\n");
2369                 return rval;
2370         }
2371
2372         for (i = 0; i < NTTY_TTY_MINORS; i++) {
2373                 init_MUTEX(&dc->port[i].tty_sem);
2374                 dc->port[i].tty_open_count = 0;
2375                 dc->port[i].tty = NULL;
2376 #ifdef KERNEL_2_6
2377                 tty_register_device(td, i, &dc->pdev->dev);
2378 #endif
2379         }
2380
2381         dev_info(&dc->pdev->dev, DRIVER_DESC " " NOZOMI_NAME_TTY "\n");
2382         return rval;
2383 }
2384
2385 /* Module initialization */
2386 static struct pci_driver nozomi_driver = {
2387         .name = NOZOMI_NAME,
2388         .id_table = nozomi_pci_tbl,
2389         .probe = nozomi_card_init,
2390         .remove = __devexit_p(nozomi_card_exit),
2391 };
2392
2393 static __init int nozomi_init(void)
2394 {
2395         int rval = 0;
2396
2397 //      rval = pci_module_init(&nozomi_driver);
2398         rval = pci_register_driver(&nozomi_driver);
2399         printk(KERN_INFO "Initializing %s\n", VERSION_STRING);
2400         return rval;
2401 }
2402
2403 static __exit void nozomi_exit(void)
2404 {
2405         printk(KERN_INFO "Unloading %s", DRIVER_DESC);
2406         pci_unregister_driver(&nozomi_driver);
2407 }
2408
2409 module_init(nozomi_init);
2410 module_exit(nozomi_exit);
2411
2412 #ifdef NOZOMI_DEBUG
2413 MODULE_PARM(nzdebug, "i");
2414 #endif
2415
2416 MODULE_LICENSE("Dual BSD/GPL");
2417 MODULE_DESCRIPTION(DRIVER_DESC);