1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/tty.h>
29#include <linux/tty_flip.h>
30#include <linux/serial_reg.h>
31#include <linux/delay.h>
32#include <linux/pci.h>
33
34#include "jsm.h"
35
36static DECLARE_BITMAP(linemap, MAXLINES);
37
38static void jsm_carrier(struct jsm_channel *ch);
39
40static inline int jsm_get_mstat(struct jsm_channel *ch)
41{
42 unsigned char mstat;
43 unsigned result;
44
45 jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "start\n");
46
47 mstat = (ch->ch_mostat | ch->ch_mistat);
48
49 result = 0;
50
51 if (mstat & UART_MCR_DTR)
52 result |= TIOCM_DTR;
53 if (mstat & UART_MCR_RTS)
54 result |= TIOCM_RTS;
55 if (mstat & UART_MSR_CTS)
56 result |= TIOCM_CTS;
57 if (mstat & UART_MSR_DSR)
58 result |= TIOCM_DSR;
59 if (mstat & UART_MSR_RI)
60 result |= TIOCM_RI;
61 if (mstat & UART_MSR_DCD)
62 result |= TIOCM_CD;
63
64 jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "finish\n");
65 return result;
66}
67
68static unsigned int jsm_tty_tx_empty(struct uart_port *port)
69{
70 return TIOCSER_TEMT;
71}
72
73
74
75
76static unsigned int jsm_tty_get_mctrl(struct uart_port *port)
77{
78 int result;
79 struct jsm_channel *channel = (struct jsm_channel *)port;
80
81 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
82
83 result = jsm_get_mstat(channel);
84
85 if (result < 0)
86 return -ENXIO;
87
88 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
89
90 return result;
91}
92
93
94
95
96
97
98static void jsm_tty_set_mctrl(struct uart_port *port, unsigned int mctrl)
99{
100 struct jsm_channel *channel = (struct jsm_channel *)port;
101
102 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
103
104 if (mctrl & TIOCM_RTS)
105 channel->ch_mostat |= UART_MCR_RTS;
106 else
107 channel->ch_mostat &= ~UART_MCR_RTS;
108
109 if (mctrl & TIOCM_DTR)
110 channel->ch_mostat |= UART_MCR_DTR;
111 else
112 channel->ch_mostat &= ~UART_MCR_DTR;
113
114 channel->ch_bd->bd_ops->assert_modem_signals(channel);
115
116 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
117 udelay(10);
118}
119
120static void jsm_tty_start_tx(struct uart_port *port)
121{
122 struct jsm_channel *channel = (struct jsm_channel *)port;
123
124 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
125
126 channel->ch_flags &= ~(CH_STOP);
127 jsm_tty_write(port);
128
129 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
130}
131
132static void jsm_tty_stop_tx(struct uart_port *port)
133{
134 struct jsm_channel *channel = (struct jsm_channel *)port;
135
136 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "start\n");
137
138 channel->ch_flags |= (CH_STOP);
139
140 jsm_printk(IOCTL, INFO, &channel->ch_bd->pci_dev, "finish\n");
141}
142
143static void jsm_tty_send_xchar(struct uart_port *port, char ch)
144{
145 unsigned long lock_flags;
146 struct jsm_channel *channel = (struct jsm_channel *)port;
147 struct ktermios *termios;
148
149 spin_lock_irqsave(&port->lock, lock_flags);
150 termios = port->state->port.tty->termios;
151 if (ch == termios->c_cc[VSTART])
152 channel->ch_bd->bd_ops->send_start_character(channel);
153
154 if (ch == termios->c_cc[VSTOP])
155 channel->ch_bd->bd_ops->send_stop_character(channel);
156 spin_unlock_irqrestore(&port->lock, lock_flags);
157}
158
159static void jsm_tty_stop_rx(struct uart_port *port)
160{
161 struct jsm_channel *channel = (struct jsm_channel *)port;
162
163 channel->ch_bd->bd_ops->disable_receiver(channel);
164}
165
166static void jsm_tty_enable_ms(struct uart_port *port)
167{
168
169}
170
171static void jsm_tty_break(struct uart_port *port, int break_state)
172{
173 unsigned long lock_flags;
174 struct jsm_channel *channel = (struct jsm_channel *)port;
175
176 spin_lock_irqsave(&port->lock, lock_flags);
177 if (break_state == -1)
178 channel->ch_bd->bd_ops->send_break(channel);
179 else
180 channel->ch_bd->bd_ops->clear_break(channel, 0);
181
182 spin_unlock_irqrestore(&port->lock, lock_flags);
183}
184
185static int jsm_tty_open(struct uart_port *port)
186{
187 struct jsm_board *brd;
188 struct jsm_channel *channel = (struct jsm_channel *)port;
189 struct ktermios *termios;
190
191
192 brd = channel->ch_bd;
193
194
195
196
197
198 channel->ch_flags |= (CH_OPENING);
199
200
201
202 if (!channel->ch_rqueue) {
203 channel->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL);
204 if (!channel->ch_rqueue) {
205 jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
206 "unable to allocate read queue buf");
207 return -ENOMEM;
208 }
209 }
210 if (!channel->ch_equeue) {
211 channel->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL);
212 if (!channel->ch_equeue) {
213 jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
214 "unable to allocate error queue buf");
215 return -ENOMEM;
216 }
217 }
218 if (!channel->ch_wqueue) {
219 channel->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL);
220 if (!channel->ch_wqueue) {
221 jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
222 "unable to allocate write queue buf");
223 return -ENOMEM;
224 }
225 }
226
227 channel->ch_flags &= ~(CH_OPENING);
228
229
230
231 jsm_printk(OPEN, INFO, &channel->ch_bd->pci_dev,
232 "jsm_open: initializing channel in open...\n");
233
234
235
236
237 channel->ch_r_head = channel->ch_r_tail = 0;
238 channel->ch_e_head = channel->ch_e_tail = 0;
239 channel->ch_w_head = channel->ch_w_tail = 0;
240
241 brd->bd_ops->flush_uart_write(channel);
242 brd->bd_ops->flush_uart_read(channel);
243
244 channel->ch_flags = 0;
245 channel->ch_cached_lsr = 0;
246 channel->ch_stops_sent = 0;
247
248 termios = port->state->port.tty->termios;
249 channel->ch_c_cflag = termios->c_cflag;
250 channel->ch_c_iflag = termios->c_iflag;
251 channel->ch_c_oflag = termios->c_oflag;
252 channel->ch_c_lflag = termios->c_lflag;
253 channel->ch_startc = termios->c_cc[VSTART];
254 channel->ch_stopc = termios->c_cc[VSTOP];
255
256
257 brd->bd_ops->uart_init(channel);
258
259
260
261
262 brd->bd_ops->param(channel);
263
264 jsm_carrier(channel);
265
266 channel->ch_open_count++;
267
268 jsm_printk(OPEN, INFO, &channel->ch_bd->pci_dev, "finish\n");
269 return 0;
270}
271
272static void jsm_tty_close(struct uart_port *port)
273{
274 struct jsm_board *bd;
275 struct ktermios *ts;
276 struct jsm_channel *channel = (struct jsm_channel *)port;
277
278 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
279
280 bd = channel->ch_bd;
281 ts = port->state->port.tty->termios;
282
283 channel->ch_flags &= ~(CH_STOPI);
284
285 channel->ch_open_count--;
286
287
288
289
290 if (channel->ch_c_cflag & HUPCL) {
291 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev,
292 "Close. HUPCL set, dropping DTR/RTS\n");
293
294
295 channel->ch_mostat &= ~(UART_MCR_DTR | UART_MCR_RTS);
296 bd->bd_ops->assert_modem_signals(channel);
297 }
298
299 channel->ch_old_baud = 0;
300
301
302 channel->ch_bd->bd_ops->uart_off(channel);
303
304 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "finish\n");
305}
306
307static void jsm_tty_set_termios(struct uart_port *port,
308 struct ktermios *termios,
309 struct ktermios *old_termios)
310{
311 unsigned long lock_flags;
312 struct jsm_channel *channel = (struct jsm_channel *)port;
313
314 spin_lock_irqsave(&port->lock, lock_flags);
315 channel->ch_c_cflag = termios->c_cflag;
316 channel->ch_c_iflag = termios->c_iflag;
317 channel->ch_c_oflag = termios->c_oflag;
318 channel->ch_c_lflag = termios->c_lflag;
319 channel->ch_startc = termios->c_cc[VSTART];
320 channel->ch_stopc = termios->c_cc[VSTOP];
321
322 channel->ch_bd->bd_ops->param(channel);
323 jsm_carrier(channel);
324 spin_unlock_irqrestore(&port->lock, lock_flags);
325}
326
327static const char *jsm_tty_type(struct uart_port *port)
328{
329 return "jsm";
330}
331
332static void jsm_tty_release_port(struct uart_port *port)
333{
334}
335
336static int jsm_tty_request_port(struct uart_port *port)
337{
338 return 0;
339}
340
341static void jsm_config_port(struct uart_port *port, int flags)
342{
343 port->type = PORT_JSM;
344}
345
346static struct uart_ops jsm_ops = {
347 .tx_empty = jsm_tty_tx_empty,
348 .set_mctrl = jsm_tty_set_mctrl,
349 .get_mctrl = jsm_tty_get_mctrl,
350 .stop_tx = jsm_tty_stop_tx,
351 .start_tx = jsm_tty_start_tx,
352 .send_xchar = jsm_tty_send_xchar,
353 .stop_rx = jsm_tty_stop_rx,
354 .enable_ms = jsm_tty_enable_ms,
355 .break_ctl = jsm_tty_break,
356 .startup = jsm_tty_open,
357 .shutdown = jsm_tty_close,
358 .set_termios = jsm_tty_set_termios,
359 .type = jsm_tty_type,
360 .release_port = jsm_tty_release_port,
361 .request_port = jsm_tty_request_port,
362 .config_port = jsm_config_port,
363};
364
365
366
367
368
369
370
371int __devinit jsm_tty_init(struct jsm_board *brd)
372{
373 int i;
374 void __iomem *vaddr;
375 struct jsm_channel *ch;
376
377 if (!brd)
378 return -ENXIO;
379
380 jsm_printk(INIT, INFO, &brd->pci_dev, "start\n");
381
382
383
384
385
386 brd->nasync = brd->maxports;
387
388
389
390
391
392 for (i = 0; i < brd->nasync; i++) {
393 if (!brd->channels[i]) {
394
395
396
397
398
399 brd->channels[i] = kzalloc(sizeof(struct jsm_channel), GFP_KERNEL);
400 if (!brd->channels[i]) {
401 jsm_printk(CORE, ERR, &brd->pci_dev,
402 "%s:%d Unable to allocate memory for channel struct\n",
403 __FILE__, __LINE__);
404 }
405 }
406 }
407
408 ch = brd->channels[0];
409 vaddr = brd->re_map_membase;
410
411
412 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
413
414 if (!brd->channels[i])
415 continue;
416
417 spin_lock_init(&ch->ch_lock);
418
419 if (brd->bd_uart_offset == 0x200)
420 ch->ch_neo_uart = vaddr + (brd->bd_uart_offset * i);
421
422 ch->ch_bd = brd;
423 ch->ch_portnum = i;
424
425
426 ch->ch_close_delay = 250;
427
428 init_waitqueue_head(&ch->ch_flags_wait);
429 }
430
431 jsm_printk(INIT, INFO, &brd->pci_dev, "finish\n");
432 return 0;
433}
434
435int __devinit jsm_uart_port_init(struct jsm_board *brd)
436{
437 int i;
438 unsigned int line;
439 struct jsm_channel *ch;
440
441 if (!brd)
442 return -ENXIO;
443
444 jsm_printk(INIT, INFO, &brd->pci_dev, "start\n");
445
446
447
448
449
450 brd->nasync = brd->maxports;
451
452
453 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
454
455 if (!brd->channels[i])
456 continue;
457
458 brd->channels[i]->uart_port.irq = brd->irq;
459 brd->channels[i]->uart_port.uartclk = 14745600;
460 brd->channels[i]->uart_port.type = PORT_JSM;
461 brd->channels[i]->uart_port.iotype = UPIO_MEM;
462 brd->channels[i]->uart_port.membase = brd->re_map_membase;
463 brd->channels[i]->uart_port.fifosize = 16;
464 brd->channels[i]->uart_port.ops = &jsm_ops;
465 line = find_first_zero_bit(linemap, MAXLINES);
466 if (line >= MAXLINES) {
467 printk(KERN_INFO "jsm: linemap is full, added device failed\n");
468 continue;
469 } else
470 set_bit(line, linemap);
471 brd->channels[i]->uart_port.line = line;
472 if (uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port))
473 printk(KERN_INFO "jsm: add device failed\n");
474 else
475 printk(KERN_INFO "Added device \n");
476 }
477
478 jsm_printk(INIT, INFO, &brd->pci_dev, "finish\n");
479 return 0;
480}
481
482int jsm_remove_uart_port(struct jsm_board *brd)
483{
484 int i;
485 struct jsm_channel *ch;
486
487 if (!brd)
488 return -ENXIO;
489
490 jsm_printk(INIT, INFO, &brd->pci_dev, "start\n");
491
492
493
494
495
496 brd->nasync = brd->maxports;
497
498
499 for (i = 0; i < brd->nasync; i++) {
500
501 if (!brd->channels[i])
502 continue;
503
504 ch = brd->channels[i];
505
506 clear_bit(ch->uart_port.line, linemap);
507 uart_remove_one_port(&jsm_uart_driver, &brd->channels[i]->uart_port);
508 }
509
510 jsm_printk(INIT, INFO, &brd->pci_dev, "finish\n");
511 return 0;
512}
513
514void jsm_input(struct jsm_channel *ch)
515{
516 struct jsm_board *bd;
517 struct tty_struct *tp;
518 u32 rmask;
519 u16 head;
520 u16 tail;
521 int data_len;
522 unsigned long lock_flags;
523 int len = 0;
524 int n = 0;
525 int s = 0;
526 int i = 0;
527
528 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "start\n");
529
530 if (!ch)
531 return;
532
533 tp = ch->uart_port.state->port.tty;
534
535 bd = ch->ch_bd;
536 if(!bd)
537 return;
538
539 spin_lock_irqsave(&ch->ch_lock, lock_flags);
540
541
542
543
544
545
546 rmask = RQUEUEMASK;
547
548 head = ch->ch_r_head & rmask;
549 tail = ch->ch_r_tail & rmask;
550
551 data_len = (head - tail) & rmask;
552 if (data_len == 0) {
553 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
554 return;
555 }
556
557 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "start\n");
558
559
560
561
562
563 if (!tp ||
564 !(tp->termios->c_cflag & CREAD) ) {
565
566 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
567 "input. dropping %d bytes on port %d...\n", data_len, ch->ch_portnum);
568 ch->ch_r_head = tail;
569
570
571 jsm_check_queue_flow_control(ch);
572
573 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
574 return;
575 }
576
577
578
579
580 if (ch->ch_flags & CH_STOPI) {
581 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
582 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
583 "Port %d throttled, not reading any data. head: %x tail: %x\n",
584 ch->ch_portnum, head, tail);
585 return;
586 }
587
588 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "start 2\n");
589
590 if (data_len <= 0) {
591 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
592 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "jsm_input 1\n");
593 return;
594 }
595
596 len = tty_buffer_request_room(tp, data_len);
597 n = len;
598
599
600
601
602
603
604 while (n) {
605 s = ((head >= tail) ? head : RQUEUESIZE) - tail;
606 s = min(s, n);
607
608 if (s <= 0)
609 break;
610
611
612
613
614
615
616
617
618 if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
619 for (i = 0; i < s; i++) {
620
621
622
623
624 if (*(ch->ch_equeue +tail +i) & UART_LSR_BI)
625 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_BREAK);
626 else if (*(ch->ch_equeue +tail +i) & UART_LSR_PE)
627 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_PARITY);
628 else if (*(ch->ch_equeue +tail +i) & UART_LSR_FE)
629 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_FRAME);
630 else
631 tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_NORMAL);
632 }
633 } else {
634 tty_insert_flip_string(tp, ch->ch_rqueue + tail, s) ;
635 }
636 tail += s;
637 n -= s;
638
639 tail &= rmask;
640 }
641
642 ch->ch_r_tail = tail & rmask;
643 ch->ch_e_tail = tail & rmask;
644 jsm_check_queue_flow_control(ch);
645 spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
646
647
648 tty_flip_buffer_push(tp);
649
650 jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "finish\n");
651}
652
653static void jsm_carrier(struct jsm_channel *ch)
654{
655 struct jsm_board *bd;
656
657 int virt_carrier = 0;
658 int phys_carrier = 0;
659
660 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev, "start\n");
661 if (!ch)
662 return;
663
664 bd = ch->ch_bd;
665
666 if (!bd)
667 return;
668
669 if (ch->ch_mistat & UART_MSR_DCD) {
670 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
671 "mistat: %x D_CD: %x\n", ch->ch_mistat, ch->ch_mistat & UART_MSR_DCD);
672 phys_carrier = 1;
673 }
674
675 if (ch->ch_c_cflag & CLOCAL)
676 virt_carrier = 1;
677
678 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
679 "DCD: physical: %d virt: %d\n", phys_carrier, virt_carrier);
680
681
682
683
684 if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) {
685
686
687
688
689
690
691 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
692 "carrier: virt DCD rose\n");
693
694 if (waitqueue_active(&(ch->ch_flags_wait)))
695 wake_up_interruptible(&ch->ch_flags_wait);
696 }
697
698
699
700
701 if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) {
702
703
704
705
706
707
708 jsm_printk(CARR, INFO, &ch->ch_bd->pci_dev,
709 "carrier: physical DCD rose\n");
710
711 if (waitqueue_active(&(ch->ch_flags_wait)))
712 wake_up_interruptible(&ch->ch_flags_wait);
713 }
714
715
716
717
718
719
720
721
722
723
724 if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0)
725 && (phys_carrier == 0)) {
726
727
728
729
730
731
732
733
734
735
736
737
738 if (waitqueue_active(&(ch->ch_flags_wait)))
739 wake_up_interruptible(&ch->ch_flags_wait);
740 }
741
742
743
744
745 if (virt_carrier == 1)
746 ch->ch_flags |= CH_FCAR;
747 else
748 ch->ch_flags &= ~CH_FCAR;
749
750 if (phys_carrier == 1)
751 ch->ch_flags |= CH_CD;
752 else
753 ch->ch_flags &= ~CH_CD;
754}
755
756
757void jsm_check_queue_flow_control(struct jsm_channel *ch)
758{
759 struct board_ops *bd_ops = ch->ch_bd->bd_ops;
760 int qleft;
761
762
763 if ((qleft = ch->ch_r_tail - ch->ch_r_head - 1) < 0)
764 qleft += RQUEUEMASK + 1;
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781 if (qleft < 256) {
782
783 if (ch->ch_c_cflag & CRTSCTS) {
784 if(!(ch->ch_flags & CH_RECEIVER_OFF)) {
785 bd_ops->disable_receiver(ch);
786 ch->ch_flags |= (CH_RECEIVER_OFF);
787 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
788 "Internal queue hit hilevel mark (%d)! Turning off interrupts.\n",
789 qleft);
790 }
791 }
792
793 else if (ch->ch_c_iflag & IXOFF) {
794 if (ch->ch_stops_sent <= MAX_STOPS_SENT) {
795 bd_ops->send_stop_character(ch);
796 ch->ch_stops_sent++;
797 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
798 "Sending stop char! Times sent: %x\n", ch->ch_stops_sent);
799 }
800 }
801 }
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818 if (qleft > (RQUEUESIZE / 2)) {
819
820 if (ch->ch_c_cflag & CRTSCTS) {
821 if (ch->ch_flags & CH_RECEIVER_OFF) {
822 bd_ops->enable_receiver(ch);
823 ch->ch_flags &= ~(CH_RECEIVER_OFF);
824 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
825 "Internal queue hit lowlevel mark (%d)! Turning on interrupts.\n",
826 qleft);
827 }
828 }
829
830 else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) {
831 ch->ch_stops_sent = 0;
832 bd_ops->send_start_character(ch);
833 jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "Sending start char!\n");
834 }
835 }
836}
837
838
839
840
841
842
843
844int jsm_tty_write(struct uart_port *port)
845{
846 int bufcount;
847 int data_count = 0,data_count1 =0;
848 u16 head;
849 u16 tail;
850 u16 tmask;
851 u32 remain;
852 int temp_tail = port->state->xmit.tail;
853 struct jsm_channel *channel = (struct jsm_channel *)port;
854
855 tmask = WQUEUEMASK;
856 head = (channel->ch_w_head) & tmask;
857 tail = (channel->ch_w_tail) & tmask;
858
859 if ((bufcount = tail - head - 1) < 0)
860 bufcount += WQUEUESIZE;
861
862 bufcount = min(bufcount, 56);
863 remain = WQUEUESIZE - head;
864
865 data_count = 0;
866 if (bufcount >= remain) {
867 bufcount -= remain;
868 while ((port->state->xmit.head != temp_tail) &&
869 (data_count < remain)) {
870 channel->ch_wqueue[head++] =
871 port->state->xmit.buf[temp_tail];
872
873 temp_tail++;
874 temp_tail &= (UART_XMIT_SIZE - 1);
875 data_count++;
876 }
877 if (data_count == remain) head = 0;
878 }
879
880 data_count1 = 0;
881 if (bufcount > 0) {
882 remain = bufcount;
883 while ((port->state->xmit.head != temp_tail) &&
884 (data_count1 < remain)) {
885 channel->ch_wqueue[head++] =
886 port->state->xmit.buf[temp_tail];
887
888 temp_tail++;
889 temp_tail &= (UART_XMIT_SIZE - 1);
890 data_count1++;
891
892 }
893 }
894
895 port->state->xmit.tail = temp_tail;
896
897 data_count += data_count1;
898 if (data_count) {
899 head &= tmask;
900 channel->ch_w_head = head;
901 }
902
903 if (data_count) {
904 channel->ch_bd->bd_ops->copy_data_from_queue_to_uart(channel);
905 }
906
907 return data_count;
908}
909