V4L/DVB (4165): Add in tuner names
[linux-2.6] / drivers / serial / pmac_zilog.c
1 /*
2  * linux/drivers/serial/pmac_zilog.c
3  * 
4  * Driver for PowerMac Z85c30 based ESCC cell found in the
5  * "macio" ASICs of various PowerMac models
6  * 
7  * Copyright (C) 2003 Ben. Herrenschmidt (benh@kernel.crashing.org)
8  *
9  * Derived from drivers/macintosh/macserial.c by Paul Mackerras
10  * and drivers/serial/sunzilog.c by David S. Miller
11  *
12  * Hrm... actually, I ripped most of sunzilog (Thanks David !) and
13  * adapted special tweaks needed for us. I don't think it's worth
14  * merging back those though. The DMA code still has to get in
15  * and once done, I expect that driver to remain fairly stable in
16  * the long term, unless we change the driver model again...
17  *
18  * This program is free software; you can redistribute it and/or modify
19  * it under the terms of the GNU General Public License as published by
20  * the Free Software Foundation; either version 2 of the License, or
21  * (at your option) any later version.
22  *
23  * This program is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, write to the Free Software
30  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
31  *
32  * 2004-08-06 Harald Welte <laforge@gnumonks.org>
33  *      - Enable BREAK interrupt
34  *      - Add support for sysreq
35  *
36  * TODO:   - Add DMA support
37  *         - Defer port shutdown to a few seconds after close
38  *         - maybe put something right into uap->clk_divisor
39  */
40
41 #undef DEBUG
42 #undef DEBUG_HARD
43 #undef USE_CTRL_O_SYSRQ
44
45 #include <linux/config.h>
46 #include <linux/module.h>
47 #include <linux/tty.h>
48
49 #include <linux/tty_flip.h>
50 #include <linux/major.h>
51 #include <linux/string.h>
52 #include <linux/fcntl.h>
53 #include <linux/mm.h>
54 #include <linux/kernel.h>
55 #include <linux/delay.h>
56 #include <linux/init.h>
57 #include <linux/console.h>
58 #include <linux/slab.h>
59 #include <linux/adb.h>
60 #include <linux/pmu.h>
61 #include <linux/bitops.h>
62 #include <linux/sysrq.h>
63 #include <linux/mutex.h>
64 #include <asm/sections.h>
65 #include <asm/io.h>
66 #include <asm/irq.h>
67 #include <asm/prom.h>
68 #include <asm/machdep.h>
69 #include <asm/pmac_feature.h>
70 #include <asm/dbdma.h>
71 #include <asm/macio.h>
72
73 #if defined (CONFIG_SERIAL_PMACZILOG_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
74 #define SUPPORT_SYSRQ
75 #endif
76
77 #include <linux/serial.h>
78 #include <linux/serial_core.h>
79
80 #include "pmac_zilog.h"
81
82 /* Not yet implemented */
83 #undef HAS_DBDMA
84
85 static char version[] __initdata = "pmac_zilog: 0.6 (Benjamin Herrenschmidt <benh@kernel.crashing.org>)";
86 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
87 MODULE_DESCRIPTION("Driver for the PowerMac serial ports.");
88 MODULE_LICENSE("GPL");
89
90 #define PWRDBG(fmt, arg...)     printk(KERN_DEBUG fmt , ## arg)
91
92
93 /*
94  * For the sake of early serial console, we can do a pre-probe
95  * (optional) of the ports at rather early boot time.
96  */
97 static struct uart_pmac_port    pmz_ports[MAX_ZS_PORTS];
98 static int                      pmz_ports_count;
99 static DEFINE_MUTEX(pmz_irq_mutex);
100
101 static struct uart_driver pmz_uart_reg = {
102         .owner          =       THIS_MODULE,
103         .driver_name    =       "ttyS",
104         .devfs_name     =       "tts/",
105         .dev_name       =       "ttyS",
106         .major          =       TTY_MAJOR,
107 };
108
109
110 /* 
111  * Load all registers to reprogram the port
112  * This function must only be called when the TX is not busy.  The UART
113  * port lock must be held and local interrupts disabled.
114  */
115 static void pmz_load_zsregs(struct uart_pmac_port *uap, u8 *regs)
116 {
117         int i;
118
119         if (ZS_IS_ASLEEP(uap))
120                 return;
121
122         /* Let pending transmits finish.  */
123         for (i = 0; i < 1000; i++) {
124                 unsigned char stat = read_zsreg(uap, R1);
125                 if (stat & ALL_SNT)
126                         break;
127                 udelay(100);
128         }
129
130         ZS_CLEARERR(uap);
131         zssync(uap);
132         ZS_CLEARFIFO(uap);
133         zssync(uap);
134         ZS_CLEARERR(uap);
135
136         /* Disable all interrupts.  */
137         write_zsreg(uap, R1,
138                     regs[R1] & ~(RxINT_MASK | TxINT_ENAB | EXT_INT_ENAB));
139
140         /* Set parity, sync config, stop bits, and clock divisor.  */
141         write_zsreg(uap, R4, regs[R4]);
142
143         /* Set misc. TX/RX control bits.  */
144         write_zsreg(uap, R10, regs[R10]);
145
146         /* Set TX/RX controls sans the enable bits.  */
147         write_zsreg(uap, R3, regs[R3] & ~RxENABLE);
148         write_zsreg(uap, R5, regs[R5] & ~TxENABLE);
149
150         /* now set R7 "prime" on ESCC */
151         write_zsreg(uap, R15, regs[R15] | EN85C30);
152         write_zsreg(uap, R7, regs[R7P]);
153
154         /* make sure we use R7 "non-prime" on ESCC */
155         write_zsreg(uap, R15, regs[R15] & ~EN85C30);
156
157         /* Synchronous mode config.  */
158         write_zsreg(uap, R6, regs[R6]);
159         write_zsreg(uap, R7, regs[R7]);
160
161         /* Disable baud generator.  */
162         write_zsreg(uap, R14, regs[R14] & ~BRENAB);
163
164         /* Clock mode control.  */
165         write_zsreg(uap, R11, regs[R11]);
166
167         /* Lower and upper byte of baud rate generator divisor.  */
168         write_zsreg(uap, R12, regs[R12]);
169         write_zsreg(uap, R13, regs[R13]);
170         
171         /* Now rewrite R14, with BRENAB (if set).  */
172         write_zsreg(uap, R14, regs[R14]);
173
174         /* Reset external status interrupts.  */
175         write_zsreg(uap, R0, RES_EXT_INT);
176         write_zsreg(uap, R0, RES_EXT_INT);
177
178         /* Rewrite R3/R5, this time without enables masked.  */
179         write_zsreg(uap, R3, regs[R3]);
180         write_zsreg(uap, R5, regs[R5]);
181
182         /* Rewrite R1, this time without IRQ enabled masked.  */
183         write_zsreg(uap, R1, regs[R1]);
184
185         /* Enable interrupts */
186         write_zsreg(uap, R9, regs[R9]);
187 }
188
189 /* 
190  * We do like sunzilog to avoid disrupting pending Tx
191  * Reprogram the Zilog channel HW registers with the copies found in the
192  * software state struct.  If the transmitter is busy, we defer this update
193  * until the next TX complete interrupt.  Else, we do it right now.
194  *
195  * The UART port lock must be held and local interrupts disabled.
196  */
197 static void pmz_maybe_update_regs(struct uart_pmac_port *uap)
198 {
199         if (!ZS_REGS_HELD(uap)) {
200                 if (ZS_TX_ACTIVE(uap)) {
201                         uap->flags |= PMACZILOG_FLAG_REGS_HELD;
202                 } else {
203                         pmz_debug("pmz: maybe_update_regs: updating\n");
204                         pmz_load_zsregs(uap, uap->curregs);
205                 }
206         }
207 }
208
209 static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap,
210                                             struct pt_regs *regs)
211 {
212         struct tty_struct *tty = NULL;
213         unsigned char ch, r1, drop, error, flag;
214         int loops = 0;
215
216         /* The interrupt can be enabled when the port isn't open, typically
217          * that happens when using one port is open and the other closed (stale
218          * interrupt) or when one port is used as a console.
219          */
220         if (!ZS_IS_OPEN(uap)) {
221                 pmz_debug("pmz: draining input\n");
222                 /* Port is closed, drain input data */
223                 for (;;) {
224                         if ((++loops) > 1000)
225                                 goto flood;
226                         (void)read_zsreg(uap, R1);
227                         write_zsreg(uap, R0, ERR_RES);
228                         (void)read_zsdata(uap);
229                         ch = read_zsreg(uap, R0);
230                         if (!(ch & Rx_CH_AV))
231                                 break;
232                 }
233                 return NULL;
234         }
235
236         /* Sanity check, make sure the old bug is no longer happening */
237         if (uap->port.info == NULL || uap->port.info->tty == NULL) {
238                 WARN_ON(1);
239                 (void)read_zsdata(uap);
240                 return NULL;
241         }
242         tty = uap->port.info->tty;
243
244         while (1) {
245                 error = 0;
246                 drop = 0;
247
248                 r1 = read_zsreg(uap, R1);
249                 ch = read_zsdata(uap);
250
251                 if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR)) {
252                         write_zsreg(uap, R0, ERR_RES);
253                         zssync(uap);
254                 }
255
256                 ch &= uap->parity_mask;
257                 if (ch == 0 && uap->flags & PMACZILOG_FLAG_BREAK) {
258                         uap->flags &= ~PMACZILOG_FLAG_BREAK;
259                 }
260
261 #if defined(CONFIG_MAGIC_SYSRQ) && defined(CONFIG_SERIAL_CORE_CONSOLE)
262 #ifdef USE_CTRL_O_SYSRQ
263                 /* Handle the SysRq ^O Hack */
264                 if (ch == '\x0f') {
265                         uap->port.sysrq = jiffies + HZ*5;
266                         goto next_char;
267                 }
268 #endif /* USE_CTRL_O_SYSRQ */
269                 if (uap->port.sysrq) {
270                         int swallow;
271                         spin_unlock(&uap->port.lock);
272                         swallow = uart_handle_sysrq_char(&uap->port, ch, regs);
273                         spin_lock(&uap->port.lock);
274                         if (swallow)
275                                 goto next_char;
276                 }
277 #endif /* CONFIG_MAGIC_SYSRQ && CONFIG_SERIAL_CORE_CONSOLE */
278
279                 /* A real serial line, record the character and status.  */
280                 if (drop)
281                         goto next_char;
282
283                 flag = TTY_NORMAL;
284                 uap->port.icount.rx++;
285
286                 if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR | BRK_ABRT)) {
287                         error = 1;
288                         if (r1 & BRK_ABRT) {
289                                 pmz_debug("pmz: got break !\n");
290                                 r1 &= ~(PAR_ERR | CRC_ERR);
291                                 uap->port.icount.brk++;
292                                 if (uart_handle_break(&uap->port))
293                                         goto next_char;
294                         }
295                         else if (r1 & PAR_ERR)
296                                 uap->port.icount.parity++;
297                         else if (r1 & CRC_ERR)
298                                 uap->port.icount.frame++;
299                         if (r1 & Rx_OVR)
300                                 uap->port.icount.overrun++;
301                         r1 &= uap->port.read_status_mask;
302                         if (r1 & BRK_ABRT)
303                                 flag = TTY_BREAK;
304                         else if (r1 & PAR_ERR)
305                                 flag = TTY_PARITY;
306                         else if (r1 & CRC_ERR)
307                                 flag = TTY_FRAME;
308                 }
309
310                 if (uap->port.ignore_status_mask == 0xff ||
311                     (r1 & uap->port.ignore_status_mask) == 0) {
312                         tty_insert_flip_char(tty, ch, flag);
313                 }
314                 if (r1 & Rx_OVR)
315                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
316         next_char:
317                 /* We can get stuck in an infinite loop getting char 0 when the
318                  * line is in a wrong HW state, we break that here.
319                  * When that happens, I disable the receive side of the driver.
320                  * Note that what I've been experiencing is a real irq loop where
321                  * I'm getting flooded regardless of the actual port speed.
322                  * Something stange is going on with the HW
323                  */
324                 if ((++loops) > 1000)
325                         goto flood;
326                 ch = read_zsreg(uap, R0);
327                 if (!(ch & Rx_CH_AV))
328                         break;
329         }
330
331         return tty;
332  flood:
333         uap->curregs[R1] &= ~(EXT_INT_ENAB | TxINT_ENAB | RxINT_MASK);
334         write_zsreg(uap, R1, uap->curregs[R1]);
335         zssync(uap);
336         dev_err(&uap->dev->ofdev.dev, "pmz: rx irq flood !\n");
337         return tty;
338 }
339
340 static void pmz_status_handle(struct uart_pmac_port *uap, struct pt_regs *regs)
341 {
342         unsigned char status;
343
344         status = read_zsreg(uap, R0);
345         write_zsreg(uap, R0, RES_EXT_INT);
346         zssync(uap);
347
348         if (ZS_IS_OPEN(uap) && ZS_WANTS_MODEM_STATUS(uap)) {
349                 if (status & SYNC_HUNT)
350                         uap->port.icount.dsr++;
351
352                 /* The Zilog just gives us an interrupt when DCD/CTS/etc. change.
353                  * But it does not tell us which bit has changed, we have to keep
354                  * track of this ourselves.
355                  * The CTS input is inverted for some reason.  -- paulus
356                  */
357                 if ((status ^ uap->prev_status) & DCD)
358                         uart_handle_dcd_change(&uap->port,
359                                                (status & DCD));
360                 if ((status ^ uap->prev_status) & CTS)
361                         uart_handle_cts_change(&uap->port,
362                                                !(status & CTS));
363
364                 wake_up_interruptible(&uap->port.info->delta_msr_wait);
365         }
366
367         if (status & BRK_ABRT)
368                 uap->flags |= PMACZILOG_FLAG_BREAK;
369
370         uap->prev_status = status;
371 }
372
373 static void pmz_transmit_chars(struct uart_pmac_port *uap)
374 {
375         struct circ_buf *xmit;
376
377         if (ZS_IS_ASLEEP(uap))
378                 return;
379         if (ZS_IS_CONS(uap)) {
380                 unsigned char status = read_zsreg(uap, R0);
381
382                 /* TX still busy?  Just wait for the next TX done interrupt.
383                  *
384                  * It can occur because of how we do serial console writes.  It would
385                  * be nice to transmit console writes just like we normally would for
386                  * a TTY line. (ie. buffered and TX interrupt driven).  That is not
387                  * easy because console writes cannot sleep.  One solution might be
388                  * to poll on enough port->xmit space becomming free.  -DaveM
389                  */
390                 if (!(status & Tx_BUF_EMP))
391                         return;
392         }
393
394         uap->flags &= ~PMACZILOG_FLAG_TX_ACTIVE;
395
396         if (ZS_REGS_HELD(uap)) {
397                 pmz_load_zsregs(uap, uap->curregs);
398                 uap->flags &= ~PMACZILOG_FLAG_REGS_HELD;
399         }
400
401         if (ZS_TX_STOPPED(uap)) {
402                 uap->flags &= ~PMACZILOG_FLAG_TX_STOPPED;
403                 goto ack_tx_int;
404         }
405
406         if (uap->port.x_char) {
407                 uap->flags |= PMACZILOG_FLAG_TX_ACTIVE;
408                 write_zsdata(uap, uap->port.x_char);
409                 zssync(uap);
410                 uap->port.icount.tx++;
411                 uap->port.x_char = 0;
412                 return;
413         }
414
415         if (uap->port.info == NULL)
416                 goto ack_tx_int;
417         xmit = &uap->port.info->xmit;
418         if (uart_circ_empty(xmit)) {
419                 uart_write_wakeup(&uap->port);
420                 goto ack_tx_int;
421         }
422         if (uart_tx_stopped(&uap->port))
423                 goto ack_tx_int;
424
425         uap->flags |= PMACZILOG_FLAG_TX_ACTIVE;
426         write_zsdata(uap, xmit->buf[xmit->tail]);
427         zssync(uap);
428
429         xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
430         uap->port.icount.tx++;
431
432         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
433                 uart_write_wakeup(&uap->port);
434
435         return;
436
437 ack_tx_int:
438         write_zsreg(uap, R0, RES_Tx_P);
439         zssync(uap);
440 }
441
442 /* Hrm... we register that twice, fixme later.... */
443 static irqreturn_t pmz_interrupt(int irq, void *dev_id, struct pt_regs *regs)
444 {
445         struct uart_pmac_port *uap = dev_id;
446         struct uart_pmac_port *uap_a;
447         struct uart_pmac_port *uap_b;
448         int rc = IRQ_NONE;
449         struct tty_struct *tty;
450         u8 r3;
451
452         uap_a = pmz_get_port_A(uap);
453         uap_b = uap_a->mate;
454        
455         spin_lock(&uap_a->port.lock);
456         r3 = read_zsreg(uap_a, R3);
457
458 #ifdef DEBUG_HARD
459         pmz_debug("irq, r3: %x\n", r3);
460 #endif
461         /* Channel A */
462         tty = NULL;
463         if (r3 & (CHAEXT | CHATxIP | CHARxIP)) {
464                 write_zsreg(uap_a, R0, RES_H_IUS);
465                 zssync(uap_a);          
466                 if (r3 & CHAEXT)
467                         pmz_status_handle(uap_a, regs);
468                 if (r3 & CHARxIP)
469                         tty = pmz_receive_chars(uap_a, regs);
470                 if (r3 & CHATxIP)
471                         pmz_transmit_chars(uap_a);
472                 rc = IRQ_HANDLED;
473         }
474         spin_unlock(&uap_a->port.lock);
475         if (tty != NULL)
476                 tty_flip_buffer_push(tty);
477
478         if (uap_b->node == NULL)
479                 goto out;
480
481         spin_lock(&uap_b->port.lock);
482         tty = NULL;
483         if (r3 & (CHBEXT | CHBTxIP | CHBRxIP)) {
484                 write_zsreg(uap_b, R0, RES_H_IUS);
485                 zssync(uap_b);
486                 if (r3 & CHBEXT)
487                         pmz_status_handle(uap_b, regs);
488                 if (r3 & CHBRxIP)
489                         tty = pmz_receive_chars(uap_b, regs);
490                 if (r3 & CHBTxIP)
491                         pmz_transmit_chars(uap_b);
492                 rc = IRQ_HANDLED;
493         }
494         spin_unlock(&uap_b->port.lock);
495         if (tty != NULL)
496                 tty_flip_buffer_push(tty);
497
498  out:
499 #ifdef DEBUG_HARD
500         pmz_debug("irq done.\n");
501 #endif
502         return rc;
503 }
504
505 /*
506  * Peek the status register, lock not held by caller
507  */
508 static inline u8 pmz_peek_status(struct uart_pmac_port *uap)
509 {
510         unsigned long flags;
511         u8 status;
512         
513         spin_lock_irqsave(&uap->port.lock, flags);
514         status = read_zsreg(uap, R0);
515         spin_unlock_irqrestore(&uap->port.lock, flags);
516
517         return status;
518 }
519
520 /* 
521  * Check if transmitter is empty
522  * The port lock is not held.
523  */
524 static unsigned int pmz_tx_empty(struct uart_port *port)
525 {
526         struct uart_pmac_port *uap = to_pmz(port);
527         unsigned char status;
528
529         if (ZS_IS_ASLEEP(uap) || uap->node == NULL)
530                 return TIOCSER_TEMT;
531
532         status = pmz_peek_status(to_pmz(port));
533         if (status & Tx_BUF_EMP)
534                 return TIOCSER_TEMT;
535         return 0;
536 }
537
538 /* 
539  * Set Modem Control (RTS & DTR) bits
540  * The port lock is held and interrupts are disabled.
541  * Note: Shall we really filter out RTS on external ports or
542  * should that be dealt at higher level only ?
543  */
544 static void pmz_set_mctrl(struct uart_port *port, unsigned int mctrl)
545 {
546         struct uart_pmac_port *uap = to_pmz(port);
547         unsigned char set_bits, clear_bits;
548
549         /* Do nothing for irda for now... */
550         if (ZS_IS_IRDA(uap))
551                 return;
552         /* We get called during boot with a port not up yet */
553         if (ZS_IS_ASLEEP(uap) ||
554             !(ZS_IS_OPEN(uap) || ZS_IS_CONS(uap)))
555                 return;
556
557         set_bits = clear_bits = 0;
558
559         if (ZS_IS_INTMODEM(uap)) {
560                 if (mctrl & TIOCM_RTS)
561                         set_bits |= RTS;
562                 else
563                         clear_bits |= RTS;
564         }
565         if (mctrl & TIOCM_DTR)
566                 set_bits |= DTR;
567         else
568                 clear_bits |= DTR;
569
570         /* NOTE: Not subject to 'transmitter active' rule.  */ 
571         uap->curregs[R5] |= set_bits;
572         uap->curregs[R5] &= ~clear_bits;
573         if (ZS_IS_ASLEEP(uap))
574                 return;
575         write_zsreg(uap, R5, uap->curregs[R5]);
576         pmz_debug("pmz_set_mctrl: set bits: %x, clear bits: %x -> %x\n",
577                   set_bits, clear_bits, uap->curregs[R5]);
578         zssync(uap);
579 }
580
581 /* 
582  * Get Modem Control bits (only the input ones, the core will
583  * or that with a cached value of the control ones)
584  * The port lock is held and interrupts are disabled.
585  */
586 static unsigned int pmz_get_mctrl(struct uart_port *port)
587 {
588         struct uart_pmac_port *uap = to_pmz(port);
589         unsigned char status;
590         unsigned int ret;
591
592         if (ZS_IS_ASLEEP(uap) || uap->node == NULL)
593                 return 0;
594
595         status = read_zsreg(uap, R0);
596
597         ret = 0;
598         if (status & DCD)
599                 ret |= TIOCM_CAR;
600         if (status & SYNC_HUNT)
601                 ret |= TIOCM_DSR;
602         if (!(status & CTS))
603                 ret |= TIOCM_CTS;
604
605         return ret;
606 }
607
608 /* 
609  * Stop TX side. Dealt like sunzilog at next Tx interrupt,
610  * though for DMA, we will have to do a bit more.
611  * The port lock is held and interrupts are disabled.
612  */
613 static void pmz_stop_tx(struct uart_port *port)
614 {
615         to_pmz(port)->flags |= PMACZILOG_FLAG_TX_STOPPED;
616 }
617
618 /* 
619  * Kick the Tx side.
620  * The port lock is held and interrupts are disabled.
621  */
622 static void pmz_start_tx(struct uart_port *port)
623 {
624         struct uart_pmac_port *uap = to_pmz(port);
625         unsigned char status;
626
627         pmz_debug("pmz: start_tx()\n");
628
629         uap->flags |= PMACZILOG_FLAG_TX_ACTIVE;
630         uap->flags &= ~PMACZILOG_FLAG_TX_STOPPED;
631
632         if (ZS_IS_ASLEEP(uap) || uap->node == NULL)
633                 return;
634
635         status = read_zsreg(uap, R0);
636
637         /* TX busy?  Just wait for the TX done interrupt.  */
638         if (!(status & Tx_BUF_EMP))
639                 return;
640
641         /* Send the first character to jump-start the TX done
642          * IRQ sending engine.
643          */
644         if (port->x_char) {
645                 write_zsdata(uap, port->x_char);
646                 zssync(uap);
647                 port->icount.tx++;
648                 port->x_char = 0;
649         } else {
650                 struct circ_buf *xmit = &port->info->xmit;
651
652                 write_zsdata(uap, xmit->buf[xmit->tail]);
653                 zssync(uap);
654                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
655                 port->icount.tx++;
656
657                 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
658                         uart_write_wakeup(&uap->port);
659         }
660         pmz_debug("pmz: start_tx() done.\n");
661 }
662
663 /* 
664  * Stop Rx side, basically disable emitting of
665  * Rx interrupts on the port. We don't disable the rx
666  * side of the chip proper though
667  * The port lock is held.
668  */
669 static void pmz_stop_rx(struct uart_port *port)
670 {
671         struct uart_pmac_port *uap = to_pmz(port);
672
673         if (ZS_IS_ASLEEP(uap) || uap->node == NULL)
674                 return;
675
676         pmz_debug("pmz: stop_rx()()\n");
677
678         /* Disable all RX interrupts.  */
679         uap->curregs[R1] &= ~RxINT_MASK;
680         pmz_maybe_update_regs(uap);
681
682         pmz_debug("pmz: stop_rx() done.\n");
683 }
684
685 /* 
686  * Enable modem status change interrupts
687  * The port lock is held.
688  */
689 static void pmz_enable_ms(struct uart_port *port)
690 {
691         struct uart_pmac_port *uap = to_pmz(port);
692         unsigned char new_reg;
693
694         if (ZS_IS_IRDA(uap) || uap->node == NULL)
695                 return;
696         new_reg = uap->curregs[R15] | (DCDIE | SYNCIE | CTSIE);
697         if (new_reg != uap->curregs[R15]) {
698                 uap->curregs[R15] = new_reg;
699
700                 if (ZS_IS_ASLEEP(uap))
701                         return;
702                 /* NOTE: Not subject to 'transmitter active' rule.  */ 
703                 write_zsreg(uap, R15, uap->curregs[R15]);
704         }
705 }
706
707 /* 
708  * Control break state emission
709  * The port lock is not held.
710  */
711 static void pmz_break_ctl(struct uart_port *port, int break_state)
712 {
713         struct uart_pmac_port *uap = to_pmz(port);
714         unsigned char set_bits, clear_bits, new_reg;
715         unsigned long flags;
716
717         if (uap->node == NULL)
718                 return;
719         set_bits = clear_bits = 0;
720
721         if (break_state)
722                 set_bits |= SND_BRK;
723         else
724                 clear_bits |= SND_BRK;
725
726         spin_lock_irqsave(&port->lock, flags);
727
728         new_reg = (uap->curregs[R5] | set_bits) & ~clear_bits;
729         if (new_reg != uap->curregs[R5]) {
730                 uap->curregs[R5] = new_reg;
731
732                 /* NOTE: Not subject to 'transmitter active' rule.  */ 
733                 if (ZS_IS_ASLEEP(uap))
734                         return;
735                 write_zsreg(uap, R5, uap->curregs[R5]);
736         }
737
738         spin_unlock_irqrestore(&port->lock, flags);
739 }
740
741 /*
742  * Turn power on or off to the SCC and associated stuff
743  * (port drivers, modem, IR port, etc.)
744  * Returns the number of milliseconds we should wait before
745  * trying to use the port.
746  */
747 static int pmz_set_scc_power(struct uart_pmac_port *uap, int state)
748 {
749         int delay = 0;
750         int rc;
751
752         if (state) {
753                 rc = pmac_call_feature(
754                         PMAC_FTR_SCC_ENABLE, uap->node, uap->port_type, 1);
755                 pmz_debug("port power on result: %d\n", rc);
756                 if (ZS_IS_INTMODEM(uap)) {
757                         rc = pmac_call_feature(
758                                 PMAC_FTR_MODEM_ENABLE, uap->node, 0, 1);
759                         delay = 2500;   /* wait for 2.5s before using */
760                         pmz_debug("modem power result: %d\n", rc);
761                 }
762         } else {
763                 /* TODO: Make that depend on a timer, don't power down
764                  * immediately
765                  */
766                 if (ZS_IS_INTMODEM(uap)) {
767                         rc = pmac_call_feature(
768                                 PMAC_FTR_MODEM_ENABLE, uap->node, 0, 0);
769                         pmz_debug("port power off result: %d\n", rc);
770                 }
771                 pmac_call_feature(PMAC_FTR_SCC_ENABLE, uap->node, uap->port_type, 0);
772         }
773         return delay;
774 }
775
776 /*
777  * FixZeroBug....Works around a bug in the SCC receving channel.
778  * Inspired from Darwin code, 15 Sept. 2000  -DanM
779  *
780  * The following sequence prevents a problem that is seen with O'Hare ASICs
781  * (most versions -- also with some Heathrow and Hydra ASICs) where a zero
782  * at the input to the receiver becomes 'stuck' and locks up the receiver.
783  * This problem can occur as a result of a zero bit at the receiver input
784  * coincident with any of the following events:
785  *
786  *      The SCC is initialized (hardware or software).
787  *      A framing error is detected.
788  *      The clocking option changes from synchronous or X1 asynchronous
789  *              clocking to X16, X32, or X64 asynchronous clocking.
790  *      The decoding mode is changed among NRZ, NRZI, FM0, or FM1.
791  *
792  * This workaround attempts to recover from the lockup condition by placing
793  * the SCC in synchronous loopback mode with a fast clock before programming
794  * any of the asynchronous modes.
795  */
796 static void pmz_fix_zero_bug_scc(struct uart_pmac_port *uap)
797 {
798         write_zsreg(uap, 9, ZS_IS_CHANNEL_A(uap) ? CHRA : CHRB);
799         zssync(uap);
800         udelay(10);
801         write_zsreg(uap, 9, (ZS_IS_CHANNEL_A(uap) ? CHRA : CHRB) | NV);
802         zssync(uap);
803
804         write_zsreg(uap, 4, X1CLK | MONSYNC);
805         write_zsreg(uap, 3, Rx8);
806         write_zsreg(uap, 5, Tx8 | RTS);
807         write_zsreg(uap, 9, NV);        /* Didn't we already do this? */
808         write_zsreg(uap, 11, RCBR | TCBR);
809         write_zsreg(uap, 12, 0);
810         write_zsreg(uap, 13, 0);
811         write_zsreg(uap, 14, (LOOPBAK | BRSRC));
812         write_zsreg(uap, 14, (LOOPBAK | BRSRC | BRENAB));
813         write_zsreg(uap, 3, Rx8 | RxENABLE);
814         write_zsreg(uap, 0, RES_EXT_INT);
815         write_zsreg(uap, 0, RES_EXT_INT);
816         write_zsreg(uap, 0, RES_EXT_INT);       /* to kill some time */
817
818         /* The channel should be OK now, but it is probably receiving
819          * loopback garbage.
820          * Switch to asynchronous mode, disable the receiver,
821          * and discard everything in the receive buffer.
822          */
823         write_zsreg(uap, 9, NV);
824         write_zsreg(uap, 4, X16CLK | SB_MASK);
825         write_zsreg(uap, 3, Rx8);
826
827         while (read_zsreg(uap, 0) & Rx_CH_AV) {
828                 (void)read_zsreg(uap, 8);
829                 write_zsreg(uap, 0, RES_EXT_INT);
830                 write_zsreg(uap, 0, ERR_RES);
831         }
832 }
833
834 /*
835  * Real startup routine, powers up the hardware and sets up
836  * the SCC. Returns a delay in ms where you need to wait before
837  * actually using the port, this is typically the internal modem
838  * powerup delay. This routine expect the lock to be taken.
839  */
840 static int __pmz_startup(struct uart_pmac_port *uap)
841 {
842         int pwr_delay = 0;
843
844         memset(&uap->curregs, 0, sizeof(uap->curregs));
845
846         /* Power up the SCC & underlying hardware (modem/irda) */
847         pwr_delay = pmz_set_scc_power(uap, 1);
848
849         /* Nice buggy HW ... */
850         pmz_fix_zero_bug_scc(uap);
851
852         /* Reset the channel */
853         uap->curregs[R9] = 0;
854         write_zsreg(uap, 9, ZS_IS_CHANNEL_A(uap) ? CHRA : CHRB);
855         zssync(uap);
856         udelay(10);
857         write_zsreg(uap, 9, 0);
858         zssync(uap);
859
860         /* Clear the interrupt registers */
861         write_zsreg(uap, R1, 0);
862         write_zsreg(uap, R0, ERR_RES);
863         write_zsreg(uap, R0, ERR_RES);
864         write_zsreg(uap, R0, RES_H_IUS);
865         write_zsreg(uap, R0, RES_H_IUS);
866
867         /* Setup some valid baud rate */
868         uap->curregs[R4] = X16CLK | SB1;
869         uap->curregs[R3] = Rx8;
870         uap->curregs[R5] = Tx8 | RTS;
871         if (!ZS_IS_IRDA(uap))
872                 uap->curregs[R5] |= DTR;
873         uap->curregs[R12] = 0;
874         uap->curregs[R13] = 0;
875         uap->curregs[R14] = BRENAB;
876
877         /* Clear handshaking, enable BREAK interrupts */
878         uap->curregs[R15] = BRKIE;
879
880         /* Master interrupt enable */
881         uap->curregs[R9] |= NV | MIE;
882
883         pmz_load_zsregs(uap, uap->curregs);
884
885         /* Enable receiver and transmitter.  */
886         write_zsreg(uap, R3, uap->curregs[R3] |= RxENABLE);
887         write_zsreg(uap, R5, uap->curregs[R5] |= TxENABLE);
888
889         /* Remember status for DCD/CTS changes */
890         uap->prev_status = read_zsreg(uap, R0);
891
892
893         return pwr_delay;
894 }
895
896 static void pmz_irda_reset(struct uart_pmac_port *uap)
897 {
898         uap->curregs[R5] |= DTR;
899         write_zsreg(uap, R5, uap->curregs[R5]);
900         zssync(uap);
901         mdelay(110);
902         uap->curregs[R5] &= ~DTR;
903         write_zsreg(uap, R5, uap->curregs[R5]);
904         zssync(uap);
905         mdelay(10);
906 }
907
908 /*
909  * This is the "normal" startup routine, using the above one
910  * wrapped with the lock and doing a schedule delay
911  */
912 static int pmz_startup(struct uart_port *port)
913 {
914         struct uart_pmac_port *uap = to_pmz(port);
915         unsigned long flags;
916         int pwr_delay = 0;
917
918         pmz_debug("pmz: startup()\n");
919
920         if (ZS_IS_ASLEEP(uap))
921                 return -EAGAIN;
922         if (uap->node == NULL)
923                 return -ENODEV;
924
925         mutex_lock(&pmz_irq_mutex);
926
927         uap->flags |= PMACZILOG_FLAG_IS_OPEN;
928
929         /* A console is never powered down. Else, power up and
930          * initialize the chip
931          */
932         if (!ZS_IS_CONS(uap)) {
933                 spin_lock_irqsave(&port->lock, flags);
934                 pwr_delay = __pmz_startup(uap);
935                 spin_unlock_irqrestore(&port->lock, flags);
936         }       
937
938         pmz_get_port_A(uap)->flags |= PMACZILOG_FLAG_IS_IRQ_ON;
939         if (request_irq(uap->port.irq, pmz_interrupt, SA_SHIRQ, "PowerMac Zilog", uap)) {
940                 dev_err(&uap->dev->ofdev.dev,
941                         "Unable to register zs interrupt handler.\n");
942                 pmz_set_scc_power(uap, 0);
943                 mutex_unlock(&pmz_irq_mutex);
944                 return -ENXIO;
945         }
946
947         mutex_unlock(&pmz_irq_mutex);
948
949         /* Right now, we deal with delay by blocking here, I'll be
950          * smarter later on
951          */
952         if (pwr_delay != 0) {
953                 pmz_debug("pmz: delaying %d ms\n", pwr_delay);
954                 msleep(pwr_delay);
955         }
956
957         /* IrDA reset is done now */
958         if (ZS_IS_IRDA(uap))
959                 pmz_irda_reset(uap);
960
961         /* Enable interrupts emission from the chip */
962         spin_lock_irqsave(&port->lock, flags);
963         uap->curregs[R1] |= INT_ALL_Rx | TxINT_ENAB;
964         if (!ZS_IS_EXTCLK(uap))
965                 uap->curregs[R1] |= EXT_INT_ENAB;
966         write_zsreg(uap, R1, uap->curregs[R1]);
967         spin_unlock_irqrestore(&port->lock, flags);
968
969         pmz_debug("pmz: startup() done.\n");
970
971         return 0;
972 }
973
974 static void pmz_shutdown(struct uart_port *port)
975 {
976         struct uart_pmac_port *uap = to_pmz(port);
977         unsigned long flags;
978
979         pmz_debug("pmz: shutdown()\n");
980
981         if (uap->node == NULL)
982                 return;
983
984         mutex_lock(&pmz_irq_mutex);
985
986         /* Release interrupt handler */
987         free_irq(uap->port.irq, uap);
988
989         spin_lock_irqsave(&port->lock, flags);
990
991         uap->flags &= ~PMACZILOG_FLAG_IS_OPEN;
992
993         if (!ZS_IS_OPEN(uap->mate))
994                 pmz_get_port_A(uap)->flags &= ~PMACZILOG_FLAG_IS_IRQ_ON;
995
996         /* Disable interrupts */
997         if (!ZS_IS_ASLEEP(uap)) {
998                 uap->curregs[R1] &= ~(EXT_INT_ENAB | TxINT_ENAB | RxINT_MASK);
999                 write_zsreg(uap, R1, uap->curregs[R1]);
1000                 zssync(uap);
1001         }
1002
1003         if (ZS_IS_CONS(uap) || ZS_IS_ASLEEP(uap)) {
1004                 spin_unlock_irqrestore(&port->lock, flags);
1005                 mutex_unlock(&pmz_irq_mutex);
1006                 return;
1007         }
1008
1009         /* Disable receiver and transmitter.  */
1010         uap->curregs[R3] &= ~RxENABLE;
1011         uap->curregs[R5] &= ~TxENABLE;
1012
1013         /* Disable all interrupts and BRK assertion.  */
1014         uap->curregs[R5] &= ~SND_BRK;
1015         pmz_maybe_update_regs(uap);
1016
1017         /* Shut the chip down */
1018         pmz_set_scc_power(uap, 0);
1019
1020         spin_unlock_irqrestore(&port->lock, flags);
1021
1022         mutex_unlock(&pmz_irq_mutex);
1023
1024         pmz_debug("pmz: shutdown() done.\n");
1025 }
1026
1027 /* Shared by TTY driver and serial console setup.  The port lock is held
1028  * and local interrupts are disabled.
1029  */
1030 static void pmz_convert_to_zs(struct uart_pmac_port *uap, unsigned int cflag,
1031                               unsigned int iflag, unsigned long baud)
1032 {
1033         int brg;
1034
1035
1036         /* Switch to external clocking for IrDA high clock rates. That
1037          * code could be re-used for Midi interfaces with different
1038          * multipliers
1039          */
1040         if (baud >= 115200 && ZS_IS_IRDA(uap)) {
1041                 uap->curregs[R4] = X1CLK;
1042                 uap->curregs[R11] = RCTRxCP | TCTRxCP;
1043                 uap->curregs[R14] = 0; /* BRG off */
1044                 uap->curregs[R12] = 0;
1045                 uap->curregs[R13] = 0;
1046                 uap->flags |= PMACZILOG_FLAG_IS_EXTCLK;
1047         } else {
1048                 switch (baud) {
1049                 case ZS_CLOCK/16:       /* 230400 */
1050                         uap->curregs[R4] = X16CLK;
1051                         uap->curregs[R11] = 0;
1052                         uap->curregs[R14] = 0;
1053                         break;
1054                 case ZS_CLOCK/32:       /* 115200 */
1055                         uap->curregs[R4] = X32CLK;
1056                         uap->curregs[R11] = 0;
1057                         uap->curregs[R14] = 0;
1058                         break;
1059                 default:
1060                         uap->curregs[R4] = X16CLK;
1061                         uap->curregs[R11] = TCBR | RCBR;
1062                         brg = BPS_TO_BRG(baud, ZS_CLOCK / 16);
1063                         uap->curregs[R12] = (brg & 255);
1064                         uap->curregs[R13] = ((brg >> 8) & 255);
1065                         uap->curregs[R14] = BRENAB;
1066                 }
1067                 uap->flags &= ~PMACZILOG_FLAG_IS_EXTCLK;
1068         }
1069
1070         /* Character size, stop bits, and parity. */
1071         uap->curregs[3] &= ~RxN_MASK;
1072         uap->curregs[5] &= ~TxN_MASK;
1073
1074         switch (cflag & CSIZE) {
1075         case CS5:
1076                 uap->curregs[3] |= Rx5;
1077                 uap->curregs[5] |= Tx5;
1078                 uap->parity_mask = 0x1f;
1079                 break;
1080         case CS6:
1081                 uap->curregs[3] |= Rx6;
1082                 uap->curregs[5] |= Tx6;
1083                 uap->parity_mask = 0x3f;
1084                 break;
1085         case CS7:
1086                 uap->curregs[3] |= Rx7;
1087                 uap->curregs[5] |= Tx7;
1088                 uap->parity_mask = 0x7f;
1089                 break;
1090         case CS8:
1091         default:
1092                 uap->curregs[3] |= Rx8;
1093                 uap->curregs[5] |= Tx8;
1094                 uap->parity_mask = 0xff;
1095                 break;
1096         };
1097         uap->curregs[4] &= ~(SB_MASK);
1098         if (cflag & CSTOPB)
1099                 uap->curregs[4] |= SB2;
1100         else
1101                 uap->curregs[4] |= SB1;
1102         if (cflag & PARENB)
1103                 uap->curregs[4] |= PAR_ENAB;
1104         else
1105                 uap->curregs[4] &= ~PAR_ENAB;
1106         if (!(cflag & PARODD))
1107                 uap->curregs[4] |= PAR_EVEN;
1108         else
1109                 uap->curregs[4] &= ~PAR_EVEN;
1110
1111         uap->port.read_status_mask = Rx_OVR;
1112         if (iflag & INPCK)
1113                 uap->port.read_status_mask |= CRC_ERR | PAR_ERR;
1114         if (iflag & (BRKINT | PARMRK))
1115                 uap->port.read_status_mask |= BRK_ABRT;
1116
1117         uap->port.ignore_status_mask = 0;
1118         if (iflag & IGNPAR)
1119                 uap->port.ignore_status_mask |= CRC_ERR | PAR_ERR;
1120         if (iflag & IGNBRK) {
1121                 uap->port.ignore_status_mask |= BRK_ABRT;
1122                 if (iflag & IGNPAR)
1123                         uap->port.ignore_status_mask |= Rx_OVR;
1124         }
1125
1126         if ((cflag & CREAD) == 0)
1127                 uap->port.ignore_status_mask = 0xff;
1128 }
1129
1130
1131 /*
1132  * Set the irda codec on the imac to the specified baud rate.
1133  */
1134 static void pmz_irda_setup(struct uart_pmac_port *uap, unsigned long *baud)
1135 {
1136         u8 cmdbyte;
1137         int t, version;
1138
1139         switch (*baud) {
1140         /* SIR modes */
1141         case 2400:
1142                 cmdbyte = 0x53;
1143                 break;
1144         case 4800:
1145                 cmdbyte = 0x52;
1146                 break;
1147         case 9600:
1148                 cmdbyte = 0x51;
1149                 break;
1150         case 19200:
1151                 cmdbyte = 0x50;
1152                 break;
1153         case 38400:
1154                 cmdbyte = 0x4f;
1155                 break;
1156         case 57600:
1157                 cmdbyte = 0x4e;
1158                 break;
1159         case 115200:
1160                 cmdbyte = 0x4d;
1161                 break;
1162         /* The FIR modes aren't really supported at this point, how
1163          * do we select the speed ? via the FCR on KeyLargo ?
1164          */
1165         case 1152000:
1166                 cmdbyte = 0;
1167                 break;
1168         case 4000000:
1169                 cmdbyte = 0;
1170                 break;
1171         default: /* 9600 */
1172                 cmdbyte = 0x51;
1173                 *baud = 9600;
1174                 break;
1175         }
1176
1177         /* Wait for transmitter to drain */
1178         t = 10000;
1179         while ((read_zsreg(uap, R0) & Tx_BUF_EMP) == 0
1180                || (read_zsreg(uap, R1) & ALL_SNT) == 0) {
1181                 if (--t <= 0) {
1182                         dev_err(&uap->dev->ofdev.dev, "transmitter didn't drain\n");
1183                         return;
1184                 }
1185                 udelay(10);
1186         }
1187
1188         /* Drain the receiver too */
1189         t = 100;
1190         (void)read_zsdata(uap);
1191         (void)read_zsdata(uap);
1192         (void)read_zsdata(uap);
1193         mdelay(10);
1194         while (read_zsreg(uap, R0) & Rx_CH_AV) {
1195                 read_zsdata(uap);
1196                 mdelay(10);
1197                 if (--t <= 0) {
1198                         dev_err(&uap->dev->ofdev.dev, "receiver didn't drain\n");
1199                         return;
1200                 }
1201         }
1202
1203         /* Switch to command mode */
1204         uap->curregs[R5] |= DTR;
1205         write_zsreg(uap, R5, uap->curregs[R5]);
1206         zssync(uap);
1207         mdelay(1);
1208
1209         /* Switch SCC to 19200 */
1210         pmz_convert_to_zs(uap, CS8, 0, 19200);          
1211         pmz_load_zsregs(uap, uap->curregs);
1212         mdelay(1);
1213
1214         /* Write get_version command byte */
1215         write_zsdata(uap, 1);
1216         t = 5000;
1217         while ((read_zsreg(uap, R0) & Rx_CH_AV) == 0) {
1218                 if (--t <= 0) {
1219                         dev_err(&uap->dev->ofdev.dev,
1220                                 "irda_setup timed out on get_version byte\n");
1221                         goto out;
1222                 }
1223                 udelay(10);
1224         }
1225         version = read_zsdata(uap);
1226
1227         if (version < 4) {
1228                 dev_info(&uap->dev->ofdev.dev, "IrDA: dongle version %d not supported\n",
1229                          version);
1230                 goto out;
1231         }
1232
1233         /* Send speed mode */
1234         write_zsdata(uap, cmdbyte);
1235         t = 5000;
1236         while ((read_zsreg(uap, R0) & Rx_CH_AV) == 0) {
1237                 if (--t <= 0) {
1238                         dev_err(&uap->dev->ofdev.dev,
1239                                 "irda_setup timed out on speed mode byte\n");
1240                         goto out;
1241                 }
1242                 udelay(10);
1243         }
1244         t = read_zsdata(uap);
1245         if (t != cmdbyte)
1246                 dev_err(&uap->dev->ofdev.dev,
1247                         "irda_setup speed mode byte = %x (%x)\n", t, cmdbyte);
1248
1249         dev_info(&uap->dev->ofdev.dev, "IrDA setup for %ld bps, dongle version: %d\n",
1250                  *baud, version);
1251
1252         (void)read_zsdata(uap);
1253         (void)read_zsdata(uap);
1254         (void)read_zsdata(uap);
1255
1256  out:
1257         /* Switch back to data mode */
1258         uap->curregs[R5] &= ~DTR;
1259         write_zsreg(uap, R5, uap->curregs[R5]);
1260         zssync(uap);
1261
1262         (void)read_zsdata(uap);
1263         (void)read_zsdata(uap);
1264         (void)read_zsdata(uap);
1265 }
1266
1267
1268 static void __pmz_set_termios(struct uart_port *port, struct termios *termios,
1269                               struct termios *old)
1270 {
1271         struct uart_pmac_port *uap = to_pmz(port);
1272         unsigned long baud;
1273
1274         pmz_debug("pmz: set_termios()\n");
1275
1276         if (ZS_IS_ASLEEP(uap))
1277                 return;
1278
1279         memcpy(&uap->termios_cache, termios, sizeof(struct termios));
1280
1281         /* XXX Check which revs of machines actually allow 1 and 4Mb speeds
1282          * on the IR dongle. Note that the IRTTY driver currently doesn't know
1283          * about the FIR mode and high speed modes. So these are unused. For
1284          * implementing proper support for these, we should probably add some
1285          * DMA as well, at least on the Rx side, which isn't a simple thing
1286          * at this point.
1287          */
1288         if (ZS_IS_IRDA(uap)) {
1289                 /* Calc baud rate */
1290                 baud = uart_get_baud_rate(port, termios, old, 1200, 4000000);
1291                 pmz_debug("pmz: switch IRDA to %ld bauds\n", baud);
1292                 /* Cet the irda codec to the right rate */
1293                 pmz_irda_setup(uap, &baud);
1294                 /* Set final baud rate */
1295                 pmz_convert_to_zs(uap, termios->c_cflag, termios->c_iflag, baud);
1296                 pmz_load_zsregs(uap, uap->curregs);
1297                 zssync(uap);
1298         } else {
1299                 baud = uart_get_baud_rate(port, termios, old, 1200, 230400);
1300                 pmz_convert_to_zs(uap, termios->c_cflag, termios->c_iflag, baud);
1301                 /* Make sure modem status interrupts are correctly configured */
1302                 if (UART_ENABLE_MS(&uap->port, termios->c_cflag)) {
1303                         uap->curregs[R15] |= DCDIE | SYNCIE | CTSIE;
1304                         uap->flags |= PMACZILOG_FLAG_MODEM_STATUS;
1305                 } else {
1306                         uap->curregs[R15] &= ~(DCDIE | SYNCIE | CTSIE);
1307                         uap->flags &= ~PMACZILOG_FLAG_MODEM_STATUS;
1308                 }
1309
1310                 /* Load registers to the chip */
1311                 pmz_maybe_update_regs(uap);
1312         }
1313         uart_update_timeout(port, termios->c_cflag, baud);
1314
1315         pmz_debug("pmz: set_termios() done.\n");
1316 }
1317
1318 /* The port lock is not held.  */
1319 static void pmz_set_termios(struct uart_port *port, struct termios *termios,
1320                             struct termios *old)
1321 {
1322         struct uart_pmac_port *uap = to_pmz(port);
1323         unsigned long flags;
1324
1325         spin_lock_irqsave(&port->lock, flags);  
1326
1327         /* Disable IRQs on the port */
1328         uap->curregs[R1] &= ~(EXT_INT_ENAB | TxINT_ENAB | RxINT_MASK);
1329         write_zsreg(uap, R1, uap->curregs[R1]);
1330
1331         /* Setup new port configuration */
1332         __pmz_set_termios(port, termios, old);
1333
1334         /* Re-enable IRQs on the port */
1335         if (ZS_IS_OPEN(uap)) {
1336                 uap->curregs[R1] |= INT_ALL_Rx | TxINT_ENAB;
1337                 if (!ZS_IS_EXTCLK(uap))
1338                         uap->curregs[R1] |= EXT_INT_ENAB;
1339                 write_zsreg(uap, R1, uap->curregs[R1]);
1340         }
1341         spin_unlock_irqrestore(&port->lock, flags);
1342 }
1343
1344 static const char *pmz_type(struct uart_port *port)
1345 {
1346         struct uart_pmac_port *uap = to_pmz(port);
1347
1348         if (ZS_IS_IRDA(uap))
1349                 return "Z85c30 ESCC - Infrared port";
1350         else if (ZS_IS_INTMODEM(uap))
1351                 return "Z85c30 ESCC - Internal modem";
1352         return "Z85c30 ESCC - Serial port";
1353 }
1354
1355 /* We do not request/release mappings of the registers here, this
1356  * happens at early serial probe time.
1357  */
1358 static void pmz_release_port(struct uart_port *port)
1359 {
1360 }
1361
1362 static int pmz_request_port(struct uart_port *port)
1363 {
1364         return 0;
1365 }
1366
1367 /* These do not need to do anything interesting either.  */
1368 static void pmz_config_port(struct uart_port *port, int flags)
1369 {
1370 }
1371
1372 /* We do not support letting the user mess with the divisor, IRQ, etc. */
1373 static int pmz_verify_port(struct uart_port *port, struct serial_struct *ser)
1374 {
1375         return -EINVAL;
1376 }
1377
1378 static struct uart_ops pmz_pops = {
1379         .tx_empty       =       pmz_tx_empty,
1380         .set_mctrl      =       pmz_set_mctrl,
1381         .get_mctrl      =       pmz_get_mctrl,
1382         .stop_tx        =       pmz_stop_tx,
1383         .start_tx       =       pmz_start_tx,
1384         .stop_rx        =       pmz_stop_rx,
1385         .enable_ms      =       pmz_enable_ms,
1386         .break_ctl      =       pmz_break_ctl,
1387         .startup        =       pmz_startup,
1388         .shutdown       =       pmz_shutdown,
1389         .set_termios    =       pmz_set_termios,
1390         .type           =       pmz_type,
1391         .release_port   =       pmz_release_port,
1392         .request_port   =       pmz_request_port,
1393         .config_port    =       pmz_config_port,
1394         .verify_port    =       pmz_verify_port,
1395 };
1396
1397 /*
1398  * Setup one port structure after probing, HW is down at this point,
1399  * Unlike sunzilog, we don't need to pre-init the spinlock as we don't
1400  * register our console before uart_add_one_port() is called
1401  */
1402 static int __init pmz_init_port(struct uart_pmac_port *uap)
1403 {
1404         struct device_node *np = uap->node;
1405         char *conn;
1406         struct slot_names_prop {
1407                 int     count;
1408                 char    name[1];
1409         } *slots;
1410         int len;
1411         struct resource r_ports, r_rxdma, r_txdma;
1412
1413         /*
1414          * Request & map chip registers
1415          */
1416         if (of_address_to_resource(np, 0, &r_ports))
1417                 return -ENODEV;
1418         uap->port.mapbase = r_ports.start;
1419         uap->port.membase = ioremap(uap->port.mapbase, 0x1000);
1420       
1421         uap->control_reg = uap->port.membase;
1422         uap->data_reg = uap->control_reg + 0x10;
1423         
1424         /*
1425          * Request & map DBDMA registers
1426          */
1427 #ifdef HAS_DBDMA
1428         if (of_address_to_resource(np, 1, &r_txdma) == 0 &&
1429             of_address_to_resource(np, 2, &r_rxdma) == 0)
1430                 uap->flags |= PMACZILOG_FLAG_HAS_DMA;
1431 #else
1432         memset(&r_txdma, 0, sizeof(struct resource));
1433         memset(&r_rxdma, 0, sizeof(struct resource));
1434 #endif  
1435         if (ZS_HAS_DMA(uap)) {
1436                 uap->tx_dma_regs = ioremap(r_txdma.start, 0x100);
1437                 if (uap->tx_dma_regs == NULL) { 
1438                         uap->flags &= ~PMACZILOG_FLAG_HAS_DMA;
1439                         goto no_dma;
1440                 }
1441                 uap->rx_dma_regs = ioremap(r_rxdma.start, 0x100);
1442                 if (uap->rx_dma_regs == NULL) { 
1443                         iounmap(uap->tx_dma_regs);
1444                         uap->tx_dma_regs = NULL;
1445                         uap->flags &= ~PMACZILOG_FLAG_HAS_DMA;
1446                         goto no_dma;
1447                 }
1448                 uap->tx_dma_irq = np->intrs[1].line;
1449                 uap->rx_dma_irq = np->intrs[2].line;
1450         }
1451 no_dma:
1452
1453         /*
1454          * Detect port type
1455          */
1456         if (device_is_compatible(np, "cobalt"))
1457                 uap->flags |= PMACZILOG_FLAG_IS_INTMODEM;
1458         conn = get_property(np, "AAPL,connector", &len);
1459         if (conn && (strcmp(conn, "infrared") == 0))
1460                 uap->flags |= PMACZILOG_FLAG_IS_IRDA;
1461         uap->port_type = PMAC_SCC_ASYNC;
1462         /* 1999 Powerbook G3 has slot-names property instead */
1463         slots = (struct slot_names_prop *)get_property(np, "slot-names", &len);
1464         if (slots && slots->count > 0) {
1465                 if (strcmp(slots->name, "IrDA") == 0)
1466                         uap->flags |= PMACZILOG_FLAG_IS_IRDA;
1467                 else if (strcmp(slots->name, "Modem") == 0)
1468                         uap->flags |= PMACZILOG_FLAG_IS_INTMODEM;
1469         }
1470         if (ZS_IS_IRDA(uap))
1471                 uap->port_type = PMAC_SCC_IRDA;
1472         if (ZS_IS_INTMODEM(uap)) {
1473                 struct device_node* i2c_modem = find_devices("i2c-modem");
1474                 if (i2c_modem) {
1475                         char* mid = get_property(i2c_modem, "modem-id", NULL);
1476                         if (mid) switch(*mid) {
1477                         case 0x04 :
1478                         case 0x05 :
1479                         case 0x07 :
1480                         case 0x08 :
1481                         case 0x0b :
1482                         case 0x0c :
1483                                 uap->port_type = PMAC_SCC_I2S1;
1484                         }
1485                         printk(KERN_INFO "pmac_zilog: i2c-modem detected, id: %d\n",
1486                                 mid ? (*mid) : 0);
1487                 } else {
1488                         printk(KERN_INFO "pmac_zilog: serial modem detected\n");
1489                 }
1490         }
1491
1492         /*
1493          * Init remaining bits of "port" structure
1494          */
1495         uap->port.iotype = UPIO_MEM;
1496         uap->port.irq = np->intrs[0].line;
1497         uap->port.uartclk = ZS_CLOCK;
1498         uap->port.fifosize = 1;
1499         uap->port.ops = &pmz_pops;
1500         uap->port.type = PORT_PMAC_ZILOG;
1501         uap->port.flags = 0;
1502
1503         /* Setup some valid baud rate information in the register
1504          * shadows so we don't write crap there before baud rate is
1505          * first initialized.
1506          */
1507         pmz_convert_to_zs(uap, CS8, 0, 9600);
1508
1509         return 0;
1510 }
1511
1512 /*
1513  * Get rid of a port on module removal
1514  */
1515 static void pmz_dispose_port(struct uart_pmac_port *uap)
1516 {
1517         struct device_node *np;
1518
1519         np = uap->node;
1520         iounmap(uap->rx_dma_regs);
1521         iounmap(uap->tx_dma_regs);
1522         iounmap(uap->control_reg);
1523         uap->node = NULL;
1524         of_node_put(np);
1525         memset(uap, 0, sizeof(struct uart_pmac_port));
1526 }
1527
1528 /*
1529  * Called upon match with an escc node in the devive-tree.
1530  */
1531 static int pmz_attach(struct macio_dev *mdev, const struct of_device_id *match)
1532 {
1533         int i;
1534         
1535         /* Iterate the pmz_ports array to find a matching entry
1536          */
1537         for (i = 0; i < MAX_ZS_PORTS; i++)
1538                 if (pmz_ports[i].node == mdev->ofdev.node) {
1539                         struct uart_pmac_port *uap = &pmz_ports[i];
1540
1541                         uap->dev = mdev;
1542                         dev_set_drvdata(&mdev->ofdev.dev, uap);
1543                         if (macio_request_resources(uap->dev, "pmac_zilog"))
1544                                 printk(KERN_WARNING "%s: Failed to request resource"
1545                                        ", port still active\n",
1546                                        uap->node->name);
1547                         else
1548                                 uap->flags |= PMACZILOG_FLAG_RSRC_REQUESTED;                            
1549                         return 0;
1550                 }
1551         return -ENODEV;
1552 }
1553
1554 /*
1555  * That one should not be called, macio isn't really a hotswap device,
1556  * we don't expect one of those serial ports to go away...
1557  */
1558 static int pmz_detach(struct macio_dev *mdev)
1559 {
1560         struct uart_pmac_port   *uap = dev_get_drvdata(&mdev->ofdev.dev);
1561         
1562         if (!uap)
1563                 return -ENODEV;
1564
1565         if (uap->flags & PMACZILOG_FLAG_RSRC_REQUESTED) {
1566                 macio_release_resources(uap->dev);
1567                 uap->flags &= ~PMACZILOG_FLAG_RSRC_REQUESTED;
1568         }
1569         dev_set_drvdata(&mdev->ofdev.dev, NULL);
1570         uap->dev = NULL;
1571         
1572         return 0;
1573 }
1574
1575
1576 static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
1577 {
1578         struct uart_pmac_port *uap = dev_get_drvdata(&mdev->ofdev.dev);
1579         struct uart_state *state;
1580         unsigned long flags;
1581
1582         if (uap == NULL) {
1583                 printk("HRM... pmz_suspend with NULL uap\n");
1584                 return 0;
1585         }
1586
1587         if (pm_state.event == mdev->ofdev.dev.power.power_state.event)
1588                 return 0;
1589
1590         pmz_debug("suspend, switching to state %d\n", pm_state);
1591
1592         state = pmz_uart_reg.state + uap->port.line;
1593
1594         mutex_lock(&pmz_irq_mutex);
1595         mutex_lock(&state->mutex);
1596
1597         spin_lock_irqsave(&uap->port.lock, flags);
1598
1599         if (ZS_IS_OPEN(uap) || ZS_IS_CONS(uap)) {
1600                 /* Disable receiver and transmitter.  */
1601                 uap->curregs[R3] &= ~RxENABLE;
1602                 uap->curregs[R5] &= ~TxENABLE;
1603
1604                 /* Disable all interrupts and BRK assertion.  */
1605                 uap->curregs[R1] &= ~(EXT_INT_ENAB | TxINT_ENAB | RxINT_MASK);
1606                 uap->curregs[R5] &= ~SND_BRK;
1607                 pmz_load_zsregs(uap, uap->curregs);
1608                 uap->flags |= PMACZILOG_FLAG_IS_ASLEEP;
1609                 mb();
1610         }
1611
1612         spin_unlock_irqrestore(&uap->port.lock, flags);
1613
1614         if (ZS_IS_OPEN(uap) || ZS_IS_OPEN(uap->mate))
1615                 if (ZS_IS_ASLEEP(uap->mate) && ZS_IS_IRQ_ON(pmz_get_port_A(uap))) {
1616                         pmz_get_port_A(uap)->flags &= ~PMACZILOG_FLAG_IS_IRQ_ON;
1617                         disable_irq(uap->port.irq);
1618                 }
1619
1620         if (ZS_IS_CONS(uap))
1621                 uap->port.cons->flags &= ~CON_ENABLED;
1622
1623         /* Shut the chip down */
1624         pmz_set_scc_power(uap, 0);
1625
1626         mutex_unlock(&state->mutex);
1627         mutex_unlock(&pmz_irq_mutex);
1628
1629         pmz_debug("suspend, switching complete\n");
1630
1631         mdev->ofdev.dev.power.power_state = pm_state;
1632
1633         return 0;
1634 }
1635
1636
1637 static int pmz_resume(struct macio_dev *mdev)
1638 {
1639         struct uart_pmac_port *uap = dev_get_drvdata(&mdev->ofdev.dev);
1640         struct uart_state *state;
1641         unsigned long flags;
1642         int pwr_delay = 0;
1643
1644         if (uap == NULL)
1645                 return 0;
1646
1647         if (mdev->ofdev.dev.power.power_state.event == PM_EVENT_ON)
1648                 return 0;
1649         
1650         pmz_debug("resume, switching to state 0\n");
1651
1652         state = pmz_uart_reg.state + uap->port.line;
1653
1654         mutex_lock(&pmz_irq_mutex);
1655         mutex_lock(&state->mutex);
1656
1657         spin_lock_irqsave(&uap->port.lock, flags);
1658         if (!ZS_IS_OPEN(uap) && !ZS_IS_CONS(uap)) {
1659                 spin_unlock_irqrestore(&uap->port.lock, flags);
1660                 goto bail;
1661         }
1662         pwr_delay = __pmz_startup(uap);
1663
1664         /* Take care of config that may have changed while asleep */
1665         __pmz_set_termios(&uap->port, &uap->termios_cache, NULL);
1666
1667         if (ZS_IS_OPEN(uap)) {
1668                 /* Enable interrupts */         
1669                 uap->curregs[R1] |= INT_ALL_Rx | TxINT_ENAB;
1670                 if (!ZS_IS_EXTCLK(uap))
1671                         uap->curregs[R1] |= EXT_INT_ENAB;
1672                 write_zsreg(uap, R1, uap->curregs[R1]);
1673         }
1674
1675         spin_unlock_irqrestore(&uap->port.lock, flags);
1676
1677         if (ZS_IS_CONS(uap))
1678                 uap->port.cons->flags |= CON_ENABLED;
1679
1680         /* Re-enable IRQ on the controller */
1681         if (ZS_IS_OPEN(uap) && !ZS_IS_IRQ_ON(pmz_get_port_A(uap))) {
1682                 pmz_get_port_A(uap)->flags |= PMACZILOG_FLAG_IS_IRQ_ON;
1683                 enable_irq(uap->port.irq);
1684         }
1685
1686  bail:
1687         mutex_unlock(&state->mutex);
1688         mutex_unlock(&pmz_irq_mutex);
1689
1690         /* Right now, we deal with delay by blocking here, I'll be
1691          * smarter later on
1692          */
1693         if (pwr_delay != 0) {
1694                 pmz_debug("pmz: delaying %d ms\n", pwr_delay);
1695                 msleep(pwr_delay);
1696         }
1697
1698         pmz_debug("resume, switching complete\n");
1699
1700         mdev->ofdev.dev.power.power_state.event = PM_EVENT_ON;
1701
1702         return 0;
1703 }
1704
1705 /*
1706  * Probe all ports in the system and build the ports array, we register
1707  * with the serial layer at this point, the macio-type probing is only
1708  * used later to "attach" to the sysfs tree so we get power management
1709  * events
1710  */
1711 static int __init pmz_probe(void)
1712 {
1713         struct device_node      *node_p, *node_a, *node_b, *np;
1714         int                     count = 0;
1715         int                     rc;
1716
1717         /*
1718          * Find all escc chips in the system
1719          */
1720         node_p = of_find_node_by_name(NULL, "escc");
1721         while (node_p) {
1722                 /*
1723                  * First get channel A/B node pointers
1724                  * 
1725                  * TODO: Add routines with proper locking to do that...
1726                  */
1727                 node_a = node_b = NULL;
1728                 for (np = NULL; (np = of_get_next_child(node_p, np)) != NULL;) {
1729                         if (strncmp(np->name, "ch-a", 4) == 0)
1730                                 node_a = of_node_get(np);
1731                         else if (strncmp(np->name, "ch-b", 4) == 0)
1732                                 node_b = of_node_get(np);
1733                 }
1734                 if (!node_a && !node_b) {
1735                         of_node_put(node_a);
1736                         of_node_put(node_b);
1737                         printk(KERN_ERR "pmac_zilog: missing node %c for escc %s\n",
1738                                 (!node_a) ? 'a' : 'b', node_p->full_name);
1739                         goto next;
1740                 }
1741
1742                 /*
1743                  * Fill basic fields in the port structures
1744                  */
1745                 pmz_ports[count].mate           = &pmz_ports[count+1];
1746                 pmz_ports[count+1].mate         = &pmz_ports[count];
1747                 pmz_ports[count].flags          = PMACZILOG_FLAG_IS_CHANNEL_A;
1748                 pmz_ports[count].node           = node_a;
1749                 pmz_ports[count+1].node         = node_b;
1750                 pmz_ports[count].port.line      = count;
1751                 pmz_ports[count+1].port.line    = count+1;
1752
1753                 /*
1754                  * Setup the ports for real
1755                  */
1756                 rc = pmz_init_port(&pmz_ports[count]);
1757                 if (rc == 0 && node_b != NULL)
1758                         rc = pmz_init_port(&pmz_ports[count+1]);
1759                 if (rc != 0) {
1760                         of_node_put(node_a);
1761                         of_node_put(node_b);
1762                         memset(&pmz_ports[count], 0, sizeof(struct uart_pmac_port));
1763                         memset(&pmz_ports[count+1], 0, sizeof(struct uart_pmac_port));
1764                         goto next;
1765                 }
1766                 count += 2;
1767 next:
1768                 node_p = of_find_node_by_name(node_p, "escc");
1769         }
1770         pmz_ports_count = count;
1771
1772         return 0;
1773 }
1774
1775 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
1776
1777 static void pmz_console_write(struct console *con, const char *s, unsigned int count);
1778 static int __init pmz_console_setup(struct console *co, char *options);
1779
1780 static struct console pmz_console = {
1781         .name   =       "ttyS",
1782         .write  =       pmz_console_write,
1783         .device =       uart_console_device,
1784         .setup  =       pmz_console_setup,
1785         .flags  =       CON_PRINTBUFFER,
1786         .index  =       -1,
1787         .data   =       &pmz_uart_reg,
1788 };
1789
1790 #define PMACZILOG_CONSOLE       &pmz_console
1791 #else /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
1792 #define PMACZILOG_CONSOLE       (NULL)
1793 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
1794
1795 /*
1796  * Register the driver, console driver and ports with the serial
1797  * core
1798  */
1799 static int __init pmz_register(void)
1800 {
1801         int i, rc;
1802         
1803         pmz_uart_reg.nr = pmz_ports_count;
1804         pmz_uart_reg.cons = PMACZILOG_CONSOLE;
1805         pmz_uart_reg.minor = 64;
1806
1807         /*
1808          * Register this driver with the serial core
1809          */
1810         rc = uart_register_driver(&pmz_uart_reg);
1811         if (rc)
1812                 return rc;
1813
1814         /*
1815          * Register each port with the serial core
1816          */
1817         for (i = 0; i < pmz_ports_count; i++) {
1818                 struct uart_pmac_port *uport = &pmz_ports[i];
1819                 /* NULL node may happen on wallstreet */
1820                 if (uport->node != NULL)
1821                         rc = uart_add_one_port(&pmz_uart_reg, &uport->port);
1822                 if (rc)
1823                         goto err_out;
1824         }
1825
1826         return 0;
1827 err_out:
1828         while (i-- > 0) {
1829                 struct uart_pmac_port *uport = &pmz_ports[i];
1830                 uart_remove_one_port(&pmz_uart_reg, &uport->port);
1831         }
1832         uart_unregister_driver(&pmz_uart_reg);
1833         return rc;
1834 }
1835
1836 static struct of_device_id pmz_match[] = 
1837 {
1838         {
1839         .name           = "ch-a",
1840         },
1841         {
1842         .name           = "ch-b",
1843         },
1844         {},
1845 };
1846 MODULE_DEVICE_TABLE (of, pmz_match);
1847
1848 static struct macio_driver pmz_driver = 
1849 {
1850         .name           = "pmac_zilog",
1851         .match_table    = pmz_match,
1852         .probe          = pmz_attach,
1853         .remove         = pmz_detach,
1854         .suspend        = pmz_suspend,
1855         .resume         = pmz_resume,
1856 };
1857
1858 static int __init init_pmz(void)
1859 {
1860         int rc, i;
1861         printk(KERN_INFO "%s\n", version);
1862
1863         /* 
1864          * First, we need to do a direct OF-based probe pass. We
1865          * do that because we want serial console up before the
1866          * macio stuffs calls us back, and since that makes it
1867          * easier to pass the proper number of channels to
1868          * uart_register_driver()
1869          */
1870         if (pmz_ports_count == 0)
1871                 pmz_probe();
1872
1873         /*
1874          * Bail early if no port found
1875          */
1876         if (pmz_ports_count == 0)
1877                 return -ENODEV;
1878
1879         /*
1880          * Now we register with the serial layer
1881          */
1882         rc = pmz_register();
1883         if (rc) {
1884                 printk(KERN_ERR 
1885                         "pmac_zilog: Error registering serial device, disabling pmac_zilog.\n"
1886                         "pmac_zilog: Did another serial driver already claim the minors?\n"); 
1887                 /* effectively "pmz_unprobe()" */
1888                 for (i=0; i < pmz_ports_count; i++)
1889                         pmz_dispose_port(&pmz_ports[i]);
1890                 return rc;
1891         }
1892         
1893         /*
1894          * Then we register the macio driver itself
1895          */
1896         return macio_register_driver(&pmz_driver);
1897 }
1898
1899 static void __exit exit_pmz(void)
1900 {
1901         int i;
1902
1903         /* Get rid of macio-driver (detach from macio) */
1904         macio_unregister_driver(&pmz_driver);
1905
1906         for (i = 0; i < pmz_ports_count; i++) {
1907                 struct uart_pmac_port *uport = &pmz_ports[i];
1908                 if (uport->node != NULL) {
1909                         uart_remove_one_port(&pmz_uart_reg, &uport->port);
1910                         pmz_dispose_port(uport);
1911                 }
1912         }
1913         /* Unregister UART driver */
1914         uart_unregister_driver(&pmz_uart_reg);
1915 }
1916
1917 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
1918
1919 static void pmz_console_putchar(struct uart_port *port, int ch)
1920 {
1921         struct uart_pmac_port *uap = (struct uart_pmac_port *)port;
1922
1923         /* Wait for the transmit buffer to empty. */
1924         while ((read_zsreg(uap, R0) & Tx_BUF_EMP) == 0)
1925                 udelay(5);
1926         write_zsdata(uap, ch);
1927 }
1928
1929 /*
1930  * Print a string to the serial port trying not to disturb
1931  * any possible real use of the port...
1932  */
1933 static void pmz_console_write(struct console *con, const char *s, unsigned int count)
1934 {
1935         struct uart_pmac_port *uap = &pmz_ports[con->index];
1936         unsigned long flags;
1937
1938         if (ZS_IS_ASLEEP(uap))
1939                 return;
1940         spin_lock_irqsave(&uap->port.lock, flags);
1941
1942         /* Turn of interrupts and enable the transmitter. */
1943         write_zsreg(uap, R1, uap->curregs[1] & ~TxINT_ENAB);
1944         write_zsreg(uap, R5, uap->curregs[5] | TxENABLE | RTS | DTR);
1945
1946         uart_console_write(&uap->port, s, count, pmz_console_putchar);
1947
1948         /* Restore the values in the registers. */
1949         write_zsreg(uap, R1, uap->curregs[1]);
1950         /* Don't disable the transmitter. */
1951
1952         spin_unlock_irqrestore(&uap->port.lock, flags);
1953 }
1954
1955 /*
1956  * Setup the serial console
1957  */
1958 static int __init pmz_console_setup(struct console *co, char *options)
1959 {
1960         struct uart_pmac_port *uap;
1961         struct uart_port *port;
1962         int baud = 38400;
1963         int bits = 8;
1964         int parity = 'n';
1965         int flow = 'n';
1966         unsigned long pwr_delay;
1967
1968         /*
1969          * XServe's default to 57600 bps
1970          */
1971         if (machine_is_compatible("RackMac1,1")
1972             || machine_is_compatible("RackMac1,2")
1973             || machine_is_compatible("MacRISC4"))
1974                 baud = 57600;
1975
1976         /*
1977          * Check whether an invalid uart number has been specified, and
1978          * if so, search for the first available port that does have
1979          * console support.
1980          */
1981         if (co->index >= pmz_ports_count)
1982                 co->index = 0;
1983         uap = &pmz_ports[co->index];
1984         if (uap->node == NULL)
1985                 return -ENODEV;
1986         port = &uap->port;
1987
1988         /*
1989          * Mark port as beeing a console
1990          */
1991         uap->flags |= PMACZILOG_FLAG_IS_CONS;
1992
1993         /*
1994          * Temporary fix for uart layer who didn't setup the spinlock yet
1995          */
1996         spin_lock_init(&port->lock);
1997
1998         /*
1999          * Enable the hardware
2000          */
2001         pwr_delay = __pmz_startup(uap);
2002         if (pwr_delay)
2003                 mdelay(pwr_delay);
2004         
2005         if (options)
2006                 uart_parse_options(options, &baud, &parity, &bits, &flow);
2007
2008         return uart_set_options(port, co, baud, parity, bits, flow);
2009 }
2010
2011 static int __init pmz_console_init(void)
2012 {
2013         /* Probe ports */
2014         pmz_probe();
2015
2016         /* TODO: Autoprobe console based on OF */
2017         /* pmz_console.index = i; */
2018         register_console(&pmz_console);
2019
2020         return 0;
2021
2022 }
2023 console_initcall(pmz_console_init);
2024 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
2025
2026 module_init(init_pmz);
2027 module_exit(exit_pmz);