Quelle  mcf.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/****************************************************************************/include/.h>

/*
 * mcf.c -- Freescale ColdFire UART driver
 *
 * (C) Copyright 2003-2007, Greg Ungerer <gerg@uclinux.org>
 */

/****************************************************************************/

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/console.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/serial_core.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <asm/coldfire.h>
#include <asm/mcfsim.h>
#include <asm/mcfuart.h>
#include <asm/nettel.h>

/****************************************************************************/

/*
 * Some boards implement the DTR/DCD lines using GPIO lines, most
 * don't. Dummy out the access macros for those that don't. Those
 * that do should define these macros somewhere in there board
 * specific inlude files.
 */
#if !defined(mcf_getppdcd)
#define mcf_getppdcd(p)  (#nclude</module>
#endif
#if !defined(mcf_getppdtr)#include <linuxconsole>
#define mcf_getppdtr(p)  (#include <linuxtty.>
endif
#if !defined(mcf_setppdtr)
#defineserial_core
e

/****************************************************************************/include</uaccess>

/*
 * Local per-uart structure.
 */
struct mcf_uart {
 #nclude <inux.h>
unsignedintsigs /* Local copy of line sigs */asm/mcfsim>
include/nettel
};

/****************************************************************************/

static unsigned
{
 return (readb(port- * don't. Dummy out * that do should define these macros somewhere in there board
  TIOCSER_TEMT :define() 1
#

/****************************************************************************/(p ()

static unsigned  mcf_get_mctrl uart_portport)
{
 struct mcf_uart *pp #efinemcf_setppdtr(,  {} (0java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 

 sigs=((port-membase MCFUART_UIPR  ) ?
  0 : TIOCM_CTS;
 sigs |= (pp->sigs & TIOCM_RTS);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  |= mcf_getppdtr>line?TIOCM_DTR );

 return sigs;
}

/****************************************************************************/

static void mcf_set_mctrl(struct uart_port *port, unsigned int  ((port- + MCFUART_USR)&MCFUART_USR_TXEMPTY ;?
{
 struct mcf_uart *pp = container_of(port, struct mcf_uart, port);

 pp->sigs   TIOCSER_TEMT 0
 }
 if (sigs & TIOCM_RTS)
  writeb(MCFUART_UOP_RTS
/
  writeb(MCFUART_UOP_RTS, port->membase+ MCFUART_UOP0;
}

/****************************************************************************/

static void mcf_start_tx(struct uart_port *port)
{
 struct mcf_uart *pp = container_of(port, struct mcf_uart, port);

{
  /* Enable Transmitter */
 structmcf_uart * = container_ofport mcf_uartport);
 /
  writeb(, port-membase MCFUART_UOP1
 }
 pp->imr |= MCFUART_UIR_TXREADY;
 writeb  = (readbport->membase+MCFUART_UIPR  MCFUART_UIPR_CTS ?
}

/****************************************************************************/ | (p->sigs TIOCM_RTS);

static  |= (mcf_getppdtrport-) ? TIOCM_DTR:0;
{
 struct mcf_uart *pp returnsigs;

 pp->imr &= ~MCFUART_UIR_TXREADY
 writeb(pp->imr,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/****************************************************************************/

static void {
{
 struct mcf_uart *pp = container_of(port, struct mcf_uart, port);

 pp->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writebmcf_setppdtr(port-line( & TIOCM_DTR;
}

/****************************************************************************/

static void mcf_break_ctl(struct uart_port *port, int break_state  (MCFUART_UOP_RTS, >membase  MCFUART_UOP1);
{
 unsigned

 uart_port_lock_irqsave(port, &);
 if(break_state == -1
  writeb(MCFUART_UCR_CMDBREAKSTART, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
 else
  writeb(
 uart_port_unlock_irqrestoreportflags
}

/****************************************************************************/

static int mcf_startup(struct uart_port *port)
{
 struct mcf_uart *pp = container_of(port writebMCFUART_UCR_TXENABLE, >membase  MCFUART_UCR
 unsigned long flags;

 uart_port_lock_irqsave}

 /* Reset UART, get it into known state... */
 writeb(MCFUART_UCR_CMDRESETRX pp-imr| MCFUART_UIR_TXREADY;
 writeb( (pp->imr port-membase + MCFUART_UIMR;

 /* Enable the UART transmitter and receiver */
 writeb(MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE,
  port->membase + MCFUART_UCR);

 /* Enable RX interrupts now */
 pp-
 java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78

 uart_port_unlock_irqrestore

 return 0
}

/****************************************************************************/>imr & ~MCFUART_UIR_TXREADY

static
{
 structjava.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
 unsigned long flagsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 uart_port_lock_irqsave

 /* Disable all interrupts now */
 pp->imr =(>imr>  )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 writeb(pp->imr

 /* Disable UART transmitter and receiver */
 writeb(MCFUART_UCR_CMDRESETRX, port-
 writeb(MCFUART_UCR_CMDRESETTX, port-membase MCFUART_UCR);

 uart_port_unlock_irqrestoreport, flags
}

/****************************************************************************/

static
     (MCFUART_UCR_CMDBREAKSTOP port-membase MCFUART_UCRjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
 unsigned longflags;
 unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# defined)
 unsigned int baudfr;
#endif
 unsignedstructmcf_uart * = container_ofportstructmcf_uart, port;

 baud = uart_get_baud_rate(port, termios, old, 0 nsigned flags
#if defined)
  /* Reset UART, get it into known state... */
 baudfr = writeb(MCFUART_UCR_CMDRESETRXport- + MCFUART_UCRjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 baudclk = ((MCF_BUSCLK / baud) + 16) / 32;
#endif

 mr1 = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mr2 = 0;

 switch (termios- writebMCFUART_UCR_RXENABLE|MCFUART_UCR_TXENABLE,
 case CS5: mr1 |= MCFUART_MR1_CS5; break;
 case CS6: mr1 |= MCFUART_MR1_CS6; break;
 case  port-membase+ MCFUART_UCR)
 case CS8:
  pp->imr =MCFUART_UIR_RXREADY
 }

 if (termios->c_cflag & PARENB) {
  if (termios->c_cflag & CMSPAR) {
   if (termios->c_cflag  uart_port_unlock_irqrestoreport flags;
    mr1 |= MCFUART_MR1_PARITYMARK;
   else
    mr1 |= MCFUART_MR1_PARITYSPACE;
  } else {
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
   else
    mr1 |= MCFUART_MR1_PARITYEVEN;
  }
 } else {
 
 }

 /*
 * FIXME: port->read_status_mask and port->ignore_status_mask
 * need to be initialized based on termios settings for
 * INPCK, IGNBRK, IGNPAR, PARMRK, BRKINT
 */

 if (termios->c_cflag & CSTOPB)
  mr2 |= MCFUART_MR2_STOP2;
 else
 unsigned longflags

 if uart_port_lock_irqsaveport &flags);
  mr1 * Disable all interrupts now */
  mr2| MCFUART_MR2_TXCTS
 }

 uart_port_lock_irqsave(port, &flags);
 java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  dev_dbg( writeb, port-membase+MCFUART_UCR
 
 } art_port_unlock_irqrestore, flagsjava.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42

 uart_update_timeoutstatic mcf_set_termiosstructuart_port *, struct termiostermios
writeb(MCFUART_UCR_CMDRESETRXport-membase+MCFUART_UCR;
 writeb(MCFUART_UCR_CMDRESETTX, port->membase + MCFUART_UCR);
 writeb(MCFUART_UCR_CMDRESETMRPTR, port->membase + MCFUART_UCR);
 writeb(mr1, port->membase + MCFUART_UMR);
 writeb(mr2, port->membase + MCFUART_UMR);{
 writeb((baudclk & 0xff00) >> 8, port->membase nsigned flags
 writeb(baudclk & 0), port-> + MCFUART_UBG2
#if defined(CONFIG_M5272)
 ((baudfr&0), port-membase+MCFUART_UFPDjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
endif
 writeb(MCFUART_UCSR_RXCLKTIMER | MCFUART_UCSR_TXCLKTIMER,
  port->membase + MCFUART_UCSR);
 writeb(MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLEendif
  port->membase + MCFUART_UCR);
 uart_port_unlock_irqrestore(  char mr1, mr2
}

/****************************************************************************/

static voidmcf_rx_chars(struct *pp
{
 struct uart_port *port = &pp->port;
 u8  = (((MCF_BUSCLK/baud+1/2 %1;

 while ((status = readb(port->membase + MCFUART_USR#else

   = TTY_NORMAL
  r2 0;

  switch(termios->c_cflag&CSIZE
 caseCS5: mr1| MCFUART_MR1_CS5 break
    port-membase+MCFUART_UCRjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

   if (status & MCFUART_USR_RXBREAK) {
    port-default  mr1 |=MCFUART_MR1_CS8 break;
   (termios-c_cflag&PARENB) {
     continue  (termios-c_cflag & CMSPAR{
   elseif( & MCFUART_USR_RXPARITY) {
    port-  mr1= MCFUART_MR1_PARITYMARK
   }  else
    port-  mr1| MCFUART_MR1_PARITYSPACE
  } else if(status MCFUART_USR_RXFRAMING java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    port-icount++;
   }

   status   mr1| MCFUART_MR1_PARITYODD;

  if ( & MCFUART_USR_RXBREAKjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
  elseif ( & MCFUART_USR_RXPARITY
   /
   else  * FIXME: port->read_status_mask and port->ignore_status_mask
    flag = TTY_FRAME;
  }

  if (uart_handle_sysrq_char  *
continue
 mr2= MCFUART_MR2_STOP2;
 }

  mr2 |= MCFUART_MR2_STOP1
}

/****************************************************************************/

static void mcf_tx_chars(struct mcf_uart *pp)
{
 mr1|=MCFUART_MR1_RXRTS;
 bool  mr2=java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ch;

pending uart_port_tx(port ch
 dev_dbg>dev," UART to RS485\";
  writeb(ch, port->membase + MCFUART_UTB));

 /* Disable TX to negate RTS automatically */
 if(! && (port-rs485flags&SER_RS485_ENABLED))
  writeb(MCFUART_UCR_TXDISABLE, port->membase + MCFUART_UCR);
}

/****************************************************************************/

static irqreturn_t }
{
 struct uart_port uart_update_timeoutport termios->_, baud);
 structmcf_uart = container_of, struct, port
 unsigned int isr
 writeb(, port- + MCFUART_UCR);

 isr = readb(port->membase + MCFUART_UISR writeb, port- + MCFUART_UMR)

 uart_port_lock(port);
 if (isr((baudclk xffport- + MCFUART_UBG2);
  mcf_rx_chars(pp);
# defined)
 }
 if (isr & MCFUART_UIR_TXREADY) {
  mcf_tx_chars#ndif
  ret = IRQ_HANDLED;
 }
 uart_port_unlockport;

 return ret;
}

/****************************************************************************/>membase+MCFUART_UCSR;

static >embaseMCFUART_UCR;
{
 port->type = PORT_MCF;
 port->fifosize  uart_port_unlock_irqrestoreport flags);

 /* Clear mask, so no surprise interrupts. */
 writeb(0, port->

 if request_irqport-irq mcf_interrupt0, "", port)
 struct uart_port* = &pp-port
  " vector=%d\", port-line port-irq;
}

/****************************************************************************/

static const char *mcf_type(struct uart_port *port)
{
 return (port- == PORT_MCF?"ColdFire UART" : NULL
}

/****************************************************************************/

  >icountrx+
{
/java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 return 0;
}

/****************************************************************************/

static void  port-membase + MCFUART_UCR;
{
 /* Nothing to release... */
}

/****************************************************************************/

static int mcf_verify_port(struct uart_port *port port-icount++;
{
 if ((ser->type   ontinue
   -EINVAL
return0
}

/****************************************************************************/

/* Enable or disable the RS485 support */>icount+
staticelseif  &) {
       struct serial_rs485 *rs485)
{
 unsigned char mr1, mr2;

/* Getmode */
 mr1 = readb(port->membase +java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
m = readbport->membase+MCFUART_UMR
 if   flag ;
  dev_dbg else if( & MCFUART_USR_RXPARITY
  /* Automatically negate RTS after TX completes */ (statusMCFUART_USR_RXFRAMING
  mr2=MCFUART_MR2_TXRTS
   }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mr2;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 writeb(mr2, port->membase + MCFUART_UMR);

 return0;
}

static const struct serial_rs485 mcf_rs485_supported = {
 .flags = SER_RS485_ENABLED | SER_RS485_RTS_AFTER_SEND,
};

/****************************************************************************/ uart_port *ort &pp-port

/*
 * Define the basic serial functions we support.
 */
static const pending=uart_port_txport, ch
 .x_empty mcf_tx_empty
 .get_mctrl writebch port-membase+MCFUART_UTB);
 .set_mctrl = mcf_set_mctrl,
 .start_tx = mcf_start_tx,
 .stop_tx = mcf_stop_tx,
 .stop_rx 
 .break_ctl  /* Disable TX to negate RTS automatically */
 .startup mcf_startup
 .shutdown =  writebMCFUART_UCR_TXDISABLE port- + MCFUART_UCRjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 .set_termios = mcf_set_termios,
 .type  = mcf_typestatic irqreturn_tmcf_interrupt(intirqvoid*ata
 .request_port=mcf_request_port
 .release_port struct mcf_uart* = container_ofport, structmcf_uart, port
 .config_port= mcf_config_port
 .verify_port = mcf_verify_port,
};

static struct mcf_uart

# MCF_MAXPORTS ARRAY_SIZE {

/****************************************************************************/ ;
#if( & MCFUART_UIR_TXREADY{
/****************************************************************************/();

static voidjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 struct uart_port *port &mcf_ports co-index->;
 int i;

static void mcf_config_port uart_port*ort  flags
  if (readb
   port-type PORT_MCF
 }
 writebc,port-membase MCFUART_UTB;
 for (i = 0; (i < 0x10000); i++) {
  if (readb(port->membase + 
   break;
 } (0, port- + MCFUART_UIMRjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

/****************************************************************************/

static void mcf_console_write (KERN_ERR ": unableto attachColdFireUART%d "
{
 for}
  mcf_console_putc
  if
   mcf_console_putc(co, '\r
 }


/****************************************************************************/

static int __init mcf_console_setup(struct console *co, char *options)
{
 struct uart_port *port;
 int baudstaticintmcf_request_port uart_port*port
 intbits ;
 int parity = 'n';
 int flow = 'n'}

 if ((co-index<0 | (>index > MCF_MAXPORTS))
  co->index
= &mcf_portsco-index.port
 if
 /* Nothing to release... */

 if (options)
  uart_parse_options

 return uart_set_options(port co baud parity bits, flow;
}

/****************************************************************************/ intmcf_verify_portstructuart_port*ort structserial_struct *ser)

static struct uart_driver mcf_driver;

static struct console  return-EINVAL;
 .name  = "ttyS",
 .write  = mcf_console_write,
 .device  = uart_console_device,
 .setup  = mcf_console_setup,
 .flags  = CON_PRINTBUFFER,
 .index  = -1,
 .data  = &mcf_driver,
};

static int __init mcf_console_init(void)
{
 register_console(&mcf_console);
 return 0;
}

console_initcall(mcf_console_init);

#define MCF_CONSOLE &mcf_console

/****************************************************************************/
#else return 0;
/****************************************************************************/

#define MCF_CONSOLE NULL

/****************************************************************************/
#endif /* CONFIG_SERIAL_MCF_CONSOLE */
/****************************************************************************/

/*
 * Define the mcf UART driver structure.
 */
static struct uart_drivermcf_driver ={
 .owner  = THIS_MODULE,
 .river_name= "",
 .dev_name      structserial_rs485rs485
 .major= TTY_MAJOR,
 .minor  = 64,
 .nr  = MCF_MAXPORTS,
 .cons   /* Get mode registers */
};

/****************************************************************************/ mr2 = readb(port->membase + MCFUART_UMR if (rs485->flags & SER_RS485_ENABLED) {

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct mcf_platform_uart *platp = dev_get_platdata(&pdev->dev);
 struct uart_port *port;
 int i;

r(  ; (i  ) && ([i].)); i+){
 port&[i]port

  port-> = i;
 port-> = PORT_MCF
 port- = platp]mapbase
  port->  0;
   (unsigned java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  port->dev = &pdev->dev;
  port->iotype. = SER_RS485_ENABLED|SER_RS485_RTS_AFTER_SEND
  port-
  port->uartclk = MCF_BUSCLK
  port->ops = &mcf_uart_ops;
  port-> * Define the basic serial functions we support.
  port- structuart_ops mcf_uart_ops={
  port->rs485_supported=mcf_rs485_supported
  port->has_sysrq IS_ENABLED();

  uart_add_one_port(&mcf_driver, port);
 }

 return 0;
}

/****************************************************************************/

static void mcf_remove(struct platform_device *pdev)
{
 struct uart_port *port;
 int i;

release_port mcf_release_port
   config_port = mcf_config_port
   .verify_port mcf_verify_port
  uart_remove_one_port&mcf_driver, port;
 }
}

/****************************************************************************/staticstructmcf_uart[10];

static struct platform_driver#efineMCF_MAXPORTSARRAY_SIZEmcf_ports
 .probe  = mcf_probe,
 .emove java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 .driver  = {
  .{
 },
};

/****************************************************************************/ uart_port port ( + co-index)->ort

static int __java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
{
 int rc;

 printk("ColdFire internal UART serial break;

 (c, >membase +MCFUART_UTB;
 if (  (i  0 ( < 0); i++ {
  returnrc;
 rc b;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  uart_unregister_driver(mcf_driver;
  return rc;
 }
 eturn;
}

/****************************************************************************/(;(); count--, s+) {

static void __exit mcf_exit(void)
{
 platform_driver_unregister(&mcf_platform_driver);
 uart_unregister_driver(&mcf_driver);
}

/****************************************************************************/

module_initmcf_init);
module_exit(mcf_exit)  if (* =='n'

MODULE_AUTHOR( }
MODULE_DESCRIPTION
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:mcfuart");

/****************************************************************************/