?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sh_eth: Register MDIO bus before registering the network device
[linux-2.6/btrfs-unstable.git] / drivers / staging / sb105x / sb_pci_mp.c
blobc9d6ee3903adc07decc03700c4af3f2d5d54896f
1 #include "sb_pci_mp.h"
2 #include <linux/module.h>
3 #include <linux/parport.h>
4
5 extern struct parport *parport_pc_probe_port(unsigned long base_lo,
6 unsigned long base_hi,
7 int irq, int dma,
8 struct device *dev,
9 int irqflags);
10
11 static struct mp_device_t mp_devs[MAX_MP_DEV];
12 static int mp_nrpcibrds = sizeof(mp_pciboards)/sizeof(mppcibrd_t);
13 static int NR_BOARD=0;
14 static int NR_PORTS=0;
15 static struct mp_port multi_ports[MAX_MP_PORT];
16 static struct irq_info irq_lists[NR_IRQS];
17
18 static _INLINE_ unsigned int serial_in(struct mp_port *mtpt, int offset);
19 static _INLINE_ void serial_out(struct mp_port *mtpt, int offset, int value);
20 static _INLINE_ unsigned int read_option_register(struct mp_port *mtpt, int offset);
21 static int sb1054_get_register(struct sb_uart_port *port, int page, int reg);
22 static int sb1054_set_register(struct sb_uart_port *port, int page, int reg, int value);
23 static void SendATCommand(struct mp_port *mtpt);
24 static int set_deep_fifo(struct sb_uart_port *port, int status);
25 static int get_deep_fifo(struct sb_uart_port *port);
26 static int get_device_type(int arg);
27 static int set_auto_rts(struct sb_uart_port *port, int status);
28 static void mp_stop(struct tty_struct *tty);
29 static void __mp_start(struct tty_struct *tty);
30 static void mp_start(struct tty_struct *tty);
31 static void mp_tasklet_action(unsigned long data);
32 static inline void mp_update_mctrl(struct sb_uart_port *port, unsigned int set, unsigned int clear);
33 static int mp_startup(struct sb_uart_state *state, int init_hw);
34 static void mp_shutdown(struct sb_uart_state *state);
35 static void mp_change_speed(struct sb_uart_state *state, struct MP_TERMIOS *old_termios);
36
37 static inline int __mp_put_char(struct sb_uart_port *port, struct circ_buf *circ, unsigned char c);
38 static int mp_put_char(struct tty_struct *tty, unsigned char ch);
39
40 static void mp_put_chars(struct tty_struct *tty);
41 static int mp_write(struct tty_struct *tty, const unsigned char *buf, int count);
42 static int mp_write_room(struct tty_struct *tty);
43 static int mp_chars_in_buffer(struct tty_struct *tty);
44 static void mp_flush_buffer(struct tty_struct *tty);
45 static void mp_send_xchar(struct tty_struct *tty, char ch);
46 static void mp_throttle(struct tty_struct *tty);
47 static void mp_unthrottle(struct tty_struct *tty);
48 static int mp_get_info(struct sb_uart_state *state, struct serial_struct *retinfo);
49 static int mp_set_info(struct sb_uart_state *state, struct serial_struct *newinfo);
50 static int mp_get_lsr_info(struct sb_uart_state *state, unsigned int *value);
51
52 static int mp_tiocmget(struct tty_struct *tty);
53 static int mp_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear);
54 static int mp_break_ctl(struct tty_struct *tty, int break_state);
55 static int mp_do_autoconfig(struct sb_uart_state *state);
56 static int mp_wait_modem_status(struct sb_uart_state *state, unsigned long arg);
57 static int mp_get_count(struct sb_uart_state *state, struct serial_icounter_struct *icnt);
58 static int mp_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg);
59 static void mp_set_termios(struct tty_struct *tty, struct MP_TERMIOS *old_termios);
60 static void mp_close(struct tty_struct *tty, struct file *filp);
61 static void mp_wait_until_sent(struct tty_struct *tty, int timeout);
62 static void mp_hangup(struct tty_struct *tty);
63 static void mp_update_termios(struct sb_uart_state *state);
64 static int mp_block_til_ready(struct file *filp, struct sb_uart_state *state);
65 static struct sb_uart_state *uart_get(struct uart_driver *drv, int line);
66 static int mp_open(struct tty_struct *tty, struct file *filp);
67 static const char *mp_type(struct sb_uart_port *port);
68 static void mp_change_pm(struct sb_uart_state *state, int pm_state);
69 static inline void mp_report_port(struct uart_driver *drv, struct sb_uart_port *port);
70 static void mp_configure_port(struct uart_driver *drv, struct sb_uart_state *state, struct sb_uart_port *port);
71 static void mp_unconfigure_port(struct uart_driver *drv, struct sb_uart_state *state);
72 static int mp_register_driver(struct uart_driver *drv);
73 static void mp_unregister_driver(struct uart_driver *drv);
74 static int mp_add_one_port(struct uart_driver *drv, struct sb_uart_port *port);
75 static int mp_remove_one_port(struct uart_driver *drv, struct sb_uart_port *port);
76 static void autoconfig(struct mp_port *mtpt, unsigned int probeflags);
77 static void autoconfig_irq(struct mp_port *mtpt);
78 static void multi_stop_tx(struct sb_uart_port *port);
79 static void multi_start_tx(struct sb_uart_port *port);
80 static void multi_stop_rx(struct sb_uart_port *port);
81 static void multi_enable_ms(struct sb_uart_port *port);
82 static _INLINE_ void receive_chars(struct mp_port *mtpt, int *status );
83 static _INLINE_ void transmit_chars(struct mp_port *mtpt);
84 static _INLINE_ void check_modem_status(struct mp_port *mtpt);
85 static inline void multi_handle_port(struct mp_port *mtpt);
86 static irqreturn_t multi_interrupt(int irq, void *dev_id);
87 static void serial_do_unlink(struct irq_info *i, struct mp_port *mtpt);
88 static int serial_link_irq_chain(struct mp_port *mtpt);
89 static void serial_unlink_irq_chain(struct mp_port *mtpt);
90 static void multi_timeout(unsigned long data);
91 static unsigned int multi_tx_empty(struct sb_uart_port *port);
92 static unsigned int multi_get_mctrl(struct sb_uart_port *port);
93 static void multi_set_mctrl(struct sb_uart_port *port, unsigned int mctrl);
94 static void multi_break_ctl(struct sb_uart_port *port, int break_state);
95 static int multi_startup(struct sb_uart_port *port);
96 static void multi_shutdown(struct sb_uart_port *port);
97 static unsigned int multi_get_divisor(struct sb_uart_port *port, unsigned int baud);
98 static void multi_set_termios(struct sb_uart_port *port, struct MP_TERMIOS *termios, struct MP_TERMIOS *old);
99 static void multi_pm(struct sb_uart_port *port, unsigned int state, unsigned int oldstate);
100 static void multi_release_std_resource(struct mp_port *mtpt);
101 static void multi_release_port(struct sb_uart_port *port);
102 static int multi_request_port(struct sb_uart_port *port);
103 static void multi_config_port(struct sb_uart_port *port, int flags);
104 static int multi_verify_port(struct sb_uart_port *port, struct serial_struct *ser);
105 static const char *multi_type(struct sb_uart_port *port);
106 static void __init multi_init_ports(void);
107 static void __init multi_register_ports(struct uart_driver *drv);
108 static int init_mp_dev(struct pci_dev *pcidev, mppcibrd_t brd);
109
110 static int deep[256];
111 static int deep_count;
112 static int fcr_arr[256];
113 static int fcr_count;
114 static int ttr[256];
115 static int ttr_count;
116 static int rtr[256];
117 static int rtr_count;
118
119 module_param_array(deep,int,&deep_count,0);
120 module_param_array(fcr_arr,int,&fcr_count,0);
121 module_param_array(ttr,int,&ttr_count,0);
122 module_param_array(rtr,int,&rtr_count,0);
123
124 static _INLINE_ unsigned int serial_in(struct mp_port *mtpt, int offset)
125 {
126 return inb(mtpt->port.iobase + offset);
127 }
128
129 static _INLINE_ void serial_out(struct mp_port *mtpt, int offset, int value)
130 {
131 outb(value, mtpt->port.iobase + offset);
132 }
133
134 static _INLINE_ unsigned int read_option_register(struct mp_port *mtpt, int offset)
135 {
136 return inb(mtpt->option_base_addr + offset);
137 }
138
139 static int sb1053a_get_interface(struct mp_port *mtpt, int port_num)
140 {
141 unsigned long option_base_addr = mtpt->option_base_addr;
142 unsigned int interface = 0;
143
144 switch (port_num)
145 {
146 case 0:
147 case 1:
148 /* set GPO[1:0] = 00 */
149 outb(0x00, option_base_addr + MP_OPTR_GPODR);
150 break;
151 case 2:
152 case 3:
153 /* set GPO[1:0] = 01 */
154 outb(0x01, option_base_addr + MP_OPTR_GPODR);
155 break;
156 case 4:
157 case 5:
158 /* set GPO[1:0] = 10 */
159 outb(0x02, option_base_addr + MP_OPTR_GPODR);
160 break;
161 default:
162 break;
163 }
164
165 port_num &= 0x1;
166
167 /* get interface */
168 interface = inb(option_base_addr + MP_OPTR_IIR0 + port_num);
169
170 /* set GPO[1:0] = 11 */
171 outb(0x03, option_base_addr + MP_OPTR_GPODR);
172
173 return (interface);
174 }
175
176 static int sb1054_get_register(struct sb_uart_port *port, int page, int reg)
177 {
178 int ret = 0;
179 unsigned int lcr = 0;
180 unsigned int mcr = 0;
181 unsigned int tmp = 0;
182
183 if( page <= 0)
184 {
185 printk(" page 0 can not use this function\n");
186 return -1;
187 }
188
189 switch(page)
190 {
191 case 1:
192 lcr = SB105X_GET_LCR(port);
193 tmp = lcr | SB105X_LCR_DLAB;
194 SB105X_PUT_LCR(port, tmp);
195
196 tmp = SB105X_GET_LCR(port);
197
198 ret = SB105X_GET_REG(port,reg);
199 SB105X_PUT_LCR(port,lcr);
200 break;
201 case 2:
202 mcr = SB105X_GET_MCR(port);
203 tmp = mcr | SB105X_MCR_P2S;
204 SB105X_PUT_MCR(port,tmp);
205
206 ret = SB105X_GET_REG(port,reg);
207
208 SB105X_PUT_MCR(port,mcr);
209 break;
210 case 3:
211 lcr = SB105X_GET_LCR(port);
212 tmp = lcr | SB105X_LCR_BF;
213 SB105X_PUT_LCR(port,tmp);
214 SB105X_PUT_REG(port,SB105X_PSR,SB105X_PSR_P3KEY);
215
216 ret = SB105X_GET_REG(port,reg);
217
218 SB105X_PUT_LCR(port,lcr);
219 break;
220 case 4:
221 lcr = SB105X_GET_LCR(port);
222 tmp = lcr | SB105X_LCR_BF;
223 SB105X_PUT_LCR(port,tmp);
224 SB105X_PUT_REG(port,SB105X_PSR,SB105X_PSR_P4KEY);
225
226 ret = SB105X_GET_REG(port,reg);
227
228 SB105X_PUT_LCR(port,lcr);
229 break;
230 default:
231 printk(" error invalid page number \n");
232 return -1;
233 }
234
235 return ret;
236 }
237
238 static int sb1054_set_register(struct sb_uart_port *port, int page, int reg, int value)
239 {
240 int lcr = 0;
241 int mcr = 0;
242 int ret = 0;
243
244 if( page <= 0)
245 {
246 printk(" page 0 can not use this function\n");
247 return -1;
248 }
249 switch(page)
250 {
251 case 1:
252 lcr = SB105X_GET_LCR(port);
253 SB105X_PUT_LCR(port, lcr | SB105X_LCR_DLAB);
254
255 SB105X_PUT_REG(port,reg,value);
256
257 SB105X_PUT_LCR(port, lcr);
258 ret = 1;
259 break;
260 case 2:
261 mcr = SB105X_GET_MCR(port);
262 SB105X_PUT_MCR(port, mcr | SB105X_MCR_P2S);
263
264 SB105X_PUT_REG(port,reg,value);
265
266 SB105X_PUT_MCR(port, mcr);
267 ret = 1;
268 break;
269 case 3:
270 lcr = SB105X_GET_LCR(port);
271 SB105X_PUT_LCR(port, lcr | SB105X_LCR_BF);
272 SB105X_PUT_PSR(port, SB105X_PSR_P3KEY);
273
274 SB105X_PUT_REG(port,reg,value);
275
276 SB105X_PUT_LCR(port, lcr);
277 ret = 1;
278 break;
279 case 4:
280 lcr = SB105X_GET_LCR(port);
281 SB105X_PUT_LCR(port, lcr | SB105X_LCR_BF);
282 SB105X_PUT_PSR(port, SB105X_PSR_P4KEY);
283
284 SB105X_PUT_REG(port,reg,value);
285
286 SB105X_PUT_LCR(port, lcr);
287 ret = 1;
288 break;
289 default:
290 printk(" error invalid page number \n");
291 return -1;
292 }
293
294 return ret;
295 }
296
297 static int set_multidrop_mode(struct sb_uart_port *port, unsigned int mode)
298 {
299 int mdr = SB105XA_MDR_NPS;
300
301 if (mode & MDMODE_ENABLE)
302 {
303 mdr |= SB105XA_MDR_MDE;
304 }
305
306 if (1) //(mode & MDMODE_AUTO)
307 {
308 int efr = 0;
309 mdr |= SB105XA_MDR_AME;
310 efr = sb1054_get_register(port, PAGE_3, SB105X_EFR);
311 efr |= SB105X_EFR_SCD;
312 sb1054_set_register(port, PAGE_3, SB105X_EFR, efr);
313 }
314
315 sb1054_set_register(port, PAGE_1, SB105XA_MDR, mdr);
316 port->mdmode &= ~0x6;
317 port->mdmode |= mode;
318 printk("[%d] multidrop init: %x\n", port->line, port->mdmode);
319
320 return 0;
321 }
322
323 static int get_multidrop_addr(struct sb_uart_port *port)
324 {
325 return sb1054_get_register(port, PAGE_3, SB105X_XOFF2);
326 }
327
328 static int set_multidrop_addr(struct sb_uart_port *port, unsigned int addr)
329 {
330 sb1054_set_register(port, PAGE_3, SB105X_XOFF2, addr);
331
332 return 0;
333 }
334
335 static void SendATCommand(struct mp_port *mtpt)
336 {
337 // a t cr lf
338 unsigned char ch[] = {0x61,0x74,0x0d,0x0a,0x0};
339 unsigned char lineControl;
340 unsigned char i=0;
341 unsigned char Divisor = 0xc;
342
343 lineControl = serial_inp(mtpt,UART_LCR);
344 serial_outp(mtpt,UART_LCR,(lineControl | UART_LCR_DLAB));
345 serial_outp(mtpt,UART_DLL,(Divisor & 0xff));
346 serial_outp(mtpt,UART_DLM,(Divisor & 0xff00)>>8); //baudrate is 4800
347
348
349 serial_outp(mtpt,UART_LCR,lineControl);
350 serial_outp(mtpt,UART_LCR,0x03); // N-8-1
351 serial_outp(mtpt,UART_FCR,7);
352 serial_outp(mtpt,UART_MCR,0x3);
353 while(ch[i]){
354 while((serial_inp(mtpt,UART_LSR) & 0x60) !=0x60){
355 ;
356 }
357 serial_outp(mtpt,0,ch[i++]);
358 }
359
360
361 }// end of SendATCommand()
362
363 static int set_deep_fifo(struct sb_uart_port *port, int status)
364 {
365 int afr_status = 0;
366 afr_status = sb1054_get_register(port, PAGE_4, SB105X_AFR);
367
368 if(status == ENABLE)
369 {
370 afr_status |= SB105X_AFR_AFEN;
371 }
372 else
373 {
374 afr_status &= ~SB105X_AFR_AFEN;
375 }
376
377 sb1054_set_register(port,PAGE_4,SB105X_AFR,afr_status);
378 sb1054_set_register(port,PAGE_4,SB105X_TTR,ttr[port->line]);
379 sb1054_set_register(port,PAGE_4,SB105X_RTR,rtr[port->line]);
380 afr_status = sb1054_get_register(port, PAGE_4, SB105X_AFR);
381
382 return afr_status;
383 }
384
385 static int get_device_type(int arg)
386 {
387 int ret;
388 ret = inb(mp_devs[arg].option_reg_addr+MP_OPTR_DIR0);
389 ret = (ret & 0xf0) >> 4;
390 switch (ret)
391 {
392 case DIR_UART_16C550:
393 return PORT_16C55X;
394 case DIR_UART_16C1050:
395 return PORT_16C105X;
396 case DIR_UART_16C1050A:
397 /*
398 if (mtpt->port.line < 2)
399 {
400 return PORT_16C105XA;
401 }
402 else
403 {
404 if (mtpt->device->device_id & 0x50)
405 {
406 return PORT_16C55X;
407 }
408 else
409 {
410 return PORT_16C105X;
411 }
412 }*/
413 return PORT_16C105XA;
414 default:
415 return PORT_UNKNOWN;
416 }
417
418 }
419 static int get_deep_fifo(struct sb_uart_port *port)
420 {
421 int afr_status = 0;
422 afr_status = sb1054_get_register(port, PAGE_4, SB105X_AFR);
423 return afr_status;
424 }
425
426 static int set_auto_rts(struct sb_uart_port *port, int status)
427 {
428 int atr_status = 0;
429
430 #if 0
431 int efr_status = 0;
432
433 efr_status = sb1054_get_register(port, PAGE_3, SB105X_EFR);
434 if(status == ENABLE)
435 efr_status |= SB105X_EFR_ARTS;
436 else
437 efr_status &= ~SB105X_EFR_ARTS;
438 sb1054_set_register(port,PAGE_3,SB105X_EFR,efr_status);
439 efr_status = sb1054_get_register(port, PAGE_3, SB105X_EFR);
440 #endif
441
442 //ATR
443 atr_status = sb1054_get_register(port, PAGE_3, SB105X_ATR);
444 switch(status)
445 {
446 case RS422PTP:
447 atr_status = (SB105X_ATR_TPS) | (SB105X_ATR_A80);
448 break;
449 case RS422MD:
450 atr_status = (SB105X_ATR_TPS) | (SB105X_ATR_TCMS) | (SB105X_ATR_A80);
451 break;
452 case RS485NE:
453 atr_status = (SB105X_ATR_RCMS) | (SB105X_ATR_TPS) | (SB105X_ATR_TCMS) | (SB105X_ATR_A80);
454 break;
455 case RS485ECHO:
456 atr_status = (SB105X_ATR_TPS) | (SB105X_ATR_TCMS) | (SB105X_ATR_A80);
457 break;
458 }
459
460 sb1054_set_register(port,PAGE_3,SB105X_ATR,atr_status);
461 atr_status = sb1054_get_register(port, PAGE_3, SB105X_ATR);
462
463 return atr_status;
464 }
465
466 static void mp_stop(struct tty_struct *tty)
467 {
468 struct sb_uart_state *state = tty->driver_data;
469 struct sb_uart_port *port = state->port;
470 unsigned long flags;
471
472 spin_lock_irqsave(&port->lock, flags);
473 port->ops->stop_tx(port);
474 spin_unlock_irqrestore(&port->lock, flags);
475 }
476
477 static void __mp_start(struct tty_struct *tty)
478 {
479 struct sb_uart_state *state = tty->driver_data;
480 struct sb_uart_port *port = state->port;
481
482 if (!uart_circ_empty(&state->info->xmit) && state->info->xmit.buf &&
483 !tty->stopped && !tty->hw_stopped)
484 port->ops->start_tx(port);
485 }
486
487 static void mp_start(struct tty_struct *tty)
488 {
489 __mp_start(tty);
490 }
491
492 static void mp_tasklet_action(unsigned long data)
493 {
494 struct sb_uart_state *state = (struct sb_uart_state *)data;
495 struct tty_struct *tty;
496
497 printk("tasklet is called!\n");
498 tty = state->info->tty;
499 tty_wakeup(tty);
500 }
501
502 static inline void mp_update_mctrl(struct sb_uart_port *port, unsigned int set, unsigned int clear)
503 {
504 unsigned int old;
505
506 old = port->mctrl;
507 port->mctrl = (old & ~clear) | set;
508 if (old != port->mctrl)
509 port->ops->set_mctrl(port, port->mctrl);
510 }
511
512 #define uart_set_mctrl(port,set) mp_update_mctrl(port,set,0)
513 #define uart_clear_mctrl(port,clear) mp_update_mctrl(port,0,clear)
514
515 static int mp_startup(struct sb_uart_state *state, int init_hw)
516 {
517 struct sb_uart_info *info = state->info;
518 struct sb_uart_port *port = state->port;
519 unsigned long page;
520 int retval = 0;
521
522 if (info->flags & UIF_INITIALIZED)
523 return 0;
524
525 if (info->tty)
526 set_bit(TTY_IO_ERROR, &info->tty->flags);
527
528 if (port->type == PORT_UNKNOWN)
529 return 0;
530
531 if (!info->xmit.buf) {
532 page = get_zeroed_page(GFP_KERNEL);
533 if (!page)
534 return -ENOMEM;
535
536 info->xmit.buf = (unsigned char *) page;
537
538 uart_circ_clear(&info->xmit);
539 }
540
541 retval = port->ops->startup(port);
542 if (retval == 0) {
543 if (init_hw) {
544 mp_change_speed(state, NULL);
545
546 if (info->tty && (info->tty->termios.c_cflag & CBAUD))
547 uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
548 }
549
550 info->flags |= UIF_INITIALIZED;
551
552 if (info->tty)
553 clear_bit(TTY_IO_ERROR, &info->tty->flags);
554 }
555
556 if (retval && capable(CAP_SYS_ADMIN))
557 retval = 0;
558
559 return retval;
560 }
561
562 static void mp_shutdown(struct sb_uart_state *state)
563 {
564 struct sb_uart_info *info = state->info;
565 struct sb_uart_port *port = state->port;
566
567 if (info->tty)
568 set_bit(TTY_IO_ERROR, &info->tty->flags);
569
570 if (info->flags & UIF_INITIALIZED) {
571 info->flags &= ~UIF_INITIALIZED;
572
573 if (!info->tty || (info->tty->termios.c_cflag & HUPCL))
574 uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
575
576 wake_up_interruptible(&info->delta_msr_wait);
577
578 port->ops->shutdown(port);
579
580 synchronize_irq(port->irq);
581 }
582 tasklet_kill(&info->tlet);
583
584 if (info->xmit.buf) {
585 free_page((unsigned long)info->xmit.buf);
586 info->xmit.buf = NULL;
587 }
588 }
589
590 static void mp_change_speed(struct sb_uart_state *state, struct MP_TERMIOS *old_termios)
591 {
592 struct tty_struct *tty = state->info->tty;
593 struct sb_uart_port *port = state->port;
594
595 if (!tty || port->type == PORT_UNKNOWN)
596 return;
597
598 if (tty->termios.c_cflag & CRTSCTS)
599 state->info->flags |= UIF_CTS_FLOW;
600 else
601 state->info->flags &= ~UIF_CTS_FLOW;
602
603 if (tty->termios.c_cflag & CLOCAL)
604 state->info->flags &= ~UIF_CHECK_CD;
605 else
606 state->info->flags |= UIF_CHECK_CD;
607
608 port->ops->set_termios(port, &tty->termios, old_termios);
609 }
610
611 static inline int __mp_put_char(struct sb_uart_port *port, struct circ_buf *circ, unsigned char c)
612 {
613 unsigned long flags;
614 int ret = 0;
615
616 if (!circ->buf)
617 return 0;
618
619 spin_lock_irqsave(&port->lock, flags);
620 if (uart_circ_chars_free(circ) != 0) {
621 circ->buf[circ->head] = c;
622 circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
623 ret = 1;
624 }
625 spin_unlock_irqrestore(&port->lock, flags);
626 return ret;
627 }
628
629 static int mp_put_char(struct tty_struct *tty, unsigned char ch)
630 {
631 struct sb_uart_state *state = tty->driver_data;
632
633 return __mp_put_char(state->port, &state->info->xmit, ch);
634 }
635
636 static void mp_put_chars(struct tty_struct *tty)
637 {
638 mp_start(tty);
639 }
640
641 static int mp_write(struct tty_struct *tty, const unsigned char *buf, int count)
642 {
643 struct sb_uart_state *state = tty->driver_data;
644 struct sb_uart_port *port;
645 struct circ_buf *circ;
646 int c, ret = 0;
647
648 if (!state || !state->info) {
649 return -EL3HLT;
650 }
651
652 port = state->port;
653 circ = &state->info->xmit;
654
655 if (!circ->buf)
656 return 0;
657
658 while (1) {
659 c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
660 if (count < c)
661 c = count;
662 if (c <= 0)
663 break;
664 memcpy(circ->buf + circ->head, buf, c);
665
666 circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
667 buf += c;
668 count -= c;
669 ret += c;
670 }
671 mp_start(tty);
672 return ret;
673 }
674
675 static int mp_write_room(struct tty_struct *tty)
676 {
677 struct sb_uart_state *state = tty->driver_data;
678
679 return uart_circ_chars_free(&state->info->xmit);
680 }
681
682 static int mp_chars_in_buffer(struct tty_struct *tty)
683 {
684 struct sb_uart_state *state = tty->driver_data;
685
686 return uart_circ_chars_pending(&state->info->xmit);
687 }
688
689 static void mp_flush_buffer(struct tty_struct *tty)
690 {
691 struct sb_uart_state *state = tty->driver_data;
692 struct sb_uart_port *port;
693 unsigned long flags;
694
695 if (!state || !state->info) {
696 return;
697 }
698
699 port = state->port;
700 spin_lock_irqsave(&port->lock, flags);
701 uart_circ_clear(&state->info->xmit);
702 spin_unlock_irqrestore(&port->lock, flags);
703 wake_up_interruptible(&tty->write_wait);
704 tty_wakeup(tty);
705 }
706
707 static void mp_send_xchar(struct tty_struct *tty, char ch)
708 {
709 struct sb_uart_state *state = tty->driver_data;
710 struct sb_uart_port *port = state->port;
711 unsigned long flags;
712
713 if (port->ops->send_xchar)
714 port->ops->send_xchar(port, ch);
715 else {
716 port->x_char = ch;
717 if (ch) {
718 spin_lock_irqsave(&port->lock, flags);
719 port->ops->start_tx(port);
720 spin_unlock_irqrestore(&port->lock, flags);
721 }
722 }
723 }
724
725 static void mp_throttle(struct tty_struct *tty)
726 {
727 struct sb_uart_state *state = tty->driver_data;
728
729 if (I_IXOFF(tty))
730 mp_send_xchar(tty, STOP_CHAR(tty));
731
732 if (tty->termios.c_cflag & CRTSCTS)
733 uart_clear_mctrl(state->port, TIOCM_RTS);
734 }
735
736 static void mp_unthrottle(struct tty_struct *tty)
737 {
738 struct sb_uart_state *state = tty->driver_data;
739 struct sb_uart_port *port = state->port;
740
741 if (I_IXOFF(tty)) {
742 if (port->x_char)
743 port->x_char = 0;
744 else
745 mp_send_xchar(tty, START_CHAR(tty));
746 }
747
748 if (tty->termios.c_cflag & CRTSCTS)
749 uart_set_mctrl(port, TIOCM_RTS);
750 }
751
752 static int mp_get_info(struct sb_uart_state *state, struct serial_struct *retinfo)
753 {
754 struct sb_uart_port *port = state->port;
755 struct serial_struct tmp;
756
757 memset(&tmp, 0, sizeof(tmp));
758 tmp.type = port->type;
759 tmp.line = port->line;
760 tmp.port = port->iobase;
761 if (HIGH_BITS_OFFSET)
762 tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET;
763 tmp.irq = port->irq;
764 tmp.flags = port->flags;
765 tmp.xmit_fifo_size = port->fifosize;
766 tmp.baud_base = port->uartclk / 16;
767 tmp.close_delay = state->close_delay;
768 tmp.closing_wait = state->closing_wait == USF_CLOSING_WAIT_NONE ?
769 ASYNC_CLOSING_WAIT_NONE :
770 state->closing_wait;
771 tmp.custom_divisor = port->custom_divisor;
772 tmp.hub6 = port->hub6;
773 tmp.io_type = port->iotype;
774 tmp.iomem_reg_shift = port->regshift;
775 tmp.iomem_base = (void *)port->mapbase;
776
777 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
778 return -EFAULT;
779 return 0;
780 }
781
782 static int mp_set_info(struct sb_uart_state *state, struct serial_struct *newinfo)
783 {
784 struct serial_struct new_serial;
785 struct sb_uart_port *port = state->port;
786 unsigned long new_port;
787 unsigned int change_irq, change_port, closing_wait;
788 unsigned int old_custom_divisor;
789 unsigned int old_flags, new_flags;
790 int retval = 0;
791
792 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
793 return -EFAULT;
794
795 new_port = new_serial.port;
796 if (HIGH_BITS_OFFSET)
797 new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET;
798
799 new_serial.irq = irq_canonicalize(new_serial.irq);
800
801 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
802 USF_CLOSING_WAIT_NONE : new_serial.closing_wait;
803 MP_STATE_LOCK(state);
804
805 change_irq = new_serial.irq != port->irq;
806 change_port = new_port != port->iobase ||
807 (unsigned long)new_serial.iomem_base != port->mapbase ||
808 new_serial.hub6 != port->hub6 ||
809 new_serial.io_type != port->iotype ||
810 new_serial.iomem_reg_shift != port->regshift ||
811 new_serial.type != port->type;
812 old_flags = port->flags;
813 new_flags = new_serial.flags;
814 old_custom_divisor = port->custom_divisor;
815
816 if (!capable(CAP_SYS_ADMIN)) {
817 retval = -EPERM;
818 if (change_irq || change_port ||
819 (new_serial.baud_base != port->uartclk / 16) ||
820 (new_serial.close_delay != state->close_delay) ||
821 (closing_wait != state->closing_wait) ||
822 (new_serial.xmit_fifo_size != port->fifosize) ||
823 (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
824 goto exit;
825 port->flags = ((port->flags & ~UPF_USR_MASK) |
826 (new_flags & UPF_USR_MASK));
827 port->custom_divisor = new_serial.custom_divisor;
828 goto check_and_exit;
829 }
830
831 if (port->ops->verify_port)
832 retval = port->ops->verify_port(port, &new_serial);
833
834 if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) ||
835 (new_serial.baud_base < 9600))
836 retval = -EINVAL;
837
838 if (retval)
839 goto exit;
840
841 if (change_port || change_irq) {
842 retval = -EBUSY;
843
844 if (uart_users(state) > 1)
845 goto exit;
846
847 mp_shutdown(state);
848 }
849
850 if (change_port) {
851 unsigned long old_iobase, old_mapbase;
852 unsigned int old_type, old_iotype, old_hub6, old_shift;
853
854 old_iobase = port->iobase;
855 old_mapbase = port->mapbase;
856 old_type = port->type;
857 old_hub6 = port->hub6;
858 old_iotype = port->iotype;
859 old_shift = port->regshift;
860
861 if (old_type != PORT_UNKNOWN)
862 port->ops->release_port(port);
863
864 port->iobase = new_port;
865 port->type = new_serial.type;
866 port->hub6 = new_serial.hub6;
867 port->iotype = new_serial.io_type;
868 port->regshift = new_serial.iomem_reg_shift;
869 port->mapbase = (unsigned long)new_serial.iomem_base;
870
871 if (port->type != PORT_UNKNOWN) {
872 retval = port->ops->request_port(port);
873 } else {
874 retval = 0;
875 }
876
877 if (retval && old_type != PORT_UNKNOWN) {
878 port->iobase = old_iobase;
879 port->type = old_type;
880 port->hub6 = old_hub6;
881 port->iotype = old_iotype;
882 port->regshift = old_shift;
883 port->mapbase = old_mapbase;
884 retval = port->ops->request_port(port);
885 if (retval)
886 port->type = PORT_UNKNOWN;
887
888 retval = -EBUSY;
889 }
890 }
891
892 port->irq = new_serial.irq;
893 port->uartclk = new_serial.baud_base * 16;
894 port->flags = (port->flags & ~UPF_CHANGE_MASK) |
895 (new_flags & UPF_CHANGE_MASK);
896 port->custom_divisor = new_serial.custom_divisor;
897 state->close_delay = new_serial.close_delay;
898 state->closing_wait = closing_wait;
899 port->fifosize = new_serial.xmit_fifo_size;
900 if (state->info->tty)
901 state->info->tty->low_latency =
902 (port->flags & UPF_LOW_LATENCY) ? 1 : 0;
903
904 check_and_exit:
905 retval = 0;
906 if (port->type == PORT_UNKNOWN)
907 goto exit;
908 if (state->info->flags & UIF_INITIALIZED) {
909 if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
910 old_custom_divisor != port->custom_divisor) {
911 if (port->flags & UPF_SPD_MASK) {
912 printk(KERN_NOTICE
913 "%s sets custom speed on ttyMP%d. This "
914 "is deprecated.\n", current->comm,
915 port->line);
916 }
917 mp_change_speed(state, NULL);
918 }
919 } else
920 retval = mp_startup(state, 1);
921 exit:
922 MP_STATE_UNLOCK(state);
923 return retval;
924 }
925
926
927 static int mp_get_lsr_info(struct sb_uart_state *state, unsigned int *value)
928 {
929 struct sb_uart_port *port = state->port;
930 unsigned int result;
931
932 result = port->ops->tx_empty(port);
933
934 if (port->x_char ||
935 ((uart_circ_chars_pending(&state->info->xmit) > 0) &&
936 !state->info->tty->stopped && !state->info->tty->hw_stopped))
937 result &= ~TIOCSER_TEMT;
938
939 return put_user(result, value);
940 }
941
942 static int mp_tiocmget(struct tty_struct *tty)
943 {
944 struct sb_uart_state *state = tty->driver_data;
945 struct sb_uart_port *port = state->port;
946 int result = -EIO;
947
948 MP_STATE_LOCK(state);
949 if (!(tty->flags & (1 << TTY_IO_ERROR))) {
950 result = port->mctrl;
951 spin_lock_irq(&port->lock);
952 result |= port->ops->get_mctrl(port);
953 spin_unlock_irq(&port->lock);
954 }
955 MP_STATE_UNLOCK(state);
956 return result;
957 }
958
959 static int mp_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
960 {
961 struct sb_uart_state *state = tty->driver_data;
962 struct sb_uart_port *port = state->port;
963 int ret = -EIO;
964
965
966 MP_STATE_LOCK(state);
967 if (!(tty->flags & (1 << TTY_IO_ERROR))) {
968 mp_update_mctrl(port, set, clear);
969 ret = 0;
970 }
971 MP_STATE_UNLOCK(state);
972
973 return ret;
974 }
975
976 static int mp_break_ctl(struct tty_struct *tty, int break_state)
977 {
978 struct sb_uart_state *state = tty->driver_data;
979 struct sb_uart_port *port = state->port;
980
981 MP_STATE_LOCK(state);
982
983 if (port->type != PORT_UNKNOWN)
984 port->ops->break_ctl(port, break_state);
985
986 MP_STATE_UNLOCK(state);
987 return 0;
988 }
989
990 static int mp_do_autoconfig(struct sb_uart_state *state)
991 {
992 struct sb_uart_port *port = state->port;
993 int flags, ret;
994
995 if (!capable(CAP_SYS_ADMIN))
996 return -EPERM;
997
998 if (mutex_lock_interruptible(&state->mutex))
999 return -ERESTARTSYS;
1000 ret = -EBUSY;
1001 if (uart_users(state) == 1) {
1002 mp_shutdown(state);
1003
1004 if (port->type != PORT_UNKNOWN)
1005 port->ops->release_port(port);
1006
1007 flags = UART_CONFIG_TYPE;
1008 if (port->flags & UPF_AUTO_IRQ)
1009 flags |= UART_CONFIG_IRQ;
1010
1011 port->ops->config_port(port, flags);
1012
1013 ret = mp_startup(state, 1);
1014 }
1015 MP_STATE_UNLOCK(state);
1016 return ret;
1017 }
1018
1019 static int mp_wait_modem_status(struct sb_uart_state *state, unsigned long arg)
1020 {
1021 struct sb_uart_port *port = state->port;
1022 DECLARE_WAITQUEUE(wait, current);
1023 struct sb_uart_icount cprev, cnow;
1024 int ret;
1025
1026 spin_lock_irq(&port->lock);
1027 memcpy(&cprev, &port->icount, sizeof(struct sb_uart_icount));
1028
1029 port->ops->enable_ms(port);
1030 spin_unlock_irq(&port->lock);
1031
1032 add_wait_queue(&state->info->delta_msr_wait, &wait);
1033 for (;;) {
1034 spin_lock_irq(&port->lock);
1035 memcpy(&cnow, &port->icount, sizeof(struct sb_uart_icount));
1036 spin_unlock_irq(&port->lock);
1037
1038 set_current_state(TASK_INTERRUPTIBLE);
1039
1040 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1041 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1042 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
1043 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1044 ret = 0;
1045 break;
1046 }
1047
1048 schedule();
1049
1050 if (signal_pending(current)) {
1051 ret = -ERESTARTSYS;
1052 break;
1053 }
1054
1055 cprev = cnow;
1056 }
1057
1058 current->state = TASK_RUNNING;
1059 remove_wait_queue(&state->info->delta_msr_wait, &wait);
1060
1061 return ret;
1062 }
1063
1064 static int mp_get_count(struct sb_uart_state *state, struct serial_icounter_struct *icnt)
1065 {
1066 struct serial_icounter_struct icount = {};
1067 struct sb_uart_icount cnow;
1068 struct sb_uart_port *port = state->port;
1069
1070 spin_lock_irq(&port->lock);
1071 memcpy(&cnow, &port->icount, sizeof(struct sb_uart_icount));
1072 spin_unlock_irq(&port->lock);
1073
1074 icount.cts = cnow.cts;
1075 icount.dsr = cnow.dsr;
1076 icount.rng = cnow.rng;
1077 icount.dcd = cnow.dcd;
1078 icount.rx = cnow.rx;
1079 icount.tx = cnow.tx;
1080 icount.frame = cnow.frame;
1081 icount.overrun = cnow.overrun;
1082 icount.parity = cnow.parity;
1083 icount.brk = cnow.brk;
1084 icount.buf_overrun = cnow.buf_overrun;
1085
1086 return copy_to_user(icnt, &icount, sizeof(icount)) ? -EFAULT : 0;
1087 }
1088
1089 static int mp_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
1090 {
1091 struct sb_uart_state *state = tty->driver_data;
1092 struct mp_port *info = (struct mp_port *)state->port;
1093 int ret = -ENOIOCTLCMD;
1094
1095
1096 switch (cmd) {
1097 case TIOCSMULTIDROP:
1098 /* set multi-drop mode enable or disable, and default operation mode is H/W mode */
1099 if (info->port.type == PORT_16C105XA)
1100 {
1101 //arg &= ~0x6;
1102 //state->port->mdmode = 0;
1103 return set_multidrop_mode((struct sb_uart_port *)info, (unsigned int)arg);
1104 }
1105 ret = -ENOTSUPP;
1106 break;
1107 case GETDEEPFIFO:
1108 ret = get_deep_fifo(state->port);
1109 return ret;
1110 case SETDEEPFIFO:
1111 ret = set_deep_fifo(state->port,arg);
1112 deep[state->port->line] = arg;
1113 return ret;
1114 case SETTTR:
1115 if (info->port.type == PORT_16C105X || info->port.type == PORT_16C105XA){
1116 ret = sb1054_set_register(state->port,PAGE_4,SB105X_TTR,arg);
1117 ttr[state->port->line] = arg;
1118 }
1119 return ret;
1120 case SETRTR:
1121 if (info->port.type == PORT_16C105X || info->port.type == PORT_16C105XA){
1122 ret = sb1054_set_register(state->port,PAGE_4,SB105X_RTR,arg);
1123 rtr[state->port->line] = arg;
1124 }
1125 return ret;
1126 case GETTTR:
1127 if (info->port.type == PORT_16C105X || info->port.type == PORT_16C105XA){
1128 ret = sb1054_get_register(state->port,PAGE_4,SB105X_TTR);
1129 }
1130 return ret;
1131 case GETRTR:
1132 if (info->port.type == PORT_16C105X || info->port.type == PORT_16C105XA){
1133 ret = sb1054_get_register(state->port,PAGE_4,SB105X_RTR);
1134 }
1135 return ret;
1136
1137 case SETFCR:
1138 if (info->port.type == PORT_16C105X || info->port.type == PORT_16C105XA){
1139 ret = sb1054_set_register(state->port,PAGE_1,SB105X_FCR,arg);
1140 }
1141 else{
1142 serial_out(info,2,arg);
1143 }
1144
1145 return ret;
1146 case TIOCSMDADDR:
1147 /* set multi-drop address */
1148 if (info->port.type == PORT_16C105XA)
1149 {
1150 state->port->mdmode |= MDMODE_ADDR;
1151 return set_multidrop_addr((struct sb_uart_port *)info, (unsigned int)arg);
1152 }
1153 ret = -ENOTSUPP;
1154 break;
1155
1156 case TIOCGMDADDR:
1157 /* set multi-drop address */
1158 if ((info->port.type == PORT_16C105XA) && (state->port->mdmode & MDMODE_ADDR))
1159 {
1160 return get_multidrop_addr((struct sb_uart_port *)info);
1161 }
1162 ret = -ENOTSUPP;
1163 break;
1164
1165 case TIOCSENDADDR:
1166 /* send address in multi-drop mode */
1167 if ((info->port.type == PORT_16C105XA)
1168 && (state->port->mdmode & (MDMODE_ENABLE)))
1169 {
1170 if (mp_chars_in_buffer(tty) > 0)
1171 {
1172 tty_wait_until_sent(tty, 0);
1173 }
1174 //while ((serial_in(info, UART_LSR) & 0x60) != 0x60);
1175 //while (sb1054_get_register(state->port, PAGE_2, SB105X_TFCR) != 0);
1176 while ((serial_in(info, UART_LSR) & 0x60) != 0x60);
1177 serial_out(info, UART_SCR, (int)arg);
1178 }
1179 break;
1180
1181 case TIOCGSERIAL:
1182 ret = mp_get_info(state, (struct serial_struct *)arg);
1183 break;
1184
1185 case TIOCSSERIAL:
1186 ret = mp_set_info(state, (struct serial_struct *)arg);
1187 break;
1188
1189 case TIOCSERCONFIG:
1190 ret = mp_do_autoconfig(state);
1191 break;
1192
1193 case TIOCSERGWILD: /* obsolete */
1194 case TIOCSERSWILD: /* obsolete */
1195 ret = 0;
1196 break;
1197 /* for Multiport */
1198 case TIOCGNUMOFPORT: /* Get number of ports */
1199 return NR_PORTS;
1200 case TIOCGGETDEVID:
1201 return mp_devs[arg].device_id;
1202 case TIOCGGETREV:
1203 return mp_devs[arg].revision;
1204 case TIOCGGETNRPORTS:
1205 return mp_devs[arg].nr_ports;
1206 case TIOCGGETBDNO:
1207 return NR_BOARD;
1208 case TIOCGGETINTERFACE:
1209 if (mp_devs[arg].revision == 0xc0)
1210 {
1211 /* for SB16C1053APCI */
1212 return (sb1053a_get_interface(info, info->port.line));
1213 }
1214 else
1215 {
1216 return (inb(mp_devs[arg].option_reg_addr+MP_OPTR_IIR0+(state->port->line/8)));
1217 }
1218 case TIOCGGETPORTTYPE:
1219 ret = get_device_type(arg);
1220 return ret;
1221 case TIOCSMULTIECHO: /* set to multi-drop mode(RS422) or echo mode(RS485)*/
1222 outb( ( inb(info->interface_config_addr) & ~0x03 ) | 0x01 ,
1223 info->interface_config_addr);
1224 return 0;
1225 case TIOCSPTPNOECHO: /* set to multi-drop mode(RS422) or echo mode(RS485) */
1226 outb( ( inb(info->interface_config_addr) & ~0x03 ) ,
1227 info->interface_config_addr);
1228 return 0;
1229 }
1230
1231 if (ret != -ENOIOCTLCMD)
1232 goto out;
1233
1234 if (tty->flags & (1 << TTY_IO_ERROR)) {
1235 ret = -EIO;
1236 goto out;
1237 }
1238
1239 switch (cmd) {
1240 case TIOCMIWAIT:
1241 ret = mp_wait_modem_status(state, arg);
1242 break;
1243
1244 case TIOCGICOUNT:
1245 ret = mp_get_count(state, (struct serial_icounter_struct *)arg);
1246 break;
1247 }
1248
1249 if (ret != -ENOIOCTLCMD)
1250 goto out;
1251
1252 MP_STATE_LOCK(state);
1253 switch (cmd) {
1254 case TIOCSERGETLSR: /* Get line status register */
1255 ret = mp_get_lsr_info(state, (unsigned int *)arg);
1256 break;
1257
1258 default: {
1259 struct sb_uart_port *port = state->port;
1260 if (port->ops->ioctl)
1261 ret = port->ops->ioctl(port, cmd, arg);
1262 break;
1263 }
1264 }
1265
1266 MP_STATE_UNLOCK(state);
1267 out:
1268 return ret;
1269 }
1270
1271 static void mp_set_termios(struct tty_struct *tty, struct MP_TERMIOS *old_termios)
1272 {
1273 struct sb_uart_state *state = tty->driver_data;
1274 unsigned long flags;
1275 unsigned int cflag = tty->termios.c_cflag;
1276
1277 #define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
1278
1279 if ((cflag ^ old_termios->c_cflag) == 0 &&
1280 RELEVANT_IFLAG(tty->termios.c_iflag ^ old_termios->c_iflag) == 0)
1281 return;
1282
1283 mp_change_speed(state, old_termios);
1284
1285 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1286 uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR);
1287
1288 if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1289 unsigned int mask = TIOCM_DTR;
1290 if (!(cflag & CRTSCTS) ||
1291 !test_bit(TTY_THROTTLED, &tty->flags))
1292 mask |= TIOCM_RTS;
1293 uart_set_mctrl(state->port, mask);
1294 }
1295
1296 if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1297 spin_lock_irqsave(&state->port->lock, flags);
1298 tty->hw_stopped = 0;
1299 __mp_start(tty);
1300 spin_unlock_irqrestore(&state->port->lock, flags);
1301 }
1302
1303 if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1304 spin_lock_irqsave(&state->port->lock, flags);
1305 if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {
1306 tty->hw_stopped = 1;
1307 state->port->ops->stop_tx(state->port);
1308 }
1309 spin_unlock_irqrestore(&state->port->lock, flags);
1310 }
1311 }
1312
1313 static void mp_close(struct tty_struct *tty, struct file *filp)
1314 {
1315 struct sb_uart_state *state = tty->driver_data;
1316 struct sb_uart_port *port;
1317
1318 printk("mp_close!\n");
1319 if (!state || !state->port)
1320 return;
1321
1322 port = state->port;
1323
1324 printk("close1 %d\n", __LINE__);
1325 MP_STATE_LOCK(state);
1326
1327 printk("close2 %d\n", __LINE__);
1328 if (tty_hung_up_p(filp))
1329 goto done;
1330
1331 printk("close3 %d\n", __LINE__);
1332 if ((tty->count == 1) && (state->count != 1)) {
1333 printk("mp_close: bad serial port count; tty->count is 1, "
1334 "state->count is %d\n", state->count);
1335 state->count = 1;
1336 }
1337 printk("close4 %d\n", __LINE__);
1338 if (--state->count < 0) {
1339 printk("rs_close: bad serial port count for ttyMP%d: %d\n",
1340 port->line, state->count);
1341 state->count = 0;
1342 }
1343 if (state->count)
1344 goto done;
1345
1346 tty->closing = 1;
1347
1348 printk("close5 %d\n", __LINE__);
1349 if (state->closing_wait != USF_CLOSING_WAIT_NONE)
1350 tty_wait_until_sent(tty, state->closing_wait);
1351
1352 printk("close6 %d\n", __LINE__);
1353 if (state->info->flags & UIF_INITIALIZED) {
1354 unsigned long flags;
1355 spin_lock_irqsave(&port->lock, flags);
1356 port->ops->stop_rx(port);
1357 spin_unlock_irqrestore(&port->lock, flags);
1358 mp_wait_until_sent(tty, port->timeout);
1359 }
1360 printk("close7 %d\n", __LINE__);
1361
1362 mp_shutdown(state);
1363 printk("close8 %d\n", __LINE__);
1364 mp_flush_buffer(tty);
1365 tty_ldisc_flush(tty);
1366 tty->closing = 0;
1367 state->info->tty = NULL;
1368 if (state->info->blocked_open)
1369 {
1370 if (state->close_delay)
1371 {
1372 set_current_state(TASK_INTERRUPTIBLE);
1373 schedule_timeout(state->close_delay);
1374 }
1375 }
1376 else
1377 {
1378 mp_change_pm(state, 3);
1379 }
1380 printk("close8 %d\n", __LINE__);
1381
1382 state->info->flags &= ~UIF_NORMAL_ACTIVE;
1383 wake_up_interruptible(&state->info->open_wait);
1384
1385 done:
1386 printk("close done\n");
1387 MP_STATE_UNLOCK(state);
1388 module_put(THIS_MODULE);
1389 }
1390
1391 static void mp_wait_until_sent(struct tty_struct *tty, int timeout)
1392 {
1393 struct sb_uart_state *state = tty->driver_data;
1394 struct sb_uart_port *port = state->port;
1395 unsigned long char_time, expire;
1396
1397 if (port->type == PORT_UNKNOWN || port->fifosize == 0)
1398 return;
1399
1400 char_time = (port->timeout - HZ/50) / port->fifosize;
1401 char_time = char_time / 5;
1402 if (char_time == 0)
1403 char_time = 1;
1404 if (timeout && timeout < char_time)
1405 char_time = timeout;
1406
1407 if (timeout == 0 || timeout > 2 * port->timeout)
1408 timeout = 2 * port->timeout;
1409
1410 expire = jiffies + timeout;
1411
1412 while (!port->ops->tx_empty(port)) {
1413 set_current_state(TASK_INTERRUPTIBLE);
1414 schedule_timeout(char_time);
1415 if (signal_pending(current))
1416 break;
1417 if (time_after(jiffies, expire))
1418 break;
1419 }
1420 set_current_state(TASK_RUNNING); /* might not be needed */
1421 }
1422
1423 static void mp_hangup(struct tty_struct *tty)
1424 {
1425 struct sb_uart_state *state = tty->driver_data;
1426
1427 MP_STATE_LOCK(state);
1428 if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) {
1429 mp_flush_buffer(tty);
1430 mp_shutdown(state);
1431 state->count = 0;
1432 state->info->flags &= ~UIF_NORMAL_ACTIVE;
1433 state->info->tty = NULL;
1434 wake_up_interruptible(&state->info->open_wait);
1435 wake_up_interruptible(&state->info->delta_msr_wait);
1436 }
1437 MP_STATE_UNLOCK(state);
1438 }
1439
1440 static void mp_update_termios(struct sb_uart_state *state)
1441 {
1442 struct tty_struct *tty = state->info->tty;
1443 struct sb_uart_port *port = state->port;
1444
1445 if (!(tty->flags & (1 << TTY_IO_ERROR))) {
1446 mp_change_speed(state, NULL);
1447
1448 if (tty->termios.c_cflag & CBAUD)
1449 uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1450 }
1451 }
1452
1453 static int mp_block_til_ready(struct file *filp, struct sb_uart_state *state)
1454 {
1455 DECLARE_WAITQUEUE(wait, current);
1456 struct sb_uart_info *info = state->info;
1457 struct sb_uart_port *port = state->port;
1458 unsigned int mctrl;
1459
1460 info->blocked_open++;
1461 state->count--;
1462
1463 add_wait_queue(&info->open_wait, &wait);
1464 while (1) {
1465 set_current_state(TASK_INTERRUPTIBLE);
1466
1467 if (tty_hung_up_p(filp) || info->tty == NULL)
1468 break;
1469
1470 if (!(info->flags & UIF_INITIALIZED))
1471 break;
1472
1473 if ((filp->f_flags & O_NONBLOCK) ||
1474 (info->tty->termios.c_cflag & CLOCAL) ||
1475 (info->tty->flags & (1 << TTY_IO_ERROR))) {
1476 break;
1477 }
1478
1479 if (info->tty->termios.c_cflag & CBAUD)
1480 uart_set_mctrl(port, TIOCM_DTR);
1481
1482 spin_lock_irq(&port->lock);
1483 port->ops->enable_ms(port);
1484 mctrl = port->ops->get_mctrl(port);
1485 spin_unlock_irq(&port->lock);
1486 if (mctrl & TIOCM_CAR)
1487 break;
1488
1489 MP_STATE_UNLOCK(state);
1490 schedule();
1491 MP_STATE_LOCK(state);
1492
1493 if (signal_pending(current))
1494 break;
1495 }
1496 set_current_state(TASK_RUNNING);
1497 remove_wait_queue(&info->open_wait, &wait);
1498
1499 state->count++;
1500 info->blocked_open--;
1501
1502 if (signal_pending(current))
1503 return -ERESTARTSYS;
1504
1505 if (!info->tty || tty_hung_up_p(filp))
1506 return -EAGAIN;
1507
1508 return 0;
1509 }
1510
1511 static struct sb_uart_state *uart_get(struct uart_driver *drv, int line)
1512 {
1513 struct sb_uart_state *state;
1514
1515 MP_MUTEX_LOCK(mp_mutex);
1516 state = drv->state + line;
1517 if (mutex_lock_interruptible(&state->mutex)) {
1518 state = ERR_PTR(-ERESTARTSYS);
1519 goto out;
1520 }
1521 state->count++;
1522 if (!state->port) {
1523 state->count--;
1524 MP_STATE_UNLOCK(state);
1525 state = ERR_PTR(-ENXIO);
1526 goto out;
1527 }
1528
1529 if (!state->info) {
1530 state->info = kmalloc(sizeof(struct sb_uart_info), GFP_KERNEL);
1531 if (state->info) {
1532 memset(state->info, 0, sizeof(struct sb_uart_info));
1533 init_waitqueue_head(&state->info->open_wait);
1534 init_waitqueue_head(&state->info->delta_msr_wait);
1535
1536 state->port->info = state->info;
1537
1538 tasklet_init(&state->info->tlet, mp_tasklet_action,
1539 (unsigned long)state);
1540 } else {
1541 state->count--;
1542 MP_STATE_UNLOCK(state);
1543 state = ERR_PTR(-ENOMEM);
1544 }
1545 }
1546
1547 out:
1548 MP_MUTEX_UNLOCK(mp_mutex);
1549 return state;
1550 }
1551
1552 static int mp_open(struct tty_struct *tty, struct file *filp)
1553 {
1554 struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
1555 struct sb_uart_state *state;
1556 int retval;
1557 int line = tty->index;
1558 struct mp_port *mtpt;
1559
1560 retval = -ENODEV;
1561 if (line >= tty->driver->num)
1562 goto fail;
1563
1564 state = uart_get(drv, line);
1565
1566 if (IS_ERR(state)) {
1567 retval = PTR_ERR(state);
1568 goto fail;
1569 }
1570
1571 mtpt = (struct mp_port *)state->port;
1572
1573 tty->driver_data = state;
1574 tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1575 tty->alt_speed = 0;
1576 state->info->tty = tty;
1577
1578 if (tty_hung_up_p(filp)) {
1579 retval = -EAGAIN;
1580 state->count--;
1581 MP_STATE_UNLOCK(state);
1582 goto fail;
1583 }
1584
1585 if (state->count == 1)
1586 mp_change_pm(state, 0);
1587
1588 retval = mp_startup(state, 0);
1589
1590 if (retval == 0)
1591 retval = mp_block_til_ready(filp, state);
1592 MP_STATE_UNLOCK(state);
1593
1594 if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) {
1595 state->info->flags |= UIF_NORMAL_ACTIVE;
1596
1597 mp_update_termios(state);
1598 }
1599
1600 uart_clear_mctrl(state->port, TIOCM_RTS);
1601 try_module_get(THIS_MODULE);
1602 fail:
1603 return retval;
1604 }
1605
1606
1607 static const char *mp_type(struct sb_uart_port *port)
1608 {
1609 const char *str = NULL;
1610
1611 if (port->ops->type)
1612 str = port->ops->type(port);
1613
1614 if (!str)
1615 str = "unknown";
1616
1617 return str;
1618 }
1619
1620 static void mp_change_pm(struct sb_uart_state *state, int pm_state)
1621 {
1622 struct sb_uart_port *port = state->port;
1623 if (port->ops->pm)
1624 port->ops->pm(port, pm_state, state->pm_state);
1625 state->pm_state = pm_state;
1626 }
1627
1628 static inline void mp_report_port(struct uart_driver *drv, struct sb_uart_port *port)
1629 {
1630 char address[64];
1631
1632 switch (port->iotype) {
1633 case UPIO_PORT:
1634 snprintf(address, sizeof(address),"I/O 0x%x", port->iobase);
1635 break;
1636 case UPIO_HUB6:
1637 snprintf(address, sizeof(address),"I/O 0x%x offset 0x%x", port->iobase, port->hub6);
1638 break;
1639 case UPIO_MEM:
1640 snprintf(address, sizeof(address),"MMIO 0x%lx", port->mapbase);
1641 break;
1642 default:
1643 snprintf(address, sizeof(address),"*unknown*" );
1644 strlcpy(address, "*unknown*", sizeof(address));
1645 break;
1646 }
1647
1648 printk( "%s%d at %s (irq = %d) is a %s\n",
1649 drv->dev_name, port->line, address, port->irq, mp_type(port));
1650
1651 }
1652
1653 static void mp_configure_port(struct uart_driver *drv, struct sb_uart_state *state, struct sb_uart_port *port)
1654 {
1655 unsigned int flags;
1656
1657
1658 if (!port->iobase && !port->mapbase && !port->membase)
1659 {
1660 DPRINTK("%s error \n",__FUNCTION__);
1661 return;
1662 }
1663 flags = UART_CONFIG_TYPE;
1664 if (port->flags & UPF_AUTO_IRQ)
1665 flags |= UART_CONFIG_IRQ;
1666 if (port->flags & UPF_BOOT_AUTOCONF) {
1667 port->type = PORT_UNKNOWN;
1668 port->ops->config_port(port, flags);
1669 }
1670
1671 if (port->type != PORT_UNKNOWN) {
1672 unsigned long flags;
1673
1674 mp_report_port(drv, port);
1675
1676 spin_lock_irqsave(&port->lock, flags);
1677 port->ops->set_mctrl(port, 0);
1678 spin_unlock_irqrestore(&port->lock, flags);
1679
1680 mp_change_pm(state, 3);
1681 }
1682 }
1683
1684 static void mp_unconfigure_port(struct uart_driver *drv, struct sb_uart_state *state)
1685 {
1686 struct sb_uart_port *port = state->port;
1687 struct sb_uart_info *info = state->info;
1688
1689 if (info && info->tty)
1690 tty_hangup(info->tty);
1691
1692 MP_STATE_LOCK(state);
1693
1694 state->info = NULL;
1695
1696 if (port->type != PORT_UNKNOWN)
1697 port->ops->release_port(port);
1698
1699 port->type = PORT_UNKNOWN;
1700
1701 if (info) {
1702 tasklet_kill(&info->tlet);
1703 kfree(info);
1704 }
1705
1706 MP_STATE_UNLOCK(state);
1707 }
1708 static struct tty_operations mp_ops = {
1709 .open = mp_open,
1710 .close = mp_close,
1711 .write = mp_write,
1712 .put_char = mp_put_char,
1713 .flush_chars = mp_put_chars,
1714 .write_room = mp_write_room,
1715 .chars_in_buffer= mp_chars_in_buffer,
1716 .flush_buffer = mp_flush_buffer,
1717 .ioctl = mp_ioctl,
1718 .throttle = mp_throttle,
1719 .unthrottle = mp_unthrottle,
1720 .send_xchar = mp_send_xchar,
1721 .set_termios = mp_set_termios,
1722 .stop = mp_stop,
1723 .start = mp_start,
1724 .hangup = mp_hangup,
1725 .break_ctl = mp_break_ctl,
1726 .wait_until_sent= mp_wait_until_sent,
1727 #ifdef CONFIG_PROC_FS
1728 .proc_fops = NULL,
1729 #endif
1730 .tiocmget = mp_tiocmget,
1731 .tiocmset = mp_tiocmset,
1732 };
1733
1734 static int mp_register_driver(struct uart_driver *drv)
1735 {
1736 struct tty_driver *normal = NULL;
1737 int i, retval;
1738
1739 drv->state = kmalloc(sizeof(struct sb_uart_state) * drv->nr, GFP_KERNEL);
1740 retval = -ENOMEM;
1741 if (!drv->state)
1742 {
1743 printk("SB PCI Error: Kernel memory allocation error!\n");
1744 goto out;
1745 }
1746 memset(drv->state, 0, sizeof(struct sb_uart_state) * drv->nr);
1747
1748 normal = alloc_tty_driver(drv->nr);
1749 if (!normal)
1750 {
1751 printk("SB PCI Error: tty allocation error!\n");
1752 goto out;
1753 }
1754
1755 drv->tty_driver = normal;
1756
1757 normal->owner = drv->owner;
1758 normal->magic = TTY_DRIVER_MAGIC;
1759 normal->driver_name = drv->driver_name;
1760 normal->name = drv->dev_name;
1761 normal->major = drv->major;
1762 normal->minor_start = drv->minor;
1763
1764 normal->num = MAX_MP_PORT ;
1765
1766 normal->type = TTY_DRIVER_TYPE_SERIAL;
1767 normal->subtype = SERIAL_TYPE_NORMAL;
1768 normal->init_termios = tty_std_termios;
1769 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1770 normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1771 normal->driver_state = drv;
1772
1773 tty_set_operations(normal, &mp_ops);
1774
1775 for (i = 0; i < drv->nr; i++) {
1776 struct sb_uart_state *state = drv->state + i;
1777
1778 state->close_delay = 500;
1779 state->closing_wait = 30000;
1780
1781 mutex_init(&state->mutex);
1782 }
1783
1784 retval = tty_register_driver(normal);
1785 out:
1786 if (retval < 0) {
1787 printk("Register tty driver Fail!\n");
1788 put_tty_driver(normal);
1789 kfree(drv->state);
1790 }
1791
1792 return retval;
1793 }
1794
1795 void mp_unregister_driver(struct uart_driver *drv)
1796 {
1797 struct tty_driver *normal = NULL;
1798
1799 normal = drv->tty_driver;
1800
1801 if (!normal)
1802 {
1803 return;
1804 }
1805
1806 tty_unregister_driver(normal);
1807 put_tty_driver(normal);
1808 drv->tty_driver = NULL;
1809
1810
1811 kfree(drv->state);
1812
1813 }
1814
1815 static int mp_add_one_port(struct uart_driver *drv, struct sb_uart_port *port)
1816 {
1817 struct sb_uart_state *state;
1818 int ret = 0;
1819
1820
1821 if (port->line >= drv->nr)
1822 return -EINVAL;
1823
1824 state = drv->state + port->line;
1825
1826 MP_MUTEX_LOCK(mp_mutex);
1827 if (state->port) {
1828 ret = -EINVAL;
1829 goto out;
1830 }
1831
1832 state->port = port;
1833
1834 spin_lock_init(&port->lock);
1835 port->cons = drv->cons;
1836 port->info = state->info;
1837
1838 mp_configure_port(drv, state, port);
1839
1840 tty_register_device(drv->tty_driver, port->line, port->dev);
1841
1842 out:
1843 MP_MUTEX_UNLOCK(mp_mutex);
1844
1845
1846 return ret;
1847 }
1848
1849 static int mp_remove_one_port(struct uart_driver *drv, struct sb_uart_port *port)
1850 {
1851 struct sb_uart_state *state = drv->state + port->line;
1852
1853 if (state->port != port)
1854 printk(KERN_ALERT "Removing wrong port: %p != %p\n",
1855 state->port, port);
1856
1857 MP_MUTEX_LOCK(mp_mutex);
1858
1859 tty_unregister_device(drv->tty_driver, port->line);
1860
1861 mp_unconfigure_port(drv, state);
1862 state->port = NULL;
1863 MP_MUTEX_UNLOCK(mp_mutex);
1864
1865 return 0;
1866 }
1867
1868 static void autoconfig(struct mp_port *mtpt, unsigned int probeflags)
1869 {
1870 unsigned char status1, scratch, scratch2, scratch3;
1871 unsigned char save_lcr, save_mcr;
1872 unsigned long flags;
1873
1874 unsigned char u_type;
1875 unsigned char b_ret = 0;
1876
1877 if (!mtpt->port.iobase && !mtpt->port.mapbase && !mtpt->port.membase)
1878 return;
1879
1880 DEBUG_AUTOCONF("ttyMP%d: autoconf (0x%04x, 0x%p): ",
1881 mtpt->port.line, mtpt->port.iobase, mtpt->port.membase);
1882
1883 spin_lock_irqsave(&mtpt->port.lock, flags);
1884
1885 if (!(mtpt->port.flags & UPF_BUGGY_UART)) {
1886 scratch = serial_inp(mtpt, UART_IER);
1887 serial_outp(mtpt, UART_IER, 0);
1888 #ifdef __i386__
1889 outb(0xff, 0x080);
1890 #endif
1891 scratch2 = serial_inp(mtpt, UART_IER) & 0x0f;
1892 serial_outp(mtpt, UART_IER, 0x0F);
1893 #ifdef __i386__
1894 outb(0, 0x080);
1895 #endif
1896 scratch3 = serial_inp(mtpt, UART_IER) & 0x0F;
1897 serial_outp(mtpt, UART_IER, scratch);
1898 if (scratch2 != 0 || scratch3 != 0x0F) {
1899 DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
1900 scratch2, scratch3);
1901 goto out;
1902 }
1903 }
1904
1905 save_mcr = serial_in(mtpt, UART_MCR);
1906 save_lcr = serial_in(mtpt, UART_LCR);
1907
1908 if (!(mtpt->port.flags & UPF_SKIP_TEST)) {
1909 serial_outp(mtpt, UART_MCR, UART_MCR_LOOP | 0x0A);
1910 status1 = serial_inp(mtpt, UART_MSR) & 0xF0;
1911 serial_outp(mtpt, UART_MCR, save_mcr);
1912 if (status1 != 0x90) {
1913 DEBUG_AUTOCONF("LOOP test failed (%02x) ",
1914 status1);
1915 goto out;
1916 }
1917 }
1918
1919 serial_outp(mtpt, UART_LCR, 0xBF);
1920 serial_outp(mtpt, UART_EFR, 0);
1921 serial_outp(mtpt, UART_LCR, 0);
1922
1923 serial_outp(mtpt, UART_FCR, UART_FCR_ENABLE_FIFO);
1924 scratch = serial_in(mtpt, UART_IIR) >> 6;
1925
1926 DEBUG_AUTOCONF("iir=%d ", scratch);
1927 if(mtpt->device->nr_ports >= 8)
1928 b_ret = read_option_register(mtpt,(MP_OPTR_DIR0 + ((mtpt->port.line)/8)));
1929 else
1930 b_ret = read_option_register(mtpt,MP_OPTR_DIR0);
1931 u_type = (b_ret & 0xf0) >> 4;
1932 if(mtpt->port.type == PORT_UNKNOWN )
1933 {
1934 switch (u_type)
1935 {
1936 case DIR_UART_16C550:
1937 mtpt->port.type = PORT_16C55X;
1938 break;
1939 case DIR_UART_16C1050:
1940 mtpt->port.type = PORT_16C105X;
1941 break;
1942 case DIR_UART_16C1050A:
1943 if (mtpt->port.line < 2)
1944 {
1945 mtpt->port.type = PORT_16C105XA;
1946 }
1947 else
1948 {
1949 if (mtpt->device->device_id & 0x50)
1950 {
1951 mtpt->port.type = PORT_16C55X;
1952 }
1953 else
1954 {
1955 mtpt->port.type = PORT_16C105X;
1956 }
1957 }
1958 break;
1959 default:
1960 mtpt->port.type = PORT_UNKNOWN;
1961 break;
1962 }
1963 }
1964
1965 if(mtpt->port.type == PORT_UNKNOWN )
1966 {
1967 printk("unknow2\n");
1968 switch (scratch) {
1969 case 0:
1970 case 1:
1971 mtpt->port.type = PORT_UNKNOWN;
1972 break;
1973 case 2:
1974 case 3:
1975 mtpt->port.type = PORT_16C55X;
1976 break;
1977 }
1978 }
1979
1980 serial_outp(mtpt, UART_LCR, save_lcr);
1981
1982 mtpt->port.fifosize = uart_config[mtpt->port.type].dfl_xmit_fifo_size;
1983 mtpt->capabilities = uart_config[mtpt->port.type].flags;
1984
1985 if (mtpt->port.type == PORT_UNKNOWN)
1986 goto out;
1987 serial_outp(mtpt, UART_MCR, save_mcr);
1988 serial_outp(mtpt, UART_FCR, (UART_FCR_ENABLE_FIFO |
1989 UART_FCR_CLEAR_RCVR |
1990 UART_FCR_CLEAR_XMIT));
1991 serial_outp(mtpt, UART_FCR, 0);
1992 (void)serial_in(mtpt, UART_RX);
1993 serial_outp(mtpt, UART_IER, 0);
1994
1995 out:
1996 spin_unlock_irqrestore(&mtpt->port.lock, flags);
1997 DEBUG_AUTOCONF("type=%s\n", uart_config[mtpt->port.type].name);
1998 }
1999
2000 static void autoconfig_irq(struct mp_port *mtpt)
2001 {
2002 unsigned char save_mcr, save_ier;
2003 unsigned long irqs;
2004 int irq;
2005
2006 /* forget possible initially masked and pending IRQ */
2007 probe_irq_off(probe_irq_on());
2008 save_mcr = serial_inp(mtpt, UART_MCR);
2009 save_ier = serial_inp(mtpt, UART_IER);
2010 serial_outp(mtpt, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2);
2011
2012 irqs = probe_irq_on();
2013 serial_outp(mtpt, UART_MCR, 0);
2014 serial_outp(mtpt, UART_MCR,
2015 UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
2016
2017 serial_outp(mtpt, UART_IER, 0x0f); /* enable all intrs */
2018 (void)serial_inp(mtpt, UART_LSR);
2019 (void)serial_inp(mtpt, UART_RX);
2020 (void)serial_inp(mtpt, UART_IIR);
2021 (void)serial_inp(mtpt, UART_MSR);
2022 serial_outp(mtpt, UART_TX, 0xFF);
2023 irq = probe_irq_off(irqs);
2024
2025 serial_outp(mtpt, UART_MCR, save_mcr);
2026 serial_outp(mtpt, UART_IER, save_ier);
2027
2028 mtpt->port.irq = (irq > 0) ? irq : 0;
2029 }
2030
2031 static void multi_stop_tx(struct sb_uart_port *port)
2032 {
2033 struct mp_port *mtpt = (struct mp_port *)port;
2034
2035 if (mtpt->ier & UART_IER_THRI) {
2036 mtpt->ier &= ~UART_IER_THRI;
2037 serial_out(mtpt, UART_IER, mtpt->ier);
2038 }
2039
2040 tasklet_schedule(&port->info->tlet);
2041 }
2042
2043 static void multi_start_tx(struct sb_uart_port *port)
2044 {
2045 struct mp_port *mtpt = (struct mp_port *)port;
2046
2047 if (!(mtpt->ier & UART_IER_THRI)) {
2048 mtpt->ier |= UART_IER_THRI;
2049 serial_out(mtpt, UART_IER, mtpt->ier);
2050 }
2051 }
2052
2053 static void multi_stop_rx(struct sb_uart_port *port)
2054 {
2055 struct mp_port *mtpt = (struct mp_port *)port;
2056
2057 mtpt->ier &= ~UART_IER_RLSI;
2058 mtpt->port.read_status_mask &= ~UART_LSR_DR;
2059 serial_out(mtpt, UART_IER, mtpt->ier);
2060 }
2061
2062 static void multi_enable_ms(struct sb_uart_port *port)
2063 {
2064 struct mp_port *mtpt = (struct mp_port *)port;
2065
2066 mtpt->ier |= UART_IER_MSI;
2067 serial_out(mtpt, UART_IER, mtpt->ier);
2068 }
2069
2070
2071 static _INLINE_ void receive_chars(struct mp_port *mtpt, int *status )
2072 {
2073 struct tty_struct *tty = mtpt->port.info->tty;
2074 unsigned char lsr = *status;
2075 int max_count = 256;
2076 unsigned char ch;
2077 char flag;
2078
2079 //lsr &= mtpt->port.read_status_mask;
2080
2081 do {
2082 if ((lsr & UART_LSR_PE) && (mtpt->port.mdmode & MDMODE_ENABLE))
2083 {
2084 ch = serial_inp(mtpt, UART_RX);
2085 }
2086 else if (lsr & UART_LSR_SPECIAL)
2087 {
2088 flag = 0;
2089 ch = serial_inp(mtpt, UART_RX);
2090
2091 if (lsr & UART_LSR_BI)
2092 {
2093
2094 mtpt->port.icount.brk++;
2095 flag = TTY_BREAK;
2096
2097 if (sb_uart_handle_break(&mtpt->port))
2098 goto ignore_char;
2099 }
2100 if (lsr & UART_LSR_PE)
2101 {
2102 mtpt->port.icount.parity++;
2103 flag = TTY_PARITY;
2104 }
2105 if (lsr & UART_LSR_FE)
2106 {
2107 mtpt->port.icount.frame++;
2108 flag = TTY_FRAME;
2109 }
2110 if (lsr & UART_LSR_OE)
2111 {
2112 mtpt->port.icount.overrun++;
2113 flag = TTY_OVERRUN;
2114 }
2115 tty_insert_flip_char(tty, ch, flag);
2116 }
2117 else
2118 {
2119 ch = serial_inp(mtpt, UART_RX);
2120 tty_insert_flip_char(tty, ch, 0);
2121 }
2122 ignore_char:
2123 lsr = serial_inp(mtpt, UART_LSR);
2124 } while ((lsr & UART_LSR_DR) && (max_count-- > 0));
2125
2126 tty_flip_buffer_push(tty);
2127 }
2128
2129
2130
2131
2132 static _INLINE_ void transmit_chars(struct mp_port *mtpt)
2133 {
2134 struct circ_buf *xmit = &mtpt->port.info->xmit;
2135 int count;
2136
2137 if (mtpt->port.x_char) {
2138 serial_outp(mtpt, UART_TX, mtpt->port.x_char);
2139 mtpt->port.icount.tx++;
2140 mtpt->port.x_char = 0;
2141 return;
2142 }
2143 if (uart_circ_empty(xmit) || uart_tx_stopped(&mtpt->port)) {
2144 multi_stop_tx(&mtpt->port);
2145 return;
2146 }
2147
2148 count = uart_circ_chars_pending(xmit);
2149
2150 if(count > mtpt->port.fifosize)
2151 {
2152 count = mtpt->port.fifosize;
2153 }
2154
2155 printk("[%d] mdmode: %x\n", mtpt->port.line, mtpt->port.mdmode);
2156 do {
2157 #if 0
2158 /* check multi-drop mode */
2159 if ((mtpt->port.mdmode & (MDMODE_ENABLE | MDMODE_ADDR)) == (MDMODE_ENABLE | MDMODE_ADDR))
2160 {
2161 printk("send address\n");
2162 /* send multi-drop address */
2163 serial_out(mtpt, UART_SCR, xmit->buf[xmit->tail]);
2164 }
2165 else
2166 #endif
2167 {
2168 serial_out(mtpt, UART_TX, xmit->buf[xmit->tail]);
2169 }
2170 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
2171 mtpt->port.icount.tx++;
2172 } while (--count > 0);
2173 }
2174
2175
2176
2177 static _INLINE_ void check_modem_status(struct mp_port *mtpt)
2178 {
2179 int status;
2180
2181 status = serial_in(mtpt, UART_MSR);
2182
2183 if ((status & UART_MSR_ANY_DELTA) == 0)
2184 return;
2185
2186 if (status & UART_MSR_TERI)
2187 mtpt->port.icount.rng++;
2188 if (status & UART_MSR_DDSR)
2189 mtpt->port.icount.dsr++;
2190 if (status & UART_MSR_DDCD)
2191 sb_uart_handle_dcd_change(&mtpt->port, status & UART_MSR_DCD);
2192 if (status & UART_MSR_DCTS)
2193 sb_uart_handle_cts_change(&mtpt->port, status & UART_MSR_CTS);
2194
2195 wake_up_interruptible(&mtpt->port.info->delta_msr_wait);
2196 }
2197
2198 static inline void multi_handle_port(struct mp_port *mtpt)
2199 {
2200 unsigned int status = serial_inp(mtpt, UART_LSR);
2201
2202 //printk("lsr: %x\n", status);
2203
2204 if ((status & UART_LSR_DR) || (status & UART_LSR_SPECIAL))
2205 receive_chars(mtpt, &status);
2206 check_modem_status(mtpt);
2207 if (status & UART_LSR_THRE)
2208 {
2209 if ((mtpt->port.type == PORT_16C105X)
2210 || (mtpt->port.type == PORT_16C105XA))
2211 transmit_chars(mtpt);
2212 else
2213 {
2214 if (mtpt->interface >= RS485NE)
2215 uart_set_mctrl(&mtpt->port, TIOCM_RTS);
2216
2217 transmit_chars(mtpt);
2218
2219
2220 if (mtpt->interface >= RS485NE)
2221 {
2222 while((status=serial_in(mtpt,UART_LSR) &0x60)!=0x60);
2223 uart_clear_mctrl(&mtpt->port, TIOCM_RTS);
2224 }
2225 }
2226 }
2227 }
2228
2229
2230
2231 static irqreturn_t multi_interrupt(int irq, void *dev_id)
2232 {
2233 struct irq_info *iinfo = dev_id;
2234 struct list_head *lhead, *end = NULL;
2235 int pass_counter = 0;
2236
2237
2238 spin_lock(&iinfo->lock);
2239
2240 lhead = iinfo->head;
2241 do {
2242 struct mp_port *mtpt;
2243 unsigned int iir;
2244
2245 mtpt = list_entry(lhead, struct mp_port, list);
2246
2247 iir = serial_in(mtpt, UART_IIR);
2248 printk("interrupt! port %d, iir 0x%x\n", mtpt->port.line, iir); //wlee
2249 if (!(iir & UART_IIR_NO_INT))
2250 {
2251 printk("interrupt handle\n");
2252 spin_lock(&mtpt->port.lock);
2253 multi_handle_port(mtpt);
2254 spin_unlock(&mtpt->port.lock);
2255
2256 end = NULL;
2257 } else if (end == NULL)
2258 end = lhead;
2259
2260 lhead = lhead->next;
2261 if (lhead == iinfo->head && pass_counter++ > PASS_LIMIT)
2262 {
2263 printk(KERN_ERR "multi: too much work for "
2264 "irq%d\n", irq);
2265 printk( "multi: too much work for "
2266 "irq%d\n", irq);
2267 break;
2268 }
2269 } while (lhead != end);
2270
2271 spin_unlock(&iinfo->lock);
2272
2273
2274 return IRQ_HANDLED;
2275 }
2276
2277 static void serial_do_unlink(struct irq_info *i, struct mp_port *mtpt)
2278 {
2279 spin_lock_irq(&i->lock);
2280
2281 if (!list_empty(i->head)) {
2282 if (i->head == &mtpt->list)
2283 i->head = i->head->next;
2284 list_del(&mtpt->list);
2285 } else {
2286 i->head = NULL;
2287 }
2288
2289 spin_unlock_irq(&i->lock);
2290 }
2291
2292 static int serial_link_irq_chain(struct mp_port *mtpt)
2293 {
2294 struct irq_info *i = irq_lists + mtpt->port.irq;
2295 int ret, irq_flags = mtpt->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
2296 spin_lock_irq(&i->lock);
2297
2298 if (i->head) {
2299 list_add(&mtpt->list, i->head);
2300 spin_unlock_irq(&i->lock);
2301
2302 ret = 0;
2303 } else {
2304 INIT_LIST_HEAD(&mtpt->list);
2305 i->head = &mtpt->list;
2306 spin_unlock_irq(&i->lock);
2307
2308 ret = request_irq(mtpt->port.irq, multi_interrupt,
2309 irq_flags, "serial", i);
2310 if (ret < 0)
2311 serial_do_unlink(i, mtpt);
2312 }
2313
2314 return ret;
2315 }
2316
2317
2318
2319
2320 static void serial_unlink_irq_chain(struct mp_port *mtpt)
2321 {
2322 struct irq_info *i = irq_lists + mtpt->port.irq;
2323
2324 if (list_empty(i->head))
2325 {
2326 free_irq(mtpt->port.irq, i);
2327 }
2328 serial_do_unlink(i, mtpt);
2329 }
2330
2331 static void multi_timeout(unsigned long data)
2332 {
2333 struct mp_port *mtpt = (struct mp_port *)data;
2334
2335
2336 spin_lock(&mtpt->port.lock);
2337 multi_handle_port(mtpt);
2338 spin_unlock(&mtpt->port.lock);
2339
2340 mod_timer(&mtpt->timer, jiffies+1 );
2341 }
2342
2343 static unsigned int multi_tx_empty(struct sb_uart_port *port)
2344 {
2345 struct mp_port *mtpt = (struct mp_port *)port;
2346 unsigned long flags;
2347 unsigned int ret;
2348
2349 spin_lock_irqsave(&mtpt->port.lock, flags);
2350 ret = serial_in(mtpt, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
2351 spin_unlock_irqrestore(&mtpt->port.lock, flags);
2352
2353 return ret;
2354 }
2355
2356
2357 static unsigned int multi_get_mctrl(struct sb_uart_port *port)
2358 {
2359 struct mp_port *mtpt = (struct mp_port *)port;
2360 unsigned char status;
2361 unsigned int ret;
2362
2363 status = serial_in(mtpt, UART_MSR);
2364
2365 ret = 0;
2366 if (status & UART_MSR_DCD)
2367 ret |= TIOCM_CAR;
2368 if (status & UART_MSR_RI)
2369 ret |= TIOCM_RNG;
2370 if (status & UART_MSR_DSR)
2371 ret |= TIOCM_DSR;
2372 if (status & UART_MSR_CTS)
2373 ret |= TIOCM_CTS;
2374 return ret;
2375 }
2376
2377 static void multi_set_mctrl(struct sb_uart_port *port, unsigned int mctrl)
2378 {
2379 struct mp_port *mtpt = (struct mp_port *)port;
2380 unsigned char mcr = 0;
2381
2382 mctrl &= 0xff;
2383
2384 if (mctrl & TIOCM_RTS)
2385 mcr |= UART_MCR_RTS;
2386 if (mctrl & TIOCM_DTR)
2387 mcr |= UART_MCR_DTR;
2388 if (mctrl & TIOCM_OUT1)
2389 mcr |= UART_MCR_OUT1;
2390 if (mctrl & TIOCM_OUT2)
2391 mcr |= UART_MCR_OUT2;
2392 if (mctrl & TIOCM_LOOP)
2393 mcr |= UART_MCR_LOOP;
2394
2395
2396 serial_out(mtpt, UART_MCR, mcr);
2397 }
2398
2399
2400 static void multi_break_ctl(struct sb_uart_port *port, int break_state)
2401 {
2402 struct mp_port *mtpt = (struct mp_port *)port;
2403 unsigned long flags;
2404
2405 spin_lock_irqsave(&mtpt->port.lock, flags);
2406 if (break_state == -1)
2407 mtpt->lcr |= UART_LCR_SBC;
2408 else
2409 mtpt->lcr &= ~UART_LCR_SBC;
2410 serial_out(mtpt, UART_LCR, mtpt->lcr);
2411 spin_unlock_irqrestore(&mtpt->port.lock, flags);
2412 }
2413
2414
2415
2416 static int multi_startup(struct sb_uart_port *port)
2417 {
2418 struct mp_port *mtpt = (struct mp_port *)port;
2419 unsigned long flags;
2420 int retval;
2421
2422 mtpt->capabilities = uart_config[mtpt->port.type].flags;
2423 mtpt->mcr = 0;
2424
2425 if (mtpt->capabilities & UART_CLEAR_FIFO) {
2426 serial_outp(mtpt, UART_FCR, UART_FCR_ENABLE_FIFO);
2427 serial_outp(mtpt, UART_FCR, UART_FCR_ENABLE_FIFO |
2428 UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
2429 serial_outp(mtpt, UART_FCR, 0);
2430 }
2431
2432 (void) serial_inp(mtpt, UART_LSR);
2433 (void) serial_inp(mtpt, UART_RX);
2434 (void) serial_inp(mtpt, UART_IIR);
2435 (void) serial_inp(mtpt, UART_MSR);
2436 //test-wlee 9-bit disable
2437 serial_outp(mtpt, UART_MSR, 0);
2438
2439
2440 if (!(mtpt->port.flags & UPF_BUGGY_UART) &&
2441 (serial_inp(mtpt, UART_LSR) == 0xff)) {
2442 printk("ttyS%d: LSR safety check engaged!\n", mtpt->port.line);
2443 //return -ENODEV;
2444 }
2445
2446 if ((!is_real_interrupt(mtpt->port.irq)) || (mtpt->poll_type==TYPE_POLL)) {
2447 unsigned int timeout = mtpt->port.timeout;
2448
2449 timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
2450
2451 mtpt->timer.data = (unsigned long)mtpt;
2452 mod_timer(&mtpt->timer, jiffies + timeout);
2453 }
2454 else
2455 {
2456 retval = serial_link_irq_chain(mtpt);
2457 if (retval)
2458 return retval;
2459 }
2460
2461 serial_outp(mtpt, UART_LCR, UART_LCR_WLEN8);
2462
2463 spin_lock_irqsave(&mtpt->port.lock, flags);
2464 if ((is_real_interrupt(mtpt->port.irq))||(mtpt->poll_type==TYPE_INTERRUPT))
2465 mtpt->port.mctrl |= TIOCM_OUT2;
2466
2467 multi_set_mctrl(&mtpt->port, mtpt->port.mctrl);
2468 spin_unlock_irqrestore(&mtpt->port.lock, flags);
2469
2470
2471 mtpt->ier = UART_IER_RLSI | UART_IER_RDI;
2472 serial_outp(mtpt, UART_IER, mtpt->ier);
2473
2474 (void) serial_inp(mtpt, UART_LSR);
2475 (void) serial_inp(mtpt, UART_RX);
2476 (void) serial_inp(mtpt, UART_IIR);
2477 (void) serial_inp(mtpt, UART_MSR);
2478
2479 return 0;
2480 }
2481
2482
2483
2484 static void multi_shutdown(struct sb_uart_port *port)
2485 {
2486 struct mp_port *mtpt = (struct mp_port *)port;
2487 unsigned long flags;
2488
2489
2490 mtpt->ier = 0;
2491 serial_outp(mtpt, UART_IER, 0);
2492
2493 spin_lock_irqsave(&mtpt->port.lock, flags);
2494 mtpt->port.mctrl &= ~TIOCM_OUT2;
2495
2496 multi_set_mctrl(&mtpt->port, mtpt->port.mctrl);
2497 spin_unlock_irqrestore(&mtpt->port.lock, flags);
2498
2499 serial_out(mtpt, UART_LCR, serial_inp(mtpt, UART_LCR) & ~UART_LCR_SBC);
2500 serial_outp(mtpt, UART_FCR, UART_FCR_ENABLE_FIFO |
2501 UART_FCR_CLEAR_RCVR |
2502 UART_FCR_CLEAR_XMIT);
2503 serial_outp(mtpt, UART_FCR, 0);
2504
2505
2506 (void) serial_in(mtpt, UART_RX);
2507
2508 if ((!is_real_interrupt(mtpt->port.irq))||(mtpt->poll_type==TYPE_POLL))
2509 {
2510 del_timer_sync(&mtpt->timer);
2511 }
2512 else
2513 {
2514 serial_unlink_irq_chain(mtpt);
2515 }
2516 }
2517
2518
2519
2520 static unsigned int multi_get_divisor(struct sb_uart_port *port, unsigned int baud)
2521 {
2522 unsigned int quot;
2523
2524 if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2525 baud == (port->uartclk/4))
2526 quot = 0x8001;
2527 else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2528 baud == (port->uartclk/8))
2529 quot = 0x8002;
2530 else
2531 quot = sb_uart_get_divisor(port, baud);
2532
2533 return quot;
2534 }
2535
2536
2537
2538
2539 static void multi_set_termios(struct sb_uart_port *port, struct MP_TERMIOS *termios, struct MP_TERMIOS *old)
2540 {
2541 struct mp_port *mtpt = (struct mp_port *)port;
2542 unsigned char cval, fcr = 0;
2543 unsigned long flags;
2544 unsigned int baud, quot;
2545
2546 switch (termios->c_cflag & CSIZE) {
2547 case CS5:
2548 cval = 0x00;
2549 break;
2550 case CS6:
2551 cval = 0x01;
2552 break;
2553 case CS7:
2554 cval = 0x02;
2555 break;
2556 default:
2557 case CS8:
2558 cval = 0x03;
2559 break;
2560 }
2561
2562 if (termios->c_cflag & CSTOPB)
2563 cval |= 0x04;
2564 if (termios->c_cflag & PARENB)
2565 cval |= UART_LCR_PARITY;
2566 if (!(termios->c_cflag & PARODD))
2567 cval |= UART_LCR_EPAR;
2568
2569 #ifdef CMSPAR
2570 if (termios->c_cflag & CMSPAR)
2571 cval |= UART_LCR_SPAR;
2572 #endif
2573
2574 baud = sb_uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
2575 quot = multi_get_divisor(port, baud);
2576
2577 if (mtpt->capabilities & UART_USE_FIFO) {
2578 //if (baud < 2400)
2579 // fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
2580 //else
2581 // fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
2582
2583 // fcr = UART_FCR_ENABLE_FIFO | 0x90;
2584 fcr = fcr_arr[mtpt->port.line];
2585 }
2586
2587 spin_lock_irqsave(&mtpt->port.lock, flags);
2588
2589 sb_uart_update_timeout(port, termios->c_cflag, baud);
2590
2591 mtpt->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
2592 if (termios->c_iflag & INPCK)
2593 mtpt->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
2594 if (termios->c_iflag & (BRKINT | PARMRK))
2595 mtpt->port.read_status_mask |= UART_LSR_BI;
2596
2597 mtpt->port.ignore_status_mask = 0;
2598 if (termios->c_iflag & IGNPAR)
2599 mtpt->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
2600 if (termios->c_iflag & IGNBRK) {
2601 mtpt->port.ignore_status_mask |= UART_LSR_BI;
2602 if (termios->c_iflag & IGNPAR)
2603 mtpt->port.ignore_status_mask |= UART_LSR_OE;
2604 }
2605
2606 if ((termios->c_cflag & CREAD) == 0)
2607 mtpt->port.ignore_status_mask |= UART_LSR_DR;
2608
2609 mtpt->ier &= ~UART_IER_MSI;
2610 if (UART_ENABLE_MS(&mtpt->port, termios->c_cflag))
2611 mtpt->ier |= UART_IER_MSI;
2612
2613 serial_out(mtpt, UART_IER, mtpt->ier);
2614
2615 if (mtpt->capabilities & UART_STARTECH) {
2616 serial_outp(mtpt, UART_LCR, 0xBF);
2617 serial_outp(mtpt, UART_EFR,
2618 termios->c_cflag & CRTSCTS ? UART_EFR_CTS :0);
2619 }
2620
2621 serial_outp(mtpt, UART_LCR, cval | UART_LCR_DLAB);/* set DLAB */
2622
2623 serial_outp(mtpt, UART_DLL, quot & 0xff); /* LS of divisor */
2624 serial_outp(mtpt, UART_DLM, quot >> 8); /* MS of divisor */
2625
2626 serial_outp(mtpt, UART_LCR, cval); /* reset DLAB */
2627 mtpt->lcr = cval; /* Save LCR */
2628
2629 if (fcr & UART_FCR_ENABLE_FIFO) {
2630 /* emulated UARTs (Lucent Venus 167x) need two steps */
2631 serial_outp(mtpt, UART_FCR, UART_FCR_ENABLE_FIFO);
2632 }
2633
2634 serial_outp(mtpt, UART_FCR, fcr); /* set fcr */
2635
2636
2637 if ((mtpt->port.type == PORT_16C105X)
2638 || (mtpt->port.type == PORT_16C105XA))
2639 {
2640 if(deep[mtpt->port.line]!=0)
2641 set_deep_fifo(port, ENABLE);
2642
2643 if (mtpt->interface != RS232)
2644 set_auto_rts(port,mtpt->interface);
2645
2646 }
2647 else
2648 {
2649 if (mtpt->interface >= RS485NE)
2650 {
2651 uart_clear_mctrl(&mtpt->port, TIOCM_RTS);
2652 }
2653 }
2654
2655 if(mtpt->device->device_id == PCI_DEVICE_ID_MP4M)
2656 {
2657 SendATCommand(mtpt);
2658 printk("SendATCommand\n");
2659 }
2660 multi_set_mctrl(&mtpt->port, mtpt->port.mctrl);
2661 spin_unlock_irqrestore(&mtpt->port.lock, flags);
2662 }
2663
2664 static void multi_pm(struct sb_uart_port *port, unsigned int state, unsigned int oldstate)
2665 {
2666 struct mp_port *mtpt = (struct mp_port *)port;
2667 if (state) {
2668 if (mtpt->capabilities & UART_STARTECH) {
2669 serial_outp(mtpt, UART_LCR, 0xBF);
2670 serial_outp(mtpt, UART_EFR, UART_EFR_ECB);
2671 serial_outp(mtpt, UART_LCR, 0);
2672 serial_outp(mtpt, UART_IER, UART_IERX_SLEEP);
2673 serial_outp(mtpt, UART_LCR, 0xBF);
2674 serial_outp(mtpt, UART_EFR, 0);
2675 serial_outp(mtpt, UART_LCR, 0);
2676 }
2677
2678 if (mtpt->pm)
2679 mtpt->pm(port, state, oldstate);
2680 }
2681 else
2682 {
2683 if (mtpt->capabilities & UART_STARTECH) {
2684 serial_outp(mtpt, UART_LCR, 0xBF);
2685 serial_outp(mtpt, UART_EFR, UART_EFR_ECB);
2686 serial_outp(mtpt, UART_LCR, 0);
2687 serial_outp(mtpt, UART_IER, 0);
2688 serial_outp(mtpt, UART_LCR, 0xBF);
2689 serial_outp(mtpt, UART_EFR, 0);
2690 serial_outp(mtpt, UART_LCR, 0);
2691 }
2692
2693 if (mtpt->pm)
2694 mtpt->pm(port, state, oldstate);
2695 }
2696 }
2697
2698 static void multi_release_std_resource(struct mp_port *mtpt)
2699 {
2700 unsigned int size = 8 << mtpt->port.regshift;
2701
2702 switch (mtpt->port.iotype) {
2703 case UPIO_MEM:
2704 if (!mtpt->port.mapbase)
2705 break;
2706
2707 if (mtpt->port.flags & UPF_IOREMAP) {
2708 iounmap(mtpt->port.membase);
2709 mtpt->port.membase = NULL;
2710 }
2711
2712 release_mem_region(mtpt->port.mapbase, size);
2713 break;
2714
2715 case UPIO_HUB6:
2716 case UPIO_PORT:
2717 release_region(mtpt->port.iobase,size);
2718 break;
2719 }
2720 }
2721
2722 static void multi_release_port(struct sb_uart_port *port)
2723 {
2724 }
2725
2726 static int multi_request_port(struct sb_uart_port *port)
2727 {
2728 return 0;
2729 }
2730
2731 static void multi_config_port(struct sb_uart_port *port, int flags)
2732 {
2733 struct mp_port *mtpt = (struct mp_port *)port;
2734 int probeflags = PROBE_ANY;
2735
2736 if (flags & UART_CONFIG_TYPE)
2737 autoconfig(mtpt, probeflags);
2738 if (mtpt->port.type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
2739 autoconfig_irq(mtpt);
2740
2741 if (mtpt->port.type == PORT_UNKNOWN)
2742 multi_release_std_resource(mtpt);
2743 }
2744
2745 static int multi_verify_port(struct sb_uart_port *port, struct serial_struct *ser)
2746 {
2747 if (ser->irq >= NR_IRQS || ser->irq < 0 ||
2748 ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
2749 ser->type == PORT_STARTECH)
2750 return -EINVAL;
2751 return 0;
2752 }
2753
2754 static const char *multi_type(struct sb_uart_port *port)
2755 {
2756 int type = port->type;
2757
2758 if (type >= ARRAY_SIZE(uart_config))
2759 type = 0;
2760 return uart_config[type].name;
2761 }
2762
2763 static struct sb_uart_ops multi_pops = {
2764 .tx_empty = multi_tx_empty,
2765 .set_mctrl = multi_set_mctrl,
2766 .get_mctrl = multi_get_mctrl,
2767 .stop_tx = multi_stop_tx,
2768 .start_tx = multi_start_tx,
2769 .stop_rx = multi_stop_rx,
2770 .enable_ms = multi_enable_ms,
2771 .break_ctl = multi_break_ctl,
2772 .startup = multi_startup,
2773 .shutdown = multi_shutdown,
2774 .set_termios = multi_set_termios,
2775 .pm = multi_pm,
2776 .type = multi_type,
2777 .release_port = multi_release_port,
2778 .request_port = multi_request_port,
2779 .config_port = multi_config_port,
2780 .verify_port = multi_verify_port,
2781 };
2782
2783 static struct uart_driver multi_reg = {
2784 .owner = THIS_MODULE,
2785 .driver_name = "goldel_tulip",
2786 .dev_name = "ttyMP",
2787 .major = SB_TTY_MP_MAJOR,
2788 .minor = 0,
2789 .nr = MAX_MP_PORT,
2790 .cons = NULL,
2791 };
2792
2793 static void __init multi_init_ports(void)
2794 {
2795 struct mp_port *mtpt;
2796 static int first = 1;
2797 int i,j,k;
2798 unsigned char osc;
2799 unsigned char b_ret = 0;
2800 static struct mp_device_t *sbdev;
2801
2802 if (!first)
2803 return;
2804 first = 0;
2805
2806 mtpt = multi_ports;
2807
2808 for (k=0;k<NR_BOARD;k++)
2809 {
2810 sbdev = &mp_devs[k];
2811
2812 for (i = 0; i < sbdev->nr_ports; i++, mtpt++)
2813 {
2814 mtpt->device = sbdev;
2815 mtpt->port.iobase = sbdev->uart_access_addr + 8*i;
2816 mtpt->port.irq = sbdev->irq;
2817 if ( ((sbdev->device_id == PCI_DEVICE_ID_MP4)&&(sbdev->revision==0x91)))
2818 mtpt->interface_config_addr = sbdev->option_reg_addr + 0x08 + i;
2819 else if (sbdev->revision == 0xc0)
2820 mtpt->interface_config_addr = sbdev->option_reg_addr + 0x08 + (i & 0x1);
2821 else
2822 mtpt->interface_config_addr = sbdev->option_reg_addr + 0x08 + i/8;
2823
2824 mtpt->option_base_addr = sbdev->option_reg_addr;
2825
2826 mtpt->poll_type = sbdev->poll_type;
2827
2828 mtpt->port.uartclk = BASE_BAUD * 16;
2829
2830 /* get input clock information */
2831 osc = inb(sbdev->option_reg_addr + MP_OPTR_DIR0 + i/8) & 0x0F;
2832 if (osc==0x0f)
2833 osc = 0;
2834 for(j=0;j<osc;j++)
2835 mtpt->port.uartclk *= 2;
2836 mtpt->port.flags |= STD_COM_FLAGS | UPF_SHARE_IRQ ;
2837 mtpt->port.iotype = UPIO_PORT;
2838 mtpt->port.ops = &multi_pops;
2839
2840 if (sbdev->revision == 0xc0)
2841 {
2842 /* for SB16C1053APCI */
2843 b_ret = sb1053a_get_interface(mtpt, i);
2844 }
2845 else
2846 {
2847 b_ret = read_option_register(mtpt,(MP_OPTR_IIR0 + i/8));
2848 printk("IIR_RET = %x\n",b_ret);
2849 }
2850
2851 /* default to RS232 */
2852 mtpt->interface = RS232;
2853 if (IIR_RS422 == (b_ret & IIR_TYPE_MASK))
2854 mtpt->interface = RS422PTP;
2855 if (IIR_RS485 == (b_ret & IIR_TYPE_MASK))
2856 mtpt->interface = RS485NE;
2857 }
2858 }
2859 }
2860
2861 static void __init multi_register_ports(struct uart_driver *drv)
2862 {
2863 int i;
2864
2865 multi_init_ports();
2866
2867 for (i = 0; i < NR_PORTS; i++) {
2868 struct mp_port *mtpt = &multi_ports[i];
2869
2870 mtpt->port.line = i;
2871 mtpt->port.ops = &multi_pops;
2872 init_timer(&mtpt->timer);
2873 mtpt->timer.function = multi_timeout;
2874 mp_add_one_port(drv, &mtpt->port);
2875 }
2876 }
2877
2878 /**
2879 * pci_remap_base - remap BAR value of pci device
2880 *
2881 * PARAMETERS
2882 * pcidev - pci_dev structure address
2883 * offset - BAR offset PCI_BASE_ADDRESS_0 ~ PCI_BASE_ADDRESS_4
2884 * address - address to be changed BAR value
2885 * size - size of address space
2886 *
2887 * RETURNS
2888 * If this function performs successful, it returns 0. Otherwise, It returns -1.
2889 */
2890 static int pci_remap_base(struct pci_dev *pcidev, unsigned int offset,
2891 unsigned int address, unsigned int size)
2892 {
2893 #if 0
2894 struct resource *root;
2895 unsigned index = (offset - 0x10) >> 2;
2896 #endif
2897
2898 pci_write_config_dword(pcidev, offset, address);
2899 #if 0
2900 root = pcidev->resource[index].parent;
2901 release_resource(&pcidev->resource[index]);
2902 address &= ~0x1;
2903 pcidev->resource[index].start = address;
2904 pcidev->resource[index].end = address + size - 1;
2905
2906 if (request_resource(root, &pcidev->resource[index]) != NULL)
2907 {
2908 printk(KERN_ERR "pci remap conflict!! 0x%x\n", address);
2909 return (-1);
2910 }
2911 #endif
2912
2913 return (0);
2914 }
2915
2916 static int init_mp_dev(struct pci_dev *pcidev, mppcibrd_t brd)
2917 {
2918 static struct mp_device_t *sbdev = mp_devs;
2919 unsigned long addr = 0;
2920 int j;
2921 struct resource *ret = NULL;
2922
2923 sbdev->device_id = brd.device_id;
2924 pci_read_config_byte(pcidev, PCI_CLASS_REVISION, &(sbdev->revision));
2925 sbdev->name = brd.name;
2926 sbdev->uart_access_addr = pcidev->resource[0].start & PCI_BASE_ADDRESS_IO_MASK;
2927
2928 /* check revision. The SB16C1053APCI's option i/o address is BAR4 */
2929 if (sbdev->revision == 0xc0)
2930 {
2931 /* SB16C1053APCI */
2932 sbdev->option_reg_addr = pcidev->resource[4].start & PCI_BASE_ADDRESS_IO_MASK;
2933 }
2934 else
2935 {
2936 sbdev->option_reg_addr = pcidev->resource[1].start & PCI_BASE_ADDRESS_IO_MASK;
2937 }
2938 #if 1
2939 if (sbdev->revision == 0xc0)
2940 {
2941 outb(0x00, sbdev->option_reg_addr + MP_OPTR_GPOCR);
2942 inb(sbdev->option_reg_addr + MP_OPTR_GPOCR);
2943 outb(0x83, sbdev->option_reg_addr + MP_OPTR_GPOCR);
2944 }
2945 #endif
2946
2947 sbdev->irq = pcidev->irq;
2948
2949 if ((brd.device_id & 0x0800) || !(brd.device_id &0xff00))
2950 {
2951 sbdev->poll_type = TYPE_INTERRUPT;
2952 }
2953 else
2954 {
2955 sbdev->poll_type = TYPE_POLL;
2956 }
2957
2958 /* codes which is specific to each board*/
2959 switch(brd.device_id){
2960 case PCI_DEVICE_ID_MP1 :
2961 case PCIE_DEVICE_ID_MP1 :
2962 case PCIE_DEVICE_ID_MP1E :
2963 case PCIE_DEVICE_ID_GT_MP1 :
2964 sbdev->nr_ports = 1;
2965 break;
2966 case PCI_DEVICE_ID_MP2 :
2967 case PCIE_DEVICE_ID_MP2 :
2968 case PCIE_DEVICE_ID_GT_MP2 :
2969 case PCIE_DEVICE_ID_MP2B :
2970 case PCIE_DEVICE_ID_MP2E :
2971 sbdev->nr_ports = 2;
2972
2973 /* serial base address remap */
2974 if (sbdev->revision == 0xc0)
2975 {
2976 int prev_port_addr = 0;
2977
2978 pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_0, &prev_port_addr);
2979 pci_remap_base(pcidev, PCI_BASE_ADDRESS_1, prev_port_addr + 8, 8);
2980 }
2981 break;
2982 case PCI_DEVICE_ID_MP4 :
2983 case PCI_DEVICE_ID_MP4A :
2984 case PCIE_DEVICE_ID_MP4 :
2985 case PCI_DEVICE_ID_GT_MP4 :
2986 case PCI_DEVICE_ID_GT_MP4A :
2987 case PCIE_DEVICE_ID_GT_MP4 :
2988 case PCI_DEVICE_ID_MP4M :
2989 case PCIE_DEVICE_ID_MP4B :
2990 sbdev->nr_ports = 4;
2991
2992 if(sbdev->revision == 0x91){
2993 sbdev->reserved_addr[0] = pcidev->resource[0].start & PCI_BASE_ADDRESS_IO_MASK;
2994 outb(0x03 , sbdev->reserved_addr[0] + 0x01);
2995 outb(0x03 , sbdev->reserved_addr[0] + 0x02);
2996 outb(0x01 , sbdev->reserved_addr[0] + 0x20);
2997 outb(0x00 , sbdev->reserved_addr[0] + 0x21);
2998 request_region(sbdev->reserved_addr[0], 32, sbdev->name);
2999 sbdev->uart_access_addr = pcidev->resource[1].start & PCI_BASE_ADDRESS_IO_MASK;
3000 sbdev->option_reg_addr = pcidev->resource[2].start & PCI_BASE_ADDRESS_IO_MASK;
3001 }
3002
3003 /* SB16C1053APCI */
3004 if (sbdev->revision == 0xc0)
3005 {
3006 int prev_port_addr = 0;
3007
3008 pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_0, &prev_port_addr);
3009 pci_remap_base(pcidev, PCI_BASE_ADDRESS_1, prev_port_addr + 8, 8);
3010 pci_remap_base(pcidev, PCI_BASE_ADDRESS_2, prev_port_addr + 16, 8);
3011 pci_remap_base(pcidev, PCI_BASE_ADDRESS_3, prev_port_addr + 24, 8);
3012 }
3013 break;
3014 case PCI_DEVICE_ID_MP6 :
3015 case PCI_DEVICE_ID_MP6A :
3016 case PCI_DEVICE_ID_GT_MP6 :
3017 case PCI_DEVICE_ID_GT_MP6A :
3018 sbdev->nr_ports = 6;
3019
3020 /* SB16C1053APCI */
3021 if (sbdev->revision == 0xc0)
3022 {
3023 int prev_port_addr = 0;
3024
3025 pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_0, &prev_port_addr);
3026 pci_remap_base(pcidev, PCI_BASE_ADDRESS_1, prev_port_addr + 8, 8);
3027 pci_remap_base(pcidev, PCI_BASE_ADDRESS_2, prev_port_addr + 16, 16);
3028 pci_remap_base(pcidev, PCI_BASE_ADDRESS_3, prev_port_addr + 32, 16);
3029 }
3030 break;
3031 case PCI_DEVICE_ID_MP8 :
3032 case PCIE_DEVICE_ID_MP8 :
3033 case PCI_DEVICE_ID_GT_MP8 :
3034 case PCIE_DEVICE_ID_GT_MP8 :
3035 case PCIE_DEVICE_ID_MP8B :
3036 sbdev->nr_ports = 8;
3037 break;
3038 case PCI_DEVICE_ID_MP32 :
3039 case PCIE_DEVICE_ID_MP32 :
3040 case PCI_DEVICE_ID_GT_MP32 :
3041 case PCIE_DEVICE_ID_GT_MP32 :
3042 {
3043 int portnum_hex=0;
3044 portnum_hex = inb(sbdev->option_reg_addr);
3045 sbdev->nr_ports = ((portnum_hex/16)*10) + (portnum_hex % 16);
3046 }
3047 break;
3048 #ifdef CONFIG_PARPORT_PC
3049 case PCI_DEVICE_ID_MP2S1P :
3050 sbdev->nr_ports = 2;
3051
3052 /* SB16C1053APCI */
3053 if (sbdev->revision == 0xc0)
3054 {
3055 int prev_port_addr = 0;
3056
3057 pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_0, &prev_port_addr);
3058 pci_remap_base(pcidev, PCI_BASE_ADDRESS_1, prev_port_addr + 8, 8);
3059 }
3060
3061 /* add PC compatible parallel port */
3062 parport_pc_probe_port(pcidev->resource[2].start, pcidev->resource[3].start, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &pcidev->dev, 0);
3063 break;
3064 case PCI_DEVICE_ID_MP1P :
3065 /* add PC compatible parallel port */
3066 parport_pc_probe_port(pcidev->resource[2].start, pcidev->resource[3].start, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &pcidev->dev, 0);
3067 break;
3068 #endif
3069 }
3070
3071 ret = request_region(sbdev->uart_access_addr, (8*sbdev->nr_ports), sbdev->name);
3072
3073 if (sbdev->revision == 0xc0)
3074 {
3075 ret = request_region(sbdev->option_reg_addr, 0x40, sbdev->name);
3076 }
3077 else
3078 {
3079 ret = request_region(sbdev->option_reg_addr, 0x20, sbdev->name);
3080 }
3081
3082
3083 NR_BOARD++;
3084 NR_PORTS += sbdev->nr_ports;
3085
3086 /* Enable PCI interrupt */
3087 addr = sbdev->option_reg_addr + MP_OPTR_IMR0;
3088 for(j=0; j < (sbdev->nr_ports/8)+1; j++)
3089 {
3090 if (sbdev->poll_type == TYPE_INTERRUPT)
3091 {
3092 outb(0xff,addr +j);
3093 }
3094 }
3095 sbdev++;
3096
3097 return 0;
3098 }
3099
3100 static int __init multi_init(void)
3101 {
3102 int ret, i;
3103 struct pci_dev *dev = NULL;
3104
3105 if(fcr_count==0)
3106 {
3107 for(i=0;i<256;i++)
3108 {
3109 fcr_arr[i] = 0x01;
3110
3111 }
3112 }
3113 if(deep_count==0)
3114 {
3115 for(i=0;i<256;i++)
3116 {
3117 deep[i] = 1;
3118
3119 }
3120 }
3121 if(rtr_count==0)
3122 {
3123 for(i=0;i<256;i++)
3124 {
3125 rtr[i] = 0x10;
3126 }
3127 }
3128 if(ttr_count==0)
3129 {
3130 for(i=0;i<256;i++)
3131 {
3132 ttr[i] = 0x38;
3133 }
3134 }
3135
3136
3137 printk("MULTI INIT\n");
3138 for( i=0; i< mp_nrpcibrds; i++)
3139 {
3140
3141 while( (dev = pci_get_device(mp_pciboards[i].vendor_id, mp_pciboards[i].device_id, dev) ) )
3142
3143 {
3144 printk("FOUND~~~\n");
3145 // Cent OS bug fix
3146 // if (mp_pciboards[i].device_id & 0x0800)
3147 {
3148 int status;
3149 pci_disable_device(dev);
3150 status = pci_enable_device(dev);
3151
3152 if (status != 0)
3153 {
3154 printk("Multiport Board Enable Fail !\n\n");
3155 status = -ENXIO;
3156 return status;
3157 }
3158 }
3159
3160 init_mp_dev(dev, mp_pciboards[i]);
3161 }
3162 }
3163
3164 for (i = 0; i < NR_IRQS; i++)
3165 spin_lock_init(&irq_lists[i].lock);
3166
3167 ret = mp_register_driver(&multi_reg);
3168
3169 if (ret >= 0)
3170 multi_register_ports(&multi_reg);
3171
3172 return ret;
3173 }
3174
3175 static void __exit multi_exit(void)
3176 {
3177 int i;
3178
3179 for (i = 0; i < NR_PORTS; i++)
3180 mp_remove_one_port(&multi_reg, &multi_ports[i].port);
3181
3182 mp_unregister_driver(&multi_reg);
3183 }
3184
3185 module_init(multi_init);
3186 module_exit(multi_exit);
3187
3188 MODULE_DESCRIPTION("SystemBase Multiport PCI/PCIe CORE");
3189 MODULE_LICENSE("GPL");
(deprecated) Btrfs devel tree