2 *Copyright (C) 2010 OKI SEMICONDUCTOR CO., LTD.
4 *This program is free software; you can redistribute it and/or modify
5 *it under the terms of the GNU General Public License as published by
6 *the Free Software Foundation; version 2 of the License.
8 *This program is distributed in the hope that it will be useful,
9 *but WITHOUT ANY WARRANTY; without even the implied warranty of
10 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 *GNU General Public License for more details.
13 *You should have received a copy of the GNU General Public License
14 *along with this program; if not, write to the Free Software
15 *Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
17 #include <linux/kernel.h>
18 #include <linux/serial_reg.h>
19 #include <linux/slab.h>
20 #include <linux/module.h>
21 #include <linux/pci.h>
22 #include <linux/serial_core.h>
23 #include <linux/tty.h>
24 #include <linux/tty_flip.h>
25 #include <linux/interrupt.h>
27 #include <linux/dmi.h>
29 #include <linux/dmaengine.h>
30 #include <linux/pch_dma.h>
33 PCH_UART_HANDLED_RX_INT_SHIFT
,
34 PCH_UART_HANDLED_TX_INT_SHIFT
,
35 PCH_UART_HANDLED_RX_ERR_INT_SHIFT
,
36 PCH_UART_HANDLED_RX_TRG_INT_SHIFT
,
37 PCH_UART_HANDLED_MS_INT_SHIFT
,
45 #define PCH_UART_DRIVER_DEVICE "ttyPCH"
47 /* Set the max number of UART port
48 * Intel EG20T PCH: 4 port
49 * OKI SEMICONDUCTOR ML7213 IOH: 3 port
50 * OKI SEMICONDUCTOR ML7223 IOH: 2 port
54 #define PCH_UART_HANDLED_RX_INT (1<<((PCH_UART_HANDLED_RX_INT_SHIFT)<<1))
55 #define PCH_UART_HANDLED_TX_INT (1<<((PCH_UART_HANDLED_TX_INT_SHIFT)<<1))
56 #define PCH_UART_HANDLED_RX_ERR_INT (1<<((\
57 PCH_UART_HANDLED_RX_ERR_INT_SHIFT)<<1))
58 #define PCH_UART_HANDLED_RX_TRG_INT (1<<((\
59 PCH_UART_HANDLED_RX_TRG_INT_SHIFT)<<1))
60 #define PCH_UART_HANDLED_MS_INT (1<<((PCH_UART_HANDLED_MS_INT_SHIFT)<<1))
62 #define PCH_UART_RBR 0x00
63 #define PCH_UART_THR 0x00
65 #define PCH_UART_IER_MASK (PCH_UART_IER_ERBFI|PCH_UART_IER_ETBEI|\
66 PCH_UART_IER_ELSI|PCH_UART_IER_EDSSI)
67 #define PCH_UART_IER_ERBFI 0x00000001
68 #define PCH_UART_IER_ETBEI 0x00000002
69 #define PCH_UART_IER_ELSI 0x00000004
70 #define PCH_UART_IER_EDSSI 0x00000008
72 #define PCH_UART_IIR_IP 0x00000001
73 #define PCH_UART_IIR_IID 0x00000006
74 #define PCH_UART_IIR_MSI 0x00000000
75 #define PCH_UART_IIR_TRI 0x00000002
76 #define PCH_UART_IIR_RRI 0x00000004
77 #define PCH_UART_IIR_REI 0x00000006
78 #define PCH_UART_IIR_TOI 0x00000008
79 #define PCH_UART_IIR_FIFO256 0x00000020
80 #define PCH_UART_IIR_FIFO64 PCH_UART_IIR_FIFO256
81 #define PCH_UART_IIR_FE 0x000000C0
83 #define PCH_UART_FCR_FIFOE 0x00000001
84 #define PCH_UART_FCR_RFR 0x00000002
85 #define PCH_UART_FCR_TFR 0x00000004
86 #define PCH_UART_FCR_DMS 0x00000008
87 #define PCH_UART_FCR_FIFO256 0x00000020
88 #define PCH_UART_FCR_RFTL 0x000000C0
90 #define PCH_UART_FCR_RFTL1 0x00000000
91 #define PCH_UART_FCR_RFTL64 0x00000040
92 #define PCH_UART_FCR_RFTL128 0x00000080
93 #define PCH_UART_FCR_RFTL224 0x000000C0
94 #define PCH_UART_FCR_RFTL16 PCH_UART_FCR_RFTL64
95 #define PCH_UART_FCR_RFTL32 PCH_UART_FCR_RFTL128
96 #define PCH_UART_FCR_RFTL56 PCH_UART_FCR_RFTL224
97 #define PCH_UART_FCR_RFTL4 PCH_UART_FCR_RFTL64
98 #define PCH_UART_FCR_RFTL8 PCH_UART_FCR_RFTL128
99 #define PCH_UART_FCR_RFTL14 PCH_UART_FCR_RFTL224
100 #define PCH_UART_FCR_RFTL_SHIFT 6
102 #define PCH_UART_LCR_WLS 0x00000003
103 #define PCH_UART_LCR_STB 0x00000004
104 #define PCH_UART_LCR_PEN 0x00000008
105 #define PCH_UART_LCR_EPS 0x00000010
106 #define PCH_UART_LCR_SP 0x00000020
107 #define PCH_UART_LCR_SB 0x00000040
108 #define PCH_UART_LCR_DLAB 0x00000080
109 #define PCH_UART_LCR_NP 0x00000000
110 #define PCH_UART_LCR_OP PCH_UART_LCR_PEN
111 #define PCH_UART_LCR_EP (PCH_UART_LCR_PEN | PCH_UART_LCR_EPS)
112 #define PCH_UART_LCR_1P (PCH_UART_LCR_PEN | PCH_UART_LCR_SP)
113 #define PCH_UART_LCR_0P (PCH_UART_LCR_PEN | PCH_UART_LCR_EPS |\
116 #define PCH_UART_LCR_5BIT 0x00000000
117 #define PCH_UART_LCR_6BIT 0x00000001
118 #define PCH_UART_LCR_7BIT 0x00000002
119 #define PCH_UART_LCR_8BIT 0x00000003
121 #define PCH_UART_MCR_DTR 0x00000001
122 #define PCH_UART_MCR_RTS 0x00000002
123 #define PCH_UART_MCR_OUT 0x0000000C
124 #define PCH_UART_MCR_LOOP 0x00000010
125 #define PCH_UART_MCR_AFE 0x00000020
127 #define PCH_UART_LSR_DR 0x00000001
128 #define PCH_UART_LSR_ERR (1<<7)
130 #define PCH_UART_MSR_DCTS 0x00000001
131 #define PCH_UART_MSR_DDSR 0x00000002
132 #define PCH_UART_MSR_TERI 0x00000004
133 #define PCH_UART_MSR_DDCD 0x00000008
134 #define PCH_UART_MSR_CTS 0x00000010
135 #define PCH_UART_MSR_DSR 0x00000020
136 #define PCH_UART_MSR_RI 0x00000040
137 #define PCH_UART_MSR_DCD 0x00000080
138 #define PCH_UART_MSR_DELTA (PCH_UART_MSR_DCTS | PCH_UART_MSR_DDSR |\
139 PCH_UART_MSR_TERI | PCH_UART_MSR_DDCD)
141 #define PCH_UART_DLL 0x00
142 #define PCH_UART_DLM 0x01
144 #define PCH_UART_IID_RLS (PCH_UART_IIR_REI)
145 #define PCH_UART_IID_RDR (PCH_UART_IIR_RRI)
146 #define PCH_UART_IID_RDR_TO (PCH_UART_IIR_RRI | PCH_UART_IIR_TOI)
147 #define PCH_UART_IID_THRE (PCH_UART_IIR_TRI)
148 #define PCH_UART_IID_MS (PCH_UART_IIR_MSI)
150 #define PCH_UART_HAL_PARITY_NONE (PCH_UART_LCR_NP)
151 #define PCH_UART_HAL_PARITY_ODD (PCH_UART_LCR_OP)
152 #define PCH_UART_HAL_PARITY_EVEN (PCH_UART_LCR_EP)
153 #define PCH_UART_HAL_PARITY_FIX1 (PCH_UART_LCR_1P)
154 #define PCH_UART_HAL_PARITY_FIX0 (PCH_UART_LCR_0P)
155 #define PCH_UART_HAL_5BIT (PCH_UART_LCR_5BIT)
156 #define PCH_UART_HAL_6BIT (PCH_UART_LCR_6BIT)
157 #define PCH_UART_HAL_7BIT (PCH_UART_LCR_7BIT)
158 #define PCH_UART_HAL_8BIT (PCH_UART_LCR_8BIT)
159 #define PCH_UART_HAL_STB1 0
160 #define PCH_UART_HAL_STB2 (PCH_UART_LCR_STB)
162 #define PCH_UART_HAL_CLR_TX_FIFO (PCH_UART_FCR_TFR)
163 #define PCH_UART_HAL_CLR_RX_FIFO (PCH_UART_FCR_RFR)
164 #define PCH_UART_HAL_CLR_ALL_FIFO (PCH_UART_HAL_CLR_TX_FIFO | \
165 PCH_UART_HAL_CLR_RX_FIFO)
167 #define PCH_UART_HAL_DMA_MODE0 0
168 #define PCH_UART_HAL_FIFO_DIS 0
169 #define PCH_UART_HAL_FIFO16 (PCH_UART_FCR_FIFOE)
170 #define PCH_UART_HAL_FIFO256 (PCH_UART_FCR_FIFOE | \
171 PCH_UART_FCR_FIFO256)
172 #define PCH_UART_HAL_FIFO64 (PCH_UART_HAL_FIFO256)
173 #define PCH_UART_HAL_TRIGGER1 (PCH_UART_FCR_RFTL1)
174 #define PCH_UART_HAL_TRIGGER64 (PCH_UART_FCR_RFTL64)
175 #define PCH_UART_HAL_TRIGGER128 (PCH_UART_FCR_RFTL128)
176 #define PCH_UART_HAL_TRIGGER224 (PCH_UART_FCR_RFTL224)
177 #define PCH_UART_HAL_TRIGGER16 (PCH_UART_FCR_RFTL16)
178 #define PCH_UART_HAL_TRIGGER32 (PCH_UART_FCR_RFTL32)
179 #define PCH_UART_HAL_TRIGGER56 (PCH_UART_FCR_RFTL56)
180 #define PCH_UART_HAL_TRIGGER4 (PCH_UART_FCR_RFTL4)
181 #define PCH_UART_HAL_TRIGGER8 (PCH_UART_FCR_RFTL8)
182 #define PCH_UART_HAL_TRIGGER14 (PCH_UART_FCR_RFTL14)
183 #define PCH_UART_HAL_TRIGGER_L (PCH_UART_FCR_RFTL64)
184 #define PCH_UART_HAL_TRIGGER_M (PCH_UART_FCR_RFTL128)
185 #define PCH_UART_HAL_TRIGGER_H (PCH_UART_FCR_RFTL224)
187 #define PCH_UART_HAL_RX_INT (PCH_UART_IER_ERBFI)
188 #define PCH_UART_HAL_TX_INT (PCH_UART_IER_ETBEI)
189 #define PCH_UART_HAL_RX_ERR_INT (PCH_UART_IER_ELSI)
190 #define PCH_UART_HAL_MS_INT (PCH_UART_IER_EDSSI)
191 #define PCH_UART_HAL_ALL_INT (PCH_UART_IER_MASK)
193 #define PCH_UART_HAL_DTR (PCH_UART_MCR_DTR)
194 #define PCH_UART_HAL_RTS (PCH_UART_MCR_RTS)
195 #define PCH_UART_HAL_OUT (PCH_UART_MCR_OUT)
196 #define PCH_UART_HAL_LOOP (PCH_UART_MCR_LOOP)
197 #define PCH_UART_HAL_AFE (PCH_UART_MCR_AFE)
199 #define PCI_VENDOR_ID_ROHM 0x10DB
201 struct pch_uart_buffer
{
207 struct uart_port port
;
209 void __iomem
*membase
;
210 resource_size_t mapbase
;
212 struct pci_dev
*pdev
;
221 struct pch_uart_buffer rxbuf
;
225 unsigned int use_dma
;
226 unsigned int use_dma_flag
;
227 struct dma_async_tx_descriptor
*desc_tx
;
228 struct dma_async_tx_descriptor
*desc_rx
;
229 struct pch_dma_slave param_tx
;
230 struct pch_dma_slave param_rx
;
231 struct dma_chan
*chan_tx
;
232 struct dma_chan
*chan_rx
;
233 struct scatterlist
*sg_tx_p
;
235 struct scatterlist sg_rx
;
238 dma_addr_t rx_buf_dma
;
242 * struct pch_uart_driver_data - private data structure for UART-DMA
243 * @port_type: The number of DMA channel
244 * @line_no: UART port line number (0, 1, 2...)
246 struct pch_uart_driver_data
{
251 enum pch_uart_num_t
{
263 static struct pch_uart_driver_data drv_dat
[] = {
264 [pch_et20t_uart0
] = {PCH_UART_8LINE
, 0},
265 [pch_et20t_uart1
] = {PCH_UART_2LINE
, 1},
266 [pch_et20t_uart2
] = {PCH_UART_2LINE
, 2},
267 [pch_et20t_uart3
] = {PCH_UART_2LINE
, 3},
268 [pch_ml7213_uart0
] = {PCH_UART_8LINE
, 0},
269 [pch_ml7213_uart1
] = {PCH_UART_2LINE
, 1},
270 [pch_ml7213_uart2
] = {PCH_UART_2LINE
, 2},
271 [pch_ml7223_uart0
] = {PCH_UART_8LINE
, 0},
272 [pch_ml7223_uart1
] = {PCH_UART_2LINE
, 1},
275 static unsigned int default_baud
= 9600;
276 static const int trigger_level_256
[4] = { 1, 64, 128, 224 };
277 static const int trigger_level_64
[4] = { 1, 16, 32, 56 };
278 static const int trigger_level_16
[4] = { 1, 4, 8, 14 };
279 static const int trigger_level_1
[4] = { 1, 1, 1, 1 };
281 static void pch_uart_hal_request(struct pci_dev
*pdev
, int fifosize
,
284 struct eg20t_port
*priv
= pci_get_drvdata(pdev
);
286 priv
->trigger_level
= 1;
290 static unsigned int get_msr(struct eg20t_port
*priv
, void __iomem
*base
)
292 unsigned int msr
= ioread8(base
+ UART_MSR
);
293 priv
->dmsr
|= msr
& PCH_UART_MSR_DELTA
;
298 static void pch_uart_hal_enable_interrupt(struct eg20t_port
*priv
,
301 u8 ier
= ioread8(priv
->membase
+ UART_IER
);
302 ier
|= flag
& PCH_UART_IER_MASK
;
303 iowrite8(ier
, priv
->membase
+ UART_IER
);
306 static void pch_uart_hal_disable_interrupt(struct eg20t_port
*priv
,
309 u8 ier
= ioread8(priv
->membase
+ UART_IER
);
310 ier
&= ~(flag
& PCH_UART_IER_MASK
);
311 iowrite8(ier
, priv
->membase
+ UART_IER
);
314 static int pch_uart_hal_set_line(struct eg20t_port
*priv
, int baud
,
315 unsigned int parity
, unsigned int bits
,
318 unsigned int dll
, dlm
, lcr
;
321 div
= DIV_ROUND_CLOSEST(priv
->base_baud
/ 16, baud
);
322 if (div
< 0 || USHRT_MAX
<= div
) {
323 dev_err(priv
->port
.dev
, "Invalid Baud(div=0x%x)\n", div
);
327 dll
= (unsigned int)div
& 0x00FFU
;
328 dlm
= ((unsigned int)div
>> 8) & 0x00FFU
;
330 if (parity
& ~(PCH_UART_LCR_PEN
| PCH_UART_LCR_EPS
| PCH_UART_LCR_SP
)) {
331 dev_err(priv
->port
.dev
, "Invalid parity(0x%x)\n", parity
);
335 if (bits
& ~PCH_UART_LCR_WLS
) {
336 dev_err(priv
->port
.dev
, "Invalid bits(0x%x)\n", bits
);
340 if (stb
& ~PCH_UART_LCR_STB
) {
341 dev_err(priv
->port
.dev
, "Invalid STB(0x%x)\n", stb
);
349 dev_dbg(priv
->port
.dev
, "%s:baud = %d, div = %04x, lcr = %02x (%lu)\n",
350 __func__
, baud
, div
, lcr
, jiffies
);
351 iowrite8(PCH_UART_LCR_DLAB
, priv
->membase
+ UART_LCR
);
352 iowrite8(dll
, priv
->membase
+ PCH_UART_DLL
);
353 iowrite8(dlm
, priv
->membase
+ PCH_UART_DLM
);
354 iowrite8(lcr
, priv
->membase
+ UART_LCR
);
359 static int pch_uart_hal_fifo_reset(struct eg20t_port
*priv
,
362 if (flag
& ~(PCH_UART_FCR_TFR
| PCH_UART_FCR_RFR
)) {
363 dev_err(priv
->port
.dev
, "%s:Invalid flag(0x%x)\n",
368 iowrite8(PCH_UART_FCR_FIFOE
| priv
->fcr
, priv
->membase
+ UART_FCR
);
369 iowrite8(PCH_UART_FCR_FIFOE
| priv
->fcr
| flag
,
370 priv
->membase
+ UART_FCR
);
371 iowrite8(priv
->fcr
, priv
->membase
+ UART_FCR
);
376 static int pch_uart_hal_set_fifo(struct eg20t_port
*priv
,
377 unsigned int dmamode
,
378 unsigned int fifo_size
, unsigned int trigger
)
382 if (dmamode
& ~PCH_UART_FCR_DMS
) {
383 dev_err(priv
->port
.dev
, "%s:Invalid DMA Mode(0x%x)\n",
388 if (fifo_size
& ~(PCH_UART_FCR_FIFOE
| PCH_UART_FCR_FIFO256
)) {
389 dev_err(priv
->port
.dev
, "%s:Invalid FIFO SIZE(0x%x)\n",
390 __func__
, fifo_size
);
394 if (trigger
& ~PCH_UART_FCR_RFTL
) {
395 dev_err(priv
->port
.dev
, "%s:Invalid TRIGGER(0x%x)\n",
400 switch (priv
->fifo_size
) {
402 priv
->trigger_level
=
403 trigger_level_256
[trigger
>> PCH_UART_FCR_RFTL_SHIFT
];
406 priv
->trigger_level
=
407 trigger_level_64
[trigger
>> PCH_UART_FCR_RFTL_SHIFT
];
410 priv
->trigger_level
=
411 trigger_level_16
[trigger
>> PCH_UART_FCR_RFTL_SHIFT
];
414 priv
->trigger_level
=
415 trigger_level_1
[trigger
>> PCH_UART_FCR_RFTL_SHIFT
];
419 dmamode
| fifo_size
| trigger
| PCH_UART_FCR_RFR
| PCH_UART_FCR_TFR
;
420 iowrite8(PCH_UART_FCR_FIFOE
, priv
->membase
+ UART_FCR
);
421 iowrite8(PCH_UART_FCR_FIFOE
| PCH_UART_FCR_RFR
| PCH_UART_FCR_TFR
,
422 priv
->membase
+ UART_FCR
);
423 iowrite8(fcr
, priv
->membase
+ UART_FCR
);
429 static u8
pch_uart_hal_get_modem(struct eg20t_port
*priv
)
432 return get_msr(priv
, priv
->membase
);
435 static void pch_uart_hal_write(struct eg20t_port
*priv
,
436 const unsigned char *buf
, int tx_size
)
441 for (i
= 0; i
< tx_size
;) {
443 iowrite8(thr
, priv
->membase
+ PCH_UART_THR
);
447 static int pch_uart_hal_read(struct eg20t_port
*priv
, unsigned char *buf
,
453 lsr
= ioread8(priv
->membase
+ UART_LSR
);
454 for (i
= 0, lsr
= ioread8(priv
->membase
+ UART_LSR
);
455 i
< rx_size
&& lsr
& UART_LSR_DR
;
456 lsr
= ioread8(priv
->membase
+ UART_LSR
)) {
457 rbr
= ioread8(priv
->membase
+ PCH_UART_RBR
);
463 static unsigned int pch_uart_hal_get_iid(struct eg20t_port
*priv
)
468 iir
= ioread8(priv
->membase
+ UART_IIR
);
469 ret
= (iir
& (PCH_UART_IIR_IID
| PCH_UART_IIR_TOI
| PCH_UART_IIR_IP
));
473 static u8
pch_uart_hal_get_line_status(struct eg20t_port
*priv
)
475 return ioread8(priv
->membase
+ UART_LSR
);
478 static void pch_uart_hal_set_break(struct eg20t_port
*priv
, int on
)
482 lcr
= ioread8(priv
->membase
+ UART_LCR
);
484 lcr
|= PCH_UART_LCR_SB
;
486 lcr
&= ~PCH_UART_LCR_SB
;
488 iowrite8(lcr
, priv
->membase
+ UART_LCR
);
491 static int push_rx(struct eg20t_port
*priv
, const unsigned char *buf
,
494 struct uart_port
*port
;
495 struct tty_struct
*tty
;
498 tty
= tty_port_tty_get(&port
->state
->port
);
500 dev_dbg(priv
->port
.dev
, "%s:tty is busy now", __func__
);
504 tty_insert_flip_string(tty
, buf
, size
);
505 tty_flip_buffer_push(tty
);
511 static int pop_tx_x(struct eg20t_port
*priv
, unsigned char *buf
)
514 struct uart_port
*port
= &priv
->port
;
517 dev_dbg(priv
->port
.dev
, "%s:X character send %02x (%lu)\n",
518 __func__
, port
->x_char
, jiffies
);
519 buf
[0] = port
->x_char
;
529 static int dma_push_rx(struct eg20t_port
*priv
, int size
)
531 struct tty_struct
*tty
;
533 struct uart_port
*port
= &priv
->port
;
536 tty
= tty_port_tty_get(&port
->state
->port
);
538 dev_dbg(priv
->port
.dev
, "%s:tty is busy now", __func__
);
542 room
= tty_buffer_request_room(tty
, size
);
545 dev_warn(port
->dev
, "Rx overrun: dropping %u bytes\n",
550 tty_insert_flip_string(tty
, sg_virt(&priv
->sg_rx
), size
);
552 port
->icount
.rx
+= room
;
558 static void pch_free_dma(struct uart_port
*port
)
560 struct eg20t_port
*priv
;
561 priv
= container_of(port
, struct eg20t_port
, port
);
564 dma_release_channel(priv
->chan_tx
);
565 priv
->chan_tx
= NULL
;
568 dma_release_channel(priv
->chan_rx
);
569 priv
->chan_rx
= NULL
;
571 if (sg_dma_address(&priv
->sg_rx
))
572 dma_free_coherent(port
->dev
, port
->fifosize
,
573 sg_virt(&priv
->sg_rx
),
574 sg_dma_address(&priv
->sg_rx
));
579 static bool filter(struct dma_chan
*chan
, void *slave
)
581 struct pch_dma_slave
*param
= slave
;
583 if ((chan
->chan_id
== param
->chan_id
) && (param
->dma_dev
==
584 chan
->device
->dev
)) {
585 chan
->private = param
;
592 static void pch_request_dma(struct uart_port
*port
)
595 struct dma_chan
*chan
;
596 struct pci_dev
*dma_dev
;
597 struct pch_dma_slave
*param
;
598 struct eg20t_port
*priv
=
599 container_of(port
, struct eg20t_port
, port
);
601 dma_cap_set(DMA_SLAVE
, mask
);
603 dma_dev
= pci_get_bus_and_slot(2, PCI_DEVFN(0xa, 0)); /* Get DMA's dev
606 param
= &priv
->param_tx
;
607 param
->dma_dev
= &dma_dev
->dev
;
608 param
->chan_id
= priv
->port
.line
* 2; /* Tx = 0, 2, 4, ... */
610 param
->tx_reg
= port
->mapbase
+ UART_TX
;
611 chan
= dma_request_channel(mask
, filter
, param
);
613 dev_err(priv
->port
.dev
, "%s:dma_request_channel FAILS(Tx)\n",
617 priv
->chan_tx
= chan
;
620 param
= &priv
->param_rx
;
621 param
->dma_dev
= &dma_dev
->dev
;
622 param
->chan_id
= priv
->port
.line
* 2 + 1; /* Rx = Tx + 1 */
624 param
->rx_reg
= port
->mapbase
+ UART_RX
;
625 chan
= dma_request_channel(mask
, filter
, param
);
627 dev_err(priv
->port
.dev
, "%s:dma_request_channel FAILS(Rx)\n",
629 dma_release_channel(priv
->chan_tx
);
633 /* Get Consistent memory for DMA */
634 priv
->rx_buf_virt
= dma_alloc_coherent(port
->dev
, port
->fifosize
,
635 &priv
->rx_buf_dma
, GFP_KERNEL
);
636 priv
->chan_rx
= chan
;
639 static void pch_dma_rx_complete(void *arg
)
641 struct eg20t_port
*priv
= arg
;
642 struct uart_port
*port
= &priv
->port
;
643 struct tty_struct
*tty
= tty_port_tty_get(&port
->state
->port
);
647 dev_dbg(priv
->port
.dev
, "%s:tty is busy now", __func__
);
651 dma_sync_sg_for_cpu(port
->dev
, &priv
->sg_rx
, 1, DMA_FROM_DEVICE
);
652 count
= dma_push_rx(priv
, priv
->trigger_level
);
654 tty_flip_buffer_push(tty
);
656 async_tx_ack(priv
->desc_rx
);
657 pch_uart_hal_enable_interrupt(priv
, PCH_UART_HAL_RX_INT
);
660 static void pch_dma_tx_complete(void *arg
)
662 struct eg20t_port
*priv
= arg
;
663 struct uart_port
*port
= &priv
->port
;
664 struct circ_buf
*xmit
= &port
->state
->xmit
;
665 struct scatterlist
*sg
= priv
->sg_tx_p
;
668 for (i
= 0; i
< priv
->nent
; i
++, sg
++) {
669 xmit
->tail
+= sg_dma_len(sg
);
670 port
->icount
.tx
+= sg_dma_len(sg
);
672 xmit
->tail
&= UART_XMIT_SIZE
- 1;
673 async_tx_ack(priv
->desc_tx
);
674 dma_unmap_sg(port
->dev
, sg
, priv
->nent
, DMA_TO_DEVICE
);
675 priv
->tx_dma_use
= 0;
677 kfree(priv
->sg_tx_p
);
678 pch_uart_hal_enable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
681 static int pop_tx(struct eg20t_port
*priv
, int size
)
684 struct uart_port
*port
= &priv
->port
;
685 struct circ_buf
*xmit
= &port
->state
->xmit
;
687 if (uart_tx_stopped(port
) || uart_circ_empty(xmit
) || count
>= size
)
692 CIRC_CNT_TO_END(xmit
->head
, xmit
->tail
, UART_XMIT_SIZE
);
693 int sz
= min(size
- count
, cnt_to_end
);
694 pch_uart_hal_write(priv
, &xmit
->buf
[xmit
->tail
], sz
);
695 xmit
->tail
= (xmit
->tail
+ sz
) & (UART_XMIT_SIZE
- 1);
697 } while (!uart_circ_empty(xmit
) && count
< size
);
700 dev_dbg(priv
->port
.dev
, "%d characters. Remained %d characters.(%lu)\n",
701 count
, size
- count
, jiffies
);
706 static int handle_rx_to(struct eg20t_port
*priv
)
708 struct pch_uart_buffer
*buf
;
711 if (!priv
->start_rx
) {
712 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_RX_INT
);
717 rx_size
= pch_uart_hal_read(priv
, buf
->buf
, buf
->size
);
718 ret
= push_rx(priv
, buf
->buf
, rx_size
);
721 } while (rx_size
== buf
->size
);
723 return PCH_UART_HANDLED_RX_INT
;
726 static int handle_rx(struct eg20t_port
*priv
)
728 return handle_rx_to(priv
);
731 static int dma_handle_rx(struct eg20t_port
*priv
)
733 struct uart_port
*port
= &priv
->port
;
734 struct dma_async_tx_descriptor
*desc
;
735 struct scatterlist
*sg
;
737 priv
= container_of(port
, struct eg20t_port
, port
);
740 sg_init_table(&priv
->sg_rx
, 1); /* Initialize SG table */
742 sg_dma_len(sg
) = priv
->trigger_level
;
744 sg_set_page(&priv
->sg_rx
, virt_to_page(priv
->rx_buf_virt
),
745 sg_dma_len(sg
), (unsigned long)priv
->rx_buf_virt
&
748 sg_dma_address(sg
) = priv
->rx_buf_dma
;
750 desc
= priv
->chan_rx
->device
->device_prep_slave_sg(priv
->chan_rx
,
751 sg
, 1, DMA_FROM_DEVICE
,
752 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
757 priv
->desc_rx
= desc
;
758 desc
->callback
= pch_dma_rx_complete
;
759 desc
->callback_param
= priv
;
760 desc
->tx_submit(desc
);
761 dma_async_issue_pending(priv
->chan_rx
);
763 return PCH_UART_HANDLED_RX_INT
;
766 static unsigned int handle_tx(struct eg20t_port
*priv
)
768 struct uart_port
*port
= &priv
->port
;
769 struct circ_buf
*xmit
= &port
->state
->xmit
;
775 if (!priv
->start_tx
) {
776 dev_info(priv
->port
.dev
, "%s:Tx isn't started. (%lu)\n",
778 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
783 fifo_size
= max(priv
->fifo_size
, 1);
785 if (pop_tx_x(priv
, xmit
->buf
)) {
786 pch_uart_hal_write(priv
, xmit
->buf
, 1);
791 size
= min(xmit
->head
- xmit
->tail
, fifo_size
);
795 tx_size
= pop_tx(priv
, size
);
797 port
->icount
.tx
+= tx_size
;
801 priv
->tx_empty
= tx_empty
;
804 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
805 uart_write_wakeup(port
);
808 return PCH_UART_HANDLED_TX_INT
;
811 static unsigned int dma_handle_tx(struct eg20t_port
*priv
)
813 struct uart_port
*port
= &priv
->port
;
814 struct circ_buf
*xmit
= &port
->state
->xmit
;
815 struct scatterlist
*sg
;
819 struct dma_async_tx_descriptor
*desc
;
826 if (!priv
->start_tx
) {
827 dev_info(priv
->port
.dev
, "%s:Tx isn't started. (%lu)\n",
829 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
834 if (priv
->tx_dma_use
) {
835 dev_dbg(priv
->port
.dev
, "%s:Tx is not completed. (%lu)\n",
837 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
842 fifo_size
= max(priv
->fifo_size
, 1);
844 if (pop_tx_x(priv
, xmit
->buf
)) {
845 pch_uart_hal_write(priv
, xmit
->buf
, 1);
851 bytes
= min((int)CIRC_CNT(xmit
->head
, xmit
->tail
,
852 UART_XMIT_SIZE
), CIRC_CNT_TO_END(xmit
->head
,
853 xmit
->tail
, UART_XMIT_SIZE
));
855 dev_dbg(priv
->port
.dev
, "%s 0 bytes return\n", __func__
);
856 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
857 uart_write_wakeup(port
);
861 if (bytes
> fifo_size
) {
862 num
= bytes
/ fifo_size
+ 1;
864 rem
= bytes
% fifo_size
;
871 dev_dbg(priv
->port
.dev
, "%s num=%d size=%d rem=%d\n",
872 __func__
, num
, size
, rem
);
874 priv
->tx_dma_use
= 1;
876 priv
->sg_tx_p
= kzalloc(sizeof(struct scatterlist
)*num
, GFP_ATOMIC
);
878 sg_init_table(priv
->sg_tx_p
, num
); /* Initialize SG table */
881 for (i
= 0; i
< num
; i
++, sg
++) {
883 sg_set_page(sg
, virt_to_page(xmit
->buf
),
886 sg_set_page(sg
, virt_to_page(xmit
->buf
),
887 size
, fifo_size
* i
);
891 nent
= dma_map_sg(port
->dev
, sg
, num
, DMA_TO_DEVICE
);
893 dev_err(priv
->port
.dev
, "%s:dma_map_sg Failed\n", __func__
);
898 for (i
= 0; i
< nent
; i
++, sg
++) {
899 sg
->offset
= (xmit
->tail
& (UART_XMIT_SIZE
- 1)) +
901 sg_dma_address(sg
) = (sg_dma_address(sg
) &
902 ~(UART_XMIT_SIZE
- 1)) + sg
->offset
;
904 sg_dma_len(sg
) = rem
;
906 sg_dma_len(sg
) = size
;
909 desc
= priv
->chan_tx
->device
->device_prep_slave_sg(priv
->chan_tx
,
910 priv
->sg_tx_p
, nent
, DMA_TO_DEVICE
,
911 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
913 dev_err(priv
->port
.dev
, "%s:device_prep_slave_sg Failed\n",
917 dma_sync_sg_for_device(port
->dev
, priv
->sg_tx_p
, nent
, DMA_TO_DEVICE
);
918 priv
->desc_tx
= desc
;
919 desc
->callback
= pch_dma_tx_complete
;
920 desc
->callback_param
= priv
;
922 desc
->tx_submit(desc
);
924 dma_async_issue_pending(priv
->chan_tx
);
926 return PCH_UART_HANDLED_TX_INT
;
929 static void pch_uart_err_ir(struct eg20t_port
*priv
, unsigned int lsr
)
931 u8 fcr
= ioread8(priv
->membase
+ UART_FCR
);
934 fcr
|= UART_FCR_CLEAR_RCVR
;
935 iowrite8(fcr
, priv
->membase
+ UART_FCR
);
937 if (lsr
& PCH_UART_LSR_ERR
)
938 dev_err(&priv
->pdev
->dev
, "Error data in FIFO\n");
940 if (lsr
& UART_LSR_FE
)
941 dev_err(&priv
->pdev
->dev
, "Framing Error\n");
943 if (lsr
& UART_LSR_PE
)
944 dev_err(&priv
->pdev
->dev
, "Parity Error\n");
946 if (lsr
& UART_LSR_OE
)
947 dev_err(&priv
->pdev
->dev
, "Overrun Error\n");
950 static irqreturn_t
pch_uart_interrupt(int irq
, void *dev_id
)
952 struct eg20t_port
*priv
= dev_id
;
953 unsigned int handled
;
959 spin_lock_irqsave(&priv
->port
.lock
, flags
);
961 while ((iid
= pch_uart_hal_get_iid(priv
)) > 1) {
963 case PCH_UART_IID_RLS
: /* Receiver Line Status */
964 lsr
= pch_uart_hal_get_line_status(priv
);
965 if (lsr
& (PCH_UART_LSR_ERR
| UART_LSR_FE
|
966 UART_LSR_PE
| UART_LSR_OE
)) {
967 pch_uart_err_ir(priv
, lsr
);
968 ret
= PCH_UART_HANDLED_RX_ERR_INT
;
971 case PCH_UART_IID_RDR
: /* Received Data Ready */
973 pch_uart_hal_disable_interrupt(priv
,
974 PCH_UART_HAL_RX_INT
);
975 ret
= dma_handle_rx(priv
);
977 pch_uart_hal_enable_interrupt(priv
,
978 PCH_UART_HAL_RX_INT
);
980 ret
= handle_rx(priv
);
983 case PCH_UART_IID_RDR_TO
: /* Received Data Ready
985 ret
= handle_rx_to(priv
);
987 case PCH_UART_IID_THRE
: /* Transmitter Holding Register
990 ret
= dma_handle_tx(priv
);
992 ret
= handle_tx(priv
);
994 case PCH_UART_IID_MS
: /* Modem Status */
995 ret
= PCH_UART_HANDLED_MS_INT
;
997 default: /* Never junp to this label */
998 dev_err(priv
->port
.dev
, "%s:iid=%d (%lu)\n", __func__
,
1003 handled
|= (unsigned int)ret
;
1005 if (handled
== 0 && iid
<= 1) {
1006 if (priv
->int_dis_flag
)
1007 priv
->int_dis_flag
= 0;
1010 spin_unlock_irqrestore(&priv
->port
.lock
, flags
);
1011 return IRQ_RETVAL(handled
);
1014 /* This function tests whether the transmitter fifo and shifter for the port
1015 described by 'port' is empty. */
1016 static unsigned int pch_uart_tx_empty(struct uart_port
*port
)
1018 struct eg20t_port
*priv
;
1020 priv
= container_of(port
, struct eg20t_port
, port
);
1029 /* Returns the current state of modem control inputs. */
1030 static unsigned int pch_uart_get_mctrl(struct uart_port
*port
)
1032 struct eg20t_port
*priv
;
1034 unsigned int ret
= 0;
1036 priv
= container_of(port
, struct eg20t_port
, port
);
1037 modem
= pch_uart_hal_get_modem(priv
);
1039 if (modem
& UART_MSR_DCD
)
1042 if (modem
& UART_MSR_RI
)
1045 if (modem
& UART_MSR_DSR
)
1048 if (modem
& UART_MSR_CTS
)
1054 static void pch_uart_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
1057 struct eg20t_port
*priv
= container_of(port
, struct eg20t_port
, port
);
1059 if (mctrl
& TIOCM_DTR
)
1060 mcr
|= UART_MCR_DTR
;
1061 if (mctrl
& TIOCM_RTS
)
1062 mcr
|= UART_MCR_RTS
;
1063 if (mctrl
& TIOCM_LOOP
)
1064 mcr
|= UART_MCR_LOOP
;
1066 if (priv
->mcr
& UART_MCR_AFE
)
1067 mcr
|= UART_MCR_AFE
;
1070 iowrite8(mcr
, priv
->membase
+ UART_MCR
);
1073 static void pch_uart_stop_tx(struct uart_port
*port
)
1075 struct eg20t_port
*priv
;
1076 priv
= container_of(port
, struct eg20t_port
, port
);
1078 priv
->tx_dma_use
= 0;
1081 static void pch_uart_start_tx(struct uart_port
*port
)
1083 struct eg20t_port
*priv
;
1085 priv
= container_of(port
, struct eg20t_port
, port
);
1087 if (priv
->use_dma
) {
1088 if (priv
->tx_dma_use
) {
1089 dev_dbg(priv
->port
.dev
, "%s : Tx DMA is NOT empty.\n",
1096 pch_uart_hal_enable_interrupt(priv
, PCH_UART_HAL_TX_INT
);
1099 static void pch_uart_stop_rx(struct uart_port
*port
)
1101 struct eg20t_port
*priv
;
1102 priv
= container_of(port
, struct eg20t_port
, port
);
1104 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_RX_INT
);
1105 priv
->int_dis_flag
= 1;
1108 /* Enable the modem status interrupts. */
1109 static void pch_uart_enable_ms(struct uart_port
*port
)
1111 struct eg20t_port
*priv
;
1112 priv
= container_of(port
, struct eg20t_port
, port
);
1113 pch_uart_hal_enable_interrupt(priv
, PCH_UART_HAL_MS_INT
);
1116 /* Control the transmission of a break signal. */
1117 static void pch_uart_break_ctl(struct uart_port
*port
, int ctl
)
1119 struct eg20t_port
*priv
;
1120 unsigned long flags
;
1122 priv
= container_of(port
, struct eg20t_port
, port
);
1123 spin_lock_irqsave(&port
->lock
, flags
);
1124 pch_uart_hal_set_break(priv
, ctl
);
1125 spin_unlock_irqrestore(&port
->lock
, flags
);
1128 /* Grab any interrupt resources and initialise any low level driver state. */
1129 static int pch_uart_startup(struct uart_port
*port
)
1131 struct eg20t_port
*priv
;
1136 priv
= container_of(port
, struct eg20t_port
, port
);
1140 priv
->base_baud
= port
->uartclk
;
1142 port
->uartclk
= priv
->base_baud
;
1144 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_ALL_INT
);
1145 ret
= pch_uart_hal_set_line(priv
, default_baud
,
1146 PCH_UART_HAL_PARITY_NONE
, PCH_UART_HAL_8BIT
,
1151 switch (priv
->fifo_size
) {
1153 fifo_size
= PCH_UART_HAL_FIFO256
;
1156 fifo_size
= PCH_UART_HAL_FIFO64
;
1159 fifo_size
= PCH_UART_HAL_FIFO16
;
1162 fifo_size
= PCH_UART_HAL_FIFO_DIS
;
1166 switch (priv
->trigger
) {
1167 case PCH_UART_HAL_TRIGGER1
:
1170 case PCH_UART_HAL_TRIGGER_L
:
1171 trigger_level
= priv
->fifo_size
/ 4;
1173 case PCH_UART_HAL_TRIGGER_M
:
1174 trigger_level
= priv
->fifo_size
/ 2;
1176 case PCH_UART_HAL_TRIGGER_H
:
1178 trigger_level
= priv
->fifo_size
- (priv
->fifo_size
/ 8);
1182 priv
->trigger_level
= trigger_level
;
1183 ret
= pch_uart_hal_set_fifo(priv
, PCH_UART_HAL_DMA_MODE0
,
1184 fifo_size
, priv
->trigger
);
1188 ret
= request_irq(priv
->port
.irq
, pch_uart_interrupt
, IRQF_SHARED
,
1189 KBUILD_MODNAME
, priv
);
1194 pch_request_dma(port
);
1197 pch_uart_hal_enable_interrupt(priv
, PCH_UART_HAL_RX_INT
);
1198 uart_update_timeout(port
, CS8
, default_baud
);
1203 static void pch_uart_shutdown(struct uart_port
*port
)
1205 struct eg20t_port
*priv
;
1208 priv
= container_of(port
, struct eg20t_port
, port
);
1209 pch_uart_hal_disable_interrupt(priv
, PCH_UART_HAL_ALL_INT
);
1210 pch_uart_hal_fifo_reset(priv
, PCH_UART_HAL_CLR_ALL_FIFO
);
1211 ret
= pch_uart_hal_set_fifo(priv
, PCH_UART_HAL_DMA_MODE0
,
1212 PCH_UART_HAL_FIFO_DIS
, PCH_UART_HAL_TRIGGER1
);
1214 dev_err(priv
->port
.dev
,
1215 "pch_uart_hal_set_fifo Failed(ret=%d)\n", ret
);
1217 if (priv
->use_dma_flag
)
1220 free_irq(priv
->port
.irq
, priv
);
1223 /* Change the port parameters, including word length, parity, stop
1224 *bits. Update read_status_mask and ignore_status_mask to indicate
1225 *the types of events we are interested in receiving. */
1226 static void pch_uart_set_termios(struct uart_port
*port
,
1227 struct ktermios
*termios
, struct ktermios
*old
)
1231 unsigned int parity
, bits
, stb
;
1232 struct eg20t_port
*priv
;
1233 unsigned long flags
;
1235 priv
= container_of(port
, struct eg20t_port
, port
);
1236 switch (termios
->c_cflag
& CSIZE
) {
1238 bits
= PCH_UART_HAL_5BIT
;
1241 bits
= PCH_UART_HAL_6BIT
;
1244 bits
= PCH_UART_HAL_7BIT
;
1247 bits
= PCH_UART_HAL_8BIT
;
1250 if (termios
->c_cflag
& CSTOPB
)
1251 stb
= PCH_UART_HAL_STB2
;
1253 stb
= PCH_UART_HAL_STB1
;
1255 if (termios
->c_cflag
& PARENB
) {
1256 if (!(termios
->c_cflag
& PARODD
))
1257 parity
= PCH_UART_HAL_PARITY_ODD
;
1259 parity
= PCH_UART_HAL_PARITY_EVEN
;
1262 parity
= PCH_UART_HAL_PARITY_NONE
;
1265 /* Only UART0 has auto hardware flow function */
1266 if ((termios
->c_cflag
& CRTSCTS
) && (priv
->fifo_size
== 256))
1267 priv
->mcr
|= UART_MCR_AFE
;
1269 priv
->mcr
&= ~UART_MCR_AFE
;
1271 termios
->c_cflag
&= ~CMSPAR
; /* Mark/Space parity is not supported */
1273 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/ 16);
1275 spin_lock_irqsave(&port
->lock
, flags
);
1277 uart_update_timeout(port
, termios
->c_cflag
, baud
);
1278 rtn
= pch_uart_hal_set_line(priv
, baud
, parity
, bits
, stb
);
1282 /* Don't rewrite B0 */
1283 if (tty_termios_baud_rate(termios
))
1284 tty_termios_encode_baud_rate(termios
, baud
, baud
);
1287 spin_unlock_irqrestore(&port
->lock
, flags
);
1290 static const char *pch_uart_type(struct uart_port
*port
)
1292 return KBUILD_MODNAME
;
1295 static void pch_uart_release_port(struct uart_port
*port
)
1297 struct eg20t_port
*priv
;
1299 priv
= container_of(port
, struct eg20t_port
, port
);
1300 pci_iounmap(priv
->pdev
, priv
->membase
);
1301 pci_release_regions(priv
->pdev
);
1304 static int pch_uart_request_port(struct uart_port
*port
)
1306 struct eg20t_port
*priv
;
1308 void __iomem
*membase
;
1310 priv
= container_of(port
, struct eg20t_port
, port
);
1311 ret
= pci_request_regions(priv
->pdev
, KBUILD_MODNAME
);
1315 membase
= pci_iomap(priv
->pdev
, 1, 0);
1317 pci_release_regions(priv
->pdev
);
1320 priv
->membase
= port
->membase
= membase
;
1325 static void pch_uart_config_port(struct uart_port
*port
, int type
)
1327 struct eg20t_port
*priv
;
1329 priv
= container_of(port
, struct eg20t_port
, port
);
1330 if (type
& UART_CONFIG_TYPE
) {
1331 port
->type
= priv
->port_type
;
1332 pch_uart_request_port(port
);
1336 static int pch_uart_verify_port(struct uart_port
*port
,
1337 struct serial_struct
*serinfo
)
1339 struct eg20t_port
*priv
;
1341 priv
= container_of(port
, struct eg20t_port
, port
);
1342 if (serinfo
->flags
& UPF_LOW_LATENCY
) {
1343 dev_info(priv
->port
.dev
,
1344 "PCH UART : Use PIO Mode (without DMA)\n");
1346 serinfo
->flags
&= ~UPF_LOW_LATENCY
;
1348 #ifndef CONFIG_PCH_DMA
1349 dev_err(priv
->port
.dev
, "%s : PCH DMA is not Loaded.\n",
1354 priv
->use_dma_flag
= 1;
1355 dev_info(priv
->port
.dev
, "PCH UART : Use DMA Mode\n");
1361 static struct uart_ops pch_uart_ops
= {
1362 .tx_empty
= pch_uart_tx_empty
,
1363 .set_mctrl
= pch_uart_set_mctrl
,
1364 .get_mctrl
= pch_uart_get_mctrl
,
1365 .stop_tx
= pch_uart_stop_tx
,
1366 .start_tx
= pch_uart_start_tx
,
1367 .stop_rx
= pch_uart_stop_rx
,
1368 .enable_ms
= pch_uart_enable_ms
,
1369 .break_ctl
= pch_uart_break_ctl
,
1370 .startup
= pch_uart_startup
,
1371 .shutdown
= pch_uart_shutdown
,
1372 .set_termios
= pch_uart_set_termios
,
1373 /* .pm = pch_uart_pm, Not supported yet */
1374 /* .set_wake = pch_uart_set_wake, Not supported yet */
1375 .type
= pch_uart_type
,
1376 .release_port
= pch_uart_release_port
,
1377 .request_port
= pch_uart_request_port
,
1378 .config_port
= pch_uart_config_port
,
1379 .verify_port
= pch_uart_verify_port
1382 static struct uart_driver pch_uart_driver
= {
1383 .owner
= THIS_MODULE
,
1384 .driver_name
= KBUILD_MODNAME
,
1385 .dev_name
= PCH_UART_DRIVER_DEVICE
,
1391 static struct eg20t_port
*pch_uart_init_port(struct pci_dev
*pdev
,
1392 const struct pci_device_id
*id
)
1394 struct eg20t_port
*priv
;
1396 unsigned int iobase
;
1397 unsigned int mapbase
;
1398 unsigned char *rxbuf
;
1399 int fifosize
, base_baud
;
1401 struct pch_uart_driver_data
*board
;
1402 const char *board_name
;
1404 board
= &drv_dat
[id
->driver_data
];
1405 port_type
= board
->port_type
;
1407 priv
= kzalloc(sizeof(struct eg20t_port
), GFP_KERNEL
);
1409 goto init_port_alloc_err
;
1411 rxbuf
= (unsigned char *)__get_free_page(GFP_KERNEL
);
1413 goto init_port_free_txbuf
;
1415 base_baud
= 1843200; /* 1.8432MHz */
1417 /* quirk for CM-iTC board */
1418 board_name
= dmi_get_system_info(DMI_BOARD_NAME
);
1419 if (board_name
&& strstr(board_name
, "CM-iTC"))
1420 base_baud
= 192000000; /* 192.0MHz */
1422 switch (port_type
) {
1424 fifosize
= 256; /* EG20T/ML7213: UART0 */
1427 fifosize
= 64; /* EG20T:UART1~3 ML7213: UART1~2*/
1430 dev_err(&pdev
->dev
, "Invalid Port Type(=%d)\n", port_type
);
1431 goto init_port_hal_free
;
1434 pci_enable_msi(pdev
);
1436 iobase
= pci_resource_start(pdev
, 0);
1437 mapbase
= pci_resource_start(pdev
, 1);
1438 priv
->mapbase
= mapbase
;
1439 priv
->iobase
= iobase
;
1442 priv
->rxbuf
.buf
= rxbuf
;
1443 priv
->rxbuf
.size
= PAGE_SIZE
;
1445 priv
->fifo_size
= fifosize
;
1446 priv
->base_baud
= base_baud
;
1447 priv
->port_type
= PORT_MAX_8250
+ port_type
+ 1;
1448 priv
->port
.dev
= &pdev
->dev
;
1449 priv
->port
.iobase
= iobase
;
1450 priv
->port
.membase
= NULL
;
1451 priv
->port
.mapbase
= mapbase
;
1452 priv
->port
.irq
= pdev
->irq
;
1453 priv
->port
.iotype
= UPIO_PORT
;
1454 priv
->port
.ops
= &pch_uart_ops
;
1455 priv
->port
.flags
= UPF_BOOT_AUTOCONF
;
1456 priv
->port
.fifosize
= fifosize
;
1457 priv
->port
.line
= board
->line_no
;
1458 priv
->trigger
= PCH_UART_HAL_TRIGGER_M
;
1460 spin_lock_init(&priv
->port
.lock
);
1462 pci_set_drvdata(pdev
, priv
);
1463 pch_uart_hal_request(pdev
, fifosize
, base_baud
);
1465 ret
= uart_add_one_port(&pch_uart_driver
, &priv
->port
);
1467 goto init_port_hal_free
;
1472 free_page((unsigned long)rxbuf
);
1473 init_port_free_txbuf
:
1475 init_port_alloc_err
:
1480 static void pch_uart_exit_port(struct eg20t_port
*priv
)
1482 uart_remove_one_port(&pch_uart_driver
, &priv
->port
);
1483 pci_set_drvdata(priv
->pdev
, NULL
);
1484 free_page((unsigned long)priv
->rxbuf
.buf
);
1487 static void pch_uart_pci_remove(struct pci_dev
*pdev
)
1489 struct eg20t_port
*priv
;
1491 priv
= (struct eg20t_port
*)pci_get_drvdata(pdev
);
1493 pci_disable_msi(pdev
);
1494 pch_uart_exit_port(priv
);
1495 pci_disable_device(pdev
);
1500 static int pch_uart_pci_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1502 struct eg20t_port
*priv
= pci_get_drvdata(pdev
);
1504 uart_suspend_port(&pch_uart_driver
, &priv
->port
);
1506 pci_save_state(pdev
);
1507 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
1511 static int pch_uart_pci_resume(struct pci_dev
*pdev
)
1513 struct eg20t_port
*priv
= pci_get_drvdata(pdev
);
1516 pci_set_power_state(pdev
, PCI_D0
);
1517 pci_restore_state(pdev
);
1519 ret
= pci_enable_device(pdev
);
1522 "%s-pci_enable_device failed(ret=%d) ", __func__
, ret
);
1526 uart_resume_port(&pch_uart_driver
, &priv
->port
);
1531 #define pch_uart_pci_suspend NULL
1532 #define pch_uart_pci_resume NULL
1535 static DEFINE_PCI_DEVICE_TABLE(pch_uart_pci_id
) = {
1536 {PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x8811),
1537 .driver_data
= pch_et20t_uart0
},
1538 {PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x8812),
1539 .driver_data
= pch_et20t_uart1
},
1540 {PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x8813),
1541 .driver_data
= pch_et20t_uart2
},
1542 {PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x8814),
1543 .driver_data
= pch_et20t_uart3
},
1544 {PCI_DEVICE(PCI_VENDOR_ID_ROHM
, 0x8027),
1545 .driver_data
= pch_ml7213_uart0
},
1546 {PCI_DEVICE(PCI_VENDOR_ID_ROHM
, 0x8028),
1547 .driver_data
= pch_ml7213_uart1
},
1548 {PCI_DEVICE(PCI_VENDOR_ID_ROHM
, 0x8029),
1549 .driver_data
= pch_ml7213_uart2
},
1550 {PCI_DEVICE(PCI_VENDOR_ID_ROHM
, 0x800C),
1551 .driver_data
= pch_ml7223_uart0
},
1552 {PCI_DEVICE(PCI_VENDOR_ID_ROHM
, 0x800D),
1553 .driver_data
= pch_ml7223_uart1
},
1557 static int __devinit
pch_uart_pci_probe(struct pci_dev
*pdev
,
1558 const struct pci_device_id
*id
)
1561 struct eg20t_port
*priv
;
1563 ret
= pci_enable_device(pdev
);
1567 priv
= pch_uart_init_port(pdev
, id
);
1570 goto probe_disable_device
;
1572 pci_set_drvdata(pdev
, priv
);
1576 probe_disable_device
:
1577 pci_disable_msi(pdev
);
1578 pci_disable_device(pdev
);
1583 static struct pci_driver pch_uart_pci_driver
= {
1585 .id_table
= pch_uart_pci_id
,
1586 .probe
= pch_uart_pci_probe
,
1587 .remove
= __devexit_p(pch_uart_pci_remove
),
1588 .suspend
= pch_uart_pci_suspend
,
1589 .resume
= pch_uart_pci_resume
,
1592 static int __init
pch_uart_module_init(void)
1596 /* register as UART driver */
1597 ret
= uart_register_driver(&pch_uart_driver
);
1601 /* register as PCI driver */
1602 ret
= pci_register_driver(&pch_uart_pci_driver
);
1604 uart_unregister_driver(&pch_uart_driver
);
1608 module_init(pch_uart_module_init
);
1610 static void __exit
pch_uart_module_exit(void)
1612 pci_unregister_driver(&pch_uart_pci_driver
);
1613 uart_unregister_driver(&pch_uart_driver
);
1615 module_exit(pch_uart_module_exit
);
1617 MODULE_LICENSE("GPL v2");
1618 MODULE_DESCRIPTION("Intel EG20T PCH UART PCI Driver");
1619 module_param(default_baud
, uint
, S_IRUGO
);