2 * nozomi.c -- HSDPA driver Broadband Wireless Data Card - Globe Trotter
4 * Written by: Ulf Jakobsson,
8 * Maintained by: Paul Hardwick (p.hardwick@option.com)
11 * Locking code changes for Vodafone by Sphere Systems Ltd,
12 * Andrew Bird (ajb@spheresystems.co.uk )
15 * Source has been ported from an implementation made by Filip Aben @ Option
17 * --------------------------------------------------------------------------
19 * Copyright (c) 2005,2006 Option Wireless Sweden AB
20 * Copyright (c) 2006 Sphere Systems Ltd
21 * Copyright (c) 2006 Option Wireless n/v
22 * All rights Reserved.
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2 of the License, or
27 * (at your option) any later version.
29 * This program is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 * GNU General Public License for more details.
34 * You should have received a copy of the GNU General Public License
35 * along with this program; if not, write to the Free Software
36 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
38 * --------------------------------------------------------------------------
41 /* Enable this to have a lot of debug printouts */
44 #include <linux/kernel.h>
45 #include <linux/module.h>
46 #include <linux/pci.h>
47 #include <linux/ioport.h>
48 #include <linux/tty.h>
49 #include <linux/tty_driver.h>
50 #include <linux/tty_flip.h>
51 #include <linux/sched.h>
52 #include <linux/serial.h>
53 #include <linux/interrupt.h>
54 #include <linux/kmod.h>
55 #include <linux/init.h>
56 #include <linux/kfifo.h>
57 #include <linux/uaccess.h>
58 #include <asm/byteorder.h>
60 #include <linux/delay.h>
63 #define VERSION_STRING DRIVER_DESC " 2.1d (build date: " \
64 __DATE__ " " __TIME__ ")"
66 /* Macros definitions */
68 /* Default debug printout level */
69 #define NOZOMI_DEBUG_LEVEL 0x00
71 #define P_BUF_SIZE 128
72 #define NFO(_err_flag_, args...) \
74 char tmp[P_BUF_SIZE]; \
75 snprintf(tmp, sizeof(tmp), ##args); \
76 printk(_err_flag_ "[%d] %s(): %s\n", __LINE__, \
80 #define DBG1(args...) D_(0x01, ##args)
81 #define DBG2(args...) D_(0x02, ##args)
82 #define DBG3(args...) D_(0x04, ##args)
83 #define DBG4(args...) D_(0x08, ##args)
84 #define DBG5(args...) D_(0x10, ##args)
85 #define DBG6(args...) D_(0x20, ##args)
86 #define DBG7(args...) D_(0x40, ##args)
87 #define DBG8(args...) D_(0x80, ##args)
90 /* Do we need this settable at runtime? */
91 static int debug
= NOZOMI_DEBUG_LEVEL
;
93 #define D(lvl, args...) do \
94 {if (lvl & debug) NFO(KERN_DEBUG, ##args); } \
96 #define D_(lvl, args...) D(lvl, ##args)
98 /* These printouts are always printed */
102 #define D_(lvl, args...)
105 /* TODO: rewrite to optimize macros... */
107 #define TMP_BUF_MAX 256
109 #define DUMP(buf__,len__) \
111 char tbuf[TMP_BUF_MAX] = {0};\
113 snprintf(tbuf, len__ > TMP_BUF_MAX ? TMP_BUF_MAX : len__, "%s", buf__);\
114 if (tbuf[len__-2] == '\r') {\
115 tbuf[len__-2] = 'r';\
117 DBG1("SENDING: '%s' (%d+n)", tbuf, len__);\
119 DBG1("SENDING: '%s' (%d)", tbuf, len__);\
124 #define NOZOMI_NAME "nozomi"
125 #define NOZOMI_NAME_TTY "nozomi_tty"
126 #define DRIVER_DESC "Nozomi driver"
128 #define NTTY_TTY_MAXMINORS 256
129 #define NTTY_FIFO_BUFFER_SIZE 8192
131 /* Must be power of 2 */
132 #define FIFO_BUFFER_SIZE_UL 8192
134 /* Size of tmp send buffer to card */
135 #define SEND_BUF_MAX 1024
136 #define RECEIVE_BUF_MAX 4
139 /* Define all types of vendors and devices to support */
140 #define VENDOR1 0x1931 /* Vendor Option */
141 #define DEVICE1 0x000c /* HSDPA card */
143 #define R_IIR 0x0000 /* Interrupt Identity Register */
144 #define R_FCR 0x0000 /* Flow Control Register */
145 #define R_IER 0x0004 /* Interrupt Enable Register */
147 #define CONFIG_MAGIC 0xEFEFFEFE
148 #define TOGGLE_VALID 0x0000
150 /* Definition of interrupt tokens */
151 #define MDM_DL1 0x0001
152 #define MDM_UL1 0x0002
153 #define MDM_DL2 0x0004
154 #define MDM_UL2 0x0008
155 #define DIAG_DL1 0x0010
156 #define DIAG_DL2 0x0020
157 #define DIAG_UL 0x0040
158 #define APP1_DL 0x0080
159 #define APP1_UL 0x0100
160 #define APP2_DL 0x0200
161 #define APP2_UL 0x0400
162 #define CTRL_DL 0x0800
163 #define CTRL_UL 0x1000
166 #define MDM_DL (MDM_DL1 | MDM_DL2)
167 #define MDM_UL (MDM_UL1 | MDM_UL2)
168 #define DIAG_DL (DIAG_DL1 | DIAG_DL2)
170 /* modem signal definition */
171 #define CTRL_DSR 0x0001
172 #define CTRL_DCD 0x0002
173 #define CTRL_RI 0x0004
174 #define CTRL_CTS 0x0008
176 #define CTRL_DTR 0x0001
177 #define CTRL_RTS 0x0002
180 #define NOZOMI_MAX_PORTS 5
181 #define NOZOMI_MAX_CARDS (NTTY_TTY_MAXMINORS / MAX_PORT)
183 /* Type definitions */
186 * There are two types of nozomi cards,
187 * one with 2048 memory and with 8192 memory
190 F32_2
= 2048, /* 512 bytes downlink + uplink * 2 -> 2048 */
191 F32_8
= 8192, /* 3072 bytes downl. + 1024 bytes uplink * 2 -> 8192 */
194 /* Initialization states a card can be in */
196 NOZOMI_STATE_UKNOWN
= 0,
197 NOZOMI_STATE_ENABLED
= 1, /* pci device enabled */
198 NOZOMI_STATE_ALLOCATED
= 2, /* config setup done */
199 NOZOMI_STATE_READY
= 3, /* flowcontrols received */
202 /* Two different toggle channels exist */
208 /* Port definition for the card regarding flow control */
209 enum ctrl_port_type
{
218 /* Ports that the nozomi has */
232 unsigned int enabled
:5; /*
233 * Toggle fields are valid if enabled is 0,
234 * else A-channels must always be used.
236 unsigned int diag_dl
:1;
237 unsigned int mdm_dl
:1;
238 unsigned int mdm_ul
:1;
239 } __attribute__ ((packed
));
241 /* Configuration table to read at startup of card */
242 /* Is for now only needed during initialization phase */
243 struct config_table
{
245 u16 product_information
;
248 struct toggles toggle
;
251 * If this is 64, it can hold
252 * 60 bytes + 4 that is length field
258 * If this is 64, it can hold
259 * 60 bytes + 4 that is length field
274 } __attribute__ ((packed
));
276 /* This stores all control downlink flags */
279 unsigned int reserved
:4;
284 } __attribute__ ((packed
));
286 /* This stores all control uplink flags */
289 unsigned int reserved
:6;
292 } __attribute__ ((packed
));
297 /* This represents the toggle information */
299 unsigned int mdm_ul
:1;
300 unsigned int mdm_dl
:1;
301 unsigned int diag_dl
:1;
302 unsigned int enabled
:5; /*
303 * Toggle fields are valid if enabled is 0,
304 * else A-channels must always be used.
306 } __attribute__ ((packed
));
308 /* Configuration table to read at startup of card */
309 struct config_table
{
312 u16 product_information
;
313 struct toggles toggle
;
317 * If this is 64, it can hold
318 * 60 bytes + 4 that is length field
334 } __attribute__ ((packed
));
336 /* This stores all control downlink flags */
342 unsigned int reserverd
:4;
344 } __attribute__ ((packed
));
346 /* This stores all control uplink flags */
350 unsigned int reserved
:6;
352 } __attribute__ ((packed
));
355 /* This holds all information that is needed regarding a port */
357 struct tty_port port
;
358 u8 update_flow_control
;
359 struct ctrl_ul ctrl_ul
;
360 struct ctrl_dl ctrl_dl
;
361 struct kfifo fifo_ul
;
362 void __iomem
*dl_addr
[2];
365 void __iomem
*ul_addr
[2];
370 /* mutex to ensure one access patch to this port */
371 struct mutex tty_sem
;
372 wait_queue_head_t tty_wait
;
373 struct async_icount tty_icount
;
378 /* Private data one for each card in the system */
380 void __iomem
*base_addr
;
383 /* Pointers to registers */
384 void __iomem
*reg_iir
;
385 void __iomem
*reg_fcr
;
386 void __iomem
*reg_ier
;
389 enum card_type card_type
;
390 struct config_table config_table
; /* Configuration table */
391 struct pci_dev
*pdev
;
392 struct port port
[NOZOMI_MAX_PORTS
];
395 spinlock_t spin_mutex
; /* secures access to registers and tty */
397 unsigned int index_start
;
398 enum card_state state
;
402 /* This is a data packet that is read or written to/from card */
404 u32 size
; /* size is the length of the data buffer */
406 } __attribute__ ((packed
));
408 /* Global variables */
409 static const struct pci_device_id nozomi_pci_tbl
[] __devinitconst
= {
410 {PCI_DEVICE(VENDOR1
, DEVICE1
)},
414 MODULE_DEVICE_TABLE(pci
, nozomi_pci_tbl
);
416 static struct nozomi
*ndevs
[NOZOMI_MAX_CARDS
];
417 static struct tty_driver
*ntty_driver
;
419 static const struct tty_port_operations noz_tty_port_ops
;
422 * find card by tty_index
424 static inline struct nozomi
*get_dc_by_tty(const struct tty_struct
*tty
)
426 return tty
? ndevs
[tty
->index
/ MAX_PORT
] : NULL
;
429 static inline struct port
*get_port_by_tty(const struct tty_struct
*tty
)
431 struct nozomi
*ndev
= get_dc_by_tty(tty
);
432 return ndev
? &ndev
->port
[tty
->index
% MAX_PORT
] : NULL
;
441 static void read_mem32(u32
*buf
, const void __iomem
*mem_addr_start
,
445 const u32 __iomem
*ptr
= mem_addr_start
;
448 if (unlikely(!ptr
|| !buf
))
451 /* shortcut for extremely often used cases */
452 switch (size_bytes
) {
453 case 2: /* 2 bytes */
455 *buf16
= __le16_to_cpu(readw(ptr
));
458 case 4: /* 4 bytes */
459 *(buf
) = __le32_to_cpu(readl(ptr
));
464 while (i
< size_bytes
) {
465 if (size_bytes
- i
== 2) {
466 /* Handle 2 bytes in the end */
468 *(buf16
) = __le16_to_cpu(readw(ptr
));
472 *(buf
) = __le32_to_cpu(readl(ptr
));
487 static u32
write_mem32(void __iomem
*mem_addr_start
, const u32
*buf
,
491 u32 __iomem
*ptr
= mem_addr_start
;
494 if (unlikely(!ptr
|| !buf
))
497 /* shortcut for extremely often used cases */
498 switch (size_bytes
) {
499 case 2: /* 2 bytes */
500 buf16
= (const u16
*)buf
;
501 writew(__cpu_to_le16(*buf16
), ptr
);
505 * also needs to write 4 bytes in this case
506 * so falling through..
508 case 4: /* 4 bytes */
509 writel(__cpu_to_le32(*buf
), ptr
);
514 while (i
< size_bytes
) {
515 if (size_bytes
- i
== 2) {
517 buf16
= (const u16
*)buf
;
518 writew(__cpu_to_le16(*buf16
), ptr
);
522 writel(__cpu_to_le32(*buf
), ptr
);
531 /* Setup pointers to different channels and also setup buffer sizes. */
532 static void setup_memory(struct nozomi
*dc
)
534 void __iomem
*offset
= dc
->base_addr
+ dc
->config_table
.dl_start
;
535 /* The length reported is including the length field of 4 bytes,
536 * hence subtract with 4.
538 const u16 buff_offset
= 4;
540 /* Modem port dl configuration */
541 dc
->port
[PORT_MDM
].dl_addr
[CH_A
] = offset
;
542 dc
->port
[PORT_MDM
].dl_addr
[CH_B
] =
543 (offset
+= dc
->config_table
.dl_mdm_len1
);
544 dc
->port
[PORT_MDM
].dl_size
[CH_A
] =
545 dc
->config_table
.dl_mdm_len1
- buff_offset
;
546 dc
->port
[PORT_MDM
].dl_size
[CH_B
] =
547 dc
->config_table
.dl_mdm_len2
- buff_offset
;
549 /* Diag port dl configuration */
550 dc
->port
[PORT_DIAG
].dl_addr
[CH_A
] =
551 (offset
+= dc
->config_table
.dl_mdm_len2
);
552 dc
->port
[PORT_DIAG
].dl_size
[CH_A
] =
553 dc
->config_table
.dl_diag_len1
- buff_offset
;
554 dc
->port
[PORT_DIAG
].dl_addr
[CH_B
] =
555 (offset
+= dc
->config_table
.dl_diag_len1
);
556 dc
->port
[PORT_DIAG
].dl_size
[CH_B
] =
557 dc
->config_table
.dl_diag_len2
- buff_offset
;
559 /* App1 port dl configuration */
560 dc
->port
[PORT_APP1
].dl_addr
[CH_A
] =
561 (offset
+= dc
->config_table
.dl_diag_len2
);
562 dc
->port
[PORT_APP1
].dl_size
[CH_A
] =
563 dc
->config_table
.dl_app1_len
- buff_offset
;
565 /* App2 port dl configuration */
566 dc
->port
[PORT_APP2
].dl_addr
[CH_A
] =
567 (offset
+= dc
->config_table
.dl_app1_len
);
568 dc
->port
[PORT_APP2
].dl_size
[CH_A
] =
569 dc
->config_table
.dl_app2_len
- buff_offset
;
571 /* Ctrl dl configuration */
572 dc
->port
[PORT_CTRL
].dl_addr
[CH_A
] =
573 (offset
+= dc
->config_table
.dl_app2_len
);
574 dc
->port
[PORT_CTRL
].dl_size
[CH_A
] =
575 dc
->config_table
.dl_ctrl_len
- buff_offset
;
577 offset
= dc
->base_addr
+ dc
->config_table
.ul_start
;
579 /* Modem Port ul configuration */
580 dc
->port
[PORT_MDM
].ul_addr
[CH_A
] = offset
;
581 dc
->port
[PORT_MDM
].ul_size
[CH_A
] =
582 dc
->config_table
.ul_mdm_len1
- buff_offset
;
583 dc
->port
[PORT_MDM
].ul_addr
[CH_B
] =
584 (offset
+= dc
->config_table
.ul_mdm_len1
);
585 dc
->port
[PORT_MDM
].ul_size
[CH_B
] =
586 dc
->config_table
.ul_mdm_len2
- buff_offset
;
588 /* Diag port ul configuration */
589 dc
->port
[PORT_DIAG
].ul_addr
[CH_A
] =
590 (offset
+= dc
->config_table
.ul_mdm_len2
);
591 dc
->port
[PORT_DIAG
].ul_size
[CH_A
] =
592 dc
->config_table
.ul_diag_len
- buff_offset
;
594 /* App1 port ul configuration */
595 dc
->port
[PORT_APP1
].ul_addr
[CH_A
] =
596 (offset
+= dc
->config_table
.ul_diag_len
);
597 dc
->port
[PORT_APP1
].ul_size
[CH_A
] =
598 dc
->config_table
.ul_app1_len
- buff_offset
;
600 /* App2 port ul configuration */
601 dc
->port
[PORT_APP2
].ul_addr
[CH_A
] =
602 (offset
+= dc
->config_table
.ul_app1_len
);
603 dc
->port
[PORT_APP2
].ul_size
[CH_A
] =
604 dc
->config_table
.ul_app2_len
- buff_offset
;
606 /* Ctrl ul configuration */
607 dc
->port
[PORT_CTRL
].ul_addr
[CH_A
] =
608 (offset
+= dc
->config_table
.ul_app2_len
);
609 dc
->port
[PORT_CTRL
].ul_size
[CH_A
] =
610 dc
->config_table
.ul_ctrl_len
- buff_offset
;
613 /* Dump config table under initalization phase */
615 static void dump_table(const struct nozomi
*dc
)
617 DBG3("signature: 0x%08X", dc
->config_table
.signature
);
618 DBG3("version: 0x%04X", dc
->config_table
.version
);
619 DBG3("product_information: 0x%04X", \
620 dc
->config_table
.product_information
);
621 DBG3("toggle enabled: %d", dc
->config_table
.toggle
.enabled
);
622 DBG3("toggle up_mdm: %d", dc
->config_table
.toggle
.mdm_ul
);
623 DBG3("toggle dl_mdm: %d", dc
->config_table
.toggle
.mdm_dl
);
624 DBG3("toggle dl_dbg: %d", dc
->config_table
.toggle
.diag_dl
);
626 DBG3("dl_start: 0x%04X", dc
->config_table
.dl_start
);
627 DBG3("dl_mdm_len0: 0x%04X, %d", dc
->config_table
.dl_mdm_len1
,
628 dc
->config_table
.dl_mdm_len1
);
629 DBG3("dl_mdm_len1: 0x%04X, %d", dc
->config_table
.dl_mdm_len2
,
630 dc
->config_table
.dl_mdm_len2
);
631 DBG3("dl_diag_len0: 0x%04X, %d", dc
->config_table
.dl_diag_len1
,
632 dc
->config_table
.dl_diag_len1
);
633 DBG3("dl_diag_len1: 0x%04X, %d", dc
->config_table
.dl_diag_len2
,
634 dc
->config_table
.dl_diag_len2
);
635 DBG3("dl_app1_len: 0x%04X, %d", dc
->config_table
.dl_app1_len
,
636 dc
->config_table
.dl_app1_len
);
637 DBG3("dl_app2_len: 0x%04X, %d", dc
->config_table
.dl_app2_len
,
638 dc
->config_table
.dl_app2_len
);
639 DBG3("dl_ctrl_len: 0x%04X, %d", dc
->config_table
.dl_ctrl_len
,
640 dc
->config_table
.dl_ctrl_len
);
641 DBG3("ul_start: 0x%04X, %d", dc
->config_table
.ul_start
,
642 dc
->config_table
.ul_start
);
643 DBG3("ul_mdm_len[0]: 0x%04X, %d", dc
->config_table
.ul_mdm_len1
,
644 dc
->config_table
.ul_mdm_len1
);
645 DBG3("ul_mdm_len[1]: 0x%04X, %d", dc
->config_table
.ul_mdm_len2
,
646 dc
->config_table
.ul_mdm_len2
);
647 DBG3("ul_diag_len: 0x%04X, %d", dc
->config_table
.ul_diag_len
,
648 dc
->config_table
.ul_diag_len
);
649 DBG3("ul_app1_len: 0x%04X, %d", dc
->config_table
.ul_app1_len
,
650 dc
->config_table
.ul_app1_len
);
651 DBG3("ul_app2_len: 0x%04X, %d", dc
->config_table
.ul_app2_len
,
652 dc
->config_table
.ul_app2_len
);
653 DBG3("ul_ctrl_len: 0x%04X, %d", dc
->config_table
.ul_ctrl_len
,
654 dc
->config_table
.ul_ctrl_len
);
657 static inline void dump_table(const struct nozomi
*dc
) { }
661 * Read configuration table from card under intalization phase
662 * Returns 1 if ok, else 0
664 static int nozomi_read_config_table(struct nozomi
*dc
)
666 read_mem32((u32
*) &dc
->config_table
, dc
->base_addr
+ 0,
667 sizeof(struct config_table
));
669 if (dc
->config_table
.signature
!= CONFIG_MAGIC
) {
670 dev_err(&dc
->pdev
->dev
, "ConfigTable Bad! 0x%08X != 0x%08X\n",
671 dc
->config_table
.signature
, CONFIG_MAGIC
);
675 if ((dc
->config_table
.version
== 0)
676 || (dc
->config_table
.toggle
.enabled
== TOGGLE_VALID
)) {
678 DBG1("Second phase, configuring card");
682 dc
->port
[PORT_MDM
].toggle_ul
= dc
->config_table
.toggle
.mdm_ul
;
683 dc
->port
[PORT_MDM
].toggle_dl
= dc
->config_table
.toggle
.mdm_dl
;
684 dc
->port
[PORT_DIAG
].toggle_dl
= dc
->config_table
.toggle
.diag_dl
;
685 DBG1("toggle ports: MDM UL:%d MDM DL:%d, DIAG DL:%d",
686 dc
->port
[PORT_MDM
].toggle_ul
,
687 dc
->port
[PORT_MDM
].toggle_dl
, dc
->port
[PORT_DIAG
].toggle_dl
);
691 for (i
= PORT_MDM
; i
< MAX_PORT
; i
++) {
692 memset(&dc
->port
[i
].ctrl_dl
, 0, sizeof(struct ctrl_dl
));
693 memset(&dc
->port
[i
].ctrl_ul
, 0, sizeof(struct ctrl_ul
));
696 /* Enable control channel */
697 dc
->last_ier
= dc
->last_ier
| CTRL_DL
;
698 writew(dc
->last_ier
, dc
->reg_ier
);
700 dc
->state
= NOZOMI_STATE_ALLOCATED
;
701 dev_info(&dc
->pdev
->dev
, "Initialization OK!\n");
705 if ((dc
->config_table
.version
> 0)
706 && (dc
->config_table
.toggle
.enabled
!= TOGGLE_VALID
)) {
708 DBG1("First phase: pushing upload buffers, clearing download");
710 dev_info(&dc
->pdev
->dev
, "Version of card: %d\n",
711 dc
->config_table
.version
);
713 /* Here we should disable all I/O over F32. */
717 * We should send ALL channel pair tokens back along
721 /* push upload modem buffers */
722 write_mem32(dc
->port
[PORT_MDM
].ul_addr
[CH_A
],
724 write_mem32(dc
->port
[PORT_MDM
].ul_addr
[CH_B
],
727 writew(MDM_UL
| DIAG_DL
| MDM_DL
, dc
->reg_fcr
);
729 DBG1("First phase done");
735 /* Enable uplink interrupts */
736 static void enable_transmit_ul(enum port_type port
, struct nozomi
*dc
)
738 static const u16 mask
[] = {MDM_UL
, DIAG_UL
, APP1_UL
, APP2_UL
, CTRL_UL
};
740 if (port
< NOZOMI_MAX_PORTS
) {
741 dc
->last_ier
|= mask
[port
];
742 writew(dc
->last_ier
, dc
->reg_ier
);
744 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
748 /* Disable uplink interrupts */
749 static void disable_transmit_ul(enum port_type port
, struct nozomi
*dc
)
751 static const u16 mask
[] =
752 {~MDM_UL
, ~DIAG_UL
, ~APP1_UL
, ~APP2_UL
, ~CTRL_UL
};
754 if (port
< NOZOMI_MAX_PORTS
) {
755 dc
->last_ier
&= mask
[port
];
756 writew(dc
->last_ier
, dc
->reg_ier
);
758 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
762 /* Enable downlink interrupts */
763 static void enable_transmit_dl(enum port_type port
, struct nozomi
*dc
)
765 static const u16 mask
[] = {MDM_DL
, DIAG_DL
, APP1_DL
, APP2_DL
, CTRL_DL
};
767 if (port
< NOZOMI_MAX_PORTS
) {
768 dc
->last_ier
|= mask
[port
];
769 writew(dc
->last_ier
, dc
->reg_ier
);
771 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
775 /* Disable downlink interrupts */
776 static void disable_transmit_dl(enum port_type port
, struct nozomi
*dc
)
778 static const u16 mask
[] =
779 {~MDM_DL
, ~DIAG_DL
, ~APP1_DL
, ~APP2_DL
, ~CTRL_DL
};
781 if (port
< NOZOMI_MAX_PORTS
) {
782 dc
->last_ier
&= mask
[port
];
783 writew(dc
->last_ier
, dc
->reg_ier
);
785 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
790 * Return 1 - send buffer to card and ack.
791 * Return 0 - don't ack, don't send buffer to card.
793 static int send_data(enum port_type index
, struct nozomi
*dc
)
796 struct port
*port
= &dc
->port
[index
];
797 const u8 toggle
= port
->toggle_ul
;
798 void __iomem
*addr
= port
->ul_addr
[toggle
];
799 const u32 ul_size
= port
->ul_size
[toggle
];
800 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
802 /* Get data from tty and place in buf for now */
803 size
= kfifo_out(&port
->fifo_ul
, dc
->send_buf
,
804 ul_size
< SEND_BUF_MAX
? ul_size
: SEND_BUF_MAX
);
807 DBG4("No more data to send, disable link:");
812 /* DUMP(buf, size); */
814 /* Write length + data */
815 write_mem32(addr
, (u32
*) &size
, 4);
816 write_mem32(addr
+ 4, (u32
*) dc
->send_buf
, size
);
825 /* If all data has been read, return 1, else 0 */
826 static int receive_data(enum port_type index
, struct nozomi
*dc
)
828 u8 buf
[RECEIVE_BUF_MAX
] = { 0 };
831 struct port
*port
= &dc
->port
[index
];
832 void __iomem
*addr
= port
->dl_addr
[port
->toggle_dl
];
833 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
836 if (unlikely(!tty
)) {
837 DBG1("tty not open for port: %d?", index
);
841 read_mem32((u32
*) &size
, addr
, 4);
842 /* DBG1( "%d bytes port: %d", size, index); */
844 if (test_bit(TTY_THROTTLED
, &tty
->flags
)) {
845 DBG1("No room in tty, don't read data, don't ack interrupt, "
846 "disable interrupt");
848 /* disable interrupt in downlink... */
849 disable_transmit_dl(index
, dc
);
854 if (unlikely(size
== 0)) {
855 dev_err(&dc
->pdev
->dev
, "size == 0?\n");
860 tty_buffer_request_room(tty
, size
);
863 read_mem32((u32
*) buf
, addr
+ offset
, RECEIVE_BUF_MAX
);
866 tty_insert_flip_char(tty
, buf
[0], TTY_NORMAL
);
868 } else if (size
< RECEIVE_BUF_MAX
) {
869 size
-= tty_insert_flip_string(tty
, (char *) buf
, size
);
871 i
= tty_insert_flip_string(tty
, \
872 (char *) buf
, RECEIVE_BUF_MAX
);
878 set_bit(index
, &dc
->flip
);
885 /* Debug for interrupts */
887 static char *interrupt2str(u16 interrupt
)
889 static char buf
[TMP_BUF_MAX
];
892 interrupt
& MDM_DL1
? p
+= snprintf(p
, TMP_BUF_MAX
, "MDM_DL1 ") : NULL
;
893 interrupt
& MDM_DL2
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
896 interrupt
& MDM_UL1
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
898 interrupt
& MDM_UL2
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
901 interrupt
& DIAG_DL1
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
903 interrupt
& DIAG_DL2
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
906 interrupt
& DIAG_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
909 interrupt
& APP1_DL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
911 interrupt
& APP2_DL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
914 interrupt
& APP1_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
916 interrupt
& APP2_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
919 interrupt
& CTRL_DL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
921 interrupt
& CTRL_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
924 interrupt
& RESET
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
932 * Receive flow control
933 * Return 1 - If ok, else 0
935 static int receive_flow_control(struct nozomi
*dc
)
937 enum port_type port
= PORT_MDM
;
938 struct ctrl_dl ctrl_dl
;
939 struct ctrl_dl old_ctrl
;
942 read_mem32((u32
*) &ctrl_dl
, dc
->port
[PORT_CTRL
].dl_addr
[CH_A
], 2);
944 switch (ctrl_dl
.port
) {
946 DBG1("The Base Band sends this value as a response to a "
947 "request for IMSI detach sent over the control "
948 "channel uplink (see section 7.6.1).");
956 enable_ier
= DIAG_DL
;
960 enable_ier
= APP1_DL
;
964 enable_ier
= APP2_DL
;
965 if (dc
->state
== NOZOMI_STATE_ALLOCATED
) {
967 * After card initialization the flow control
968 * received for APP2 is always the last
970 dc
->state
= NOZOMI_STATE_READY
;
971 dev_info(&dc
->pdev
->dev
, "Device READY!\n");
975 dev_err(&dc
->pdev
->dev
,
976 "ERROR: flow control received for non-existing port\n");
980 DBG1("0x%04X->0x%04X", *((u16
*)&dc
->port
[port
].ctrl_dl
),
983 old_ctrl
= dc
->port
[port
].ctrl_dl
;
984 dc
->port
[port
].ctrl_dl
= ctrl_dl
;
986 if (old_ctrl
.CTS
== 1 && ctrl_dl
.CTS
== 0) {
987 DBG1("Disable interrupt (0x%04X) on port: %d",
989 disable_transmit_ul(port
, dc
);
991 } else if (old_ctrl
.CTS
== 0 && ctrl_dl
.CTS
== 1) {
993 if (kfifo_len(&dc
->port
[port
].fifo_ul
)) {
994 DBG1("Enable interrupt (0x%04X) on port: %d",
996 DBG1("Data in buffer [%d], enable transmit! ",
997 kfifo_len(&dc
->port
[port
].fifo_ul
));
998 enable_transmit_ul(port
, dc
);
1000 DBG1("No data in buffer...");
1004 if (*(u16
*)&old_ctrl
== *(u16
*)&ctrl_dl
) {
1005 DBG1(" No change in mctrl");
1008 /* Update statistics */
1009 if (old_ctrl
.CTS
!= ctrl_dl
.CTS
)
1010 dc
->port
[port
].tty_icount
.cts
++;
1011 if (old_ctrl
.DSR
!= ctrl_dl
.DSR
)
1012 dc
->port
[port
].tty_icount
.dsr
++;
1013 if (old_ctrl
.RI
!= ctrl_dl
.RI
)
1014 dc
->port
[port
].tty_icount
.rng
++;
1015 if (old_ctrl
.DCD
!= ctrl_dl
.DCD
)
1016 dc
->port
[port
].tty_icount
.dcd
++;
1018 wake_up_interruptible(&dc
->port
[port
].tty_wait
);
1020 DBG1("port: %d DCD(%d), CTS(%d), RI(%d), DSR(%d)",
1022 dc
->port
[port
].tty_icount
.dcd
, dc
->port
[port
].tty_icount
.cts
,
1023 dc
->port
[port
].tty_icount
.rng
, dc
->port
[port
].tty_icount
.dsr
);
1028 static enum ctrl_port_type
port2ctrl(enum port_type port
,
1029 const struct nozomi
*dc
)
1041 dev_err(&dc
->pdev
->dev
,
1042 "ERROR: send flow control " \
1043 "received for non-existing port\n");
1049 * Send flow control, can only update one channel at a time
1050 * Return 0 - If we have updated all flow control
1051 * Return 1 - If we need to update more flow control, ack current enable more
1053 static int send_flow_control(struct nozomi
*dc
)
1055 u32 i
, more_flow_control_to_be_updated
= 0;
1058 for (i
= PORT_MDM
; i
< MAX_PORT
; i
++) {
1059 if (dc
->port
[i
].update_flow_control
) {
1060 if (more_flow_control_to_be_updated
) {
1061 /* We have more flow control to be updated */
1064 dc
->port
[i
].ctrl_ul
.port
= port2ctrl(i
, dc
);
1065 ctrl
= (u16
*)&dc
->port
[i
].ctrl_ul
;
1066 write_mem32(dc
->port
[PORT_CTRL
].ul_addr
[0], \
1068 dc
->port
[i
].update_flow_control
= 0;
1069 more_flow_control_to_be_updated
= 1;
1076 * Handle downlink data, ports that are handled are modem and diagnostics
1078 * Return 0 - toggle fields are out of sync
1080 static int handle_data_dl(struct nozomi
*dc
, enum port_type port
, u8
*toggle
,
1081 u16 read_iir
, u16 mask1
, u16 mask2
)
1083 if (*toggle
== 0 && read_iir
& mask1
) {
1084 if (receive_data(port
, dc
)) {
1085 writew(mask1
, dc
->reg_fcr
);
1086 *toggle
= !(*toggle
);
1089 if (read_iir
& mask2
) {
1090 if (receive_data(port
, dc
)) {
1091 writew(mask2
, dc
->reg_fcr
);
1092 *toggle
= !(*toggle
);
1095 } else if (*toggle
== 1 && read_iir
& mask2
) {
1096 if (receive_data(port
, dc
)) {
1097 writew(mask2
, dc
->reg_fcr
);
1098 *toggle
= !(*toggle
);
1101 if (read_iir
& mask1
) {
1102 if (receive_data(port
, dc
)) {
1103 writew(mask1
, dc
->reg_fcr
);
1104 *toggle
= !(*toggle
);
1108 dev_err(&dc
->pdev
->dev
, "port out of sync!, toggle:%d\n",
1116 * Handle uplink data, this is currently for the modem port
1118 * Return 0 - toggle field are out of sync
1120 static int handle_data_ul(struct nozomi
*dc
, enum port_type port
, u16 read_iir
)
1122 u8
*toggle
= &(dc
->port
[port
].toggle_ul
);
1124 if (*toggle
== 0 && read_iir
& MDM_UL1
) {
1125 dc
->last_ier
&= ~MDM_UL
;
1126 writew(dc
->last_ier
, dc
->reg_ier
);
1127 if (send_data(port
, dc
)) {
1128 writew(MDM_UL1
, dc
->reg_fcr
);
1129 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1130 writew(dc
->last_ier
, dc
->reg_ier
);
1134 if (read_iir
& MDM_UL2
) {
1135 dc
->last_ier
&= ~MDM_UL
;
1136 writew(dc
->last_ier
, dc
->reg_ier
);
1137 if (send_data(port
, dc
)) {
1138 writew(MDM_UL2
, dc
->reg_fcr
);
1139 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1140 writew(dc
->last_ier
, dc
->reg_ier
);
1145 } else if (*toggle
== 1 && read_iir
& MDM_UL2
) {
1146 dc
->last_ier
&= ~MDM_UL
;
1147 writew(dc
->last_ier
, dc
->reg_ier
);
1148 if (send_data(port
, dc
)) {
1149 writew(MDM_UL2
, dc
->reg_fcr
);
1150 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1151 writew(dc
->last_ier
, dc
->reg_ier
);
1155 if (read_iir
& MDM_UL1
) {
1156 dc
->last_ier
&= ~MDM_UL
;
1157 writew(dc
->last_ier
, dc
->reg_ier
);
1158 if (send_data(port
, dc
)) {
1159 writew(MDM_UL1
, dc
->reg_fcr
);
1160 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1161 writew(dc
->last_ier
, dc
->reg_ier
);
1166 writew(read_iir
& MDM_UL
, dc
->reg_fcr
);
1167 dev_err(&dc
->pdev
->dev
, "port out of sync!\n");
1173 static irqreturn_t
interrupt_handler(int irq
, void *dev_id
)
1175 struct nozomi
*dc
= dev_id
;
1182 spin_lock(&dc
->spin_mutex
);
1183 read_iir
= readw(dc
->reg_iir
);
1186 if (read_iir
== (u16
)-1)
1189 * Just handle interrupt enabled in IER
1190 * (by masking with dc->last_ier)
1192 read_iir
&= dc
->last_ier
;
1198 DBG4("%s irq:0x%04X, prev:0x%04X", interrupt2str(read_iir
), read_iir
,
1201 if (read_iir
& RESET
) {
1202 if (unlikely(!nozomi_read_config_table(dc
))) {
1204 writew(dc
->last_ier
, dc
->reg_ier
);
1205 dev_err(&dc
->pdev
->dev
, "Could not read status from "
1206 "card, we should disable interface\n");
1208 writew(RESET
, dc
->reg_fcr
);
1210 /* No more useful info if this was the reset interrupt. */
1213 if (read_iir
& CTRL_UL
) {
1215 dc
->last_ier
&= ~CTRL_UL
;
1216 writew(dc
->last_ier
, dc
->reg_ier
);
1217 if (send_flow_control(dc
)) {
1218 writew(CTRL_UL
, dc
->reg_fcr
);
1219 dc
->last_ier
= dc
->last_ier
| CTRL_UL
;
1220 writew(dc
->last_ier
, dc
->reg_ier
);
1223 if (read_iir
& CTRL_DL
) {
1224 receive_flow_control(dc
);
1225 writew(CTRL_DL
, dc
->reg_fcr
);
1227 if (read_iir
& MDM_DL
) {
1228 if (!handle_data_dl(dc
, PORT_MDM
,
1229 &(dc
->port
[PORT_MDM
].toggle_dl
), read_iir
,
1230 MDM_DL1
, MDM_DL2
)) {
1231 dev_err(&dc
->pdev
->dev
, "MDM_DL out of sync!\n");
1235 if (read_iir
& MDM_UL
) {
1236 if (!handle_data_ul(dc
, PORT_MDM
, read_iir
)) {
1237 dev_err(&dc
->pdev
->dev
, "MDM_UL out of sync!\n");
1241 if (read_iir
& DIAG_DL
) {
1242 if (!handle_data_dl(dc
, PORT_DIAG
,
1243 &(dc
->port
[PORT_DIAG
].toggle_dl
), read_iir
,
1244 DIAG_DL1
, DIAG_DL2
)) {
1245 dev_err(&dc
->pdev
->dev
, "DIAG_DL out of sync!\n");
1249 if (read_iir
& DIAG_UL
) {
1250 dc
->last_ier
&= ~DIAG_UL
;
1251 writew(dc
->last_ier
, dc
->reg_ier
);
1252 if (send_data(PORT_DIAG
, dc
)) {
1253 writew(DIAG_UL
, dc
->reg_fcr
);
1254 dc
->last_ier
= dc
->last_ier
| DIAG_UL
;
1255 writew(dc
->last_ier
, dc
->reg_ier
);
1258 if (read_iir
& APP1_DL
) {
1259 if (receive_data(PORT_APP1
, dc
))
1260 writew(APP1_DL
, dc
->reg_fcr
);
1262 if (read_iir
& APP1_UL
) {
1263 dc
->last_ier
&= ~APP1_UL
;
1264 writew(dc
->last_ier
, dc
->reg_ier
);
1265 if (send_data(PORT_APP1
, dc
)) {
1266 writew(APP1_UL
, dc
->reg_fcr
);
1267 dc
->last_ier
= dc
->last_ier
| APP1_UL
;
1268 writew(dc
->last_ier
, dc
->reg_ier
);
1271 if (read_iir
& APP2_DL
) {
1272 if (receive_data(PORT_APP2
, dc
))
1273 writew(APP2_DL
, dc
->reg_fcr
);
1275 if (read_iir
& APP2_UL
) {
1276 dc
->last_ier
&= ~APP2_UL
;
1277 writew(dc
->last_ier
, dc
->reg_ier
);
1278 if (send_data(PORT_APP2
, dc
)) {
1279 writew(APP2_UL
, dc
->reg_fcr
);
1280 dc
->last_ier
= dc
->last_ier
| APP2_UL
;
1281 writew(dc
->last_ier
, dc
->reg_ier
);
1286 spin_unlock(&dc
->spin_mutex
);
1287 for (a
= 0; a
< NOZOMI_MAX_PORTS
; a
++) {
1288 struct tty_struct
*tty
;
1289 if (test_and_clear_bit(a
, &dc
->flip
)) {
1290 tty
= tty_port_tty_get(&dc
->port
[a
].port
);
1292 tty_flip_buffer_push(tty
);
1298 spin_unlock(&dc
->spin_mutex
);
1302 static void nozomi_get_card_type(struct nozomi
*dc
)
1307 for (i
= 0; i
< 6; i
++)
1308 size
+= pci_resource_len(dc
->pdev
, i
);
1310 /* Assume card type F32_8 if no match */
1311 dc
->card_type
= size
== 2048 ? F32_2
: F32_8
;
1313 dev_info(&dc
->pdev
->dev
, "Card type is: %d\n", dc
->card_type
);
1316 static void nozomi_setup_private_data(struct nozomi
*dc
)
1318 void __iomem
*offset
= dc
->base_addr
+ dc
->card_type
/ 2;
1321 dc
->reg_fcr
= (void __iomem
*)(offset
+ R_FCR
);
1322 dc
->reg_iir
= (void __iomem
*)(offset
+ R_IIR
);
1323 dc
->reg_ier
= (void __iomem
*)(offset
+ R_IER
);
1327 dc
->port
[PORT_MDM
].token_dl
= MDM_DL
;
1328 dc
->port
[PORT_DIAG
].token_dl
= DIAG_DL
;
1329 dc
->port
[PORT_APP1
].token_dl
= APP1_DL
;
1330 dc
->port
[PORT_APP2
].token_dl
= APP2_DL
;
1332 for (i
= 0; i
< MAX_PORT
; i
++)
1333 init_waitqueue_head(&dc
->port
[i
].tty_wait
);
1336 static ssize_t
card_type_show(struct device
*dev
, struct device_attribute
*attr
,
1339 const struct nozomi
*dc
= pci_get_drvdata(to_pci_dev(dev
));
1341 return sprintf(buf
, "%d\n", dc
->card_type
);
1343 static DEVICE_ATTR(card_type
, S_IRUGO
, card_type_show
, NULL
);
1345 static ssize_t
open_ttys_show(struct device
*dev
, struct device_attribute
*attr
,
1348 const struct nozomi
*dc
= pci_get_drvdata(to_pci_dev(dev
));
1350 return sprintf(buf
, "%u\n", dc
->open_ttys
);
1352 static DEVICE_ATTR(open_ttys
, S_IRUGO
, open_ttys_show
, NULL
);
1354 static void make_sysfs_files(struct nozomi
*dc
)
1356 if (device_create_file(&dc
->pdev
->dev
, &dev_attr_card_type
))
1357 dev_err(&dc
->pdev
->dev
,
1358 "Could not create sysfs file for card_type\n");
1359 if (device_create_file(&dc
->pdev
->dev
, &dev_attr_open_ttys
))
1360 dev_err(&dc
->pdev
->dev
,
1361 "Could not create sysfs file for open_ttys\n");
1364 static void remove_sysfs_files(struct nozomi
*dc
)
1366 device_remove_file(&dc
->pdev
->dev
, &dev_attr_card_type
);
1367 device_remove_file(&dc
->pdev
->dev
, &dev_attr_open_ttys
);
1370 /* Allocate memory for one device */
1371 static int __devinit
nozomi_card_init(struct pci_dev
*pdev
,
1372 const struct pci_device_id
*ent
)
1374 resource_size_t start
;
1376 struct nozomi
*dc
= NULL
;
1380 dev_dbg(&pdev
->dev
, "Init, new card found\n");
1382 for (ndev_idx
= 0; ndev_idx
< ARRAY_SIZE(ndevs
); ndev_idx
++)
1383 if (!ndevs
[ndev_idx
])
1386 if (ndev_idx
>= ARRAY_SIZE(ndevs
)) {
1387 dev_err(&pdev
->dev
, "no free tty range for this card left\n");
1392 dc
= kzalloc(sizeof(struct nozomi
), GFP_KERNEL
);
1393 if (unlikely(!dc
)) {
1394 dev_err(&pdev
->dev
, "Could not allocate memory\n");
1401 ret
= pci_enable_device(dc
->pdev
);
1403 dev_err(&pdev
->dev
, "Failed to enable PCI Device\n");
1407 ret
= pci_request_regions(dc
->pdev
, NOZOMI_NAME
);
1409 dev_err(&pdev
->dev
, "I/O address 0x%04x already in use\n",
1410 (int) /* nozomi_private.io_addr */ 0);
1411 goto err_disable_device
;
1414 start
= pci_resource_start(dc
->pdev
, 0);
1416 dev_err(&pdev
->dev
, "No I/O address for card detected\n");
1421 /* Find out what card type it is */
1422 nozomi_get_card_type(dc
);
1424 dc
->base_addr
= ioremap_nocache(start
, dc
->card_type
);
1425 if (!dc
->base_addr
) {
1426 dev_err(&pdev
->dev
, "Unable to map card MMIO\n");
1431 dc
->send_buf
= kmalloc(SEND_BUF_MAX
, GFP_KERNEL
);
1432 if (!dc
->send_buf
) {
1433 dev_err(&pdev
->dev
, "Could not allocate send buffer?\n");
1438 for (i
= PORT_MDM
; i
< MAX_PORT
; i
++) {
1439 if (kfifo_alloc(&dc
->port
[i
].fifo_ul
,
1440 FIFO_BUFFER_SIZE_UL
, GFP_ATOMIC
)) {
1442 "Could not allocate kfifo buffer\n");
1444 goto err_free_kfifo
;
1448 spin_lock_init(&dc
->spin_mutex
);
1450 nozomi_setup_private_data(dc
);
1452 /* Disable all interrupts */
1454 writew(dc
->last_ier
, dc
->reg_ier
);
1456 ret
= request_irq(pdev
->irq
, &interrupt_handler
, IRQF_SHARED
,
1458 if (unlikely(ret
)) {
1459 dev_err(&pdev
->dev
, "can't request irq %d\n", pdev
->irq
);
1460 goto err_free_kfifo
;
1463 DBG1("base_addr: %p", dc
->base_addr
);
1465 make_sysfs_files(dc
);
1467 dc
->index_start
= ndev_idx
* MAX_PORT
;
1468 ndevs
[ndev_idx
] = dc
;
1470 pci_set_drvdata(pdev
, dc
);
1472 /* Enable RESET interrupt */
1473 dc
->last_ier
= RESET
;
1474 iowrite16(dc
->last_ier
, dc
->reg_ier
);
1476 dc
->state
= NOZOMI_STATE_ENABLED
;
1478 for (i
= 0; i
< MAX_PORT
; i
++) {
1479 struct device
*tty_dev
;
1480 struct port
*port
= &dc
->port
[i
];
1482 mutex_init(&port
->tty_sem
);
1483 tty_port_init(&port
->port
);
1484 port
->port
.ops
= &noz_tty_port_ops
;
1485 tty_dev
= tty_register_device(ntty_driver
, dc
->index_start
+ i
,
1488 if (IS_ERR(tty_dev
)) {
1489 ret
= PTR_ERR(tty_dev
);
1490 dev_err(&pdev
->dev
, "Could not allocate tty?\n");
1498 for (i
= dc
->index_start
; i
< dc
->index_start
+ MAX_PORT
; ++i
)
1499 tty_unregister_device(ntty_driver
, i
);
1501 for (i
= 0; i
< MAX_PORT
; i
++)
1502 kfifo_free(&dc
->port
[i
].fifo_ul
);
1504 kfree(dc
->send_buf
);
1505 iounmap(dc
->base_addr
);
1507 pci_release_regions(pdev
);
1509 pci_disable_device(pdev
);
1516 static void __devexit
tty_exit(struct nozomi
*dc
)
1522 flush_scheduled_work();
1524 for (i
= 0; i
< MAX_PORT
; ++i
) {
1525 struct tty_struct
*tty
= tty_port_tty_get(&dc
->port
[i
].port
);
1526 if (tty
&& list_empty(&tty
->hangup_work
.entry
))
1530 /* Racy below - surely should wait for scheduled work to be done or
1531 complete off a hangup method ? */
1532 while (dc
->open_ttys
)
1534 for (i
= dc
->index_start
; i
< dc
->index_start
+ MAX_PORT
; ++i
)
1535 tty_unregister_device(ntty_driver
, i
);
1538 /* Deallocate memory for one device */
1539 static void __devexit
nozomi_card_exit(struct pci_dev
*pdev
)
1542 struct ctrl_ul ctrl
;
1543 struct nozomi
*dc
= pci_get_drvdata(pdev
);
1545 /* Disable all interrupts */
1547 writew(dc
->last_ier
, dc
->reg_ier
);
1551 /* Send 0x0001, command card to resend the reset token. */
1552 /* This is to get the reset when the module is reloaded. */
1557 DBG1("sending flow control 0x%04X", *((u16
*)&ctrl
));
1559 /* Setup dc->reg addresses to we can use defines here */
1560 write_mem32(dc
->port
[PORT_CTRL
].ul_addr
[0], (u32
*)&ctrl
, 2);
1561 writew(CTRL_UL
, dc
->reg_fcr
); /* push the token to the card. */
1563 remove_sysfs_files(dc
);
1565 free_irq(pdev
->irq
, dc
);
1567 for (i
= 0; i
< MAX_PORT
; i
++)
1568 kfifo_free(&dc
->port
[i
].fifo_ul
);
1570 kfree(dc
->send_buf
);
1572 iounmap(dc
->base_addr
);
1574 pci_release_regions(pdev
);
1576 pci_disable_device(pdev
);
1578 ndevs
[dc
->index_start
/ MAX_PORT
] = NULL
;
1583 static void set_rts(const struct tty_struct
*tty
, int rts
)
1585 struct port
*port
= get_port_by_tty(tty
);
1587 port
->ctrl_ul
.RTS
= rts
;
1588 port
->update_flow_control
= 1;
1589 enable_transmit_ul(PORT_CTRL
, get_dc_by_tty(tty
));
1592 static void set_dtr(const struct tty_struct
*tty
, int dtr
)
1594 struct port
*port
= get_port_by_tty(tty
);
1596 DBG1("SETTING DTR index: %d, dtr: %d", tty
->index
, dtr
);
1598 port
->ctrl_ul
.DTR
= dtr
;
1599 port
->update_flow_control
= 1;
1600 enable_transmit_ul(PORT_CTRL
, get_dc_by_tty(tty
));
1604 * ----------------------------------------------------------------------------
1606 * ----------------------------------------------------------------------------
1609 static int ntty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1611 struct port
*port
= get_port_by_tty(tty
);
1612 struct nozomi
*dc
= get_dc_by_tty(tty
);
1614 if (!port
|| !dc
|| dc
->state
!= NOZOMI_STATE_READY
)
1616 ret
= tty_init_termios(tty
);
1618 tty_driver_kref_get(driver
);
1619 driver
->ttys
[tty
->index
] = tty
;
1624 static void ntty_cleanup(struct tty_struct
*tty
)
1626 tty
->driver_data
= NULL
;
1629 static int ntty_activate(struct tty_port
*tport
, struct tty_struct
*tty
)
1631 struct port
*port
= container_of(tport
, struct port
, port
);
1632 struct nozomi
*dc
= port
->dc
;
1633 unsigned long flags
;
1635 DBG1("open: %d", port
->token_dl
);
1636 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1637 dc
->last_ier
= dc
->last_ier
| port
->token_dl
;
1638 writew(dc
->last_ier
, dc
->reg_ier
);
1640 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1641 printk("noz: activated %d: %p\n", tty
->index
, tport
);
1645 static int ntty_open(struct tty_struct
*tty
, struct file
*filp
)
1647 struct port
*port
= get_port_by_tty(tty
);
1648 return tty_port_open(&port
->port
, tty
, filp
);
1651 static void ntty_shutdown(struct tty_port
*tport
)
1653 struct port
*port
= container_of(tport
, struct port
, port
);
1654 struct nozomi
*dc
= port
->dc
;
1655 unsigned long flags
;
1657 DBG1("close: %d", port
->token_dl
);
1658 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1659 dc
->last_ier
&= ~(port
->token_dl
);
1660 writew(dc
->last_ier
, dc
->reg_ier
);
1662 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1663 printk("noz: shutdown %p\n", tport
);
1666 static void ntty_close(struct tty_struct
*tty
, struct file
*filp
)
1668 struct port
*port
= tty
->driver_data
;
1670 tty_port_close(&port
->port
, tty
, filp
);
1673 static void ntty_hangup(struct tty_struct
*tty
)
1675 struct port
*port
= tty
->driver_data
;
1676 tty_port_hangup(&port
->port
);
1680 * called when the userspace process writes to the tty (/dev/noz*).
1681 * Data is inserted into a fifo, which is then read and transfered to the modem.
1683 static int ntty_write(struct tty_struct
*tty
, const unsigned char *buffer
,
1687 struct nozomi
*dc
= get_dc_by_tty(tty
);
1688 struct port
*port
= tty
->driver_data
;
1689 unsigned long flags
;
1691 /* DBG1( "WRITEx: %d, index = %d", count, index); */
1696 mutex_lock(&port
->tty_sem
);
1698 if (unlikely(!port
->port
.count
)) {
1703 rval
= kfifo_in(&port
->fifo_ul
, (unsigned char *)buffer
, count
);
1706 if (unlikely(dc
== NULL
)) {
1707 DBG1("No device context?");
1711 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1712 /* CTS is only valid on the modem channel */
1713 if (port
== &(dc
->port
[PORT_MDM
])) {
1714 if (port
->ctrl_dl
.CTS
) {
1715 DBG4("Enable interrupt");
1716 enable_transmit_ul(tty
->index
% MAX_PORT
, dc
);
1718 dev_err(&dc
->pdev
->dev
,
1719 "CTS not active on modem port?\n");
1722 enable_transmit_ul(tty
->index
% MAX_PORT
, dc
);
1724 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1727 mutex_unlock(&port
->tty_sem
);
1732 * Calculate how much is left in device
1733 * This method is called by the upper tty layer.
1734 * #according to sources N_TTY.c it expects a value >= 0 and
1735 * does not check for negative values.
1737 * If the port is unplugged report lots of room and let the bits
1738 * dribble away so we don't block anything.
1740 static int ntty_write_room(struct tty_struct
*tty
)
1742 struct port
*port
= tty
->driver_data
;
1744 const struct nozomi
*dc
= get_dc_by_tty(tty
);
1747 mutex_lock(&port
->tty_sem
);
1748 if (port
->port
.count
)
1749 room
= port
->fifo_ul
.size
-
1750 kfifo_len(&port
->fifo_ul
);
1751 mutex_unlock(&port
->tty_sem
);
1756 /* Gets io control parameters */
1757 static int ntty_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1759 const struct port
*port
= tty
->driver_data
;
1760 const struct ctrl_dl
*ctrl_dl
= &port
->ctrl_dl
;
1761 const struct ctrl_ul
*ctrl_ul
= &port
->ctrl_ul
;
1763 /* Note: these could change under us but it is not clear this
1765 return (ctrl_ul
->RTS
? TIOCM_RTS
: 0) |
1766 (ctrl_ul
->DTR
? TIOCM_DTR
: 0) |
1767 (ctrl_dl
->DCD
? TIOCM_CAR
: 0) |
1768 (ctrl_dl
->RI
? TIOCM_RNG
: 0) |
1769 (ctrl_dl
->DSR
? TIOCM_DSR
: 0) |
1770 (ctrl_dl
->CTS
? TIOCM_CTS
: 0);
1773 /* Sets io controls parameters */
1774 static int ntty_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1775 unsigned int set
, unsigned int clear
)
1777 struct nozomi
*dc
= get_dc_by_tty(tty
);
1778 unsigned long flags
;
1780 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1781 if (set
& TIOCM_RTS
)
1783 else if (clear
& TIOCM_RTS
)
1786 if (set
& TIOCM_DTR
)
1788 else if (clear
& TIOCM_DTR
)
1790 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1795 static int ntty_cflags_changed(struct port
*port
, unsigned long flags
,
1796 struct async_icount
*cprev
)
1798 const struct async_icount cnow
= port
->tty_icount
;
1801 ret
= ((flags
& TIOCM_RNG
) && (cnow
.rng
!= cprev
->rng
)) ||
1802 ((flags
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
->dsr
)) ||
1803 ((flags
& TIOCM_CD
) && (cnow
.dcd
!= cprev
->dcd
)) ||
1804 ((flags
& TIOCM_CTS
) && (cnow
.cts
!= cprev
->cts
));
1811 static int ntty_ioctl_tiocgicount(struct port
*port
, void __user
*argp
)
1813 const struct async_icount cnow
= port
->tty_icount
;
1814 struct serial_icounter_struct icount
;
1816 icount
.cts
= cnow
.cts
;
1817 icount
.dsr
= cnow
.dsr
;
1818 icount
.rng
= cnow
.rng
;
1819 icount
.dcd
= cnow
.dcd
;
1820 icount
.rx
= cnow
.rx
;
1821 icount
.tx
= cnow
.tx
;
1822 icount
.frame
= cnow
.frame
;
1823 icount
.overrun
= cnow
.overrun
;
1824 icount
.parity
= cnow
.parity
;
1825 icount
.brk
= cnow
.brk
;
1826 icount
.buf_overrun
= cnow
.buf_overrun
;
1828 return copy_to_user(argp
, &icount
, sizeof(icount
)) ? -EFAULT
: 0;
1831 static int ntty_ioctl(struct tty_struct
*tty
, struct file
*file
,
1832 unsigned int cmd
, unsigned long arg
)
1834 struct port
*port
= tty
->driver_data
;
1835 void __user
*argp
= (void __user
*)arg
;
1836 int rval
= -ENOIOCTLCMD
;
1838 DBG1("******** IOCTL, cmd: %d", cmd
);
1842 struct async_icount cprev
= port
->tty_icount
;
1844 rval
= wait_event_interruptible(port
->tty_wait
,
1845 ntty_cflags_changed(port
, arg
, &cprev
));
1848 rval
= ntty_ioctl_tiocgicount(port
, argp
);
1851 DBG1("ERR: 0x%08X, %d", cmd
, cmd
);
1859 * Called by the upper tty layer when tty buffers are ready
1860 * to receive data again after a call to throttle.
1862 static void ntty_unthrottle(struct tty_struct
*tty
)
1864 struct nozomi
*dc
= get_dc_by_tty(tty
);
1865 unsigned long flags
;
1868 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1869 enable_transmit_dl(tty
->index
% MAX_PORT
, dc
);
1872 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1876 * Called by the upper tty layer when the tty buffers are almost full.
1877 * The driver should stop send more data.
1879 static void ntty_throttle(struct tty_struct
*tty
)
1881 struct nozomi
*dc
= get_dc_by_tty(tty
);
1882 unsigned long flags
;
1885 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1887 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1890 /* Returns number of chars in buffer, called by tty layer */
1891 static s32
ntty_chars_in_buffer(struct tty_struct
*tty
)
1893 struct port
*port
= tty
->driver_data
;
1894 struct nozomi
*dc
= get_dc_by_tty(tty
);
1897 if (unlikely(!dc
|| !port
)) {
1898 goto exit_in_buffer
;
1901 if (unlikely(!port
->port
.count
)) {
1902 dev_err(&dc
->pdev
->dev
, "No tty open?\n");
1903 goto exit_in_buffer
;
1906 rval
= kfifo_len(&port
->fifo_ul
);
1912 static const struct tty_port_operations noz_tty_port_ops
= {
1913 .activate
= ntty_activate
,
1914 .shutdown
= ntty_shutdown
,
1917 static const struct tty_operations tty_ops
= {
1918 .ioctl
= ntty_ioctl
,
1920 .close
= ntty_close
,
1921 .hangup
= ntty_hangup
,
1922 .write
= ntty_write
,
1923 .write_room
= ntty_write_room
,
1924 .unthrottle
= ntty_unthrottle
,
1925 .throttle
= ntty_throttle
,
1926 .chars_in_buffer
= ntty_chars_in_buffer
,
1927 .tiocmget
= ntty_tiocmget
,
1928 .tiocmset
= ntty_tiocmset
,
1929 .install
= ntty_install
,
1930 .cleanup
= ntty_cleanup
,
1933 /* Module initialization */
1934 static struct pci_driver nozomi_driver
= {
1935 .name
= NOZOMI_NAME
,
1936 .id_table
= nozomi_pci_tbl
,
1937 .probe
= nozomi_card_init
,
1938 .remove
= __devexit_p(nozomi_card_exit
),
1941 static __init
int nozomi_init(void)
1945 printk(KERN_INFO
"Initializing %s\n", VERSION_STRING
);
1947 ntty_driver
= alloc_tty_driver(NTTY_TTY_MAXMINORS
);
1951 ntty_driver
->owner
= THIS_MODULE
;
1952 ntty_driver
->driver_name
= NOZOMI_NAME_TTY
;
1953 ntty_driver
->name
= "noz";
1954 ntty_driver
->major
= 0;
1955 ntty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1956 ntty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1957 ntty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1958 ntty_driver
->init_termios
= tty_std_termios
;
1959 ntty_driver
->init_termios
.c_cflag
= B115200
| CS8
| CREAD
| \
1961 ntty_driver
->init_termios
.c_ispeed
= 115200;
1962 ntty_driver
->init_termios
.c_ospeed
= 115200;
1963 tty_set_operations(ntty_driver
, &tty_ops
);
1965 ret
= tty_register_driver(ntty_driver
);
1967 printk(KERN_ERR
"Nozomi: failed to register ntty driver\n");
1971 ret
= pci_register_driver(&nozomi_driver
);
1973 printk(KERN_ERR
"Nozomi: can't register pci driver\n");
1979 tty_unregister_driver(ntty_driver
);
1981 put_tty_driver(ntty_driver
);
1985 static __exit
void nozomi_exit(void)
1987 printk(KERN_INFO
"Unloading %s\n", DRIVER_DESC
);
1988 pci_unregister_driver(&nozomi_driver
);
1989 tty_unregister_driver(ntty_driver
);
1990 put_tty_driver(ntty_driver
);
1993 module_init(nozomi_init
);
1994 module_exit(nozomi_exit
);
1996 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
1998 MODULE_LICENSE("Dual BSD/GPL");
1999 MODULE_DESCRIPTION(DRIVER_DESC
);