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 <linux/slab.h>
59 #include <asm/byteorder.h>
61 #include <linux/delay.h>
64 #define VERSION_STRING DRIVER_DESC " 2.1d"
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 R_IIR 0x0000 /* Interrupt Identity Register */
140 #define R_FCR 0x0000 /* Flow Control Register */
141 #define R_IER 0x0004 /* Interrupt Enable Register */
143 #define CONFIG_MAGIC 0xEFEFFEFE
144 #define TOGGLE_VALID 0x0000
146 /* Definition of interrupt tokens */
147 #define MDM_DL1 0x0001
148 #define MDM_UL1 0x0002
149 #define MDM_DL2 0x0004
150 #define MDM_UL2 0x0008
151 #define DIAG_DL1 0x0010
152 #define DIAG_DL2 0x0020
153 #define DIAG_UL 0x0040
154 #define APP1_DL 0x0080
155 #define APP1_UL 0x0100
156 #define APP2_DL 0x0200
157 #define APP2_UL 0x0400
158 #define CTRL_DL 0x0800
159 #define CTRL_UL 0x1000
162 #define MDM_DL (MDM_DL1 | MDM_DL2)
163 #define MDM_UL (MDM_UL1 | MDM_UL2)
164 #define DIAG_DL (DIAG_DL1 | DIAG_DL2)
166 /* modem signal definition */
167 #define CTRL_DSR 0x0001
168 #define CTRL_DCD 0x0002
169 #define CTRL_RI 0x0004
170 #define CTRL_CTS 0x0008
172 #define CTRL_DTR 0x0001
173 #define CTRL_RTS 0x0002
176 #define NOZOMI_MAX_PORTS 5
177 #define NOZOMI_MAX_CARDS (NTTY_TTY_MAXMINORS / MAX_PORT)
179 /* Type definitions */
182 * There are two types of nozomi cards,
183 * one with 2048 memory and with 8192 memory
186 F32_2
= 2048, /* 512 bytes downlink + uplink * 2 -> 2048 */
187 F32_8
= 8192, /* 3072 bytes downl. + 1024 bytes uplink * 2 -> 8192 */
190 /* Initialization states a card can be in */
192 NOZOMI_STATE_UKNOWN
= 0,
193 NOZOMI_STATE_ENABLED
= 1, /* pci device enabled */
194 NOZOMI_STATE_ALLOCATED
= 2, /* config setup done */
195 NOZOMI_STATE_READY
= 3, /* flowcontrols received */
198 /* Two different toggle channels exist */
204 /* Port definition for the card regarding flow control */
205 enum ctrl_port_type
{
214 /* Ports that the nozomi has */
228 unsigned int enabled
:5; /*
229 * Toggle fields are valid if enabled is 0,
230 * else A-channels must always be used.
232 unsigned int diag_dl
:1;
233 unsigned int mdm_dl
:1;
234 unsigned int mdm_ul
:1;
235 } __attribute__ ((packed
));
237 /* Configuration table to read at startup of card */
238 /* Is for now only needed during initialization phase */
239 struct config_table
{
241 u16 product_information
;
244 struct toggles toggle
;
247 * If this is 64, it can hold
248 * 60 bytes + 4 that is length field
254 * If this is 64, it can hold
255 * 60 bytes + 4 that is length field
270 } __attribute__ ((packed
));
272 /* This stores all control downlink flags */
275 unsigned int reserved
:4;
280 } __attribute__ ((packed
));
282 /* This stores all control uplink flags */
285 unsigned int reserved
:6;
288 } __attribute__ ((packed
));
293 /* This represents the toggle information */
295 unsigned int mdm_ul
:1;
296 unsigned int mdm_dl
:1;
297 unsigned int diag_dl
:1;
298 unsigned int enabled
:5; /*
299 * Toggle fields are valid if enabled is 0,
300 * else A-channels must always be used.
302 } __attribute__ ((packed
));
304 /* Configuration table to read at startup of card */
305 struct config_table
{
308 u16 product_information
;
309 struct toggles toggle
;
313 * If this is 64, it can hold
314 * 60 bytes + 4 that is length field
330 } __attribute__ ((packed
));
332 /* This stores all control downlink flags */
338 unsigned int reserverd
:4;
340 } __attribute__ ((packed
));
342 /* This stores all control uplink flags */
346 unsigned int reserved
:6;
348 } __attribute__ ((packed
));
351 /* This holds all information that is needed regarding a port */
353 struct tty_port port
;
354 u8 update_flow_control
;
355 struct ctrl_ul ctrl_ul
;
356 struct ctrl_dl ctrl_dl
;
357 struct kfifo fifo_ul
;
358 void __iomem
*dl_addr
[2];
361 void __iomem
*ul_addr
[2];
366 wait_queue_head_t tty_wait
;
367 struct async_icount tty_icount
;
372 /* Private data one for each card in the system */
374 void __iomem
*base_addr
;
377 /* Pointers to registers */
378 void __iomem
*reg_iir
;
379 void __iomem
*reg_fcr
;
380 void __iomem
*reg_ier
;
383 enum card_type card_type
;
384 struct config_table config_table
; /* Configuration table */
385 struct pci_dev
*pdev
;
386 struct port port
[NOZOMI_MAX_PORTS
];
389 spinlock_t spin_mutex
; /* secures access to registers and tty */
391 unsigned int index_start
;
392 enum card_state state
;
396 /* This is a data packet that is read or written to/from card */
398 u32 size
; /* size is the length of the data buffer */
400 } __attribute__ ((packed
));
402 /* Global variables */
403 static const struct pci_device_id nozomi_pci_tbl
[] = {
404 {PCI_DEVICE(0x1931, 0x000c)}, /* Nozomi HSDPA */
408 MODULE_DEVICE_TABLE(pci
, nozomi_pci_tbl
);
410 static struct nozomi
*ndevs
[NOZOMI_MAX_CARDS
];
411 static struct tty_driver
*ntty_driver
;
413 static const struct tty_port_operations noz_tty_port_ops
;
416 * find card by tty_index
418 static inline struct nozomi
*get_dc_by_tty(const struct tty_struct
*tty
)
420 return tty
? ndevs
[tty
->index
/ MAX_PORT
] : NULL
;
423 static inline struct port
*get_port_by_tty(const struct tty_struct
*tty
)
425 struct nozomi
*ndev
= get_dc_by_tty(tty
);
426 return ndev
? &ndev
->port
[tty
->index
% MAX_PORT
] : NULL
;
435 static void read_mem32(u32
*buf
, const void __iomem
*mem_addr_start
,
439 const u32 __iomem
*ptr
= mem_addr_start
;
442 if (unlikely(!ptr
|| !buf
))
445 /* shortcut for extremely often used cases */
446 switch (size_bytes
) {
447 case 2: /* 2 bytes */
449 *buf16
= __le16_to_cpu(readw(ptr
));
452 case 4: /* 4 bytes */
453 *(buf
) = __le32_to_cpu(readl(ptr
));
458 while (i
< size_bytes
) {
459 if (size_bytes
- i
== 2) {
460 /* Handle 2 bytes in the end */
462 *(buf16
) = __le16_to_cpu(readw(ptr
));
466 *(buf
) = __le32_to_cpu(readl(ptr
));
481 static u32
write_mem32(void __iomem
*mem_addr_start
, const u32
*buf
,
485 u32 __iomem
*ptr
= mem_addr_start
;
488 if (unlikely(!ptr
|| !buf
))
491 /* shortcut for extremely often used cases */
492 switch (size_bytes
) {
493 case 2: /* 2 bytes */
494 buf16
= (const u16
*)buf
;
495 writew(__cpu_to_le16(*buf16
), ptr
);
499 * also needs to write 4 bytes in this case
500 * so falling through..
502 case 4: /* 4 bytes */
503 writel(__cpu_to_le32(*buf
), ptr
);
508 while (i
< size_bytes
) {
509 if (size_bytes
- i
== 2) {
511 buf16
= (const u16
*)buf
;
512 writew(__cpu_to_le16(*buf16
), ptr
);
516 writel(__cpu_to_le32(*buf
), ptr
);
525 /* Setup pointers to different channels and also setup buffer sizes. */
526 static void setup_memory(struct nozomi
*dc
)
528 void __iomem
*offset
= dc
->base_addr
+ dc
->config_table
.dl_start
;
529 /* The length reported is including the length field of 4 bytes,
530 * hence subtract with 4.
532 const u16 buff_offset
= 4;
534 /* Modem port dl configuration */
535 dc
->port
[PORT_MDM
].dl_addr
[CH_A
] = offset
;
536 dc
->port
[PORT_MDM
].dl_addr
[CH_B
] =
537 (offset
+= dc
->config_table
.dl_mdm_len1
);
538 dc
->port
[PORT_MDM
].dl_size
[CH_A
] =
539 dc
->config_table
.dl_mdm_len1
- buff_offset
;
540 dc
->port
[PORT_MDM
].dl_size
[CH_B
] =
541 dc
->config_table
.dl_mdm_len2
- buff_offset
;
543 /* Diag port dl configuration */
544 dc
->port
[PORT_DIAG
].dl_addr
[CH_A
] =
545 (offset
+= dc
->config_table
.dl_mdm_len2
);
546 dc
->port
[PORT_DIAG
].dl_size
[CH_A
] =
547 dc
->config_table
.dl_diag_len1
- buff_offset
;
548 dc
->port
[PORT_DIAG
].dl_addr
[CH_B
] =
549 (offset
+= dc
->config_table
.dl_diag_len1
);
550 dc
->port
[PORT_DIAG
].dl_size
[CH_B
] =
551 dc
->config_table
.dl_diag_len2
- buff_offset
;
553 /* App1 port dl configuration */
554 dc
->port
[PORT_APP1
].dl_addr
[CH_A
] =
555 (offset
+= dc
->config_table
.dl_diag_len2
);
556 dc
->port
[PORT_APP1
].dl_size
[CH_A
] =
557 dc
->config_table
.dl_app1_len
- buff_offset
;
559 /* App2 port dl configuration */
560 dc
->port
[PORT_APP2
].dl_addr
[CH_A
] =
561 (offset
+= dc
->config_table
.dl_app1_len
);
562 dc
->port
[PORT_APP2
].dl_size
[CH_A
] =
563 dc
->config_table
.dl_app2_len
- buff_offset
;
565 /* Ctrl dl configuration */
566 dc
->port
[PORT_CTRL
].dl_addr
[CH_A
] =
567 (offset
+= dc
->config_table
.dl_app2_len
);
568 dc
->port
[PORT_CTRL
].dl_size
[CH_A
] =
569 dc
->config_table
.dl_ctrl_len
- buff_offset
;
571 offset
= dc
->base_addr
+ dc
->config_table
.ul_start
;
573 /* Modem Port ul configuration */
574 dc
->port
[PORT_MDM
].ul_addr
[CH_A
] = offset
;
575 dc
->port
[PORT_MDM
].ul_size
[CH_A
] =
576 dc
->config_table
.ul_mdm_len1
- buff_offset
;
577 dc
->port
[PORT_MDM
].ul_addr
[CH_B
] =
578 (offset
+= dc
->config_table
.ul_mdm_len1
);
579 dc
->port
[PORT_MDM
].ul_size
[CH_B
] =
580 dc
->config_table
.ul_mdm_len2
- buff_offset
;
582 /* Diag port ul configuration */
583 dc
->port
[PORT_DIAG
].ul_addr
[CH_A
] =
584 (offset
+= dc
->config_table
.ul_mdm_len2
);
585 dc
->port
[PORT_DIAG
].ul_size
[CH_A
] =
586 dc
->config_table
.ul_diag_len
- buff_offset
;
588 /* App1 port ul configuration */
589 dc
->port
[PORT_APP1
].ul_addr
[CH_A
] =
590 (offset
+= dc
->config_table
.ul_diag_len
);
591 dc
->port
[PORT_APP1
].ul_size
[CH_A
] =
592 dc
->config_table
.ul_app1_len
- buff_offset
;
594 /* App2 port ul configuration */
595 dc
->port
[PORT_APP2
].ul_addr
[CH_A
] =
596 (offset
+= dc
->config_table
.ul_app1_len
);
597 dc
->port
[PORT_APP2
].ul_size
[CH_A
] =
598 dc
->config_table
.ul_app2_len
- buff_offset
;
600 /* Ctrl ul configuration */
601 dc
->port
[PORT_CTRL
].ul_addr
[CH_A
] =
602 (offset
+= dc
->config_table
.ul_app2_len
);
603 dc
->port
[PORT_CTRL
].ul_size
[CH_A
] =
604 dc
->config_table
.ul_ctrl_len
- buff_offset
;
607 /* Dump config table under initalization phase */
609 static void dump_table(const struct nozomi
*dc
)
611 DBG3("signature: 0x%08X", dc
->config_table
.signature
);
612 DBG3("version: 0x%04X", dc
->config_table
.version
);
613 DBG3("product_information: 0x%04X", \
614 dc
->config_table
.product_information
);
615 DBG3("toggle enabled: %d", dc
->config_table
.toggle
.enabled
);
616 DBG3("toggle up_mdm: %d", dc
->config_table
.toggle
.mdm_ul
);
617 DBG3("toggle dl_mdm: %d", dc
->config_table
.toggle
.mdm_dl
);
618 DBG3("toggle dl_dbg: %d", dc
->config_table
.toggle
.diag_dl
);
620 DBG3("dl_start: 0x%04X", dc
->config_table
.dl_start
);
621 DBG3("dl_mdm_len0: 0x%04X, %d", dc
->config_table
.dl_mdm_len1
,
622 dc
->config_table
.dl_mdm_len1
);
623 DBG3("dl_mdm_len1: 0x%04X, %d", dc
->config_table
.dl_mdm_len2
,
624 dc
->config_table
.dl_mdm_len2
);
625 DBG3("dl_diag_len0: 0x%04X, %d", dc
->config_table
.dl_diag_len1
,
626 dc
->config_table
.dl_diag_len1
);
627 DBG3("dl_diag_len1: 0x%04X, %d", dc
->config_table
.dl_diag_len2
,
628 dc
->config_table
.dl_diag_len2
);
629 DBG3("dl_app1_len: 0x%04X, %d", dc
->config_table
.dl_app1_len
,
630 dc
->config_table
.dl_app1_len
);
631 DBG3("dl_app2_len: 0x%04X, %d", dc
->config_table
.dl_app2_len
,
632 dc
->config_table
.dl_app2_len
);
633 DBG3("dl_ctrl_len: 0x%04X, %d", dc
->config_table
.dl_ctrl_len
,
634 dc
->config_table
.dl_ctrl_len
);
635 DBG3("ul_start: 0x%04X, %d", dc
->config_table
.ul_start
,
636 dc
->config_table
.ul_start
);
637 DBG3("ul_mdm_len[0]: 0x%04X, %d", dc
->config_table
.ul_mdm_len1
,
638 dc
->config_table
.ul_mdm_len1
);
639 DBG3("ul_mdm_len[1]: 0x%04X, %d", dc
->config_table
.ul_mdm_len2
,
640 dc
->config_table
.ul_mdm_len2
);
641 DBG3("ul_diag_len: 0x%04X, %d", dc
->config_table
.ul_diag_len
,
642 dc
->config_table
.ul_diag_len
);
643 DBG3("ul_app1_len: 0x%04X, %d", dc
->config_table
.ul_app1_len
,
644 dc
->config_table
.ul_app1_len
);
645 DBG3("ul_app2_len: 0x%04X, %d", dc
->config_table
.ul_app2_len
,
646 dc
->config_table
.ul_app2_len
);
647 DBG3("ul_ctrl_len: 0x%04X, %d", dc
->config_table
.ul_ctrl_len
,
648 dc
->config_table
.ul_ctrl_len
);
651 static inline void dump_table(const struct nozomi
*dc
) { }
655 * Read configuration table from card under intalization phase
656 * Returns 1 if ok, else 0
658 static int nozomi_read_config_table(struct nozomi
*dc
)
660 read_mem32((u32
*) &dc
->config_table
, dc
->base_addr
+ 0,
661 sizeof(struct config_table
));
663 if (dc
->config_table
.signature
!= CONFIG_MAGIC
) {
664 dev_err(&dc
->pdev
->dev
, "ConfigTable Bad! 0x%08X != 0x%08X\n",
665 dc
->config_table
.signature
, CONFIG_MAGIC
);
669 if ((dc
->config_table
.version
== 0)
670 || (dc
->config_table
.toggle
.enabled
== TOGGLE_VALID
)) {
672 DBG1("Second phase, configuring card");
676 dc
->port
[PORT_MDM
].toggle_ul
= dc
->config_table
.toggle
.mdm_ul
;
677 dc
->port
[PORT_MDM
].toggle_dl
= dc
->config_table
.toggle
.mdm_dl
;
678 dc
->port
[PORT_DIAG
].toggle_dl
= dc
->config_table
.toggle
.diag_dl
;
679 DBG1("toggle ports: MDM UL:%d MDM DL:%d, DIAG DL:%d",
680 dc
->port
[PORT_MDM
].toggle_ul
,
681 dc
->port
[PORT_MDM
].toggle_dl
, dc
->port
[PORT_DIAG
].toggle_dl
);
685 for (i
= PORT_MDM
; i
< MAX_PORT
; i
++) {
686 memset(&dc
->port
[i
].ctrl_dl
, 0, sizeof(struct ctrl_dl
));
687 memset(&dc
->port
[i
].ctrl_ul
, 0, sizeof(struct ctrl_ul
));
690 /* Enable control channel */
691 dc
->last_ier
= dc
->last_ier
| CTRL_DL
;
692 writew(dc
->last_ier
, dc
->reg_ier
);
694 dc
->state
= NOZOMI_STATE_ALLOCATED
;
695 dev_info(&dc
->pdev
->dev
, "Initialization OK!\n");
699 if ((dc
->config_table
.version
> 0)
700 && (dc
->config_table
.toggle
.enabled
!= TOGGLE_VALID
)) {
702 DBG1("First phase: pushing upload buffers, clearing download");
704 dev_info(&dc
->pdev
->dev
, "Version of card: %d\n",
705 dc
->config_table
.version
);
707 /* Here we should disable all I/O over F32. */
711 * We should send ALL channel pair tokens back along
715 /* push upload modem buffers */
716 write_mem32(dc
->port
[PORT_MDM
].ul_addr
[CH_A
],
718 write_mem32(dc
->port
[PORT_MDM
].ul_addr
[CH_B
],
721 writew(MDM_UL
| DIAG_DL
| MDM_DL
, dc
->reg_fcr
);
723 DBG1("First phase done");
729 /* Enable uplink interrupts */
730 static void enable_transmit_ul(enum port_type port
, struct nozomi
*dc
)
732 static const u16 mask
[] = {MDM_UL
, DIAG_UL
, APP1_UL
, APP2_UL
, CTRL_UL
};
734 if (port
< NOZOMI_MAX_PORTS
) {
735 dc
->last_ier
|= mask
[port
];
736 writew(dc
->last_ier
, dc
->reg_ier
);
738 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
742 /* Disable uplink interrupts */
743 static void disable_transmit_ul(enum port_type port
, struct nozomi
*dc
)
745 static const u16 mask
[] =
746 {~MDM_UL
, ~DIAG_UL
, ~APP1_UL
, ~APP2_UL
, ~CTRL_UL
};
748 if (port
< NOZOMI_MAX_PORTS
) {
749 dc
->last_ier
&= mask
[port
];
750 writew(dc
->last_ier
, dc
->reg_ier
);
752 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
756 /* Enable downlink interrupts */
757 static void enable_transmit_dl(enum port_type port
, struct nozomi
*dc
)
759 static const u16 mask
[] = {MDM_DL
, DIAG_DL
, APP1_DL
, APP2_DL
, CTRL_DL
};
761 if (port
< NOZOMI_MAX_PORTS
) {
762 dc
->last_ier
|= mask
[port
];
763 writew(dc
->last_ier
, dc
->reg_ier
);
765 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
769 /* Disable downlink interrupts */
770 static void disable_transmit_dl(enum port_type port
, struct nozomi
*dc
)
772 static const u16 mask
[] =
773 {~MDM_DL
, ~DIAG_DL
, ~APP1_DL
, ~APP2_DL
, ~CTRL_DL
};
775 if (port
< NOZOMI_MAX_PORTS
) {
776 dc
->last_ier
&= mask
[port
];
777 writew(dc
->last_ier
, dc
->reg_ier
);
779 dev_err(&dc
->pdev
->dev
, "Called with wrong port?\n");
784 * Return 1 - send buffer to card and ack.
785 * Return 0 - don't ack, don't send buffer to card.
787 static int send_data(enum port_type index
, struct nozomi
*dc
)
790 struct port
*port
= &dc
->port
[index
];
791 const u8 toggle
= port
->toggle_ul
;
792 void __iomem
*addr
= port
->ul_addr
[toggle
];
793 const u32 ul_size
= port
->ul_size
[toggle
];
794 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
796 /* Get data from tty and place in buf for now */
797 size
= kfifo_out(&port
->fifo_ul
, dc
->send_buf
,
798 ul_size
< SEND_BUF_MAX
? ul_size
: SEND_BUF_MAX
);
801 DBG4("No more data to send, disable link:");
806 /* DUMP(buf, size); */
808 /* Write length + data */
809 write_mem32(addr
, (u32
*) &size
, 4);
810 write_mem32(addr
+ 4, (u32
*) dc
->send_buf
, size
);
819 /* If all data has been read, return 1, else 0 */
820 static int receive_data(enum port_type index
, struct nozomi
*dc
)
822 u8 buf
[RECEIVE_BUF_MAX
] = { 0 };
825 struct port
*port
= &dc
->port
[index
];
826 void __iomem
*addr
= port
->dl_addr
[port
->toggle_dl
];
827 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
830 read_mem32((u32
*) &size
, addr
, 4);
831 /* DBG1( "%d bytes port: %d", size, index); */
833 if (tty
&& test_bit(TTY_THROTTLED
, &tty
->flags
)) {
834 DBG1("No room in tty, don't read data, don't ack interrupt, "
835 "disable interrupt");
837 /* disable interrupt in downlink... */
838 disable_transmit_dl(index
, dc
);
843 if (unlikely(size
== 0)) {
844 dev_err(&dc
->pdev
->dev
, "size == 0?\n");
850 read_mem32((u32
*) buf
, addr
+ offset
, RECEIVE_BUF_MAX
);
853 tty_insert_flip_char(&port
->port
, buf
[0], TTY_NORMAL
);
855 } else if (size
< RECEIVE_BUF_MAX
) {
856 size
-= tty_insert_flip_string(&port
->port
,
859 i
= tty_insert_flip_string(&port
->port
,
860 (char *)buf
, RECEIVE_BUF_MAX
);
866 set_bit(index
, &dc
->flip
);
873 /* Debug for interrupts */
875 static char *interrupt2str(u16 interrupt
)
877 static char buf
[TMP_BUF_MAX
];
880 interrupt
& MDM_DL1
? p
+= snprintf(p
, TMP_BUF_MAX
, "MDM_DL1 ") : NULL
;
881 interrupt
& MDM_DL2
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
884 interrupt
& MDM_UL1
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
886 interrupt
& MDM_UL2
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
889 interrupt
& DIAG_DL1
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
891 interrupt
& DIAG_DL2
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
894 interrupt
& DIAG_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
897 interrupt
& APP1_DL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
899 interrupt
& APP2_DL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
902 interrupt
& APP1_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
904 interrupt
& APP2_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
907 interrupt
& CTRL_DL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
909 interrupt
& CTRL_UL
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
912 interrupt
& RESET
? p
+= snprintf(p
, TMP_BUF_MAX
- (p
- buf
),
920 * Receive flow control
921 * Return 1 - If ok, else 0
923 static int receive_flow_control(struct nozomi
*dc
)
925 enum port_type port
= PORT_MDM
;
926 struct ctrl_dl ctrl_dl
;
927 struct ctrl_dl old_ctrl
;
930 read_mem32((u32
*) &ctrl_dl
, dc
->port
[PORT_CTRL
].dl_addr
[CH_A
], 2);
932 switch (ctrl_dl
.port
) {
934 DBG1("The Base Band sends this value as a response to a "
935 "request for IMSI detach sent over the control "
936 "channel uplink (see section 7.6.1).");
944 enable_ier
= DIAG_DL
;
948 enable_ier
= APP1_DL
;
952 enable_ier
= APP2_DL
;
953 if (dc
->state
== NOZOMI_STATE_ALLOCATED
) {
955 * After card initialization the flow control
956 * received for APP2 is always the last
958 dc
->state
= NOZOMI_STATE_READY
;
959 dev_info(&dc
->pdev
->dev
, "Device READY!\n");
963 dev_err(&dc
->pdev
->dev
,
964 "ERROR: flow control received for non-existing port\n");
968 DBG1("0x%04X->0x%04X", *((u16
*)&dc
->port
[port
].ctrl_dl
),
971 old_ctrl
= dc
->port
[port
].ctrl_dl
;
972 dc
->port
[port
].ctrl_dl
= ctrl_dl
;
974 if (old_ctrl
.CTS
== 1 && ctrl_dl
.CTS
== 0) {
975 DBG1("Disable interrupt (0x%04X) on port: %d",
977 disable_transmit_ul(port
, dc
);
979 } else if (old_ctrl
.CTS
== 0 && ctrl_dl
.CTS
== 1) {
981 if (kfifo_len(&dc
->port
[port
].fifo_ul
)) {
982 DBG1("Enable interrupt (0x%04X) on port: %d",
984 DBG1("Data in buffer [%d], enable transmit! ",
985 kfifo_len(&dc
->port
[port
].fifo_ul
));
986 enable_transmit_ul(port
, dc
);
988 DBG1("No data in buffer...");
992 if (*(u16
*)&old_ctrl
== *(u16
*)&ctrl_dl
) {
993 DBG1(" No change in mctrl");
996 /* Update statistics */
997 if (old_ctrl
.CTS
!= ctrl_dl
.CTS
)
998 dc
->port
[port
].tty_icount
.cts
++;
999 if (old_ctrl
.DSR
!= ctrl_dl
.DSR
)
1000 dc
->port
[port
].tty_icount
.dsr
++;
1001 if (old_ctrl
.RI
!= ctrl_dl
.RI
)
1002 dc
->port
[port
].tty_icount
.rng
++;
1003 if (old_ctrl
.DCD
!= ctrl_dl
.DCD
)
1004 dc
->port
[port
].tty_icount
.dcd
++;
1006 wake_up_interruptible(&dc
->port
[port
].tty_wait
);
1008 DBG1("port: %d DCD(%d), CTS(%d), RI(%d), DSR(%d)",
1010 dc
->port
[port
].tty_icount
.dcd
, dc
->port
[port
].tty_icount
.cts
,
1011 dc
->port
[port
].tty_icount
.rng
, dc
->port
[port
].tty_icount
.dsr
);
1016 static enum ctrl_port_type
port2ctrl(enum port_type port
,
1017 const struct nozomi
*dc
)
1029 dev_err(&dc
->pdev
->dev
,
1030 "ERROR: send flow control " \
1031 "received for non-existing port\n");
1037 * Send flow control, can only update one channel at a time
1038 * Return 0 - If we have updated all flow control
1039 * Return 1 - If we need to update more flow control, ack current enable more
1041 static int send_flow_control(struct nozomi
*dc
)
1043 u32 i
, more_flow_control_to_be_updated
= 0;
1046 for (i
= PORT_MDM
; i
< MAX_PORT
; i
++) {
1047 if (dc
->port
[i
].update_flow_control
) {
1048 if (more_flow_control_to_be_updated
) {
1049 /* We have more flow control to be updated */
1052 dc
->port
[i
].ctrl_ul
.port
= port2ctrl(i
, dc
);
1053 ctrl
= (u16
*)&dc
->port
[i
].ctrl_ul
;
1054 write_mem32(dc
->port
[PORT_CTRL
].ul_addr
[0], \
1056 dc
->port
[i
].update_flow_control
= 0;
1057 more_flow_control_to_be_updated
= 1;
1064 * Handle downlink data, ports that are handled are modem and diagnostics
1066 * Return 0 - toggle fields are out of sync
1068 static int handle_data_dl(struct nozomi
*dc
, enum port_type port
, u8
*toggle
,
1069 u16 read_iir
, u16 mask1
, u16 mask2
)
1071 if (*toggle
== 0 && read_iir
& mask1
) {
1072 if (receive_data(port
, dc
)) {
1073 writew(mask1
, dc
->reg_fcr
);
1074 *toggle
= !(*toggle
);
1077 if (read_iir
& mask2
) {
1078 if (receive_data(port
, dc
)) {
1079 writew(mask2
, dc
->reg_fcr
);
1080 *toggle
= !(*toggle
);
1083 } else if (*toggle
== 1 && read_iir
& mask2
) {
1084 if (receive_data(port
, dc
)) {
1085 writew(mask2
, dc
->reg_fcr
);
1086 *toggle
= !(*toggle
);
1089 if (read_iir
& mask1
) {
1090 if (receive_data(port
, dc
)) {
1091 writew(mask1
, dc
->reg_fcr
);
1092 *toggle
= !(*toggle
);
1096 dev_err(&dc
->pdev
->dev
, "port out of sync!, toggle:%d\n",
1104 * Handle uplink data, this is currently for the modem port
1106 * Return 0 - toggle field are out of sync
1108 static int handle_data_ul(struct nozomi
*dc
, enum port_type port
, u16 read_iir
)
1110 u8
*toggle
= &(dc
->port
[port
].toggle_ul
);
1112 if (*toggle
== 0 && read_iir
& MDM_UL1
) {
1113 dc
->last_ier
&= ~MDM_UL
;
1114 writew(dc
->last_ier
, dc
->reg_ier
);
1115 if (send_data(port
, dc
)) {
1116 writew(MDM_UL1
, dc
->reg_fcr
);
1117 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1118 writew(dc
->last_ier
, dc
->reg_ier
);
1122 if (read_iir
& MDM_UL2
) {
1123 dc
->last_ier
&= ~MDM_UL
;
1124 writew(dc
->last_ier
, dc
->reg_ier
);
1125 if (send_data(port
, dc
)) {
1126 writew(MDM_UL2
, dc
->reg_fcr
);
1127 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1128 writew(dc
->last_ier
, dc
->reg_ier
);
1133 } else if (*toggle
== 1 && read_iir
& MDM_UL2
) {
1134 dc
->last_ier
&= ~MDM_UL
;
1135 writew(dc
->last_ier
, dc
->reg_ier
);
1136 if (send_data(port
, dc
)) {
1137 writew(MDM_UL2
, dc
->reg_fcr
);
1138 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1139 writew(dc
->last_ier
, dc
->reg_ier
);
1143 if (read_iir
& MDM_UL1
) {
1144 dc
->last_ier
&= ~MDM_UL
;
1145 writew(dc
->last_ier
, dc
->reg_ier
);
1146 if (send_data(port
, dc
)) {
1147 writew(MDM_UL1
, dc
->reg_fcr
);
1148 dc
->last_ier
= dc
->last_ier
| MDM_UL
;
1149 writew(dc
->last_ier
, dc
->reg_ier
);
1154 writew(read_iir
& MDM_UL
, dc
->reg_fcr
);
1155 dev_err(&dc
->pdev
->dev
, "port out of sync!\n");
1161 static irqreturn_t
interrupt_handler(int irq
, void *dev_id
)
1163 struct nozomi
*dc
= dev_id
;
1170 spin_lock(&dc
->spin_mutex
);
1171 read_iir
= readw(dc
->reg_iir
);
1174 if (read_iir
== (u16
)-1)
1177 * Just handle interrupt enabled in IER
1178 * (by masking with dc->last_ier)
1180 read_iir
&= dc
->last_ier
;
1186 DBG4("%s irq:0x%04X, prev:0x%04X", interrupt2str(read_iir
), read_iir
,
1189 if (read_iir
& RESET
) {
1190 if (unlikely(!nozomi_read_config_table(dc
))) {
1192 writew(dc
->last_ier
, dc
->reg_ier
);
1193 dev_err(&dc
->pdev
->dev
, "Could not read status from "
1194 "card, we should disable interface\n");
1196 writew(RESET
, dc
->reg_fcr
);
1198 /* No more useful info if this was the reset interrupt. */
1201 if (read_iir
& CTRL_UL
) {
1203 dc
->last_ier
&= ~CTRL_UL
;
1204 writew(dc
->last_ier
, dc
->reg_ier
);
1205 if (send_flow_control(dc
)) {
1206 writew(CTRL_UL
, dc
->reg_fcr
);
1207 dc
->last_ier
= dc
->last_ier
| CTRL_UL
;
1208 writew(dc
->last_ier
, dc
->reg_ier
);
1211 if (read_iir
& CTRL_DL
) {
1212 receive_flow_control(dc
);
1213 writew(CTRL_DL
, dc
->reg_fcr
);
1215 if (read_iir
& MDM_DL
) {
1216 if (!handle_data_dl(dc
, PORT_MDM
,
1217 &(dc
->port
[PORT_MDM
].toggle_dl
), read_iir
,
1218 MDM_DL1
, MDM_DL2
)) {
1219 dev_err(&dc
->pdev
->dev
, "MDM_DL out of sync!\n");
1223 if (read_iir
& MDM_UL
) {
1224 if (!handle_data_ul(dc
, PORT_MDM
, read_iir
)) {
1225 dev_err(&dc
->pdev
->dev
, "MDM_UL out of sync!\n");
1229 if (read_iir
& DIAG_DL
) {
1230 if (!handle_data_dl(dc
, PORT_DIAG
,
1231 &(dc
->port
[PORT_DIAG
].toggle_dl
), read_iir
,
1232 DIAG_DL1
, DIAG_DL2
)) {
1233 dev_err(&dc
->pdev
->dev
, "DIAG_DL out of sync!\n");
1237 if (read_iir
& DIAG_UL
) {
1238 dc
->last_ier
&= ~DIAG_UL
;
1239 writew(dc
->last_ier
, dc
->reg_ier
);
1240 if (send_data(PORT_DIAG
, dc
)) {
1241 writew(DIAG_UL
, dc
->reg_fcr
);
1242 dc
->last_ier
= dc
->last_ier
| DIAG_UL
;
1243 writew(dc
->last_ier
, dc
->reg_ier
);
1246 if (read_iir
& APP1_DL
) {
1247 if (receive_data(PORT_APP1
, dc
))
1248 writew(APP1_DL
, dc
->reg_fcr
);
1250 if (read_iir
& APP1_UL
) {
1251 dc
->last_ier
&= ~APP1_UL
;
1252 writew(dc
->last_ier
, dc
->reg_ier
);
1253 if (send_data(PORT_APP1
, dc
)) {
1254 writew(APP1_UL
, dc
->reg_fcr
);
1255 dc
->last_ier
= dc
->last_ier
| APP1_UL
;
1256 writew(dc
->last_ier
, dc
->reg_ier
);
1259 if (read_iir
& APP2_DL
) {
1260 if (receive_data(PORT_APP2
, dc
))
1261 writew(APP2_DL
, dc
->reg_fcr
);
1263 if (read_iir
& APP2_UL
) {
1264 dc
->last_ier
&= ~APP2_UL
;
1265 writew(dc
->last_ier
, dc
->reg_ier
);
1266 if (send_data(PORT_APP2
, dc
)) {
1267 writew(APP2_UL
, dc
->reg_fcr
);
1268 dc
->last_ier
= dc
->last_ier
| APP2_UL
;
1269 writew(dc
->last_ier
, dc
->reg_ier
);
1274 spin_unlock(&dc
->spin_mutex
);
1276 for (a
= 0; a
< NOZOMI_MAX_PORTS
; a
++)
1277 if (test_and_clear_bit(a
, &dc
->flip
))
1278 tty_flip_buffer_push(&dc
->port
[a
].port
);
1282 spin_unlock(&dc
->spin_mutex
);
1286 static void nozomi_get_card_type(struct nozomi
*dc
)
1291 for (i
= 0; i
< 6; i
++)
1292 size
+= pci_resource_len(dc
->pdev
, i
);
1294 /* Assume card type F32_8 if no match */
1295 dc
->card_type
= size
== 2048 ? F32_2
: F32_8
;
1297 dev_info(&dc
->pdev
->dev
, "Card type is: %d\n", dc
->card_type
);
1300 static void nozomi_setup_private_data(struct nozomi
*dc
)
1302 void __iomem
*offset
= dc
->base_addr
+ dc
->card_type
/ 2;
1305 dc
->reg_fcr
= (void __iomem
*)(offset
+ R_FCR
);
1306 dc
->reg_iir
= (void __iomem
*)(offset
+ R_IIR
);
1307 dc
->reg_ier
= (void __iomem
*)(offset
+ R_IER
);
1311 dc
->port
[PORT_MDM
].token_dl
= MDM_DL
;
1312 dc
->port
[PORT_DIAG
].token_dl
= DIAG_DL
;
1313 dc
->port
[PORT_APP1
].token_dl
= APP1_DL
;
1314 dc
->port
[PORT_APP2
].token_dl
= APP2_DL
;
1316 for (i
= 0; i
< MAX_PORT
; i
++)
1317 init_waitqueue_head(&dc
->port
[i
].tty_wait
);
1320 static ssize_t
card_type_show(struct device
*dev
, struct device_attribute
*attr
,
1323 const struct nozomi
*dc
= pci_get_drvdata(to_pci_dev(dev
));
1325 return sprintf(buf
, "%d\n", dc
->card_type
);
1327 static DEVICE_ATTR(card_type
, S_IRUGO
, card_type_show
, NULL
);
1329 static ssize_t
open_ttys_show(struct device
*dev
, struct device_attribute
*attr
,
1332 const struct nozomi
*dc
= pci_get_drvdata(to_pci_dev(dev
));
1334 return sprintf(buf
, "%u\n", dc
->open_ttys
);
1336 static DEVICE_ATTR(open_ttys
, S_IRUGO
, open_ttys_show
, NULL
);
1338 static void make_sysfs_files(struct nozomi
*dc
)
1340 if (device_create_file(&dc
->pdev
->dev
, &dev_attr_card_type
))
1341 dev_err(&dc
->pdev
->dev
,
1342 "Could not create sysfs file for card_type\n");
1343 if (device_create_file(&dc
->pdev
->dev
, &dev_attr_open_ttys
))
1344 dev_err(&dc
->pdev
->dev
,
1345 "Could not create sysfs file for open_ttys\n");
1348 static void remove_sysfs_files(struct nozomi
*dc
)
1350 device_remove_file(&dc
->pdev
->dev
, &dev_attr_card_type
);
1351 device_remove_file(&dc
->pdev
->dev
, &dev_attr_open_ttys
);
1354 /* Allocate memory for one device */
1355 static int nozomi_card_init(struct pci_dev
*pdev
,
1356 const struct pci_device_id
*ent
)
1358 resource_size_t start
;
1360 struct nozomi
*dc
= NULL
;
1364 dev_dbg(&pdev
->dev
, "Init, new card found\n");
1366 for (ndev_idx
= 0; ndev_idx
< ARRAY_SIZE(ndevs
); ndev_idx
++)
1367 if (!ndevs
[ndev_idx
])
1370 if (ndev_idx
>= ARRAY_SIZE(ndevs
)) {
1371 dev_err(&pdev
->dev
, "no free tty range for this card left\n");
1376 dc
= kzalloc(sizeof(struct nozomi
), GFP_KERNEL
);
1377 if (unlikely(!dc
)) {
1378 dev_err(&pdev
->dev
, "Could not allocate memory\n");
1385 ret
= pci_enable_device(dc
->pdev
);
1387 dev_err(&pdev
->dev
, "Failed to enable PCI Device\n");
1391 ret
= pci_request_regions(dc
->pdev
, NOZOMI_NAME
);
1393 dev_err(&pdev
->dev
, "I/O address 0x%04x already in use\n",
1394 (int) /* nozomi_private.io_addr */ 0);
1395 goto err_disable_device
;
1398 start
= pci_resource_start(dc
->pdev
, 0);
1400 dev_err(&pdev
->dev
, "No I/O address for card detected\n");
1405 /* Find out what card type it is */
1406 nozomi_get_card_type(dc
);
1408 dc
->base_addr
= ioremap_nocache(start
, dc
->card_type
);
1409 if (!dc
->base_addr
) {
1410 dev_err(&pdev
->dev
, "Unable to map card MMIO\n");
1415 dc
->send_buf
= kmalloc(SEND_BUF_MAX
, GFP_KERNEL
);
1416 if (!dc
->send_buf
) {
1417 dev_err(&pdev
->dev
, "Could not allocate send buffer?\n");
1422 for (i
= PORT_MDM
; i
< MAX_PORT
; i
++) {
1423 if (kfifo_alloc(&dc
->port
[i
].fifo_ul
, FIFO_BUFFER_SIZE_UL
,
1426 "Could not allocate kfifo buffer\n");
1428 goto err_free_kfifo
;
1432 spin_lock_init(&dc
->spin_mutex
);
1434 nozomi_setup_private_data(dc
);
1436 /* Disable all interrupts */
1438 writew(dc
->last_ier
, dc
->reg_ier
);
1440 ret
= request_irq(pdev
->irq
, &interrupt_handler
, IRQF_SHARED
,
1442 if (unlikely(ret
)) {
1443 dev_err(&pdev
->dev
, "can't request irq %d\n", pdev
->irq
);
1444 goto err_free_kfifo
;
1447 DBG1("base_addr: %p", dc
->base_addr
);
1449 make_sysfs_files(dc
);
1451 dc
->index_start
= ndev_idx
* MAX_PORT
;
1452 ndevs
[ndev_idx
] = dc
;
1454 pci_set_drvdata(pdev
, dc
);
1456 /* Enable RESET interrupt */
1457 dc
->last_ier
= RESET
;
1458 iowrite16(dc
->last_ier
, dc
->reg_ier
);
1460 dc
->state
= NOZOMI_STATE_ENABLED
;
1462 for (i
= 0; i
< MAX_PORT
; i
++) {
1463 struct device
*tty_dev
;
1464 struct port
*port
= &dc
->port
[i
];
1466 tty_port_init(&port
->port
);
1467 port
->port
.ops
= &noz_tty_port_ops
;
1468 tty_dev
= tty_port_register_device(&port
->port
, ntty_driver
,
1469 dc
->index_start
+ i
, &pdev
->dev
);
1471 if (IS_ERR(tty_dev
)) {
1472 ret
= PTR_ERR(tty_dev
);
1473 dev_err(&pdev
->dev
, "Could not allocate tty?\n");
1474 tty_port_destroy(&port
->port
);
1482 for (i
= 0; i
< MAX_PORT
; ++i
) {
1483 tty_unregister_device(ntty_driver
, dc
->index_start
+ i
);
1484 tty_port_destroy(&dc
->port
[i
].port
);
1487 for (i
= 0; i
< MAX_PORT
; i
++)
1488 kfifo_free(&dc
->port
[i
].fifo_ul
);
1490 kfree(dc
->send_buf
);
1491 iounmap(dc
->base_addr
);
1493 pci_release_regions(pdev
);
1495 pci_disable_device(pdev
);
1502 static void tty_exit(struct nozomi
*dc
)
1508 for (i
= 0; i
< MAX_PORT
; ++i
) {
1509 struct tty_struct
*tty
= tty_port_tty_get(&dc
->port
[i
].port
);
1510 if (tty
&& list_empty(&tty
->hangup_work
.entry
))
1514 /* Racy below - surely should wait for scheduled work to be done or
1515 complete off a hangup method ? */
1516 while (dc
->open_ttys
)
1518 for (i
= 0; i
< MAX_PORT
; ++i
) {
1519 tty_unregister_device(ntty_driver
, dc
->index_start
+ i
);
1520 tty_port_destroy(&dc
->port
[i
].port
);
1524 /* Deallocate memory for one device */
1525 static void nozomi_card_exit(struct pci_dev
*pdev
)
1528 struct ctrl_ul ctrl
;
1529 struct nozomi
*dc
= pci_get_drvdata(pdev
);
1531 /* Disable all interrupts */
1533 writew(dc
->last_ier
, dc
->reg_ier
);
1537 /* Send 0x0001, command card to resend the reset token. */
1538 /* This is to get the reset when the module is reloaded. */
1543 DBG1("sending flow control 0x%04X", *((u16
*)&ctrl
));
1545 /* Setup dc->reg addresses to we can use defines here */
1546 write_mem32(dc
->port
[PORT_CTRL
].ul_addr
[0], (u32
*)&ctrl
, 2);
1547 writew(CTRL_UL
, dc
->reg_fcr
); /* push the token to the card. */
1549 remove_sysfs_files(dc
);
1551 free_irq(pdev
->irq
, dc
);
1553 for (i
= 0; i
< MAX_PORT
; i
++)
1554 kfifo_free(&dc
->port
[i
].fifo_ul
);
1556 kfree(dc
->send_buf
);
1558 iounmap(dc
->base_addr
);
1560 pci_release_regions(pdev
);
1562 pci_disable_device(pdev
);
1564 ndevs
[dc
->index_start
/ MAX_PORT
] = NULL
;
1569 static void set_rts(const struct tty_struct
*tty
, int rts
)
1571 struct port
*port
= get_port_by_tty(tty
);
1573 port
->ctrl_ul
.RTS
= rts
;
1574 port
->update_flow_control
= 1;
1575 enable_transmit_ul(PORT_CTRL
, get_dc_by_tty(tty
));
1578 static void set_dtr(const struct tty_struct
*tty
, int dtr
)
1580 struct port
*port
= get_port_by_tty(tty
);
1582 DBG1("SETTING DTR index: %d, dtr: %d", tty
->index
, dtr
);
1584 port
->ctrl_ul
.DTR
= dtr
;
1585 port
->update_flow_control
= 1;
1586 enable_transmit_ul(PORT_CTRL
, get_dc_by_tty(tty
));
1590 * ----------------------------------------------------------------------------
1592 * ----------------------------------------------------------------------------
1595 static int ntty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1597 struct port
*port
= get_port_by_tty(tty
);
1598 struct nozomi
*dc
= get_dc_by_tty(tty
);
1600 if (!port
|| !dc
|| dc
->state
!= NOZOMI_STATE_READY
)
1602 ret
= tty_standard_install(driver
, tty
);
1604 tty
->driver_data
= port
;
1608 static void ntty_cleanup(struct tty_struct
*tty
)
1610 tty
->driver_data
= NULL
;
1613 static int ntty_activate(struct tty_port
*tport
, struct tty_struct
*tty
)
1615 struct port
*port
= container_of(tport
, struct port
, port
);
1616 struct nozomi
*dc
= port
->dc
;
1617 unsigned long flags
;
1619 DBG1("open: %d", port
->token_dl
);
1620 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1621 dc
->last_ier
= dc
->last_ier
| port
->token_dl
;
1622 writew(dc
->last_ier
, dc
->reg_ier
);
1624 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1625 printk("noz: activated %d: %p\n", tty
->index
, tport
);
1629 static int ntty_open(struct tty_struct
*tty
, struct file
*filp
)
1631 struct port
*port
= tty
->driver_data
;
1632 return tty_port_open(&port
->port
, tty
, filp
);
1635 static void ntty_shutdown(struct tty_port
*tport
)
1637 struct port
*port
= container_of(tport
, struct port
, port
);
1638 struct nozomi
*dc
= port
->dc
;
1639 unsigned long flags
;
1641 DBG1("close: %d", port
->token_dl
);
1642 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1643 dc
->last_ier
&= ~(port
->token_dl
);
1644 writew(dc
->last_ier
, dc
->reg_ier
);
1646 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1647 printk("noz: shutdown %p\n", tport
);
1650 static void ntty_close(struct tty_struct
*tty
, struct file
*filp
)
1652 struct port
*port
= tty
->driver_data
;
1654 tty_port_close(&port
->port
, tty
, filp
);
1657 static void ntty_hangup(struct tty_struct
*tty
)
1659 struct port
*port
= tty
->driver_data
;
1660 tty_port_hangup(&port
->port
);
1664 * called when the userspace process writes to the tty (/dev/noz*).
1665 * Data is inserted into a fifo, which is then read and transferred to the modem.
1667 static int ntty_write(struct tty_struct
*tty
, const unsigned char *buffer
,
1671 struct nozomi
*dc
= get_dc_by_tty(tty
);
1672 struct port
*port
= tty
->driver_data
;
1673 unsigned long flags
;
1675 /* DBG1( "WRITEx: %d, index = %d", count, index); */
1680 rval
= kfifo_in(&port
->fifo_ul
, (unsigned char *)buffer
, count
);
1682 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1683 /* CTS is only valid on the modem channel */
1684 if (port
== &(dc
->port
[PORT_MDM
])) {
1685 if (port
->ctrl_dl
.CTS
) {
1686 DBG4("Enable interrupt");
1687 enable_transmit_ul(tty
->index
% MAX_PORT
, dc
);
1689 dev_err(&dc
->pdev
->dev
,
1690 "CTS not active on modem port?\n");
1693 enable_transmit_ul(tty
->index
% MAX_PORT
, dc
);
1695 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1701 * Calculate how much is left in device
1702 * This method is called by the upper tty layer.
1703 * #according to sources N_TTY.c it expects a value >= 0 and
1704 * does not check for negative values.
1706 * If the port is unplugged report lots of room and let the bits
1707 * dribble away so we don't block anything.
1709 static int ntty_write_room(struct tty_struct
*tty
)
1711 struct port
*port
= tty
->driver_data
;
1713 const struct nozomi
*dc
= get_dc_by_tty(tty
);
1716 room
= kfifo_avail(&port
->fifo_ul
);
1721 /* Gets io control parameters */
1722 static int ntty_tiocmget(struct tty_struct
*tty
)
1724 const struct port
*port
= tty
->driver_data
;
1725 const struct ctrl_dl
*ctrl_dl
= &port
->ctrl_dl
;
1726 const struct ctrl_ul
*ctrl_ul
= &port
->ctrl_ul
;
1728 /* Note: these could change under us but it is not clear this
1730 return (ctrl_ul
->RTS
? TIOCM_RTS
: 0) |
1731 (ctrl_ul
->DTR
? TIOCM_DTR
: 0) |
1732 (ctrl_dl
->DCD
? TIOCM_CAR
: 0) |
1733 (ctrl_dl
->RI
? TIOCM_RNG
: 0) |
1734 (ctrl_dl
->DSR
? TIOCM_DSR
: 0) |
1735 (ctrl_dl
->CTS
? TIOCM_CTS
: 0);
1738 /* Sets io controls parameters */
1739 static int ntty_tiocmset(struct tty_struct
*tty
,
1740 unsigned int set
, unsigned int clear
)
1742 struct nozomi
*dc
= get_dc_by_tty(tty
);
1743 unsigned long flags
;
1745 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1746 if (set
& TIOCM_RTS
)
1748 else if (clear
& TIOCM_RTS
)
1751 if (set
& TIOCM_DTR
)
1753 else if (clear
& TIOCM_DTR
)
1755 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1760 static int ntty_cflags_changed(struct port
*port
, unsigned long flags
,
1761 struct async_icount
*cprev
)
1763 const struct async_icount cnow
= port
->tty_icount
;
1766 ret
= ((flags
& TIOCM_RNG
) && (cnow
.rng
!= cprev
->rng
)) ||
1767 ((flags
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
->dsr
)) ||
1768 ((flags
& TIOCM_CD
) && (cnow
.dcd
!= cprev
->dcd
)) ||
1769 ((flags
& TIOCM_CTS
) && (cnow
.cts
!= cprev
->cts
));
1776 static int ntty_tiocgicount(struct tty_struct
*tty
,
1777 struct serial_icounter_struct
*icount
)
1779 struct port
*port
= tty
->driver_data
;
1780 const struct async_icount cnow
= port
->tty_icount
;
1782 icount
->cts
= cnow
.cts
;
1783 icount
->dsr
= cnow
.dsr
;
1784 icount
->rng
= cnow
.rng
;
1785 icount
->dcd
= cnow
.dcd
;
1786 icount
->rx
= cnow
.rx
;
1787 icount
->tx
= cnow
.tx
;
1788 icount
->frame
= cnow
.frame
;
1789 icount
->overrun
= cnow
.overrun
;
1790 icount
->parity
= cnow
.parity
;
1791 icount
->brk
= cnow
.brk
;
1792 icount
->buf_overrun
= cnow
.buf_overrun
;
1796 static int ntty_ioctl(struct tty_struct
*tty
,
1797 unsigned int cmd
, unsigned long arg
)
1799 struct port
*port
= tty
->driver_data
;
1800 int rval
= -ENOIOCTLCMD
;
1802 DBG1("******** IOCTL, cmd: %d", cmd
);
1806 struct async_icount cprev
= port
->tty_icount
;
1808 rval
= wait_event_interruptible(port
->tty_wait
,
1809 ntty_cflags_changed(port
, arg
, &cprev
));
1813 DBG1("ERR: 0x%08X, %d", cmd
, cmd
);
1821 * Called by the upper tty layer when tty buffers are ready
1822 * to receive data again after a call to throttle.
1824 static void ntty_unthrottle(struct tty_struct
*tty
)
1826 struct nozomi
*dc
= get_dc_by_tty(tty
);
1827 unsigned long flags
;
1830 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1831 enable_transmit_dl(tty
->index
% MAX_PORT
, dc
);
1834 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1838 * Called by the upper tty layer when the tty buffers are almost full.
1839 * The driver should stop send more data.
1841 static void ntty_throttle(struct tty_struct
*tty
)
1843 struct nozomi
*dc
= get_dc_by_tty(tty
);
1844 unsigned long flags
;
1847 spin_lock_irqsave(&dc
->spin_mutex
, flags
);
1849 spin_unlock_irqrestore(&dc
->spin_mutex
, flags
);
1852 /* Returns number of chars in buffer, called by tty layer */
1853 static s32
ntty_chars_in_buffer(struct tty_struct
*tty
)
1855 struct port
*port
= tty
->driver_data
;
1856 struct nozomi
*dc
= get_dc_by_tty(tty
);
1859 if (unlikely(!dc
|| !port
)) {
1860 goto exit_in_buffer
;
1863 rval
= kfifo_len(&port
->fifo_ul
);
1869 static const struct tty_port_operations noz_tty_port_ops
= {
1870 .activate
= ntty_activate
,
1871 .shutdown
= ntty_shutdown
,
1874 static const struct tty_operations tty_ops
= {
1875 .ioctl
= ntty_ioctl
,
1877 .close
= ntty_close
,
1878 .hangup
= ntty_hangup
,
1879 .write
= ntty_write
,
1880 .write_room
= ntty_write_room
,
1881 .unthrottle
= ntty_unthrottle
,
1882 .throttle
= ntty_throttle
,
1883 .chars_in_buffer
= ntty_chars_in_buffer
,
1884 .tiocmget
= ntty_tiocmget
,
1885 .tiocmset
= ntty_tiocmset
,
1886 .get_icount
= ntty_tiocgicount
,
1887 .install
= ntty_install
,
1888 .cleanup
= ntty_cleanup
,
1891 /* Module initialization */
1892 static struct pci_driver nozomi_driver
= {
1893 .name
= NOZOMI_NAME
,
1894 .id_table
= nozomi_pci_tbl
,
1895 .probe
= nozomi_card_init
,
1896 .remove
= nozomi_card_exit
,
1899 static __init
int nozomi_init(void)
1903 printk(KERN_INFO
"Initializing %s\n", VERSION_STRING
);
1905 ntty_driver
= alloc_tty_driver(NTTY_TTY_MAXMINORS
);
1909 ntty_driver
->driver_name
= NOZOMI_NAME_TTY
;
1910 ntty_driver
->name
= "noz";
1911 ntty_driver
->major
= 0;
1912 ntty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1913 ntty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1914 ntty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1915 ntty_driver
->init_termios
= tty_std_termios
;
1916 ntty_driver
->init_termios
.c_cflag
= B115200
| CS8
| CREAD
| \
1918 ntty_driver
->init_termios
.c_ispeed
= 115200;
1919 ntty_driver
->init_termios
.c_ospeed
= 115200;
1920 tty_set_operations(ntty_driver
, &tty_ops
);
1922 ret
= tty_register_driver(ntty_driver
);
1924 printk(KERN_ERR
"Nozomi: failed to register ntty driver\n");
1928 ret
= pci_register_driver(&nozomi_driver
);
1930 printk(KERN_ERR
"Nozomi: can't register pci driver\n");
1936 tty_unregister_driver(ntty_driver
);
1938 put_tty_driver(ntty_driver
);
1942 static __exit
void nozomi_exit(void)
1944 printk(KERN_INFO
"Unloading %s\n", DRIVER_DESC
);
1945 pci_unregister_driver(&nozomi_driver
);
1946 tty_unregister_driver(ntty_driver
);
1947 put_tty_driver(ntty_driver
);
1950 module_init(nozomi_init
);
1951 module_exit(nozomi_exit
);
1953 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
1955 MODULE_LICENSE("Dual BSD/GPL");
1956 MODULE_DESCRIPTION(DRIVER_DESC
);