LCOV - code coverage report
Current view: top level - drivers/tty/serial/8250 - 8250_port.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 449 1176 38.2 %
Date: 2022-03-28 16:04:14 Functions: 41 94 43.6 %
Branches: 159 622 25.6 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0+
       2                 :            : /*
       3                 :            :  *  Base port operations for 8250/16550-type serial ports
       4                 :            :  *
       5                 :            :  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
       6                 :            :  *  Split from 8250_core.c, Copyright (C) 2001 Russell King.
       7                 :            :  *
       8                 :            :  * A note about mapbase / membase
       9                 :            :  *
      10                 :            :  *  mapbase is the physical address of the IO port.
      11                 :            :  *  membase is an 'ioremapped' cookie.
      12                 :            :  */
      13                 :            : 
      14                 :            : #include <linux/module.h>
      15                 :            : #include <linux/moduleparam.h>
      16                 :            : #include <linux/ioport.h>
      17                 :            : #include <linux/init.h>
      18                 :            : #include <linux/console.h>
      19                 :            : #include <linux/sysrq.h>
      20                 :            : #include <linux/delay.h>
      21                 :            : #include <linux/platform_device.h>
      22                 :            : #include <linux/tty.h>
      23                 :            : #include <linux/ratelimit.h>
      24                 :            : #include <linux/tty_flip.h>
      25                 :            : #include <linux/serial.h>
      26                 :            : #include <linux/serial_8250.h>
      27                 :            : #include <linux/nmi.h>
      28                 :            : #include <linux/mutex.h>
      29                 :            : #include <linux/slab.h>
      30                 :            : #include <linux/uaccess.h>
      31                 :            : #include <linux/pm_runtime.h>
      32                 :            : #include <linux/ktime.h>
      33                 :            : 
      34                 :            : #include <asm/io.h>
      35                 :            : #include <asm/irq.h>
      36                 :            : 
      37                 :            : #include "8250.h"
      38                 :            : 
      39                 :            : /* Nuvoton NPCM timeout register */
      40                 :            : #define UART_NPCM_TOR          7
      41                 :            : #define UART_NPCM_TOIE         BIT(7)  /* Timeout Interrupt Enable */
      42                 :            : 
      43                 :            : /*
      44                 :            :  * Debugging.
      45                 :            :  */
      46                 :            : #if 0
      47                 :            : #define DEBUG_AUTOCONF(fmt...)  printk(fmt)
      48                 :            : #else
      49                 :            : #define DEBUG_AUTOCONF(fmt...)  do { } while (0)
      50                 :            : #endif
      51                 :            : 
      52                 :            : #define BOTH_EMPTY      (UART_LSR_TEMT | UART_LSR_THRE)
      53                 :            : 
      54                 :            : /*
      55                 :            :  * Here we define the default xmit fifo size used for each type of UART.
      56                 :            :  */
      57                 :            : static const struct serial8250_config uart_config[] = {
      58                 :            :         [PORT_UNKNOWN] = {
      59                 :            :                 .name           = "unknown",
      60                 :            :                 .fifo_size      = 1,
      61                 :            :                 .tx_loadsz      = 1,
      62                 :            :         },
      63                 :            :         [PORT_8250] = {
      64                 :            :                 .name           = "8250",
      65                 :            :                 .fifo_size      = 1,
      66                 :            :                 .tx_loadsz      = 1,
      67                 :            :         },
      68                 :            :         [PORT_16450] = {
      69                 :            :                 .name           = "16450",
      70                 :            :                 .fifo_size      = 1,
      71                 :            :                 .tx_loadsz      = 1,
      72                 :            :         },
      73                 :            :         [PORT_16550] = {
      74                 :            :                 .name           = "16550",
      75                 :            :                 .fifo_size      = 1,
      76                 :            :                 .tx_loadsz      = 1,
      77                 :            :         },
      78                 :            :         [PORT_16550A] = {
      79                 :            :                 .name           = "16550A",
      80                 :            :                 .fifo_size      = 16,
      81                 :            :                 .tx_loadsz      = 16,
      82                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
      83                 :            :                 .rxtrig_bytes   = {1, 4, 8, 14},
      84                 :            :                 .flags          = UART_CAP_FIFO,
      85                 :            :         },
      86                 :            :         [PORT_CIRRUS] = {
      87                 :            :                 .name           = "Cirrus",
      88                 :            :                 .fifo_size      = 1,
      89                 :            :                 .tx_loadsz      = 1,
      90                 :            :         },
      91                 :            :         [PORT_16650] = {
      92                 :            :                 .name           = "ST16650",
      93                 :            :                 .fifo_size      = 1,
      94                 :            :                 .tx_loadsz      = 1,
      95                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
      96                 :            :         },
      97                 :            :         [PORT_16650V2] = {
      98                 :            :                 .name           = "ST16650V2",
      99                 :            :                 .fifo_size      = 32,
     100                 :            :                 .tx_loadsz      = 16,
     101                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
     102                 :            :                                   UART_FCR_T_TRIG_00,
     103                 :            :                 .rxtrig_bytes   = {8, 16, 24, 28},
     104                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
     105                 :            :         },
     106                 :            :         [PORT_16750] = {
     107                 :            :                 .name           = "TI16750",
     108                 :            :                 .fifo_size      = 64,
     109                 :            :                 .tx_loadsz      = 64,
     110                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
     111                 :            :                                   UART_FCR7_64BYTE,
     112                 :            :                 .rxtrig_bytes   = {1, 16, 32, 56},
     113                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP | UART_CAP_AFE,
     114                 :            :         },
     115                 :            :         [PORT_STARTECH] = {
     116                 :            :                 .name           = "Startech",
     117                 :            :                 .fifo_size      = 1,
     118                 :            :                 .tx_loadsz      = 1,
     119                 :            :         },
     120                 :            :         [PORT_16C950] = {
     121                 :            :                 .name           = "16C950/954",
     122                 :            :                 .fifo_size      = 128,
     123                 :            :                 .tx_loadsz      = 128,
     124                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     125                 :            :                 /* UART_CAP_EFR breaks billionon CF bluetooth card. */
     126                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP,
     127                 :            :         },
     128                 :            :         [PORT_16654] = {
     129                 :            :                 .name           = "ST16654",
     130                 :            :                 .fifo_size      = 64,
     131                 :            :                 .tx_loadsz      = 32,
     132                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
     133                 :            :                                   UART_FCR_T_TRIG_10,
     134                 :            :                 .rxtrig_bytes   = {8, 16, 56, 60},
     135                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
     136                 :            :         },
     137                 :            :         [PORT_16850] = {
     138                 :            :                 .name           = "XR16850",
     139                 :            :                 .fifo_size      = 128,
     140                 :            :                 .tx_loadsz      = 128,
     141                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     142                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
     143                 :            :         },
     144                 :            :         [PORT_RSA] = {
     145                 :            :                 .name           = "RSA",
     146                 :            :                 .fifo_size      = 2048,
     147                 :            :                 .tx_loadsz      = 2048,
     148                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11,
     149                 :            :                 .flags          = UART_CAP_FIFO,
     150                 :            :         },
     151                 :            :         [PORT_NS16550A] = {
     152                 :            :                 .name           = "NS16550A",
     153                 :            :                 .fifo_size      = 16,
     154                 :            :                 .tx_loadsz      = 16,
     155                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     156                 :            :                 .flags          = UART_CAP_FIFO | UART_NATSEMI,
     157                 :            :         },
     158                 :            :         [PORT_XSCALE] = {
     159                 :            :                 .name           = "XScale",
     160                 :            :                 .fifo_size      = 32,
     161                 :            :                 .tx_loadsz      = 32,
     162                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     163                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_UUE | UART_CAP_RTOIE,
     164                 :            :         },
     165                 :            :         [PORT_OCTEON] = {
     166                 :            :                 .name           = "OCTEON",
     167                 :            :                 .fifo_size      = 64,
     168                 :            :                 .tx_loadsz      = 64,
     169                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     170                 :            :                 .flags          = UART_CAP_FIFO,
     171                 :            :         },
     172                 :            :         [PORT_AR7] = {
     173                 :            :                 .name           = "AR7",
     174                 :            :                 .fifo_size      = 16,
     175                 :            :                 .tx_loadsz      = 16,
     176                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00,
     177                 :            :                 .flags          = UART_CAP_FIFO /* | UART_CAP_AFE */,
     178                 :            :         },
     179                 :            :         [PORT_U6_16550A] = {
     180                 :            :                 .name           = "U6_16550A",
     181                 :            :                 .fifo_size      = 64,
     182                 :            :                 .tx_loadsz      = 64,
     183                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     184                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
     185                 :            :         },
     186                 :            :         [PORT_TEGRA] = {
     187                 :            :                 .name           = "Tegra",
     188                 :            :                 .fifo_size      = 32,
     189                 :            :                 .tx_loadsz      = 8,
     190                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
     191                 :            :                                   UART_FCR_T_TRIG_01,
     192                 :            :                 .rxtrig_bytes   = {1, 4, 8, 14},
     193                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_RTOIE,
     194                 :            :         },
     195                 :            :         [PORT_XR17D15X] = {
     196                 :            :                 .name           = "XR17D15X",
     197                 :            :                 .fifo_size      = 64,
     198                 :            :                 .tx_loadsz      = 64,
     199                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     200                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
     201                 :            :                                   UART_CAP_SLEEP,
     202                 :            :         },
     203                 :            :         [PORT_XR17V35X] = {
     204                 :            :                 .name           = "XR17V35X",
     205                 :            :                 .fifo_size      = 256,
     206                 :            :                 .tx_loadsz      = 256,
     207                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11 |
     208                 :            :                                   UART_FCR_T_TRIG_11,
     209                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
     210                 :            :                                   UART_CAP_SLEEP,
     211                 :            :         },
     212                 :            :         [PORT_LPC3220] = {
     213                 :            :                 .name           = "LPC3220",
     214                 :            :                 .fifo_size      = 64,
     215                 :            :                 .tx_loadsz      = 32,
     216                 :            :                 .fcr            = UART_FCR_DMA_SELECT | UART_FCR_ENABLE_FIFO |
     217                 :            :                                   UART_FCR_R_TRIG_00 | UART_FCR_T_TRIG_00,
     218                 :            :                 .flags          = UART_CAP_FIFO,
     219                 :            :         },
     220                 :            :         [PORT_BRCM_TRUMANAGE] = {
     221                 :            :                 .name           = "TruManage",
     222                 :            :                 .fifo_size      = 1,
     223                 :            :                 .tx_loadsz      = 1024,
     224                 :            :                 .flags          = UART_CAP_HFIFO,
     225                 :            :         },
     226                 :            :         [PORT_8250_CIR] = {
     227                 :            :                 .name           = "CIR port"
     228                 :            :         },
     229                 :            :         [PORT_ALTR_16550_F32] = {
     230                 :            :                 .name           = "Altera 16550 FIFO32",
     231                 :            :                 .fifo_size      = 32,
     232                 :            :                 .tx_loadsz      = 32,
     233                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     234                 :            :                 .rxtrig_bytes   = {1, 8, 16, 30},
     235                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
     236                 :            :         },
     237                 :            :         [PORT_ALTR_16550_F64] = {
     238                 :            :                 .name           = "Altera 16550 FIFO64",
     239                 :            :                 .fifo_size      = 64,
     240                 :            :                 .tx_loadsz      = 64,
     241                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     242                 :            :                 .rxtrig_bytes   = {1, 16, 32, 62},
     243                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
     244                 :            :         },
     245                 :            :         [PORT_ALTR_16550_F128] = {
     246                 :            :                 .name           = "Altera 16550 FIFO128",
     247                 :            :                 .fifo_size      = 128,
     248                 :            :                 .tx_loadsz      = 128,
     249                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     250                 :            :                 .rxtrig_bytes   = {1, 32, 64, 126},
     251                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
     252                 :            :         },
     253                 :            :         /*
     254                 :            :          * tx_loadsz is set to 63-bytes instead of 64-bytes to implement
     255                 :            :          * workaround of errata A-008006 which states that tx_loadsz should
     256                 :            :          * be configured less than Maximum supported fifo bytes.
     257                 :            :          */
     258                 :            :         [PORT_16550A_FSL64] = {
     259                 :            :                 .name           = "16550A_FSL64",
     260                 :            :                 .fifo_size      = 64,
     261                 :            :                 .tx_loadsz      = 63,
     262                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
     263                 :            :                                   UART_FCR7_64BYTE,
     264                 :            :                 .flags          = UART_CAP_FIFO,
     265                 :            :         },
     266                 :            :         [PORT_RT2880] = {
     267                 :            :                 .name           = "Palmchip BK-3103",
     268                 :            :                 .fifo_size      = 16,
     269                 :            :                 .tx_loadsz      = 16,
     270                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     271                 :            :                 .rxtrig_bytes   = {1, 4, 8, 14},
     272                 :            :                 .flags          = UART_CAP_FIFO,
     273                 :            :         },
     274                 :            :         [PORT_DA830] = {
     275                 :            :                 .name           = "TI DA8xx/66AK2x",
     276                 :            :                 .fifo_size      = 16,
     277                 :            :                 .tx_loadsz      = 16,
     278                 :            :                 .fcr            = UART_FCR_DMA_SELECT | UART_FCR_ENABLE_FIFO |
     279                 :            :                                   UART_FCR_R_TRIG_10,
     280                 :            :                 .rxtrig_bytes   = {1, 4, 8, 14},
     281                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
     282                 :            :         },
     283                 :            :         [PORT_MTK_BTIF] = {
     284                 :            :                 .name           = "MediaTek BTIF",
     285                 :            :                 .fifo_size      = 16,
     286                 :            :                 .tx_loadsz      = 16,
     287                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO |
     288                 :            :                                   UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT,
     289                 :            :                 .flags          = UART_CAP_FIFO,
     290                 :            :         },
     291                 :            :         [PORT_NPCM] = {
     292                 :            :                 .name           = "Nuvoton 16550",
     293                 :            :                 .fifo_size      = 16,
     294                 :            :                 .tx_loadsz      = 16,
     295                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
     296                 :            :                                   UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT,
     297                 :            :                 .rxtrig_bytes   = {1, 4, 8, 14},
     298                 :            :                 .flags          = UART_CAP_FIFO,
     299                 :            :         },
     300                 :            :         [PORT_SUNIX] = {
     301                 :            :                 .name           = "Sunix",
     302                 :            :                 .fifo_size      = 128,
     303                 :            :                 .tx_loadsz      = 128,
     304                 :            :                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
     305                 :            :                 .rxtrig_bytes   = {1, 32, 64, 112},
     306                 :            :                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP,
     307                 :            :         },
     308                 :            : };
     309                 :            : 
     310                 :            : /* Uart divisor latch read */
     311                 :          0 : static int default_serial_dl_read(struct uart_8250_port *up)
     312                 :            : {
     313                 :          0 :         return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8;
     314                 :            : }
     315                 :            : 
     316                 :            : /* Uart divisor latch write */
     317                 :         26 : static void default_serial_dl_write(struct uart_8250_port *up, int value)
     318                 :            : {
     319                 :         26 :         serial_out(up, UART_DLL, value & 0xff);
     320                 :         26 :         serial_out(up, UART_DLM, value >> 8 & 0xff);
     321                 :         26 : }
     322                 :            : 
     323                 :            : #ifdef CONFIG_SERIAL_8250_RT288X
     324                 :            : 
     325                 :            : /* Au1x00/RT288x UART hardware has a weird register layout */
     326                 :            : static const s8 au_io_in_map[8] = {
     327                 :            :          0,     /* UART_RX  */
     328                 :            :          2,     /* UART_IER */
     329                 :            :          3,     /* UART_IIR */
     330                 :            :          5,     /* UART_LCR */
     331                 :            :          6,     /* UART_MCR */
     332                 :            :          7,     /* UART_LSR */
     333                 :            :          8,     /* UART_MSR */
     334                 :            :         -1,     /* UART_SCR (unmapped) */
     335                 :            : };
     336                 :            : 
     337                 :            : static const s8 au_io_out_map[8] = {
     338                 :            :          1,     /* UART_TX  */
     339                 :            :          2,     /* UART_IER */
     340                 :            :          4,     /* UART_FCR */
     341                 :            :          5,     /* UART_LCR */
     342                 :            :          6,     /* UART_MCR */
     343                 :            :         -1,     /* UART_LSR (unmapped) */
     344                 :            :         -1,     /* UART_MSR (unmapped) */
     345                 :            :         -1,     /* UART_SCR (unmapped) */
     346                 :            : };
     347                 :            : 
     348                 :            : unsigned int au_serial_in(struct uart_port *p, int offset)
     349                 :            : {
     350                 :            :         if (offset >= ARRAY_SIZE(au_io_in_map))
     351                 :            :                 return UINT_MAX;
     352                 :            :         offset = au_io_in_map[offset];
     353                 :            :         if (offset < 0)
     354                 :            :                 return UINT_MAX;
     355                 :            :         return __raw_readl(p->membase + (offset << p->regshift));
     356                 :            : }
     357                 :            : 
     358                 :            : void au_serial_out(struct uart_port *p, int offset, int value)
     359                 :            : {
     360                 :            :         if (offset >= ARRAY_SIZE(au_io_out_map))
     361                 :            :                 return;
     362                 :            :         offset = au_io_out_map[offset];
     363                 :            :         if (offset < 0)
     364                 :            :                 return;
     365                 :            :         __raw_writel(value, p->membase + (offset << p->regshift));
     366                 :            : }
     367                 :            : 
     368                 :            : /* Au1x00 haven't got a standard divisor latch */
     369                 :            : static int au_serial_dl_read(struct uart_8250_port *up)
     370                 :            : {
     371                 :            :         return __raw_readl(up->port.membase + 0x28);
     372                 :            : }
     373                 :            : 
     374                 :            : static void au_serial_dl_write(struct uart_8250_port *up, int value)
     375                 :            : {
     376                 :            :         __raw_writel(value, up->port.membase + 0x28);
     377                 :            : }
     378                 :            : 
     379                 :            : #endif
     380                 :            : 
     381                 :          0 : static unsigned int hub6_serial_in(struct uart_port *p, int offset)
     382                 :            : {
     383                 :          0 :         offset = offset << p->regshift;
     384                 :          0 :         outb(p->hub6 - 1 + offset, p->iobase);
     385                 :          0 :         return inb(p->iobase + 1);
     386                 :            : }
     387                 :            : 
     388                 :          0 : static void hub6_serial_out(struct uart_port *p, int offset, int value)
     389                 :            : {
     390                 :          0 :         offset = offset << p->regshift;
     391                 :          0 :         outb(p->hub6 - 1 + offset, p->iobase);
     392                 :          0 :         outb(value, p->iobase + 1);
     393                 :          0 : }
     394                 :            : 
     395                 :          0 : static unsigned int mem_serial_in(struct uart_port *p, int offset)
     396                 :            : {
     397                 :          0 :         offset = offset << p->regshift;
     398                 :          0 :         return readb(p->membase + offset);
     399                 :            : }
     400                 :            : 
     401                 :          0 : static void mem_serial_out(struct uart_port *p, int offset, int value)
     402                 :            : {
     403                 :          0 :         offset = offset << p->regshift;
     404                 :          0 :         writeb(value, p->membase + offset);
     405                 :          0 : }
     406                 :            : 
     407                 :          0 : static void mem16_serial_out(struct uart_port *p, int offset, int value)
     408                 :            : {
     409                 :          0 :         offset = offset << p->regshift;
     410                 :          0 :         writew(value, p->membase + offset);
     411                 :          0 : }
     412                 :            : 
     413                 :          0 : static unsigned int mem16_serial_in(struct uart_port *p, int offset)
     414                 :            : {
     415                 :          0 :         offset = offset << p->regshift;
     416                 :          0 :         return readw(p->membase + offset);
     417                 :            : }
     418                 :            : 
     419                 :          0 : static void mem32_serial_out(struct uart_port *p, int offset, int value)
     420                 :            : {
     421                 :          0 :         offset = offset << p->regshift;
     422                 :          0 :         writel(value, p->membase + offset);
     423                 :          0 : }
     424                 :            : 
     425                 :          0 : static unsigned int mem32_serial_in(struct uart_port *p, int offset)
     426                 :            : {
     427                 :          0 :         offset = offset << p->regshift;
     428                 :          0 :         return readl(p->membase + offset);
     429                 :            : }
     430                 :            : 
     431                 :          0 : static void mem32be_serial_out(struct uart_port *p, int offset, int value)
     432                 :            : {
     433                 :          0 :         offset = offset << p->regshift;
     434                 :          0 :         iowrite32be(value, p->membase + offset);
     435                 :          0 : }
     436                 :            : 
     437                 :          0 : static unsigned int mem32be_serial_in(struct uart_port *p, int offset)
     438                 :            : {
     439                 :          0 :         offset = offset << p->regshift;
     440                 :          0 :         return ioread32be(p->membase + offset);
     441                 :            : }
     442                 :            : 
     443                 :     344509 : static unsigned int io_serial_in(struct uart_port *p, int offset)
     444                 :            : {
     445                 :     344509 :         offset = offset << p->regshift;
     446                 :     344509 :         return inb(p->iobase + offset);
     447                 :            : }
     448                 :            : 
     449                 :     384135 : static void io_serial_out(struct uart_port *p, int offset, int value)
     450                 :            : {
     451                 :     384135 :         offset = offset << p->regshift;
     452                 :     384135 :         outb(value, p->iobase + offset);
     453                 :     384135 : }
     454                 :            : 
     455                 :            : static int serial8250_default_handle_irq(struct uart_port *port);
     456                 :            : 
     457                 :         65 : static void set_io_from_upio(struct uart_port *p)
     458                 :            : {
     459   [ -  -  -  -  :         65 :         struct uart_8250_port *up = up_to_u8250p(p);
                   -  + ]
     460                 :            : 
     461                 :         65 :         up->dl_read = default_serial_dl_read;
     462                 :         65 :         up->dl_write = default_serial_dl_write;
     463                 :            : 
     464   [ -  -  -  -  :         65 :         switch (p->iotype) {
                   -  + ]
     465                 :          0 :         case UPIO_HUB6:
     466                 :          0 :                 p->serial_in = hub6_serial_in;
     467                 :          0 :                 p->serial_out = hub6_serial_out;
     468                 :          0 :                 break;
     469                 :            : 
     470                 :          0 :         case UPIO_MEM:
     471                 :          0 :                 p->serial_in = mem_serial_in;
     472                 :          0 :                 p->serial_out = mem_serial_out;
     473                 :          0 :                 break;
     474                 :            : 
     475                 :          0 :         case UPIO_MEM16:
     476                 :          0 :                 p->serial_in = mem16_serial_in;
     477                 :          0 :                 p->serial_out = mem16_serial_out;
     478                 :          0 :                 break;
     479                 :            : 
     480                 :          0 :         case UPIO_MEM32:
     481                 :          0 :                 p->serial_in = mem32_serial_in;
     482                 :          0 :                 p->serial_out = mem32_serial_out;
     483                 :          0 :                 break;
     484                 :            : 
     485                 :          0 :         case UPIO_MEM32BE:
     486                 :          0 :                 p->serial_in = mem32be_serial_in;
     487                 :          0 :                 p->serial_out = mem32be_serial_out;
     488                 :          0 :                 break;
     489                 :            : 
     490                 :            : #ifdef CONFIG_SERIAL_8250_RT288X
     491                 :            :         case UPIO_AU:
     492                 :            :                 p->serial_in = au_serial_in;
     493                 :            :                 p->serial_out = au_serial_out;
     494                 :            :                 up->dl_read = au_serial_dl_read;
     495                 :            :                 up->dl_write = au_serial_dl_write;
     496                 :            :                 break;
     497                 :            : #endif
     498                 :            : 
     499                 :         65 :         default:
     500                 :         65 :                 p->serial_in = io_serial_in;
     501                 :         65 :                 p->serial_out = io_serial_out;
     502                 :         65 :                 break;
     503                 :            :         }
     504                 :            :         /* Remember loaded iotype */
     505                 :         65 :         up->cur_iotype = p->iotype;
     506                 :         65 :         p->handle_irq = serial8250_default_handle_irq;
     507                 :         65 : }
     508                 :            : 
     509                 :            : static void
     510                 :         26 : serial_port_out_sync(struct uart_port *p, int offset, int value)
     511                 :            : {
     512         [ -  + ]:         26 :         switch (p->iotype) {
     513                 :          0 :         case UPIO_MEM:
     514                 :            :         case UPIO_MEM16:
     515                 :            :         case UPIO_MEM32:
     516                 :            :         case UPIO_MEM32BE:
     517                 :            :         case UPIO_AU:
     518                 :          0 :                 p->serial_out(p, offset, value);
     519                 :          0 :                 p->serial_in(p, UART_LCR);   /* safe, no side-effects */
     520                 :          0 :                 break;
     521                 :         26 :         default:
     522                 :         26 :                 p->serial_out(p, offset, value);
     523                 :            :         }
     524                 :         26 : }
     525                 :            : 
     526                 :            : /*
     527                 :            :  * For the 16C950
     528                 :            :  */
     529                 :          0 : static void serial_icr_write(struct uart_8250_port *up, int offset, int value)
     530                 :            : {
     531                 :          0 :         serial_out(up, UART_SCR, offset);
     532                 :          0 :         serial_out(up, UART_ICR, value);
     533                 :          0 : }
     534                 :            : 
     535                 :            : static unsigned int serial_icr_read(struct uart_8250_port *up, int offset)
     536                 :            : {
     537                 :            :         unsigned int value;
     538                 :            : 
     539                 :            :         serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
     540                 :            :         serial_out(up, UART_SCR, offset);
     541                 :            :         value = serial_in(up, UART_ICR);
     542                 :            :         serial_icr_write(up, UART_ACR, up->acr);
     543                 :            : 
     544                 :            :         return value;
     545                 :            : }
     546                 :            : 
     547                 :            : /*
     548                 :            :  * FIFO support.
     549                 :            :  */
     550                 :         26 : static void serial8250_clear_fifos(struct uart_8250_port *p)
     551                 :            : {
     552         [ +  - ]:         26 :         if (p->capabilities & UART_CAP_FIFO) {
     553                 :         26 :                 serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO);
     554                 :         26 :                 serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO |
     555                 :            :                                UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
     556                 :         26 :                 serial_out(p, UART_FCR, 0);
     557                 :            :         }
     558                 :         26 : }
     559                 :            : 
     560                 :          0 : static inline void serial8250_em485_rts_after_send(struct uart_8250_port *p)
     561                 :            : {
     562                 :          0 :         unsigned char mcr = serial8250_in_MCR(p);
     563                 :            : 
     564         [ #  # ]:          0 :         if (p->port.rs485.flags & SER_RS485_RTS_AFTER_SEND)
     565                 :          0 :                 mcr |= UART_MCR_RTS;
     566                 :            :         else
     567                 :          0 :                 mcr &= ~UART_MCR_RTS;
     568                 :          0 :         serial8250_out_MCR(p, mcr);
     569                 :          0 : }
     570                 :            : 
     571                 :            : static enum hrtimer_restart serial8250_em485_handle_start_tx(struct hrtimer *t);
     572                 :            : static enum hrtimer_restart serial8250_em485_handle_stop_tx(struct hrtimer *t);
     573                 :            : 
     574                 :          0 : void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p)
     575                 :            : {
     576                 :          0 :         serial8250_clear_fifos(p);
     577                 :          0 :         serial_out(p, UART_FCR, p->fcr);
     578                 :          0 : }
     579                 :            : EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos);
     580                 :            : 
     581                 :      36452 : void serial8250_rpm_get(struct uart_8250_port *p)
     582                 :            : {
     583         [ #  # ]:          0 :         if (!(p->capabilities & UART_CAP_RPM))
     584                 :            :                 return;
     585                 :          0 :         pm_runtime_get_sync(p->port.dev);
     586                 :            : }
     587                 :            : EXPORT_SYMBOL_GPL(serial8250_rpm_get);
     588                 :            : 
     589                 :      36452 : void serial8250_rpm_put(struct uart_8250_port *p)
     590                 :            : {
     591         [ -  + ]:      36452 :         if (!(p->capabilities & UART_CAP_RPM))
     592                 :            :                 return;
     593                 :          0 :         pm_runtime_mark_last_busy(p->port.dev);
     594                 :          0 :         pm_runtime_put_autosuspend(p->port.dev);
     595                 :            : }
     596                 :            : EXPORT_SYMBOL_GPL(serial8250_rpm_put);
     597                 :            : 
     598                 :            : /**
     599                 :            :  *      serial8250_em485_init() - put uart_8250_port into rs485 emulating
     600                 :            :  *      @p:     uart_8250_port port instance
     601                 :            :  *
     602                 :            :  *      The function is used to start rs485 software emulating on the
     603                 :            :  *      &struct uart_8250_port* @p. Namely, RTS is switched before/after
     604                 :            :  *      transmission. The function is idempotent, so it is safe to call it
     605                 :            :  *      multiple times.
     606                 :            :  *
     607                 :            :  *      The caller MUST enable interrupt on empty shift register before
     608                 :            :  *      calling serial8250_em485_init(). This interrupt is not a part of
     609                 :            :  *      8250 standard, but implementation defined.
     610                 :            :  *
     611                 :            :  *      The function is supposed to be called from .rs485_config callback
     612                 :            :  *      or from any other callback protected with p->port.lock spinlock.
     613                 :            :  *
     614                 :            :  *      See also serial8250_em485_destroy()
     615                 :            :  *
     616                 :            :  *      Return 0 - success, -errno - otherwise
     617                 :            :  */
     618                 :          0 : int serial8250_em485_init(struct uart_8250_port *p)
     619                 :            : {
     620         [ #  # ]:          0 :         if (p->em485)
     621                 :            :                 return 0;
     622                 :            : 
     623                 :          0 :         p->em485 = kmalloc(sizeof(struct uart_8250_em485), GFP_ATOMIC);
     624         [ #  # ]:          0 :         if (!p->em485)
     625                 :            :                 return -ENOMEM;
     626                 :            : 
     627                 :          0 :         hrtimer_init(&p->em485->stop_tx_timer, CLOCK_MONOTONIC,
     628                 :            :                      HRTIMER_MODE_REL);
     629                 :          0 :         hrtimer_init(&p->em485->start_tx_timer, CLOCK_MONOTONIC,
     630                 :            :                      HRTIMER_MODE_REL);
     631                 :          0 :         p->em485->stop_tx_timer.function = &serial8250_em485_handle_stop_tx;
     632                 :          0 :         p->em485->start_tx_timer.function = &serial8250_em485_handle_start_tx;
     633                 :          0 :         p->em485->port = p;
     634                 :          0 :         p->em485->active_timer = NULL;
     635                 :          0 :         serial8250_em485_rts_after_send(p);
     636                 :            : 
     637                 :          0 :         return 0;
     638                 :            : }
     639                 :            : EXPORT_SYMBOL_GPL(serial8250_em485_init);
     640                 :            : 
     641                 :            : /**
     642                 :            :  *      serial8250_em485_destroy() - put uart_8250_port into normal state
     643                 :            :  *      @p:     uart_8250_port port instance
     644                 :            :  *
     645                 :            :  *      The function is used to stop rs485 software emulating on the
     646                 :            :  *      &struct uart_8250_port* @p. The function is idempotent, so it is safe to
     647                 :            :  *      call it multiple times.
     648                 :            :  *
     649                 :            :  *      The function is supposed to be called from .rs485_config callback
     650                 :            :  *      or from any other callback protected with p->port.lock spinlock.
     651                 :            :  *
     652                 :            :  *      See also serial8250_em485_init()
     653                 :            :  */
     654                 :          0 : void serial8250_em485_destroy(struct uart_8250_port *p)
     655                 :            : {
     656         [ #  # ]:          0 :         if (!p->em485)
     657                 :            :                 return;
     658                 :            : 
     659                 :          0 :         hrtimer_cancel(&p->em485->start_tx_timer);
     660                 :          0 :         hrtimer_cancel(&p->em485->stop_tx_timer);
     661                 :            : 
     662                 :          0 :         kfree(p->em485);
     663                 :          0 :         p->em485 = NULL;
     664                 :            : }
     665                 :            : EXPORT_SYMBOL_GPL(serial8250_em485_destroy);
     666                 :            : 
     667                 :            : /*
     668                 :            :  * These two wrappers ensure that enable_runtime_pm_tx() can be called more than
     669                 :            :  * once and disable_runtime_pm_tx() will still disable RPM because the fifo is
     670                 :            :  * empty and the HW can idle again.
     671                 :            :  */
     672                 :      11141 : void serial8250_rpm_get_tx(struct uart_8250_port *p)
     673                 :            : {
     674                 :      11141 :         unsigned char rpm_active;
     675                 :            : 
     676         [ -  + ]:      11141 :         if (!(p->capabilities & UART_CAP_RPM))
     677                 :            :                 return;
     678                 :            : 
     679                 :          0 :         rpm_active = xchg(&p->rpm_tx_active, 1);
     680         [ #  # ]:          0 :         if (rpm_active)
     681                 :            :                 return;
     682                 :          0 :         pm_runtime_get_sync(p->port.dev);
     683                 :            : }
     684                 :            : EXPORT_SYMBOL_GPL(serial8250_rpm_get_tx);
     685                 :            : 
     686                 :      11141 : void serial8250_rpm_put_tx(struct uart_8250_port *p)
     687                 :            : {
     688                 :      11141 :         unsigned char rpm_active;
     689                 :            : 
     690         [ -  + ]:      11141 :         if (!(p->capabilities & UART_CAP_RPM))
     691                 :            :                 return;
     692                 :            : 
     693                 :          0 :         rpm_active = xchg(&p->rpm_tx_active, 0);
     694         [ #  # ]:          0 :         if (!rpm_active)
     695                 :            :                 return;
     696                 :          0 :         pm_runtime_mark_last_busy(p->port.dev);
     697                 :          0 :         pm_runtime_put_autosuspend(p->port.dev);
     698                 :            : }
     699                 :            : EXPORT_SYMBOL_GPL(serial8250_rpm_put_tx);
     700                 :            : 
     701                 :            : /*
     702                 :            :  * IER sleep support.  UARTs which have EFRs need the "extended
     703                 :            :  * capability" bit enabled.  Note that on XR16C850s, we need to
     704                 :            :  * reset LCR to write to IER.
     705                 :            :  */
     706                 :         13 : static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
     707                 :            : {
     708                 :         13 :         unsigned char lcr = 0, efr = 0;
     709                 :            : 
     710         [ -  + ]:         13 :         serial8250_rpm_get(p);
     711                 :            : 
     712         [ -  + ]:         13 :         if (p->capabilities & UART_CAP_SLEEP) {
     713         [ #  # ]:          0 :                 if (p->capabilities & UART_CAP_EFR) {
     714                 :          0 :                         lcr = serial_in(p, UART_LCR);
     715                 :          0 :                         efr = serial_in(p, UART_EFR);
     716                 :          0 :                         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
     717                 :          0 :                         serial_out(p, UART_EFR, UART_EFR_ECB);
     718                 :          0 :                         serial_out(p, UART_LCR, 0);
     719                 :            :                 }
     720         [ #  # ]:          0 :                 serial_out(p, UART_IER, sleep ? UART_IERX_SLEEP : 0);
     721         [ #  # ]:          0 :                 if (p->capabilities & UART_CAP_EFR) {
     722                 :          0 :                         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
     723                 :          0 :                         serial_out(p, UART_EFR, efr);
     724                 :          0 :                         serial_out(p, UART_LCR, lcr);
     725                 :            :                 }
     726                 :            :         }
     727                 :            : 
     728                 :         13 :         serial8250_rpm_put(p);
     729                 :         13 : }
     730                 :            : 
     731                 :            : #ifdef CONFIG_SERIAL_8250_RSA
     732                 :            : /*
     733                 :            :  * Attempts to turn on the RSA FIFO.  Returns zero on failure.
     734                 :            :  * We set the port uart clock rate if we succeed.
     735                 :            :  */
     736                 :          0 : static int __enable_rsa(struct uart_8250_port *up)
     737                 :            : {
     738                 :          0 :         unsigned char mode;
     739                 :          0 :         int result;
     740                 :            : 
     741                 :          0 :         mode = serial_in(up, UART_RSA_MSR);
     742                 :          0 :         result = mode & UART_RSA_MSR_FIFO;
     743                 :            : 
     744         [ #  # ]:          0 :         if (!result) {
     745                 :          0 :                 serial_out(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
     746                 :          0 :                 mode = serial_in(up, UART_RSA_MSR);
     747                 :          0 :                 result = mode & UART_RSA_MSR_FIFO;
     748                 :            :         }
     749                 :            : 
     750         [ #  # ]:          0 :         if (result)
     751                 :          0 :                 up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
     752                 :            : 
     753                 :          0 :         return result;
     754                 :            : }
     755                 :            : 
     756                 :         13 : static void enable_rsa(struct uart_8250_port *up)
     757                 :            : {
     758         [ -  + ]:         13 :         if (up->port.type == PORT_RSA) {
     759         [ #  # ]:          0 :                 if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
     760                 :          0 :                         spin_lock_irq(&up->port.lock);
     761                 :          0 :                         __enable_rsa(up);
     762                 :          0 :                         spin_unlock_irq(&up->port.lock);
     763                 :            :                 }
     764         [ #  # ]:          0 :                 if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
     765                 :          0 :                         serial_out(up, UART_RSA_FRR, 0);
     766                 :            :         }
     767                 :         13 : }
     768                 :            : 
     769                 :            : /*
     770                 :            :  * Attempts to turn off the RSA FIFO.  Returns zero on failure.
     771                 :            :  * It is unknown why interrupts were disabled in here.  However,
     772                 :            :  * the caller is expected to preserve this behaviour by grabbing
     773                 :            :  * the spinlock before calling this function.
     774                 :            :  */
     775                 :          0 : static void disable_rsa(struct uart_8250_port *up)
     776                 :            : {
     777                 :          0 :         unsigned char mode;
     778                 :          0 :         int result;
     779                 :            : 
     780         [ #  # ]:          0 :         if (up->port.type == PORT_RSA &&
     781         [ #  # ]:          0 :             up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
     782                 :          0 :                 spin_lock_irq(&up->port.lock);
     783                 :            : 
     784                 :          0 :                 mode = serial_in(up, UART_RSA_MSR);
     785                 :          0 :                 result = !(mode & UART_RSA_MSR_FIFO);
     786                 :            : 
     787         [ #  # ]:          0 :                 if (!result) {
     788                 :          0 :                         serial_out(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
     789                 :          0 :                         mode = serial_in(up, UART_RSA_MSR);
     790                 :          0 :                         result = !(mode & UART_RSA_MSR_FIFO);
     791                 :            :                 }
     792                 :            : 
     793         [ #  # ]:          0 :                 if (result)
     794                 :          0 :                         up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
     795                 :          0 :                 spin_unlock_irq(&up->port.lock);
     796                 :            :         }
     797                 :          0 : }
     798                 :            : #endif /* CONFIG_SERIAL_8250_RSA */
     799                 :            : 
     800                 :            : /*
     801                 :            :  * This is a quickie test to see how big the FIFO is.
     802                 :            :  * It doesn't work at all the time, more's the pity.
     803                 :            :  */
     804                 :            : static int size_fifo(struct uart_8250_port *up)
     805                 :            : {
     806                 :            :         unsigned char old_fcr, old_mcr, old_lcr;
     807                 :            :         unsigned short old_dl;
     808                 :            :         int count;
     809                 :            : 
     810                 :            :         old_lcr = serial_in(up, UART_LCR);
     811                 :            :         serial_out(up, UART_LCR, 0);
     812                 :            :         old_fcr = serial_in(up, UART_FCR);
     813                 :            :         old_mcr = serial8250_in_MCR(up);
     814                 :            :         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
     815                 :            :                     UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
     816                 :            :         serial8250_out_MCR(up, UART_MCR_LOOP);
     817                 :            :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
     818                 :            :         old_dl = serial_dl_read(up);
     819                 :            :         serial_dl_write(up, 0x0001);
     820                 :            :         serial_out(up, UART_LCR, 0x03);
     821                 :            :         for (count = 0; count < 256; count++)
     822                 :            :                 serial_out(up, UART_TX, count);
     823                 :            :         mdelay(20);/* FIXME - schedule_timeout */
     824                 :            :         for (count = 0; (serial_in(up, UART_LSR) & UART_LSR_DR) &&
     825                 :            :              (count < 256); count++)
     826                 :            :                 serial_in(up, UART_RX);
     827                 :            :         serial_out(up, UART_FCR, old_fcr);
     828                 :            :         serial8250_out_MCR(up, old_mcr);
     829                 :            :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
     830                 :            :         serial_dl_write(up, old_dl);
     831                 :            :         serial_out(up, UART_LCR, old_lcr);
     832                 :            : 
     833                 :            :         return count;
     834                 :            : }
     835                 :            : 
     836                 :            : /*
     837                 :            :  * Read UART ID using the divisor method - set DLL and DLM to zero
     838                 :            :  * and the revision will be in DLL and device type in DLM.  We
     839                 :            :  * preserve the device state across this.
     840                 :            :  */
     841                 :            : static unsigned int autoconfig_read_divisor_id(struct uart_8250_port *p)
     842                 :            : {
     843                 :            :         unsigned char old_lcr;
     844                 :            :         unsigned int id, old_dl;
     845                 :            : 
     846                 :            :         old_lcr = serial_in(p, UART_LCR);
     847                 :            :         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_A);
     848                 :            :         old_dl = serial_dl_read(p);
     849                 :            :         serial_dl_write(p, 0);
     850                 :            :         id = serial_dl_read(p);
     851                 :            :         serial_dl_write(p, old_dl);
     852                 :            : 
     853                 :            :         serial_out(p, UART_LCR, old_lcr);
     854                 :            : 
     855                 :            :         return id;
     856                 :            : }
     857                 :            : 
     858                 :            : /*
     859                 :            :  * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's.
     860                 :            :  * When this function is called we know it is at least a StarTech
     861                 :            :  * 16650 V2, but it might be one of several StarTech UARTs, or one of
     862                 :            :  * its clones.  (We treat the broken original StarTech 16650 V1 as a
     863                 :            :  * 16550, and why not?  Startech doesn't seem to even acknowledge its
     864                 :            :  * existence.)
     865                 :            :  *
     866                 :            :  * What evil have men's minds wrought...
     867                 :            :  */
     868                 :            : static void autoconfig_has_efr(struct uart_8250_port *up)
     869                 :            : {
     870                 :            :         unsigned int id1, id2, id3, rev;
     871                 :            : 
     872                 :            :         /*
     873                 :            :          * Everything with an EFR has SLEEP
     874                 :            :          */
     875                 :            :         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
     876                 :            : 
     877                 :            :         /*
     878                 :            :          * First we check to see if it's an Oxford Semiconductor UART.
     879                 :            :          *
     880                 :            :          * If we have to do this here because some non-National
     881                 :            :          * Semiconductor clone chips lock up if you try writing to the
     882                 :            :          * LSR register (which serial_icr_read does)
     883                 :            :          */
     884                 :            : 
     885                 :            :         /*
     886                 :            :          * Check for Oxford Semiconductor 16C950.
     887                 :            :          *
     888                 :            :          * EFR [4] must be set else this test fails.
     889                 :            :          *
     890                 :            :          * This shouldn't be necessary, but Mike Hudson (Exoray@isys.ca)
     891                 :            :          * claims that it's needed for 952 dual UART's (which are not
     892                 :            :          * recommended for new designs).
     893                 :            :          */
     894                 :            :         up->acr = 0;
     895                 :            :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
     896                 :            :         serial_out(up, UART_EFR, UART_EFR_ECB);
     897                 :            :         serial_out(up, UART_LCR, 0x00);
     898                 :            :         id1 = serial_icr_read(up, UART_ID1);
     899                 :            :         id2 = serial_icr_read(up, UART_ID2);
     900                 :            :         id3 = serial_icr_read(up, UART_ID3);
     901                 :            :         rev = serial_icr_read(up, UART_REV);
     902                 :            : 
     903                 :            :         DEBUG_AUTOCONF("950id=%02x:%02x:%02x:%02x ", id1, id2, id3, rev);
     904                 :            : 
     905                 :            :         if (id1 == 0x16 && id2 == 0xC9 &&
     906                 :            :             (id3 == 0x50 || id3 == 0x52 || id3 == 0x54)) {
     907                 :            :                 up->port.type = PORT_16C950;
     908                 :            : 
     909                 :            :                 /*
     910                 :            :                  * Enable work around for the Oxford Semiconductor 952 rev B
     911                 :            :                  * chip which causes it to seriously miscalculate baud rates
     912                 :            :                  * when DLL is 0.
     913                 :            :                  */
     914                 :            :                 if (id3 == 0x52 && rev == 0x01)
     915                 :            :                         up->bugs |= UART_BUG_QUOT;
     916                 :            :                 return;
     917                 :            :         }
     918                 :            : 
     919                 :            :         /*
     920                 :            :          * We check for a XR16C850 by setting DLL and DLM to 0, and then
     921                 :            :          * reading back DLL and DLM.  The chip type depends on the DLM
     922                 :            :          * value read back:
     923                 :            :          *  0x10 - XR16C850 and the DLL contains the chip revision.
     924                 :            :          *  0x12 - XR16C2850.
     925                 :            :          *  0x14 - XR16C854.
     926                 :            :          */
     927                 :            :         id1 = autoconfig_read_divisor_id(up);
     928                 :            :         DEBUG_AUTOCONF("850id=%04x ", id1);
     929                 :            : 
     930                 :            :         id2 = id1 >> 8;
     931                 :            :         if (id2 == 0x10 || id2 == 0x12 || id2 == 0x14) {
     932                 :            :                 up->port.type = PORT_16850;
     933                 :            :                 return;
     934                 :            :         }
     935                 :            : 
     936                 :            :         /*
     937                 :            :          * It wasn't an XR16C850.
     938                 :            :          *
     939                 :            :          * We distinguish between the '654 and the '650 by counting
     940                 :            :          * how many bytes are in the FIFO.  I'm using this for now,
     941                 :            :          * since that's the technique that was sent to me in the
     942                 :            :          * serial driver update, but I'm not convinced this works.
     943                 :            :          * I've had problems doing this in the past.  -TYT
     944                 :            :          */
     945                 :            :         if (size_fifo(up) == 64)
     946                 :            :                 up->port.type = PORT_16654;
     947                 :            :         else
     948                 :            :                 up->port.type = PORT_16650V2;
     949                 :            : }
     950                 :            : 
     951                 :            : /*
     952                 :            :  * We detected a chip without a FIFO.  Only two fall into
     953                 :            :  * this category - the original 8250 and the 16450.  The
     954                 :            :  * 16450 has a scratch register (accessible with LCR=0)
     955                 :            :  */
     956                 :          0 : static void autoconfig_8250(struct uart_8250_port *up)
     957                 :            : {
     958                 :          0 :         unsigned char scratch, status1, status2;
     959                 :            : 
     960                 :          0 :         up->port.type = PORT_8250;
     961                 :            : 
     962                 :          0 :         scratch = serial_in(up, UART_SCR);
     963                 :          0 :         serial_out(up, UART_SCR, 0xa5);
     964                 :          0 :         status1 = serial_in(up, UART_SCR);
     965                 :          0 :         serial_out(up, UART_SCR, 0x5a);
     966                 :          0 :         status2 = serial_in(up, UART_SCR);
     967                 :          0 :         serial_out(up, UART_SCR, scratch);
     968                 :            : 
     969         [ #  # ]:          0 :         if (status1 == 0xa5 && status2 == 0x5a)
     970                 :          0 :                 up->port.type = PORT_16450;
     971                 :          0 : }
     972                 :            : 
     973                 :            : static int broken_efr(struct uart_8250_port *up)
     974                 :            : {
     975                 :            :         /*
     976                 :            :          * Exar ST16C2550 "A2" devices incorrectly detect as
     977                 :            :          * having an EFR, and report an ID of 0x0201.  See
     978                 :            :          * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html
     979                 :            :          */
     980                 :            :         if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16)
     981                 :            :                 return 1;
     982                 :            : 
     983                 :            :         return 0;
     984                 :            : }
     985                 :            : 
     986                 :            : /*
     987                 :            :  * We know that the chip has FIFOs.  Does it have an EFR?  The
     988                 :            :  * EFR is located in the same register position as the IIR and
     989                 :            :  * we know the top two bits of the IIR are currently set.  The
     990                 :            :  * EFR should contain zero.  Try to read the EFR.
     991                 :            :  */
     992                 :         13 : static void autoconfig_16550a(struct uart_8250_port *up)
     993                 :            : {
     994                 :         13 :         unsigned char status1, status2;
     995                 :         13 :         unsigned int iersave;
     996                 :            : 
     997                 :         13 :         up->port.type = PORT_16550A;
     998                 :         13 :         up->capabilities |= UART_CAP_FIFO;
     999                 :            : 
    1000                 :         13 :         if (!IS_ENABLED(CONFIG_SERIAL_8250_16550A_VARIANTS))
    1001                 :         13 :                 return;
    1002                 :            : 
    1003                 :            :         /*
    1004                 :            :          * Check for presence of the EFR when DLAB is set.
    1005                 :            :          * Only ST16C650V1 UARTs pass this test.
    1006                 :            :          */
    1007                 :            :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
    1008                 :            :         if (serial_in(up, UART_EFR) == 0) {
    1009                 :            :                 serial_out(up, UART_EFR, 0xA8);
    1010                 :            :                 if (serial_in(up, UART_EFR) != 0) {
    1011                 :            :                         DEBUG_AUTOCONF("EFRv1 ");
    1012                 :            :                         up->port.type = PORT_16650;
    1013                 :            :                         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
    1014                 :            :                 } else {
    1015                 :            :                         serial_out(up, UART_LCR, 0);
    1016                 :            :                         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
    1017                 :            :                                    UART_FCR7_64BYTE);
    1018                 :            :                         status1 = serial_in(up, UART_IIR) >> 5;
    1019                 :            :                         serial_out(up, UART_FCR, 0);
    1020                 :            :                         serial_out(up, UART_LCR, 0);
    1021                 :            : 
    1022                 :            :                         if (status1 == 7)
    1023                 :            :                                 up->port.type = PORT_16550A_FSL64;
    1024                 :            :                         else
    1025                 :            :                                 DEBUG_AUTOCONF("Motorola 8xxx DUART ");
    1026                 :            :                 }
    1027                 :            :                 serial_out(up, UART_EFR, 0);
    1028                 :            :                 return;
    1029                 :            :         }
    1030                 :            : 
    1031                 :            :         /*
    1032                 :            :          * Maybe it requires 0xbf to be written to the LCR.
    1033                 :            :          * (other ST16C650V2 UARTs, TI16C752A, etc)
    1034                 :            :          */
    1035                 :            :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
    1036                 :            :         if (serial_in(up, UART_EFR) == 0 && !broken_efr(up)) {
    1037                 :            :                 DEBUG_AUTOCONF("EFRv2 ");
    1038                 :            :                 autoconfig_has_efr(up);
    1039                 :            :                 return;
    1040                 :            :         }
    1041                 :            : 
    1042                 :            :         /*
    1043                 :            :          * Check for a National Semiconductor SuperIO chip.
    1044                 :            :          * Attempt to switch to bank 2, read the value of the LOOP bit
    1045                 :            :          * from EXCR1. Switch back to bank 0, change it in MCR. Then
    1046                 :            :          * switch back to bank 2, read it from EXCR1 again and check
    1047                 :            :          * it's changed. If so, set baud_base in EXCR2 to 921600. -- dwmw2
    1048                 :            :          */
    1049                 :            :         serial_out(up, UART_LCR, 0);
    1050                 :            :         status1 = serial8250_in_MCR(up);
    1051                 :            :         serial_out(up, UART_LCR, 0xE0);
    1052                 :            :         status2 = serial_in(up, 0x02); /* EXCR1 */
    1053                 :            : 
    1054                 :            :         if (!((status2 ^ status1) & UART_MCR_LOOP)) {
    1055                 :            :                 serial_out(up, UART_LCR, 0);
    1056                 :            :                 serial8250_out_MCR(up, status1 ^ UART_MCR_LOOP);
    1057                 :            :                 serial_out(up, UART_LCR, 0xE0);
    1058                 :            :                 status2 = serial_in(up, 0x02); /* EXCR1 */
    1059                 :            :                 serial_out(up, UART_LCR, 0);
    1060                 :            :                 serial8250_out_MCR(up, status1);
    1061                 :            : 
    1062                 :            :                 if ((status2 ^ status1) & UART_MCR_LOOP) {
    1063                 :            :                         unsigned short quot;
    1064                 :            : 
    1065                 :            :                         serial_out(up, UART_LCR, 0xE0);
    1066                 :            : 
    1067                 :            :                         quot = serial_dl_read(up);
    1068                 :            :                         quot <<= 3;
    1069                 :            : 
    1070                 :            :                         if (ns16550a_goto_highspeed(up))
    1071                 :            :                                 serial_dl_write(up, quot);
    1072                 :            : 
    1073                 :            :                         serial_out(up, UART_LCR, 0);
    1074                 :            : 
    1075                 :            :                         up->port.uartclk = 921600*16;
    1076                 :            :                         up->port.type = PORT_NS16550A;
    1077                 :            :                         up->capabilities |= UART_NATSEMI;
    1078                 :            :                         return;
    1079                 :            :                 }
    1080                 :            :         }
    1081                 :            : 
    1082                 :            :         /*
    1083                 :            :          * No EFR.  Try to detect a TI16750, which only sets bit 5 of
    1084                 :            :          * the IIR when 64 byte FIFO mode is enabled when DLAB is set.
    1085                 :            :          * Try setting it with and without DLAB set.  Cheap clones
    1086                 :            :          * set bit 5 without DLAB set.
    1087                 :            :          */
    1088                 :            :         serial_out(up, UART_LCR, 0);
    1089                 :            :         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
    1090                 :            :         status1 = serial_in(up, UART_IIR) >> 5;
    1091                 :            :         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
    1092                 :            :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
    1093                 :            :         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
    1094                 :            :         status2 = serial_in(up, UART_IIR) >> 5;
    1095                 :            :         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
    1096                 :            :         serial_out(up, UART_LCR, 0);
    1097                 :            : 
    1098                 :            :         DEBUG_AUTOCONF("iir1=%d iir2=%d ", status1, status2);
    1099                 :            : 
    1100                 :            :         if (status1 == 6 && status2 == 7) {
    1101                 :            :                 up->port.type = PORT_16750;
    1102                 :            :                 up->capabilities |= UART_CAP_AFE | UART_CAP_SLEEP;
    1103                 :            :                 return;
    1104                 :            :         }
    1105                 :            : 
    1106                 :            :         /*
    1107                 :            :          * Try writing and reading the UART_IER_UUE bit (b6).
    1108                 :            :          * If it works, this is probably one of the Xscale platform's
    1109                 :            :          * internal UARTs.
    1110                 :            :          * We're going to explicitly set the UUE bit to 0 before
    1111                 :            :          * trying to write and read a 1 just to make sure it's not
    1112                 :            :          * already a 1 and maybe locked there before we even start start.
    1113                 :            :          */
    1114                 :            :         iersave = serial_in(up, UART_IER);
    1115                 :            :         serial_out(up, UART_IER, iersave & ~UART_IER_UUE);
    1116                 :            :         if (!(serial_in(up, UART_IER) & UART_IER_UUE)) {
    1117                 :            :                 /*
    1118                 :            :                  * OK it's in a known zero state, try writing and reading
    1119                 :            :                  * without disturbing the current state of the other bits.
    1120                 :            :                  */
    1121                 :            :                 serial_out(up, UART_IER, iersave | UART_IER_UUE);
    1122                 :            :                 if (serial_in(up, UART_IER) & UART_IER_UUE) {
    1123                 :            :                         /*
    1124                 :            :                          * It's an Xscale.
    1125                 :            :                          * We'll leave the UART_IER_UUE bit set to 1 (enabled).
    1126                 :            :                          */
    1127                 :            :                         DEBUG_AUTOCONF("Xscale ");
    1128                 :            :                         up->port.type = PORT_XSCALE;
    1129                 :            :                         up->capabilities |= UART_CAP_UUE | UART_CAP_RTOIE;
    1130                 :            :                         return;
    1131                 :            :                 }
    1132                 :            :         } else {
    1133                 :            :                 /*
    1134                 :            :                  * If we got here we couldn't force the IER_UUE bit to 0.
    1135                 :            :                  * Log it and continue.
    1136                 :            :                  */
    1137                 :            :                 DEBUG_AUTOCONF("Couldn't force IER_UUE to 0 ");
    1138                 :            :         }
    1139                 :            :         serial_out(up, UART_IER, iersave);
    1140                 :            : 
    1141                 :            :         /*
    1142                 :            :          * We distinguish between 16550A and U6 16550A by counting
    1143                 :            :          * how many bytes are in the FIFO.
    1144                 :            :          */
    1145                 :            :         if (up->port.type == PORT_16550A && size_fifo(up) == 64) {
    1146                 :            :                 up->port.type = PORT_U6_16550A;
    1147                 :            :                 up->capabilities |= UART_CAP_AFE;
    1148                 :            :         }
    1149                 :            : }
    1150                 :            : 
    1151                 :            : /*
    1152                 :            :  * This routine is called by rs_init() to initialize a specific serial
    1153                 :            :  * port.  It determines what type of UART chip this serial port is
    1154                 :            :  * using: 8250, 16450, 16550, 16550A.  The important question is
    1155                 :            :  * whether or not this UART is a 16550A or not, since this will
    1156                 :            :  * determine whether or not we can use its FIFO features or not.
    1157                 :            :  */
    1158                 :         52 : static void autoconfig(struct uart_8250_port *up)
    1159                 :            : {
    1160                 :         52 :         unsigned char status1, scratch, scratch2, scratch3;
    1161                 :         52 :         unsigned char save_lcr, save_mcr;
    1162                 :         52 :         struct uart_port *port = &up->port;
    1163                 :         52 :         unsigned long flags;
    1164                 :         52 :         unsigned int old_capabilities;
    1165                 :            : 
    1166   [ -  +  -  -  :         52 :         if (!port->iobase && !port->mapbase && !port->membase)
                   -  - ]
    1167                 :            :                 return;
    1168                 :            : 
    1169                 :         52 :         DEBUG_AUTOCONF("%s: autoconf (0x%04lx, 0x%p): ",
    1170                 :            :                        port->name, port->iobase, port->membase);
    1171                 :            : 
    1172                 :            :         /*
    1173                 :            :          * We really do need global IRQs disabled here - we're going to
    1174                 :            :          * be frobbing the chips IRQ enable register to see if it exists.
    1175                 :            :          */
    1176                 :         52 :         spin_lock_irqsave(&port->lock, flags);
    1177                 :            : 
    1178                 :         52 :         up->capabilities = 0;
    1179                 :         52 :         up->bugs = 0;
    1180                 :            : 
    1181         [ +  - ]:         52 :         if (!(port->flags & UPF_BUGGY_UART)) {
    1182                 :            :                 /*
    1183                 :            :                  * Do a simple existence test first; if we fail this,
    1184                 :            :                  * there's no point trying anything else.
    1185                 :            :                  *
    1186                 :            :                  * 0x80 is used as a nonsense port to prevent against
    1187                 :            :                  * false positives due to ISA bus float.  The
    1188                 :            :                  * assumption is that 0x80 is a non-existent port;
    1189                 :            :                  * which should be safe since include/asm/io.h also
    1190                 :            :                  * makes this assumption.
    1191                 :            :                  *
    1192                 :            :                  * Note: this is safe as long as MCR bit 4 is clear
    1193                 :            :                  * and the device is in "PC" mode.
    1194                 :            :                  */
    1195                 :         52 :                 scratch = serial_in(up, UART_IER);
    1196                 :         52 :                 serial_out(up, UART_IER, 0);
    1197                 :            : #ifdef __i386__
    1198                 :            :                 outb(0xff, 0x080);
    1199                 :            : #endif
    1200                 :            :                 /*
    1201                 :            :                  * Mask out IER[7:4] bits for test as some UARTs (e.g. TL
    1202                 :            :                  * 16C754B) allow only to modify them if an EFR bit is set.
    1203                 :            :                  */
    1204                 :         52 :                 scratch2 = serial_in(up, UART_IER) & 0x0f;
    1205                 :         52 :                 serial_out(up, UART_IER, 0x0F);
    1206                 :            : #ifdef __i386__
    1207                 :            :                 outb(0, 0x080);
    1208                 :            : #endif
    1209                 :         52 :                 scratch3 = serial_in(up, UART_IER) & 0x0f;
    1210                 :         52 :                 serial_out(up, UART_IER, scratch);
    1211         [ +  + ]:         52 :                 if (scratch2 != 0 || scratch3 != 0x0F) {
    1212                 :            :                         /*
    1213                 :            :                          * We failed; there's nothing here
    1214                 :            :                          */
    1215                 :         39 :                         spin_unlock_irqrestore(&port->lock, flags);
    1216                 :         39 :                         DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
    1217                 :            :                                        scratch2, scratch3);
    1218                 :         39 :                         goto out;
    1219                 :            :                 }
    1220                 :            :         }
    1221                 :            : 
    1222                 :         13 :         save_mcr = serial8250_in_MCR(up);
    1223                 :         13 :         save_lcr = serial_in(up, UART_LCR);
    1224                 :            : 
    1225                 :            :         /*
    1226                 :            :          * Check to see if a UART is really there.  Certain broken
    1227                 :            :          * internal modems based on the Rockwell chipset fail this
    1228                 :            :          * test, because they apparently don't implement the loopback
    1229                 :            :          * test mode.  So this test is skipped on the COM 1 through
    1230                 :            :          * COM 4 ports.  This *should* be safe, since no board
    1231                 :            :          * manufacturer would be stupid enough to design a board
    1232                 :            :          * that conflicts with COM 1-4 --- we hope!
    1233                 :            :          */
    1234         [ -  + ]:         13 :         if (!(port->flags & UPF_SKIP_TEST)) {
    1235                 :          0 :                 serial8250_out_MCR(up, UART_MCR_LOOP | 0x0A);
    1236                 :          0 :                 status1 = serial_in(up, UART_MSR) & 0xF0;
    1237                 :          0 :                 serial8250_out_MCR(up, save_mcr);
    1238         [ #  # ]:          0 :                 if (status1 != 0x90) {
    1239                 :          0 :                         spin_unlock_irqrestore(&port->lock, flags);
    1240                 :          0 :                         DEBUG_AUTOCONF("LOOP test failed (%02x) ",
    1241                 :            :                                        status1);
    1242                 :          0 :                         goto out;
    1243                 :            :                 }
    1244                 :            :         }
    1245                 :            : 
    1246                 :            :         /*
    1247                 :            :          * We're pretty sure there's a port here.  Lets find out what
    1248                 :            :          * type of port it is.  The IIR top two bits allows us to find
    1249                 :            :          * out if it's 8250 or 16450, 16550, 16550A or later.  This
    1250                 :            :          * determines what we test for next.
    1251                 :            :          *
    1252                 :            :          * We also initialise the EFR (if any) to zero for later.  The
    1253                 :            :          * EFR occupies the same register location as the FCR and IIR.
    1254                 :            :          */
    1255                 :         13 :         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
    1256                 :         13 :         serial_out(up, UART_EFR, 0);
    1257                 :         13 :         serial_out(up, UART_LCR, 0);
    1258                 :            : 
    1259                 :         13 :         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
    1260                 :         13 :         scratch = serial_in(up, UART_IIR) >> 6;
    1261                 :            : 
    1262   [ -  -  -  +  :         13 :         switch (scratch) {
                      - ]
    1263                 :          0 :         case 0:
    1264                 :          0 :                 autoconfig_8250(up);
    1265                 :          0 :                 break;
    1266                 :          0 :         case 1:
    1267                 :          0 :                 port->type = PORT_UNKNOWN;
    1268                 :          0 :                 break;
    1269                 :          0 :         case 2:
    1270                 :          0 :                 port->type = PORT_16550;
    1271                 :          0 :                 break;
    1272                 :         13 :         case 3:
    1273                 :         13 :                 autoconfig_16550a(up);
    1274                 :            :                 break;
    1275                 :            :         }
    1276                 :            : 
    1277                 :            : #ifdef CONFIG_SERIAL_8250_RSA
    1278                 :            :         /*
    1279                 :            :          * Only probe for RSA ports if we got the region.
    1280                 :            :          */
    1281   [ +  -  -  +  :         13 :         if (port->type == PORT_16550A && up->probe & UART_PROBE_RSA &&
                   -  - ]
    1282                 :          0 :             __enable_rsa(up))
    1283                 :          0 :                 port->type = PORT_RSA;
    1284                 :            : #endif
    1285                 :            : 
    1286                 :         13 :         serial_out(up, UART_LCR, save_lcr);
    1287                 :            : 
    1288                 :         13 :         port->fifosize = uart_config[up->port.type].fifo_size;
    1289                 :         13 :         old_capabilities = up->capabilities;
    1290                 :         13 :         up->capabilities = uart_config[port->type].flags;
    1291                 :         13 :         up->tx_loadsz = uart_config[port->type].tx_loadsz;
    1292                 :            : 
    1293         [ -  + ]:         13 :         if (port->type == PORT_UNKNOWN)
    1294                 :          0 :                 goto out_lock;
    1295                 :            : 
    1296                 :            :         /*
    1297                 :            :          * Reset the UART.
    1298                 :            :          */
    1299                 :            : #ifdef CONFIG_SERIAL_8250_RSA
    1300         [ -  + ]:         13 :         if (port->type == PORT_RSA)
    1301                 :          0 :                 serial_out(up, UART_RSA_FRR, 0);
    1302                 :            : #endif
    1303                 :         13 :         serial8250_out_MCR(up, save_mcr);
    1304                 :         13 :         serial8250_clear_fifos(up);
    1305                 :         13 :         serial_in(up, UART_RX);
    1306         [ -  + ]:         13 :         if (up->capabilities & UART_CAP_UUE)
    1307                 :          0 :                 serial_out(up, UART_IER, UART_IER_UUE);
    1308                 :            :         else
    1309                 :         13 :                 serial_out(up, UART_IER, 0);
    1310                 :            : 
    1311                 :         13 : out_lock:
    1312                 :         13 :         spin_unlock_irqrestore(&port->lock, flags);
    1313                 :            : 
    1314                 :            :         /*
    1315                 :            :          * Check if the device is a Fintek F81216A
    1316                 :            :          */
    1317                 :         13 :         if (port->type == PORT_16550A && port->iotype == UPIO_PORT)
    1318                 :            :                 fintek_8250_probe(up);
    1319                 :            : 
    1320         [ +  - ]:         13 :         if (up->capabilities != old_capabilities) {
    1321                 :          0 :                 pr_warn("%s: detected caps %08x should be %08x\n",
    1322                 :            :                         port->name, old_capabilities, up->capabilities);
    1323                 :            :         }
    1324                 :         13 : out:
    1325                 :         52 :         DEBUG_AUTOCONF("iir=%d ", scratch);
    1326                 :         52 :         DEBUG_AUTOCONF("type=%s\n", uart_config[port->type].name);
    1327                 :            : }
    1328                 :            : 
    1329                 :          0 : static void autoconfig_irq(struct uart_8250_port *up)
    1330                 :            : {
    1331                 :          0 :         struct uart_port *port = &up->port;
    1332                 :          0 :         unsigned char save_mcr, save_ier;
    1333                 :          0 :         unsigned char save_ICP = 0;
    1334                 :          0 :         unsigned int ICP = 0;
    1335                 :          0 :         unsigned long irqs;
    1336                 :          0 :         int irq;
    1337                 :            : 
    1338         [ #  # ]:          0 :         if (port->flags & UPF_FOURPORT) {
    1339                 :          0 :                 ICP = (port->iobase & 0xfe0) | 0x1f;
    1340                 :          0 :                 save_ICP = inb_p(ICP);
    1341                 :          0 :                 outb_p(0x80, ICP);
    1342                 :          0 :                 inb_p(ICP);
    1343                 :            :         }
    1344                 :            : 
    1345   [ #  #  #  # ]:          0 :         if (uart_console(port))
    1346                 :          0 :                 console_lock();
    1347                 :            : 
    1348                 :            :         /* forget possible initially masked and pending IRQ */
    1349                 :          0 :         probe_irq_off(probe_irq_on());
    1350                 :          0 :         save_mcr = serial8250_in_MCR(up);
    1351                 :          0 :         save_ier = serial_in(up, UART_IER);
    1352                 :          0 :         serial8250_out_MCR(up, UART_MCR_OUT1 | UART_MCR_OUT2);
    1353                 :            : 
    1354                 :          0 :         irqs = probe_irq_on();
    1355                 :          0 :         serial8250_out_MCR(up, 0);
    1356                 :          0 :         udelay(10);
    1357         [ #  # ]:          0 :         if (port->flags & UPF_FOURPORT) {
    1358                 :          0 :                 serial8250_out_MCR(up, UART_MCR_DTR | UART_MCR_RTS);
    1359                 :            :         } else {
    1360                 :          0 :                 serial8250_out_MCR(up,
    1361                 :            :                         UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
    1362                 :            :         }
    1363                 :          0 :         serial_out(up, UART_IER, 0x0f); /* enable all intrs */
    1364                 :          0 :         serial_in(up, UART_LSR);
    1365                 :          0 :         serial_in(up, UART_RX);
    1366                 :          0 :         serial_in(up, UART_IIR);
    1367                 :          0 :         serial_in(up, UART_MSR);
    1368                 :          0 :         serial_out(up, UART_TX, 0xFF);
    1369                 :          0 :         udelay(20);
    1370                 :          0 :         irq = probe_irq_off(irqs);
    1371                 :            : 
    1372                 :          0 :         serial8250_out_MCR(up, save_mcr);
    1373                 :          0 :         serial_out(up, UART_IER, save_ier);
    1374                 :            : 
    1375         [ #  # ]:          0 :         if (port->flags & UPF_FOURPORT)
    1376                 :          0 :                 outb_p(save_ICP, ICP);
    1377                 :            : 
    1378   [ #  #  #  # ]:          0 :         if (uart_console(port))
    1379                 :          0 :                 console_unlock();
    1380                 :            : 
    1381                 :          0 :         port->irq = (irq > 0) ? irq : 0;
    1382                 :          0 : }
    1383                 :            : 
    1384                 :          0 : static void serial8250_stop_rx(struct uart_port *port)
    1385                 :            : {
    1386         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1387                 :            : 
    1388         [ #  # ]:          0 :         serial8250_rpm_get(up);
    1389                 :            : 
    1390                 :          0 :         up->ier &= ~(UART_IER_RLSI | UART_IER_RDI);
    1391                 :          0 :         up->port.read_status_mask &= ~UART_LSR_DR;
    1392                 :          0 :         serial_port_out(port, UART_IER, up->ier);
    1393                 :            : 
    1394                 :          0 :         serial8250_rpm_put(up);
    1395                 :          0 : }
    1396                 :            : 
    1397                 :          0 : static void __do_stop_tx_rs485(struct uart_8250_port *p)
    1398                 :            : {
    1399                 :          0 :         serial8250_em485_rts_after_send(p);
    1400                 :            : 
    1401                 :            :         /*
    1402                 :            :          * Empty the RX FIFO, we are not interested in anything
    1403                 :            :          * received during the half-duplex transmission.
    1404                 :            :          * Enable previously disabled RX interrupts.
    1405                 :            :          */
    1406         [ #  # ]:          0 :         if (!(p->port.rs485.flags & SER_RS485_RX_DURING_TX)) {
    1407                 :          0 :                 serial8250_clear_and_reinit_fifos(p);
    1408                 :            : 
    1409                 :          0 :                 p->ier |= UART_IER_RLSI | UART_IER_RDI;
    1410                 :          0 :                 serial_port_out(&p->port, UART_IER, p->ier);
    1411                 :            :         }
    1412                 :          0 : }
    1413                 :          0 : static enum hrtimer_restart serial8250_em485_handle_stop_tx(struct hrtimer *t)
    1414                 :            : {
    1415                 :          0 :         struct uart_8250_em485 *em485;
    1416                 :          0 :         struct uart_8250_port *p;
    1417                 :          0 :         unsigned long flags;
    1418                 :            : 
    1419                 :          0 :         em485 = container_of(t, struct uart_8250_em485, stop_tx_timer);
    1420                 :          0 :         p = em485->port;
    1421                 :            : 
    1422         [ #  # ]:          0 :         serial8250_rpm_get(p);
    1423                 :          0 :         spin_lock_irqsave(&p->port.lock, flags);
    1424         [ #  # ]:          0 :         if (em485->active_timer == &em485->stop_tx_timer) {
    1425                 :          0 :                 __do_stop_tx_rs485(p);
    1426                 :          0 :                 em485->active_timer = NULL;
    1427                 :            :         }
    1428                 :          0 :         spin_unlock_irqrestore(&p->port.lock, flags);
    1429                 :          0 :         serial8250_rpm_put(p);
    1430                 :          0 :         return HRTIMER_NORESTART;
    1431                 :            : }
    1432                 :            : 
    1433                 :          0 : static void start_hrtimer_ms(struct hrtimer *hrt, unsigned long msec)
    1434                 :            : {
    1435                 :          0 :         long sec = msec / 1000;
    1436                 :          0 :         long nsec = (msec % 1000) * 1000000;
    1437         [ #  # ]:          0 :         ktime_t t = ktime_set(sec, nsec);
    1438                 :            : 
    1439                 :          0 :         hrtimer_start(hrt, t, HRTIMER_MODE_REL);
    1440                 :          0 : }
    1441                 :            : 
    1442                 :          0 : static void __stop_tx_rs485(struct uart_8250_port *p)
    1443                 :            : {
    1444                 :          0 :         struct uart_8250_em485 *em485 = p->em485;
    1445                 :            : 
    1446                 :            :         /*
    1447                 :            :          * __do_stop_tx_rs485 is going to set RTS according to config
    1448                 :            :          * AND flush RX FIFO if required.
    1449                 :            :          */
    1450         [ #  # ]:          0 :         if (p->port.rs485.delay_rts_after_send > 0) {
    1451                 :          0 :                 em485->active_timer = &em485->stop_tx_timer;
    1452                 :          0 :                 start_hrtimer_ms(&em485->stop_tx_timer,
    1453                 :          0 :                                    p->port.rs485.delay_rts_after_send);
    1454                 :            :         } else {
    1455                 :          0 :                 __do_stop_tx_rs485(p);
    1456                 :            :         }
    1457                 :          0 : }
    1458                 :            : 
    1459                 :      11141 : static inline void __do_stop_tx(struct uart_8250_port *p)
    1460                 :            : {
    1461         [ +  - ]:      11141 :         if (serial8250_clear_THRI(p))
    1462                 :      11141 :                 serial8250_rpm_put_tx(p);
    1463                 :      11141 : }
    1464                 :            : 
    1465                 :      11141 : static inline void __stop_tx(struct uart_8250_port *p)
    1466                 :            : {
    1467                 :      11141 :         struct uart_8250_em485 *em485 = p->em485;
    1468                 :            : 
    1469         [ -  + ]:      11141 :         if (em485) {
    1470                 :          0 :                 unsigned char lsr = serial_in(p, UART_LSR);
    1471                 :            :                 /*
    1472                 :            :                  * To provide required timeing and allow FIFO transfer,
    1473                 :            :                  * __stop_tx_rs485() must be called only when both FIFO and
    1474                 :            :                  * shift register are empty. It is for device driver to enable
    1475                 :            :                  * interrupt on TEMT.
    1476                 :            :                  */
    1477         [ #  # ]:          0 :                 if ((lsr & BOTH_EMPTY) != BOTH_EMPTY)
    1478                 :            :                         return;
    1479                 :            : 
    1480                 :          0 :                 em485->active_timer = NULL;
    1481                 :            : 
    1482                 :          0 :                 __stop_tx_rs485(p);
    1483                 :            :         }
    1484                 :      11141 :         __do_stop_tx(p);
    1485                 :            : }
    1486                 :            : 
    1487                 :          0 : static void serial8250_stop_tx(struct uart_port *port)
    1488                 :            : {
    1489         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1490                 :            : 
    1491         [ #  # ]:          0 :         serial8250_rpm_get(up);
    1492                 :          0 :         __stop_tx(up);
    1493                 :            : 
    1494                 :            :         /*
    1495                 :            :          * We really want to stop the transmitter from sending.
    1496                 :            :          */
    1497         [ #  # ]:          0 :         if (port->type == PORT_16C950) {
    1498                 :          0 :                 up->acr |= UART_ACR_TXDIS;
    1499                 :          0 :                 serial_icr_write(up, UART_ACR, up->acr);
    1500                 :            :         }
    1501                 :          0 :         serial8250_rpm_put(up);
    1502                 :          0 : }
    1503                 :            : 
    1504                 :      11141 : static inline void __start_tx(struct uart_port *port)
    1505                 :            : {
    1506         [ -  + ]:      11141 :         struct uart_8250_port *up = up_to_u8250p(port);
    1507                 :            : 
    1508   [ -  +  -  - ]:      11141 :         if (up->dma && !up->dma->tx_dma(up))
    1509                 :            :                 return;
    1510                 :            : 
    1511         [ +  - ]:      11141 :         if (serial8250_set_THRI(up)) {
    1512         [ -  + ]:      11141 :                 if (up->bugs & UART_BUG_TXEN) {
    1513                 :          0 :                         unsigned char lsr;
    1514                 :            : 
    1515                 :          0 :                         lsr = serial_in(up, UART_LSR);
    1516                 :          0 :                         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
    1517         [ #  # ]:          0 :                         if (lsr & UART_LSR_THRE)
    1518                 :          0 :                                 serial8250_tx_chars(up);
    1519                 :            :                 }
    1520                 :            :         }
    1521                 :            : 
    1522                 :            :         /*
    1523                 :            :          * Re-enable the transmitter if we disabled it.
    1524                 :            :          */
    1525   [ -  +  -  - ]:      11141 :         if (port->type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
    1526                 :          0 :                 up->acr &= ~UART_ACR_TXDIS;
    1527                 :          0 :                 serial_icr_write(up, UART_ACR, up->acr);
    1528                 :            :         }
    1529                 :            : }
    1530                 :            : 
    1531                 :          0 : static inline void start_tx_rs485(struct uart_port *port)
    1532                 :            : {
    1533         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1534                 :          0 :         struct uart_8250_em485 *em485 = up->em485;
    1535                 :          0 :         unsigned char mcr;
    1536                 :            : 
    1537         [ #  # ]:          0 :         if (!(up->port.rs485.flags & SER_RS485_RX_DURING_TX))
    1538                 :          0 :                 serial8250_stop_rx(&up->port);
    1539                 :            : 
    1540                 :          0 :         em485->active_timer = NULL;
    1541                 :            : 
    1542                 :          0 :         mcr = serial8250_in_MCR(up);
    1543                 :          0 :         if (!!(up->port.rs485.flags & SER_RS485_RTS_ON_SEND) !=
    1544         [ #  # ]:          0 :             !!(mcr & UART_MCR_RTS)) {
    1545         [ #  # ]:          0 :                 if (up->port.rs485.flags & SER_RS485_RTS_ON_SEND)
    1546                 :          0 :                         mcr |= UART_MCR_RTS;
    1547                 :            :                 else
    1548                 :          0 :                         mcr &= ~UART_MCR_RTS;
    1549                 :          0 :                 serial8250_out_MCR(up, mcr);
    1550                 :            : 
    1551         [ #  # ]:          0 :                 if (up->port.rs485.delay_rts_before_send > 0) {
    1552                 :          0 :                         em485->active_timer = &em485->start_tx_timer;
    1553                 :          0 :                         start_hrtimer_ms(&em485->start_tx_timer,
    1554                 :          0 :                                          up->port.rs485.delay_rts_before_send);
    1555                 :          0 :                         return;
    1556                 :            :                 }
    1557                 :            :         }
    1558                 :            : 
    1559                 :          0 :         __start_tx(port);
    1560                 :            : }
    1561                 :            : 
    1562                 :          0 : static enum hrtimer_restart serial8250_em485_handle_start_tx(struct hrtimer *t)
    1563                 :            : {
    1564                 :          0 :         struct uart_8250_em485 *em485;
    1565                 :          0 :         struct uart_8250_port *p;
    1566                 :          0 :         unsigned long flags;
    1567                 :            : 
    1568                 :          0 :         em485 = container_of(t, struct uart_8250_em485, start_tx_timer);
    1569                 :          0 :         p = em485->port;
    1570                 :            : 
    1571                 :          0 :         spin_lock_irqsave(&p->port.lock, flags);
    1572         [ #  # ]:          0 :         if (em485->active_timer == &em485->start_tx_timer) {
    1573                 :          0 :                 __start_tx(&p->port);
    1574                 :          0 :                 em485->active_timer = NULL;
    1575                 :            :         }
    1576                 :          0 :         spin_unlock_irqrestore(&p->port.lock, flags);
    1577                 :          0 :         return HRTIMER_NORESTART;
    1578                 :            : }
    1579                 :            : 
    1580                 :      11141 : static void serial8250_start_tx(struct uart_port *port)
    1581                 :            : {
    1582                 :      11141 :         struct uart_8250_port *up = up_to_u8250p(port);
    1583                 :      11141 :         struct uart_8250_em485 *em485 = up->em485;
    1584                 :            : 
    1585                 :      11141 :         serial8250_rpm_get_tx(up);
    1586                 :            : 
    1587         [ -  + ]:      11141 :         if (em485 &&
    1588         [ #  # ]:          0 :             em485->active_timer == &em485->start_tx_timer)
    1589                 :            :                 return;
    1590                 :            : 
    1591         [ -  + ]:      11141 :         if (em485)
    1592                 :          0 :                 start_tx_rs485(port);
    1593                 :            :         else
    1594                 :      11141 :                 __start_tx(port);
    1595                 :            : }
    1596                 :            : 
    1597                 :          0 : static void serial8250_throttle(struct uart_port *port)
    1598                 :            : {
    1599                 :          0 :         port->throttle(port);
    1600                 :          0 : }
    1601                 :            : 
    1602                 :          0 : static void serial8250_unthrottle(struct uart_port *port)
    1603                 :            : {
    1604                 :          0 :         port->unthrottle(port);
    1605                 :          0 : }
    1606                 :            : 
    1607                 :          0 : static void serial8250_disable_ms(struct uart_port *port)
    1608                 :            : {
    1609                 :          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1610                 :            : 
    1611                 :            :         /* no MSR capabilities */
    1612         [ #  # ]:          0 :         if (up->bugs & UART_BUG_NOMSR)
    1613                 :            :                 return;
    1614                 :            : 
    1615                 :          0 :         mctrl_gpio_disable_ms(up->gpios);
    1616                 :            : 
    1617                 :          0 :         up->ier &= ~UART_IER_MSI;
    1618                 :          0 :         serial_port_out(port, UART_IER, up->ier);
    1619                 :            : }
    1620                 :            : 
    1621                 :          0 : static void serial8250_enable_ms(struct uart_port *port)
    1622                 :            : {
    1623         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1624                 :            : 
    1625                 :            :         /* no MSR capabilities */
    1626         [ #  # ]:          0 :         if (up->bugs & UART_BUG_NOMSR)
    1627                 :            :                 return;
    1628                 :            : 
    1629         [ #  # ]:          0 :         mctrl_gpio_enable_ms(up->gpios);
    1630                 :            : 
    1631                 :          0 :         up->ier |= UART_IER_MSI;
    1632                 :            : 
    1633         [ #  # ]:          0 :         serial8250_rpm_get(up);
    1634                 :          0 :         serial_port_out(port, UART_IER, up->ier);
    1635                 :          0 :         serial8250_rpm_put(up);
    1636                 :            : }
    1637                 :            : 
    1638                 :          0 : void serial8250_read_char(struct uart_8250_port *up, unsigned char lsr)
    1639                 :            : {
    1640                 :          0 :         struct uart_port *port = &up->port;
    1641                 :          0 :         unsigned char ch;
    1642                 :          0 :         char flag = TTY_NORMAL;
    1643                 :            : 
    1644         [ #  # ]:          0 :         if (likely(lsr & UART_LSR_DR))
    1645                 :          0 :                 ch = serial_in(up, UART_RX);
    1646                 :            :         else
    1647                 :            :                 /*
    1648                 :            :                  * Intel 82571 has a Serial Over Lan device that will
    1649                 :            :                  * set UART_LSR_BI without setting UART_LSR_DR when
    1650                 :            :                  * it receives a break. To avoid reading from the
    1651                 :            :                  * receive buffer without UART_LSR_DR bit set, we
    1652                 :            :                  * just force the read character to be 0
    1653                 :            :                  */
    1654                 :            :                 ch = 0;
    1655                 :            : 
    1656                 :          0 :         port->icount.rx++;
    1657                 :            : 
    1658                 :          0 :         lsr |= up->lsr_saved_flags;
    1659                 :          0 :         up->lsr_saved_flags = 0;
    1660                 :            : 
    1661         [ #  # ]:          0 :         if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
    1662         [ #  # ]:          0 :                 if (lsr & UART_LSR_BI) {
    1663                 :          0 :                         lsr &= ~(UART_LSR_FE | UART_LSR_PE);
    1664                 :          0 :                         port->icount.brk++;
    1665                 :            :                         /*
    1666                 :            :                          * We do the SysRQ and SAK checking
    1667                 :            :                          * here because otherwise the break
    1668                 :            :                          * may get masked by ignore_status_mask
    1669                 :            :                          * or read_status_mask.
    1670                 :            :                          */
    1671         [ #  # ]:          0 :                         if (uart_handle_break(port))
    1672                 :            :                                 return;
    1673         [ #  # ]:          0 :                 } else if (lsr & UART_LSR_PE)
    1674                 :          0 :                         port->icount.parity++;
    1675         [ #  # ]:          0 :                 else if (lsr & UART_LSR_FE)
    1676                 :          0 :                         port->icount.frame++;
    1677         [ #  # ]:          0 :                 if (lsr & UART_LSR_OE)
    1678                 :          0 :                         port->icount.overrun++;
    1679                 :            : 
    1680                 :            :                 /*
    1681                 :            :                  * Mask off conditions which should be ignored.
    1682                 :            :                  */
    1683                 :          0 :                 lsr &= port->read_status_mask;
    1684                 :            : 
    1685         [ #  # ]:          0 :                 if (lsr & UART_LSR_BI) {
    1686                 :            :                         pr_debug("%s: handling break\n", __func__);
    1687                 :            :                         flag = TTY_BREAK;
    1688         [ #  # ]:          0 :                 } else if (lsr & UART_LSR_PE)
    1689                 :            :                         flag = TTY_PARITY;
    1690         [ #  # ]:          0 :                 else if (lsr & UART_LSR_FE)
    1691                 :          0 :                         flag = TTY_FRAME;
    1692                 :            :         }
    1693         [ #  # ]:          0 :         if (uart_prepare_sysrq_char(port, ch))
    1694                 :            :                 return;
    1695                 :            : 
    1696                 :          0 :         uart_insert_char(port, lsr, UART_LSR_OE, ch, flag);
    1697                 :            : }
    1698                 :            : EXPORT_SYMBOL_GPL(serial8250_read_char);
    1699                 :            : 
    1700                 :            : /*
    1701                 :            :  * serial8250_rx_chars: processes according to the passed in LSR
    1702                 :            :  * value, and returns the remaining LSR bits not handled
    1703                 :            :  * by this Rx routine.
    1704                 :            :  */
    1705                 :          0 : unsigned char serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
    1706                 :            : {
    1707                 :          0 :         struct uart_port *port = &up->port;
    1708                 :          0 :         int max_count = 256;
    1709                 :            : 
    1710                 :          0 :         do {
    1711                 :          0 :                 serial8250_read_char(up, lsr);
    1712         [ #  # ]:          0 :                 if (--max_count == 0)
    1713                 :            :                         break;
    1714                 :          0 :                 lsr = serial_in(up, UART_LSR);
    1715         [ #  # ]:          0 :         } while (lsr & (UART_LSR_DR | UART_LSR_BI));
    1716                 :            : 
    1717                 :          0 :         tty_flip_buffer_push(&port->state->port);
    1718                 :          0 :         return lsr;
    1719                 :            : }
    1720                 :            : EXPORT_SYMBOL_GPL(serial8250_rx_chars);
    1721                 :            : 
    1722                 :      14807 : void serial8250_tx_chars(struct uart_8250_port *up)
    1723                 :            : {
    1724                 :      14807 :         struct uart_port *port = &up->port;
    1725                 :      14807 :         struct circ_buf *xmit = &port->state->xmit;
    1726                 :      14807 :         int count;
    1727                 :            : 
    1728         [ -  + ]:      14807 :         if (port->x_char) {
    1729                 :          0 :                 serial_out(up, UART_TX, port->x_char);
    1730                 :          0 :                 port->icount.tx++;
    1731                 :          0 :                 port->x_char = 0;
    1732                 :          0 :                 return;
    1733                 :            :         }
    1734         [ +  - ]:      14807 :         if (uart_tx_stopped(port)) {
    1735                 :          0 :                 serial8250_stop_tx(port);
    1736                 :          0 :                 return;
    1737                 :            :         }
    1738         [ +  + ]:      14807 :         if (uart_circ_empty(xmit)) {
    1739                 :       6123 :                 __stop_tx(up);
    1740                 :       6123 :                 return;
    1741                 :            :         }
    1742                 :            : 
    1743                 :       8684 :         count = up->tx_loadsz;
    1744                 :      78845 :         do {
    1745                 :      78845 :                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
    1746                 :      78845 :                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
    1747                 :      78845 :                 port->icount.tx++;
    1748         [ +  + ]:      78845 :                 if (uart_circ_empty(xmit))
    1749                 :            :                         break;
    1750         [ -  + ]:      73827 :                 if ((up->capabilities & UART_CAP_HFIFO) &&
    1751         [ #  # ]:          0 :                     (serial_in(up, UART_LSR) & BOTH_EMPTY) != BOTH_EMPTY)
    1752                 :            :                         break;
    1753                 :            :                 /* The BCM2835 MINI UART THRE bit is really a not-full bit. */
    1754         [ -  + ]:      73827 :                 if ((up->capabilities & UART_CAP_MINI) &&
    1755         [ #  # ]:          0 :                     !(serial_in(up, UART_LSR) & UART_LSR_THRE))
    1756                 :            :                         break;
    1757         [ +  + ]:      73827 :         } while (--count > 0);
    1758                 :            : 
    1759         [ +  - ]:       8684 :         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
    1760                 :       8684 :                 uart_write_wakeup(port);
    1761                 :            : 
    1762                 :            :         /*
    1763                 :            :          * With RPM enabled, we have to wait until the FIFO is empty before the
    1764                 :            :          * HW can go idle. So we get here once again with empty FIFO and disable
    1765                 :            :          * the interrupt and RPM in __stop_tx()
    1766                 :            :          */
    1767   [ +  +  +  - ]:       8684 :         if (uart_circ_empty(xmit) && !(up->capabilities & UART_CAP_RPM))
    1768                 :       5018 :                 __stop_tx(up);
    1769                 :            : }
    1770                 :            : EXPORT_SYMBOL_GPL(serial8250_tx_chars);
    1771                 :            : 
    1772                 :            : /* Caller holds uart port lock */
    1773                 :      14807 : unsigned int serial8250_modem_status(struct uart_8250_port *up)
    1774                 :            : {
    1775                 :      14807 :         struct uart_port *port = &up->port;
    1776                 :      14807 :         unsigned int status = serial_in(up, UART_MSR);
    1777                 :            : 
    1778                 :      14807 :         status |= up->msr_saved_flags;
    1779                 :      14807 :         up->msr_saved_flags = 0;
    1780   [ -  +  -  - ]:      14807 :         if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
    1781         [ #  # ]:          0 :             port->state != NULL) {
    1782         [ #  # ]:          0 :                 if (status & UART_MSR_TERI)
    1783                 :          0 :                         port->icount.rng++;
    1784         [ #  # ]:          0 :                 if (status & UART_MSR_DDSR)
    1785                 :          0 :                         port->icount.dsr++;
    1786         [ #  # ]:          0 :                 if (status & UART_MSR_DDCD)
    1787                 :          0 :                         uart_handle_dcd_change(port, status & UART_MSR_DCD);
    1788         [ #  # ]:          0 :                 if (status & UART_MSR_DCTS)
    1789                 :          0 :                         uart_handle_cts_change(port, status & UART_MSR_CTS);
    1790                 :            : 
    1791                 :          0 :                 wake_up_interruptible(&port->state->port.delta_msr_wait);
    1792                 :            :         }
    1793                 :            : 
    1794                 :      14807 :         return status;
    1795                 :            : }
    1796                 :            : EXPORT_SYMBOL_GPL(serial8250_modem_status);
    1797                 :            : 
    1798                 :          0 : static bool handle_rx_dma(struct uart_8250_port *up, unsigned int iir)
    1799                 :            : {
    1800      [ #  #  # ]:          0 :         switch (iir & 0x3f) {
    1801                 :          0 :         case UART_IIR_RX_TIMEOUT:
    1802                 :          0 :                 serial8250_rx_dma_flush(up);
    1803                 :            :                 /* fall-through */
    1804                 :            :         case UART_IIR_RLSI:
    1805                 :            :                 return true;
    1806                 :            :         }
    1807                 :          0 :         return up->dma->rx_dma(up);
    1808                 :            : }
    1809                 :            : 
    1810                 :            : /*
    1811                 :            :  * This handles the interrupt from one port.
    1812                 :            :  */
    1813                 :      30979 : int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
    1814                 :            : {
    1815                 :      30979 :         unsigned char status;
    1816                 :      30979 :         unsigned long flags;
    1817         [ +  + ]:      30979 :         struct uart_8250_port *up = up_to_u8250p(port);
    1818                 :            : 
    1819         [ +  + ]:      30979 :         if (iir & UART_IIR_NO_INT)
    1820                 :            :                 return 0;
    1821                 :            : 
    1822                 :      14807 :         spin_lock_irqsave(&port->lock, flags);
    1823                 :            : 
    1824                 :      14807 :         status = serial_port_in(port, UART_LSR);
    1825                 :            : 
    1826         [ -  + ]:      14807 :         if (status & (UART_LSR_DR | UART_LSR_BI)) {
    1827   [ #  #  #  # ]:          0 :                 if (!up->dma || handle_rx_dma(up, iir))
    1828                 :          0 :                         status = serial8250_rx_chars(up, status);
    1829                 :            :         }
    1830                 :      14807 :         serial8250_modem_status(up);
    1831   [ -  +  -  -  :      14807 :         if ((!up->dma || up->dma->tx_err) && (status & UART_LSR_THRE) &&
                   +  - ]
    1832         [ +  - ]:      14807 :                 (up->ier & UART_IER_THRI))
    1833                 :      14807 :                 serial8250_tx_chars(up);
    1834                 :            : 
    1835                 :      14807 :         uart_unlock_and_check_sysrq(port, flags);
    1836                 :      14807 :         return 1;
    1837                 :            : }
    1838                 :            : EXPORT_SYMBOL_GPL(serial8250_handle_irq);
    1839                 :            : 
    1840                 :      30979 : static int serial8250_default_handle_irq(struct uart_port *port)
    1841                 :            : {
    1842         [ -  + ]:      30979 :         struct uart_8250_port *up = up_to_u8250p(port);
    1843                 :      30979 :         unsigned int iir;
    1844                 :      30979 :         int ret;
    1845                 :            : 
    1846         [ -  + ]:      30979 :         serial8250_rpm_get(up);
    1847                 :            : 
    1848                 :      30979 :         iir = serial_port_in(port, UART_IIR);
    1849                 :      30979 :         ret = serial8250_handle_irq(port, iir);
    1850                 :            : 
    1851                 :      30979 :         serial8250_rpm_put(up);
    1852                 :      30979 :         return ret;
    1853                 :            : }
    1854                 :            : 
    1855                 :            : /*
    1856                 :            :  * Newer 16550 compatible parts such as the SC16C650 & Altera 16550 Soft IP
    1857                 :            :  * have a programmable TX threshold that triggers the THRE interrupt in
    1858                 :            :  * the IIR register. In this case, the THRE interrupt indicates the FIFO
    1859                 :            :  * has space available. Load it up with tx_loadsz bytes.
    1860                 :            :  */
    1861                 :          0 : static int serial8250_tx_threshold_handle_irq(struct uart_port *port)
    1862                 :            : {
    1863                 :          0 :         unsigned long flags;
    1864                 :          0 :         unsigned int iir = serial_port_in(port, UART_IIR);
    1865                 :            : 
    1866                 :            :         /* TX Threshold IRQ triggered so load up FIFO */
    1867         [ #  # ]:          0 :         if ((iir & UART_IIR_ID) == UART_IIR_THRI) {
    1868                 :          0 :                 struct uart_8250_port *up = up_to_u8250p(port);
    1869                 :            : 
    1870                 :          0 :                 spin_lock_irqsave(&port->lock, flags);
    1871                 :          0 :                 serial8250_tx_chars(up);
    1872                 :          0 :                 spin_unlock_irqrestore(&port->lock, flags);
    1873                 :            :         }
    1874                 :            : 
    1875                 :          0 :         iir = serial_port_in(port, UART_IIR);
    1876                 :          0 :         return serial8250_handle_irq(port, iir);
    1877                 :            : }
    1878                 :            : 
    1879                 :       1168 : static unsigned int serial8250_tx_empty(struct uart_port *port)
    1880                 :            : {
    1881         [ -  + ]:       1168 :         struct uart_8250_port *up = up_to_u8250p(port);
    1882                 :       1168 :         unsigned long flags;
    1883                 :       1168 :         unsigned int lsr;
    1884                 :            : 
    1885         [ -  + ]:       1168 :         serial8250_rpm_get(up);
    1886                 :            : 
    1887                 :       1168 :         spin_lock_irqsave(&port->lock, flags);
    1888                 :       1168 :         lsr = serial_port_in(port, UART_LSR);
    1889                 :       1168 :         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
    1890                 :       1168 :         spin_unlock_irqrestore(&port->lock, flags);
    1891                 :            : 
    1892                 :       1168 :         serial8250_rpm_put(up);
    1893                 :            : 
    1894                 :       1168 :         return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
    1895                 :            : }
    1896                 :            : 
    1897                 :          0 : unsigned int serial8250_do_get_mctrl(struct uart_port *port)
    1898                 :            : {
    1899         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1900                 :          0 :         unsigned int status;
    1901                 :          0 :         unsigned int val;
    1902                 :            : 
    1903         [ #  # ]:          0 :         serial8250_rpm_get(up);
    1904                 :          0 :         status = serial8250_modem_status(up);
    1905                 :          0 :         serial8250_rpm_put(up);
    1906                 :            : 
    1907         [ #  # ]:          0 :         val = serial8250_MSR_to_TIOCM(status);
    1908                 :          0 :         if (up->gpios)
    1909                 :            :                 return mctrl_gpio_get(up->gpios, &val);
    1910                 :            : 
    1911                 :            :         return val;
    1912                 :            : }
    1913                 :            : EXPORT_SYMBOL_GPL(serial8250_do_get_mctrl);
    1914                 :            : 
    1915                 :          0 : static unsigned int serial8250_get_mctrl(struct uart_port *port)
    1916                 :            : {
    1917         [ #  # ]:          0 :         if (port->get_mctrl)
    1918                 :          0 :                 return port->get_mctrl(port);
    1919                 :          0 :         return serial8250_do_get_mctrl(port);
    1920                 :            : }
    1921                 :            : 
    1922                 :         65 : void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl)
    1923                 :            : {
    1924                 :         65 :         struct uart_8250_port *up = up_to_u8250p(port);
    1925                 :         65 :         unsigned char mcr;
    1926                 :            : 
    1927                 :         65 :         mcr = serial8250_TIOCM_to_MCR(mctrl);
    1928                 :            : 
    1929                 :         65 :         mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr;
    1930                 :            : 
    1931                 :         65 :         serial8250_out_MCR(up, mcr);
    1932                 :         65 : }
    1933                 :            : EXPORT_SYMBOL_GPL(serial8250_do_set_mctrl);
    1934                 :            : 
    1935                 :         65 : static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
    1936                 :            : {
    1937         [ -  + ]:         65 :         if (port->set_mctrl)
    1938                 :          0 :                 port->set_mctrl(port, mctrl);
    1939                 :            :         else
    1940                 :         65 :                 serial8250_do_set_mctrl(port, mctrl);
    1941                 :         65 : }
    1942                 :            : 
    1943                 :          0 : static void serial8250_break_ctl(struct uart_port *port, int break_state)
    1944                 :            : {
    1945         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    1946                 :          0 :         unsigned long flags;
    1947                 :            : 
    1948         [ #  # ]:          0 :         serial8250_rpm_get(up);
    1949                 :          0 :         spin_lock_irqsave(&port->lock, flags);
    1950         [ #  # ]:          0 :         if (break_state == -1)
    1951                 :          0 :                 up->lcr |= UART_LCR_SBC;
    1952                 :            :         else
    1953                 :          0 :                 up->lcr &= ~UART_LCR_SBC;
    1954                 :          0 :         serial_port_out(port, UART_LCR, up->lcr);
    1955                 :          0 :         spin_unlock_irqrestore(&port->lock, flags);
    1956                 :          0 :         serial8250_rpm_put(up);
    1957                 :          0 : }
    1958                 :            : 
    1959                 :            : /*
    1960                 :            :  *      Wait for transmitter & holding register to empty
    1961                 :            :  */
    1962                 :     278118 : static void wait_for_xmitr(struct uart_8250_port *up, int bits)
    1963                 :            : {
    1964                 :     278118 :         unsigned int status, tmout = 10000;
    1965                 :            : 
    1966                 :            :         /* Wait up to 10ms for the character(s) to be sent. */
    1967                 :     278118 :         for (;;) {
    1968                 :     278118 :                 status = serial_in(up, UART_LSR);
    1969                 :            : 
    1970                 :     278118 :                 up->lsr_saved_flags |= status & LSR_SAVE_FLAGS;
    1971                 :            : 
    1972         [ -  + ]:     278118 :                 if ((status & bits) == bits)
    1973                 :            :                         break;
    1974         [ #  # ]:          0 :                 if (--tmout == 0)
    1975                 :            :                         break;
    1976                 :          0 :                 udelay(1);
    1977                 :          0 :                 touch_nmi_watchdog();
    1978                 :            :         }
    1979                 :            : 
    1980                 :            :         /* Wait up to 1s for flow control if necessary */
    1981         [ -  + ]:     278118 :         if (up->port.flags & UPF_CONS_FLOW) {
    1982         [ #  # ]:          0 :                 for (tmout = 1000000; tmout; tmout--) {
    1983                 :          0 :                         unsigned int msr = serial_in(up, UART_MSR);
    1984                 :          0 :                         up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
    1985         [ #  # ]:          0 :                         if (msr & UART_MSR_CTS)
    1986                 :            :                                 break;
    1987                 :          0 :                         udelay(1);
    1988                 :          0 :                         touch_nmi_watchdog();
    1989                 :            :                 }
    1990                 :            :         }
    1991                 :     278118 : }
    1992                 :            : 
    1993                 :            : #ifdef CONFIG_CONSOLE_POLL
    1994                 :            : /*
    1995                 :            :  * Console polling routines for writing and reading from the uart while
    1996                 :            :  * in an interrupt or debug context.
    1997                 :            :  */
    1998                 :            : 
    1999                 :            : static int serial8250_get_poll_char(struct uart_port *port)
    2000                 :            : {
    2001                 :            :         struct uart_8250_port *up = up_to_u8250p(port);
    2002                 :            :         unsigned char lsr;
    2003                 :            :         int status;
    2004                 :            : 
    2005                 :            :         serial8250_rpm_get(up);
    2006                 :            : 
    2007                 :            :         lsr = serial_port_in(port, UART_LSR);
    2008                 :            : 
    2009                 :            :         if (!(lsr & UART_LSR_DR)) {
    2010                 :            :                 status = NO_POLL_CHAR;
    2011                 :            :                 goto out;
    2012                 :            :         }
    2013                 :            : 
    2014                 :            :         status = serial_port_in(port, UART_RX);
    2015                 :            : out:
    2016                 :            :         serial8250_rpm_put(up);
    2017                 :            :         return status;
    2018                 :            : }
    2019                 :            : 
    2020                 :            : 
    2021                 :            : static void serial8250_put_poll_char(struct uart_port *port,
    2022                 :            :                          unsigned char c)
    2023                 :            : {
    2024                 :            :         unsigned int ier;
    2025                 :            :         struct uart_8250_port *up = up_to_u8250p(port);
    2026                 :            : 
    2027                 :            :         serial8250_rpm_get(up);
    2028                 :            :         /*
    2029                 :            :          *      First save the IER then disable the interrupts
    2030                 :            :          */
    2031                 :            :         ier = serial_port_in(port, UART_IER);
    2032                 :            :         if (up->capabilities & UART_CAP_UUE)
    2033                 :            :                 serial_port_out(port, UART_IER, UART_IER_UUE);
    2034                 :            :         else
    2035                 :            :                 serial_port_out(port, UART_IER, 0);
    2036                 :            : 
    2037                 :            :         wait_for_xmitr(up, BOTH_EMPTY);
    2038                 :            :         /*
    2039                 :            :          *      Send the character out.
    2040                 :            :          */
    2041                 :            :         serial_port_out(port, UART_TX, c);
    2042                 :            : 
    2043                 :            :         /*
    2044                 :            :          *      Finally, wait for transmitter to become empty
    2045                 :            :          *      and restore the IER
    2046                 :            :          */
    2047                 :            :         wait_for_xmitr(up, BOTH_EMPTY);
    2048                 :            :         serial_port_out(port, UART_IER, ier);
    2049                 :            :         serial8250_rpm_put(up);
    2050                 :            : }
    2051                 :            : 
    2052                 :            : #endif /* CONFIG_CONSOLE_POLL */
    2053                 :            : 
    2054                 :         13 : int serial8250_do_startup(struct uart_port *port)
    2055                 :            : {
    2056         [ -  + ]:         13 :         struct uart_8250_port *up = up_to_u8250p(port);
    2057                 :         13 :         unsigned long flags;
    2058                 :         13 :         unsigned char lsr, iir;
    2059                 :         13 :         int retval;
    2060                 :            : 
    2061         [ -  + ]:         13 :         if (!port->fifosize)
    2062                 :          0 :                 port->fifosize = uart_config[port->type].fifo_size;
    2063         [ -  + ]:         13 :         if (!up->tx_loadsz)
    2064                 :          0 :                 up->tx_loadsz = uart_config[port->type].tx_loadsz;
    2065         [ -  + ]:         13 :         if (!up->capabilities)
    2066                 :          0 :                 up->capabilities = uart_config[port->type].flags;
    2067                 :         13 :         up->mcr = 0;
    2068                 :            : 
    2069         [ -  + ]:         13 :         if (port->iotype != up->cur_iotype)
    2070                 :          0 :                 set_io_from_upio(port);
    2071                 :            : 
    2072         [ -  + ]:         13 :         serial8250_rpm_get(up);
    2073         [ -  + ]:         13 :         if (port->type == PORT_16C950) {
    2074                 :            :                 /* Wake up and initialize UART */
    2075                 :          0 :                 up->acr = 0;
    2076                 :          0 :                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
    2077                 :          0 :                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
    2078                 :          0 :                 serial_port_out(port, UART_IER, 0);
    2079                 :          0 :                 serial_port_out(port, UART_LCR, 0);
    2080                 :          0 :                 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
    2081                 :          0 :                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
    2082                 :          0 :                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
    2083                 :          0 :                 serial_port_out(port, UART_LCR, 0);
    2084                 :            :         }
    2085                 :            : 
    2086         [ -  + ]:         13 :         if (port->type == PORT_DA830) {
    2087                 :            :                 /* Reset the port */
    2088                 :          0 :                 serial_port_out(port, UART_IER, 0);
    2089                 :          0 :                 serial_port_out(port, UART_DA830_PWREMU_MGMT, 0);
    2090         [ #  # ]:          0 :                 mdelay(10);
    2091                 :            : 
    2092                 :            :                 /* Enable Tx, Rx and free run mode */
    2093                 :          0 :                 serial_port_out(port, UART_DA830_PWREMU_MGMT,
    2094                 :            :                                 UART_DA830_PWREMU_MGMT_UTRST |
    2095                 :            :                                 UART_DA830_PWREMU_MGMT_URRST |
    2096                 :            :                                 UART_DA830_PWREMU_MGMT_FREE);
    2097                 :            :         }
    2098                 :            : 
    2099         [ -  + ]:         13 :         if (port->type == PORT_NPCM) {
    2100                 :            :                 /*
    2101                 :            :                  * Nuvoton calls the scratch register 'UART_TOR' (timeout
    2102                 :            :                  * register). Enable it, and set TIOC (timeout interrupt
    2103                 :            :                  * comparator) to be 0x20 for correct operation.
    2104                 :            :                  */
    2105                 :          0 :                 serial_port_out(port, UART_NPCM_TOR, UART_NPCM_TOIE | 0x20);
    2106                 :            :         }
    2107                 :            : 
    2108                 :            : #ifdef CONFIG_SERIAL_8250_RSA
    2109                 :            :         /*
    2110                 :            :          * If this is an RSA port, see if we can kick it up to the
    2111                 :            :          * higher speed clock.
    2112                 :            :          */
    2113                 :         13 :         enable_rsa(up);
    2114                 :            : #endif
    2115                 :            : 
    2116                 :            :         /*
    2117                 :            :          * Clear the FIFO buffers and disable them.
    2118                 :            :          * (they will be reenabled in set_termios())
    2119                 :            :          */
    2120                 :         13 :         serial8250_clear_fifos(up);
    2121                 :            : 
    2122                 :            :         /*
    2123                 :            :          * Clear the interrupt registers.
    2124                 :            :          */
    2125                 :         13 :         serial_port_in(port, UART_LSR);
    2126                 :         13 :         serial_port_in(port, UART_RX);
    2127                 :         13 :         serial_port_in(port, UART_IIR);
    2128                 :         13 :         serial_port_in(port, UART_MSR);
    2129                 :            : 
    2130                 :            :         /*
    2131                 :            :          * At this point, there's no way the LSR could still be 0xff;
    2132                 :            :          * if it is, then bail out, because there's likely no UART
    2133                 :            :          * here.
    2134                 :            :          */
    2135   [ +  -  -  + ]:         26 :         if (!(port->flags & UPF_BUGGY_UART) &&
    2136                 :            :             (serial_port_in(port, UART_LSR) == 0xff)) {
    2137         [ #  # ]:          0 :                 pr_info_ratelimited("%s: LSR safety check engaged!\n", port->name);
    2138                 :          0 :                 retval = -ENODEV;
    2139                 :          0 :                 goto out;
    2140                 :            :         }
    2141                 :            : 
    2142                 :            :         /*
    2143                 :            :          * For a XR16C850, we need to set the trigger levels
    2144                 :            :          */
    2145         [ -  + ]:         13 :         if (port->type == PORT_16850) {
    2146                 :          0 :                 unsigned char fctr;
    2147                 :            : 
    2148                 :          0 :                 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
    2149                 :            : 
    2150                 :          0 :                 fctr = serial_in(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX);
    2151                 :          0 :                 serial_port_out(port, UART_FCTR,
    2152                 :            :                                 fctr | UART_FCTR_TRGD | UART_FCTR_RX);
    2153                 :          0 :                 serial_port_out(port, UART_TRG, UART_TRG_96);
    2154                 :          0 :                 serial_port_out(port, UART_FCTR,
    2155                 :            :                                 fctr | UART_FCTR_TRGD | UART_FCTR_TX);
    2156                 :          0 :                 serial_port_out(port, UART_TRG, UART_TRG_96);
    2157                 :            : 
    2158                 :          0 :                 serial_port_out(port, UART_LCR, 0);
    2159                 :            :         }
    2160                 :            : 
    2161                 :            :         /*
    2162                 :            :          * For the Altera 16550 variants, set TX threshold trigger level.
    2163                 :            :          */
    2164                 :         13 :         if (((port->type == PORT_ALTR_16550_F32) ||
    2165         [ -  + ]:         13 :              (port->type == PORT_ALTR_16550_F64) ||
    2166         [ #  # ]:          0 :              (port->type == PORT_ALTR_16550_F128)) && (port->fifosize > 1)) {
    2167                 :            :                 /* Bounds checking of TX threshold (valid 0 to fifosize-2) */
    2168   [ #  #  #  # ]:          0 :                 if ((up->tx_loadsz < 2) || (up->tx_loadsz > port->fifosize)) {
    2169                 :          0 :                         pr_err("%s TX FIFO Threshold errors, skipping\n",
    2170                 :            :                                port->name);
    2171                 :            :                 } else {
    2172                 :          0 :                         serial_port_out(port, UART_ALTR_AFR,
    2173                 :            :                                         UART_ALTR_EN_TXFIFO_LW);
    2174                 :          0 :                         serial_port_out(port, UART_ALTR_TX_LOW,
    2175                 :          0 :                                         port->fifosize - up->tx_loadsz);
    2176                 :          0 :                         port->handle_irq = serial8250_tx_threshold_handle_irq;
    2177                 :            :                 }
    2178                 :            :         }
    2179                 :            : 
    2180                 :            :         /* Check if we need to have shared IRQs */
    2181   [ +  -  -  + ]:         13 :         if (port->irq && (up->port.flags & UPF_SHARE_IRQ))
    2182                 :          0 :                 up->port.irqflags |= IRQF_SHARED;
    2183                 :            : 
    2184   [ +  -  +  - ]:         13 :         if (port->irq && !(up->port.flags & UPF_NO_THRE_TEST)) {
    2185                 :         13 :                 unsigned char iir1;
    2186                 :            :                 /*
    2187                 :            :                  * Test for UARTs that do not reassert THRE when the
    2188                 :            :                  * transmitter is idle and the interrupt has already
    2189                 :            :                  * been cleared.  Real 16550s should always reassert
    2190                 :            :                  * this interrupt whenever the transmitter is idle and
    2191                 :            :                  * the interrupt is enabled.  Delays are necessary to
    2192                 :            :                  * allow register changes to become visible.
    2193                 :            :                  */
    2194                 :         13 :                 spin_lock_irqsave(&port->lock, flags);
    2195         [ -  + ]:         13 :                 if (up->port.irqflags & IRQF_SHARED)
    2196                 :          0 :                         disable_irq_nosync(port->irq);
    2197                 :            : 
    2198                 :         13 :                 wait_for_xmitr(up, UART_LSR_THRE);
    2199                 :         13 :                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
    2200                 :         13 :                 udelay(1); /* allow THRE to set */
    2201                 :         13 :                 iir1 = serial_port_in(port, UART_IIR);
    2202                 :         13 :                 serial_port_out(port, UART_IER, 0);
    2203                 :         13 :                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
    2204                 :         13 :                 udelay(1); /* allow a working UART time to re-assert THRE */
    2205                 :         13 :                 iir = serial_port_in(port, UART_IIR);
    2206                 :         13 :                 serial_port_out(port, UART_IER, 0);
    2207                 :            : 
    2208         [ -  + ]:         13 :                 if (port->irqflags & IRQF_SHARED)
    2209                 :          0 :                         enable_irq(port->irq);
    2210                 :         13 :                 spin_unlock_irqrestore(&port->lock, flags);
    2211                 :            : 
    2212                 :            :                 /*
    2213                 :            :                  * If the interrupt is not reasserted, or we otherwise
    2214                 :            :                  * don't trust the iir, setup a timer to kick the UART
    2215                 :            :                  * on a regular basis.
    2216                 :            :                  */
    2217   [ +  -  +  - ]:         13 :                 if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) ||
    2218         [ -  + ]:         13 :                     up->port.flags & UPF_BUG_THRE) {
    2219                 :          0 :                         up->bugs |= UART_BUG_THRE;
    2220                 :            :                 }
    2221                 :            :         }
    2222                 :            : 
    2223                 :         13 :         retval = up->ops->setup_irq(up);
    2224         [ -  + ]:         13 :         if (retval)
    2225                 :          0 :                 goto out;
    2226                 :            : 
    2227                 :            :         /*
    2228                 :            :          * Now, initialize the UART
    2229                 :            :          */
    2230                 :         13 :         serial_port_out(port, UART_LCR, UART_LCR_WLEN8);
    2231                 :            : 
    2232                 :         13 :         spin_lock_irqsave(&port->lock, flags);
    2233         [ -  + ]:         13 :         if (up->port.flags & UPF_FOURPORT) {
    2234         [ #  # ]:          0 :                 if (!up->port.irq)
    2235                 :          0 :                         up->port.mctrl |= TIOCM_OUT1;
    2236                 :            :         } else
    2237                 :            :                 /*
    2238                 :            :                  * Most PC uarts need OUT2 raised to enable interrupts.
    2239                 :            :                  */
    2240         [ +  - ]:         13 :                 if (port->irq)
    2241                 :         13 :                         up->port.mctrl |= TIOCM_OUT2;
    2242                 :            : 
    2243                 :         13 :         serial8250_set_mctrl(port, port->mctrl);
    2244                 :            : 
    2245                 :            :         /*
    2246                 :            :          * Serial over Lan (SoL) hack:
    2247                 :            :          * Intel 8257x Gigabit ethernet chips have a 16550 emulation, to be
    2248                 :            :          * used for Serial Over Lan.  Those chips take a longer time than a
    2249                 :            :          * normal serial device to signalize that a transmission data was
    2250                 :            :          * queued. Due to that, the above test generally fails. One solution
    2251                 :            :          * would be to delay the reading of iir. However, this is not
    2252                 :            :          * reliable, since the timeout is variable. So, let's just don't
    2253                 :            :          * test if we receive TX irq.  This way, we'll never enable
    2254                 :            :          * UART_BUG_TXEN.
    2255                 :            :          */
    2256         [ -  + ]:         13 :         if (up->port.quirks & UPQ_NO_TXEN_TEST)
    2257                 :          0 :                 goto dont_test_tx_en;
    2258                 :            : 
    2259                 :            :         /*
    2260                 :            :          * Do a quick test to see if we receive an interrupt when we enable
    2261                 :            :          * the TX irq.
    2262                 :            :          */
    2263                 :         13 :         serial_port_out(port, UART_IER, UART_IER_THRI);
    2264                 :         13 :         lsr = serial_port_in(port, UART_LSR);
    2265                 :         13 :         iir = serial_port_in(port, UART_IIR);
    2266                 :         13 :         serial_port_out(port, UART_IER, 0);
    2267                 :            : 
    2268   [ +  -  -  + ]:         13 :         if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) {
    2269         [ #  # ]:          0 :                 if (!(up->bugs & UART_BUG_TXEN)) {
    2270                 :          0 :                         up->bugs |= UART_BUG_TXEN;
    2271                 :          0 :                         pr_debug("%s - enabling bad tx status workarounds\n",
    2272                 :            :                                  port->name);
    2273                 :            :                 }
    2274                 :            :         } else {
    2275                 :         13 :                 up->bugs &= ~UART_BUG_TXEN;
    2276                 :            :         }
    2277                 :            : 
    2278                 :         13 : dont_test_tx_en:
    2279                 :         13 :         spin_unlock_irqrestore(&port->lock, flags);
    2280                 :            : 
    2281                 :            :         /*
    2282                 :            :          * Clear the interrupt registers again for luck, and clear the
    2283                 :            :          * saved flags to avoid getting false values from polling
    2284                 :            :          * routines or the previous session.
    2285                 :            :          */
    2286                 :         13 :         serial_port_in(port, UART_LSR);
    2287                 :         13 :         serial_port_in(port, UART_RX);
    2288                 :         13 :         serial_port_in(port, UART_IIR);
    2289                 :         13 :         serial_port_in(port, UART_MSR);
    2290                 :         13 :         up->lsr_saved_flags = 0;
    2291                 :         13 :         up->msr_saved_flags = 0;
    2292                 :            : 
    2293                 :            :         /*
    2294                 :            :          * Request DMA channels for both RX and TX.
    2295                 :            :          */
    2296         [ -  + ]:         13 :         if (up->dma) {
    2297                 :          0 :                 retval = serial8250_request_dma(up);
    2298         [ #  # ]:          0 :                 if (retval) {
    2299         [ #  # ]:          0 :                         pr_warn_ratelimited("%s - failed to request DMA\n",
    2300                 :            :                                             port->name);
    2301                 :          0 :                         up->dma = NULL;
    2302                 :            :                 }
    2303                 :            :         }
    2304                 :            : 
    2305                 :            :         /*
    2306                 :            :          * Set the IER shadow for rx interrupts but defer actual interrupt
    2307                 :            :          * enable until after the FIFOs are enabled; otherwise, an already-
    2308                 :            :          * active sender can swamp the interrupt handler with "too much work".
    2309                 :            :          */
    2310                 :         13 :         up->ier = UART_IER_RLSI | UART_IER_RDI;
    2311                 :            : 
    2312         [ -  + ]:         13 :         if (port->flags & UPF_FOURPORT) {
    2313                 :          0 :                 unsigned int icp;
    2314                 :            :                 /*
    2315                 :            :                  * Enable interrupts on the AST Fourport board
    2316                 :            :                  */
    2317                 :          0 :                 icp = (port->iobase & 0xfe0) | 0x01f;
    2318                 :          0 :                 outb_p(0x80, icp);
    2319                 :          0 :                 inb_p(icp);
    2320                 :            :         }
    2321                 :            :         retval = 0;
    2322                 :         13 : out:
    2323                 :         13 :         serial8250_rpm_put(up);
    2324                 :         13 :         return retval;
    2325                 :            : }
    2326                 :            : EXPORT_SYMBOL_GPL(serial8250_do_startup);
    2327                 :            : 
    2328                 :         13 : static int serial8250_startup(struct uart_port *port)
    2329                 :            : {
    2330         [ -  + ]:         13 :         if (port->startup)
    2331                 :          0 :                 return port->startup(port);
    2332                 :         13 :         return serial8250_do_startup(port);
    2333                 :            : }
    2334                 :            : 
    2335                 :          0 : void serial8250_do_shutdown(struct uart_port *port)
    2336                 :            : {
    2337         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    2338                 :          0 :         unsigned long flags;
    2339                 :            : 
    2340         [ #  # ]:          0 :         serial8250_rpm_get(up);
    2341                 :            :         /*
    2342                 :            :          * Disable interrupts from this port
    2343                 :            :          */
    2344                 :          0 :         spin_lock_irqsave(&port->lock, flags);
    2345                 :          0 :         up->ier = 0;
    2346                 :          0 :         serial_port_out(port, UART_IER, 0);
    2347                 :          0 :         spin_unlock_irqrestore(&port->lock, flags);
    2348                 :            : 
    2349                 :          0 :         synchronize_irq(port->irq);
    2350                 :            : 
    2351         [ #  # ]:          0 :         if (up->dma)
    2352                 :          0 :                 serial8250_release_dma(up);
    2353                 :            : 
    2354                 :          0 :         spin_lock_irqsave(&port->lock, flags);
    2355         [ #  # ]:          0 :         if (port->flags & UPF_FOURPORT) {
    2356                 :            :                 /* reset interrupts on the AST Fourport board */
    2357                 :          0 :                 inb((port->iobase & 0xfe0) | 0x1f);
    2358                 :          0 :                 port->mctrl |= TIOCM_OUT1;
    2359                 :            :         } else
    2360                 :          0 :                 port->mctrl &= ~TIOCM_OUT2;
    2361                 :            : 
    2362                 :          0 :         serial8250_set_mctrl(port, port->mctrl);
    2363                 :          0 :         spin_unlock_irqrestore(&port->lock, flags);
    2364                 :            : 
    2365                 :            :         /*
    2366                 :            :          * Disable break condition and FIFOs
    2367                 :            :          */
    2368                 :          0 :         serial_port_out(port, UART_LCR,
    2369                 :            :                         serial_port_in(port, UART_LCR) & ~UART_LCR_SBC);
    2370                 :          0 :         serial8250_clear_fifos(up);
    2371                 :            : 
    2372                 :            : #ifdef CONFIG_SERIAL_8250_RSA
    2373                 :            :         /*
    2374                 :            :          * Reset the RSA board back to 115kbps compat mode.
    2375                 :            :          */
    2376                 :          0 :         disable_rsa(up);
    2377                 :            : #endif
    2378                 :            : 
    2379                 :            :         /*
    2380                 :            :          * Read data port to reset things, and then unlink from
    2381                 :            :          * the IRQ chain.
    2382                 :            :          */
    2383                 :          0 :         serial_port_in(port, UART_RX);
    2384                 :          0 :         serial8250_rpm_put(up);
    2385                 :            : 
    2386                 :          0 :         up->ops->release_irq(up);
    2387                 :          0 : }
    2388                 :            : EXPORT_SYMBOL_GPL(serial8250_do_shutdown);
    2389                 :            : 
    2390                 :          0 : static void serial8250_shutdown(struct uart_port *port)
    2391                 :            : {
    2392         [ #  # ]:          0 :         if (port->shutdown)
    2393                 :          0 :                 port->shutdown(port);
    2394                 :            :         else
    2395                 :          0 :                 serial8250_do_shutdown(port);
    2396                 :          0 : }
    2397                 :            : 
    2398                 :            : /* Nuvoton NPCM UARTs have a custom divisor calculation */
    2399                 :            : static unsigned int npcm_get_divisor(struct uart_8250_port *up,
    2400                 :            :                 unsigned int baud)
    2401                 :            : {
    2402                 :            :         struct uart_port *port = &up->port;
    2403                 :            : 
    2404                 :            :         return DIV_ROUND_CLOSEST(port->uartclk, 16 * baud + 2) - 2;
    2405                 :            : }
    2406                 :            : 
    2407                 :            : static unsigned int serial8250_do_get_divisor(struct uart_port *port,
    2408                 :            :                                               unsigned int baud,
    2409                 :            :                                               unsigned int *frac)
    2410                 :            : {
    2411                 :            :         struct uart_8250_port *up = up_to_u8250p(port);
    2412                 :            :         unsigned int quot;
    2413                 :            : 
    2414                 :            :         /*
    2415                 :            :          * Handle magic divisors for baud rates above baud_base on
    2416                 :            :          * SMSC SuperIO chips.
    2417                 :            :          *
    2418                 :            :          */
    2419                 :            :         if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
    2420                 :            :             baud == (port->uartclk/4))
    2421                 :            :                 quot = 0x8001;
    2422                 :            :         else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
    2423                 :            :                  baud == (port->uartclk/8))
    2424                 :            :                 quot = 0x8002;
    2425                 :            :         else if (up->port.type == PORT_NPCM)
    2426                 :            :                 quot = npcm_get_divisor(up, baud);
    2427                 :            :         else
    2428                 :            :                 quot = uart_get_divisor(port, baud);
    2429                 :            : 
    2430                 :            :         /*
    2431                 :            :          * Oxford Semi 952 rev B workaround
    2432                 :            :          */
    2433                 :            :         if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0)
    2434                 :            :                 quot++;
    2435                 :            : 
    2436                 :            :         return quot;
    2437                 :            : }
    2438                 :            : 
    2439                 :         26 : static unsigned int serial8250_get_divisor(struct uart_port *port,
    2440                 :            :                                            unsigned int baud,
    2441                 :            :                                            unsigned int *frac)
    2442                 :            : {
    2443         [ -  + ]:         26 :         if (port->get_divisor)
    2444                 :          0 :                 return port->get_divisor(port, baud, frac);
    2445                 :            : 
    2446                 :         26 :         return serial8250_do_get_divisor(port, baud, frac);
    2447                 :            : }
    2448                 :            : 
    2449                 :            : static unsigned char serial8250_compute_lcr(struct uart_8250_port *up,
    2450                 :            :                                             tcflag_t c_cflag)
    2451                 :            : {
    2452                 :            :         unsigned char cval;
    2453                 :            : 
    2454                 :            :         switch (c_cflag & CSIZE) {
    2455                 :            :         case CS5:
    2456                 :            :                 cval = UART_LCR_WLEN5;
    2457                 :            :                 break;
    2458                 :            :         case CS6:
    2459                 :            :                 cval = UART_LCR_WLEN6;
    2460                 :            :                 break;
    2461                 :            :         case CS7:
    2462                 :            :                 cval = UART_LCR_WLEN7;
    2463                 :            :                 break;
    2464                 :            :         default:
    2465                 :            :         case CS8:
    2466                 :            :                 cval = UART_LCR_WLEN8;
    2467                 :            :                 break;
    2468                 :            :         }
    2469                 :            : 
    2470                 :            :         if (c_cflag & CSTOPB)
    2471                 :            :                 cval |= UART_LCR_STOP;
    2472                 :            :         if (c_cflag & PARENB) {
    2473                 :            :                 cval |= UART_LCR_PARITY;
    2474                 :            :                 if (up->bugs & UART_BUG_PARITY)
    2475                 :            :                         up->fifo_bug = true;
    2476                 :            :         }
    2477                 :            :         if (!(c_cflag & PARODD))
    2478                 :            :                 cval |= UART_LCR_EPAR;
    2479                 :            : #ifdef CMSPAR
    2480                 :            :         if (c_cflag & CMSPAR)
    2481                 :            :                 cval |= UART_LCR_SPAR;
    2482                 :            : #endif
    2483                 :            : 
    2484                 :            :         return cval;
    2485                 :            : }
    2486                 :            : 
    2487                 :         26 : void serial8250_do_set_divisor(struct uart_port *port, unsigned int baud,
    2488                 :            :                                unsigned int quot, unsigned int quot_frac)
    2489                 :            : {
    2490         [ -  + ]:         26 :         struct uart_8250_port *up = up_to_u8250p(port);
    2491                 :            : 
    2492                 :            :         /* Workaround to enable 115200 baud on OMAP1510 internal ports */
    2493         [ -  + ]:         26 :         if (is_omap1510_8250(up)) {
    2494                 :            :                 if (baud == 115200) {
    2495                 :            :                         quot = 1;
    2496                 :            :                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 1);
    2497                 :            :                 } else
    2498                 :            :                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 0);
    2499                 :            :         }
    2500                 :            : 
    2501                 :            :         /*
    2502                 :            :          * For NatSemi, switch to bank 2 not bank 1, to avoid resetting EXCR2,
    2503                 :            :          * otherwise just set DLAB
    2504                 :            :          */
    2505         [ -  + ]:         26 :         if (up->capabilities & UART_NATSEMI)
    2506                 :          0 :                 serial_port_out(port, UART_LCR, 0xe0);
    2507                 :            :         else
    2508                 :         26 :                 serial_port_out(port, UART_LCR, up->lcr | UART_LCR_DLAB);
    2509                 :            : 
    2510                 :         26 :         serial_dl_write(up, quot);
    2511                 :         26 : }
    2512                 :            : EXPORT_SYMBOL_GPL(serial8250_do_set_divisor);
    2513                 :            : 
    2514                 :         26 : static void serial8250_set_divisor(struct uart_port *port, unsigned int baud,
    2515                 :            :                                    unsigned int quot, unsigned int quot_frac)
    2516                 :            : {
    2517         [ -  + ]:         26 :         if (port->set_divisor)
    2518                 :          0 :                 port->set_divisor(port, baud, quot, quot_frac);
    2519                 :            :         else
    2520                 :         26 :                 serial8250_do_set_divisor(port, baud, quot, quot_frac);
    2521                 :         26 : }
    2522                 :            : 
    2523                 :         26 : static unsigned int serial8250_get_baud_rate(struct uart_port *port,
    2524                 :            :                                              struct ktermios *termios,
    2525                 :            :                                              struct ktermios *old)
    2526                 :            : {
    2527                 :            :         /*
    2528                 :            :          * Ask the core to calculate the divisor for us.
    2529                 :            :          * Allow 1% tolerance at the upper limit so uart clks marginally
    2530                 :            :          * slower than nominal still match standard baud rates without
    2531                 :            :          * causing transmission errors.
    2532                 :            :          */
    2533                 :         26 :         return uart_get_baud_rate(port, termios, old,
    2534                 :            :                                   port->uartclk / 16 / UART_DIV_MAX,
    2535                 :            :                                   port->uartclk);
    2536                 :            : }
    2537                 :            : 
    2538                 :            : void
    2539                 :         26 : serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
    2540                 :            :                           struct ktermios *old)
    2541                 :            : {
    2542         [ -  + ]:         26 :         struct uart_8250_port *up = up_to_u8250p(port);
    2543                 :         26 :         unsigned char cval;
    2544                 :         26 :         unsigned long flags;
    2545                 :         26 :         unsigned int baud, quot, frac = 0;
    2546                 :            : 
    2547         [ -  + ]:         26 :         if (up->capabilities & UART_CAP_MINI) {
    2548                 :          0 :                 termios->c_cflag &= ~(CSTOPB | PARENB | PARODD | CMSPAR);
    2549         [ #  # ]:          0 :                 if ((termios->c_cflag & CSIZE) == CS5 ||
    2550                 :            :                     (termios->c_cflag & CSIZE) == CS6)
    2551                 :          0 :                         termios->c_cflag = (termios->c_cflag & ~CSIZE) | CS7;
    2552                 :            :         }
    2553                 :         26 :         cval = serial8250_compute_lcr(up, termios->c_cflag);
    2554                 :            : 
    2555                 :         26 :         baud = serial8250_get_baud_rate(port, termios, old);
    2556                 :         26 :         quot = serial8250_get_divisor(port, baud, &frac);
    2557                 :            : 
    2558                 :            :         /*
    2559                 :            :          * Ok, we're now changing the port state.  Do it with
    2560                 :            :          * interrupts disabled.
    2561                 :            :          */
    2562         [ -  + ]:         26 :         serial8250_rpm_get(up);
    2563                 :         26 :         spin_lock_irqsave(&port->lock, flags);
    2564                 :            : 
    2565                 :         26 :         up->lcr = cval;                                      /* Save computed LCR */
    2566                 :            : 
    2567   [ +  +  +  - ]:         26 :         if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) {
    2568                 :            :                 /* NOTE: If fifo_bug is not set, a user can set RX_trigger. */
    2569   [ -  +  -  -  :         13 :                 if ((baud < 2400 && !up->dma) || up->fifo_bug) {
                   -  + ]
    2570                 :          0 :                         up->fcr &= ~UART_FCR_TRIGGER_MASK;
    2571                 :          0 :                         up->fcr |= UART_FCR_TRIGGER_1;
    2572                 :            :                 }
    2573                 :            :         }
    2574                 :            : 
    2575                 :            :         /*
    2576                 :            :          * MCR-based auto flow control.  When AFE is enabled, RTS will be
    2577                 :            :          * deasserted when the receive FIFO contains more characters than
    2578                 :            :          * the trigger, or the MCR RTS bit is cleared.
    2579                 :            :          */
    2580         [ -  + ]:         26 :         if (up->capabilities & UART_CAP_AFE) {
    2581                 :          0 :                 up->mcr &= ~UART_MCR_AFE;
    2582         [ #  # ]:          0 :                 if (termios->c_cflag & CRTSCTS)
    2583                 :          0 :                         up->mcr |= UART_MCR_AFE;
    2584                 :            :         }
    2585                 :            : 
    2586                 :            :         /*
    2587                 :            :          * Update the per-port timeout.
    2588                 :            :          */
    2589                 :         26 :         uart_update_timeout(port, termios->c_cflag, baud);
    2590                 :            : 
    2591                 :         26 :         port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
    2592         [ -  + ]:         26 :         if (termios->c_iflag & INPCK)
    2593                 :          0 :                 port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
    2594         [ -  + ]:         26 :         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
    2595                 :          0 :                 port->read_status_mask |= UART_LSR_BI;
    2596                 :            : 
    2597                 :            :         /*
    2598                 :            :          * Characteres to ignore
    2599                 :            :          */
    2600                 :         26 :         port->ignore_status_mask = 0;
    2601         [ -  + ]:         26 :         if (termios->c_iflag & IGNPAR)
    2602                 :          0 :                 port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
    2603         [ -  + ]:         26 :         if (termios->c_iflag & IGNBRK) {
    2604                 :          0 :                 port->ignore_status_mask |= UART_LSR_BI;
    2605                 :            :                 /*
    2606                 :            :                  * If we're ignoring parity and break indicators,
    2607                 :            :                  * ignore overruns too (for real raw support).
    2608                 :            :                  */
    2609         [ #  # ]:          0 :                 if (termios->c_iflag & IGNPAR)
    2610                 :          0 :                         port->ignore_status_mask |= UART_LSR_OE;
    2611                 :            :         }
    2612                 :            : 
    2613                 :            :         /*
    2614                 :            :          * ignore all characters if CREAD is not set
    2615                 :            :          */
    2616         [ -  + ]:         26 :         if ((termios->c_cflag & CREAD) == 0)
    2617                 :          0 :                 port->ignore_status_mask |= UART_LSR_DR;
    2618                 :            : 
    2619                 :            :         /*
    2620                 :            :          * CTS flow control flag and modem status interrupts
    2621                 :            :          */
    2622                 :         26 :         up->ier &= ~UART_IER_MSI;
    2623         [ +  - ]:         26 :         if (!(up->bugs & UART_BUG_NOMSR) &&
    2624   [ +  -  +  -  :         26 :                         UART_ENABLE_MS(&up->port, termios->c_cflag))
                   -  + ]
    2625                 :          0 :                 up->ier |= UART_IER_MSI;
    2626         [ -  + ]:         26 :         if (up->capabilities & UART_CAP_UUE)
    2627                 :          0 :                 up->ier |= UART_IER_UUE;
    2628         [ -  + ]:         26 :         if (up->capabilities & UART_CAP_RTOIE)
    2629                 :          0 :                 up->ier |= UART_IER_RTOIE;
    2630                 :            : 
    2631                 :         26 :         serial_port_out(port, UART_IER, up->ier);
    2632                 :            : 
    2633         [ -  + ]:         26 :         if (up->capabilities & UART_CAP_EFR) {
    2634                 :          0 :                 unsigned char efr = 0;
    2635                 :            :                 /*
    2636                 :            :                  * TI16C752/Startech hardware flow control.  FIXME:
    2637                 :            :                  * - TI16C752 requires control thresholds to be set.
    2638                 :            :                  * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled.
    2639                 :            :                  */
    2640         [ #  # ]:          0 :                 if (termios->c_cflag & CRTSCTS)
    2641                 :          0 :                         efr |= UART_EFR_CTS;
    2642                 :            : 
    2643                 :          0 :                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
    2644         [ #  # ]:          0 :                 if (port->flags & UPF_EXAR_EFR)
    2645                 :          0 :                         serial_port_out(port, UART_XR_EFR, efr);
    2646                 :            :                 else
    2647                 :          0 :                         serial_port_out(port, UART_EFR, efr);
    2648                 :            :         }
    2649                 :            : 
    2650                 :         26 :         serial8250_set_divisor(port, baud, quot, frac);
    2651                 :            : 
    2652                 :            :         /*
    2653                 :            :          * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
    2654                 :            :          * is written without DLAB set, this mode will be disabled.
    2655                 :            :          */
    2656         [ -  + ]:         26 :         if (port->type == PORT_16750)
    2657                 :          0 :                 serial_port_out(port, UART_FCR, up->fcr);
    2658                 :            : 
    2659                 :         26 :         serial_port_out(port, UART_LCR, up->lcr);    /* reset DLAB */
    2660         [ +  - ]:         26 :         if (port->type != PORT_16750) {
    2661                 :            :                 /* emulated UARTs (Lucent Venus 167x) need two steps */
    2662         [ +  + ]:         26 :                 if (up->fcr & UART_FCR_ENABLE_FIFO)
    2663                 :         13 :                         serial_port_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
    2664                 :         26 :                 serial_port_out(port, UART_FCR, up->fcr);    /* set fcr */
    2665                 :            :         }
    2666                 :         26 :         serial8250_set_mctrl(port, port->mctrl);
    2667                 :         26 :         spin_unlock_irqrestore(&port->lock, flags);
    2668                 :         26 :         serial8250_rpm_put(up);
    2669                 :            : 
    2670                 :            :         /* Don't rewrite B0 */
    2671         [ +  - ]:         26 :         if (tty_termios_baud_rate(termios))
    2672                 :         26 :                 tty_termios_encode_baud_rate(termios, baud, baud);
    2673                 :         26 : }
    2674                 :            : EXPORT_SYMBOL(serial8250_do_set_termios);
    2675                 :            : 
    2676                 :            : static void
    2677                 :         26 : serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
    2678                 :            :                        struct ktermios *old)
    2679                 :            : {
    2680         [ -  + ]:         26 :         if (port->set_termios)
    2681                 :          0 :                 port->set_termios(port, termios, old);
    2682                 :            :         else
    2683                 :         26 :                 serial8250_do_set_termios(port, termios, old);
    2684                 :         26 : }
    2685                 :            : 
    2686                 :          0 : void serial8250_do_set_ldisc(struct uart_port *port, struct ktermios *termios)
    2687                 :            : {
    2688         [ #  # ]:          0 :         if (termios->c_line == N_PPS) {
    2689                 :          0 :                 port->flags |= UPF_HARDPPS_CD;
    2690                 :          0 :                 spin_lock_irq(&port->lock);
    2691                 :          0 :                 serial8250_enable_ms(port);
    2692                 :          0 :                 spin_unlock_irq(&port->lock);
    2693                 :            :         } else {
    2694                 :          0 :                 port->flags &= ~UPF_HARDPPS_CD;
    2695   [ #  #  #  # ]:          0 :                 if (!UART_ENABLE_MS(port, termios->c_cflag)) {
    2696                 :          0 :                         spin_lock_irq(&port->lock);
    2697         [ #  # ]:          0 :                         serial8250_disable_ms(port);
    2698                 :          0 :                         spin_unlock_irq(&port->lock);
    2699                 :            :                 }
    2700                 :            :         }
    2701                 :          0 : }
    2702                 :            : EXPORT_SYMBOL_GPL(serial8250_do_set_ldisc);
    2703                 :            : 
    2704                 :            : static void
    2705                 :          0 : serial8250_set_ldisc(struct uart_port *port, struct ktermios *termios)
    2706                 :            : {
    2707         [ #  # ]:          0 :         if (port->set_ldisc)
    2708                 :          0 :                 port->set_ldisc(port, termios);
    2709                 :            :         else
    2710                 :          0 :                 serial8250_do_set_ldisc(port, termios);
    2711                 :          0 : }
    2712                 :            : 
    2713                 :         13 : void serial8250_do_pm(struct uart_port *port, unsigned int state,
    2714                 :            :                       unsigned int oldstate)
    2715                 :            : {
    2716                 :          0 :         struct uart_8250_port *p = up_to_u8250p(port);
    2717                 :            : 
    2718                 :         13 :         serial8250_set_sleep(p, state != 0);
    2719                 :         13 : }
    2720                 :            : EXPORT_SYMBOL(serial8250_do_pm);
    2721                 :            : 
    2722                 :            : static void
    2723                 :         13 : serial8250_pm(struct uart_port *port, unsigned int state,
    2724                 :            :               unsigned int oldstate)
    2725                 :            : {
    2726         [ -  + ]:         13 :         if (port->pm)
    2727                 :          0 :                 port->pm(port, state, oldstate);
    2728                 :            :         else
    2729                 :         13 :                 serial8250_do_pm(port, state, oldstate);
    2730                 :         13 : }
    2731                 :            : 
    2732                 :         91 : static unsigned int serial8250_port_size(struct uart_8250_port *pt)
    2733                 :            : {
    2734                 :         91 :         if (pt->port.mapsize)
    2735                 :          0 :                 return pt->port.mapsize;
    2736   [ -  +  -  + ]:         91 :         if (pt->port.iotype == UPIO_AU) {
    2737   [ #  #  #  # ]:          0 :                 if (pt->port.type == PORT_RT2880)
    2738                 :            :                         return 0x100;
    2739                 :          0 :                 return 0x1000;
    2740                 :            :         }
    2741                 :         91 :         if (is_omap1_8250(pt))
    2742                 :            :                 return 0x16 << pt->port.regshift;
    2743                 :            : 
    2744                 :         91 :         return 8 << pt->port.regshift;
    2745                 :            : }
    2746                 :            : 
    2747                 :            : /*
    2748                 :            :  * Resource handling.
    2749                 :            :  */
    2750                 :         52 : static int serial8250_request_std_resource(struct uart_8250_port *up)
    2751                 :            : {
    2752         [ -  + ]:         52 :         unsigned int size = serial8250_port_size(up);
    2753                 :         52 :         struct uart_port *port = &up->port;
    2754                 :         52 :         int ret = 0;
    2755                 :            : 
    2756      [ -  +  - ]:         52 :         switch (port->iotype) {
    2757                 :          0 :         case UPIO_AU:
    2758                 :            :         case UPIO_TSI:
    2759                 :            :         case UPIO_MEM32:
    2760                 :            :         case UPIO_MEM32BE:
    2761                 :            :         case UPIO_MEM16:
    2762                 :            :         case UPIO_MEM:
    2763         [ #  # ]:          0 :                 if (!port->mapbase)
    2764                 :            :                         break;
    2765                 :            : 
    2766         [ #  # ]:          0 :                 if (!request_mem_region(port->mapbase, size, "serial")) {
    2767                 :            :                         ret = -EBUSY;
    2768                 :            :                         break;
    2769                 :            :                 }
    2770                 :            : 
    2771         [ #  # ]:          0 :                 if (port->flags & UPF_IOREMAP) {
    2772                 :          0 :                         port->membase = ioremap(port->mapbase, size);
    2773         [ #  # ]:          0 :                         if (!port->membase) {
    2774                 :          0 :                                 release_mem_region(port->mapbase, size);
    2775                 :          0 :                                 ret = -ENOMEM;
    2776                 :            :                         }
    2777                 :            :                 }
    2778                 :            :                 break;
    2779                 :            : 
    2780                 :         52 :         case UPIO_HUB6:
    2781                 :            :         case UPIO_PORT:
    2782         [ -  + ]:         52 :                 if (!request_region(port->iobase, size, "serial"))
    2783                 :          0 :                         ret = -EBUSY;
    2784                 :            :                 break;
    2785                 :            :         }
    2786                 :          0 :         return ret;
    2787                 :            : }
    2788                 :            : 
    2789                 :         39 : static void serial8250_release_std_resource(struct uart_8250_port *up)
    2790                 :            : {
    2791         [ -  + ]:         39 :         unsigned int size = serial8250_port_size(up);
    2792                 :         39 :         struct uart_port *port = &up->port;
    2793                 :            : 
    2794      [ -  +  - ]:         39 :         switch (port->iotype) {
    2795                 :          0 :         case UPIO_AU:
    2796                 :            :         case UPIO_TSI:
    2797                 :            :         case UPIO_MEM32:
    2798                 :            :         case UPIO_MEM32BE:
    2799                 :            :         case UPIO_MEM16:
    2800                 :            :         case UPIO_MEM:
    2801         [ #  # ]:          0 :                 if (!port->mapbase)
    2802                 :            :                         break;
    2803                 :            : 
    2804         [ #  # ]:          0 :                 if (port->flags & UPF_IOREMAP) {
    2805                 :          0 :                         iounmap(port->membase);
    2806                 :          0 :                         port->membase = NULL;
    2807                 :            :                 }
    2808                 :            : 
    2809                 :          0 :                 release_mem_region(port->mapbase, size);
    2810                 :          0 :                 break;
    2811                 :            : 
    2812                 :         39 :         case UPIO_HUB6:
    2813                 :            :         case UPIO_PORT:
    2814                 :         39 :                 release_region(port->iobase, size);
    2815                 :         39 :                 break;
    2816                 :            :         }
    2817                 :          0 : }
    2818                 :            : 
    2819                 :          0 : static void serial8250_release_port(struct uart_port *port)
    2820                 :            : {
    2821                 :          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    2822                 :            : 
    2823                 :          0 :         serial8250_release_std_resource(up);
    2824                 :          0 : }
    2825                 :            : 
    2826                 :          0 : static int serial8250_request_port(struct uart_port *port)
    2827                 :            : {
    2828                 :          0 :         struct uart_8250_port *up = up_to_u8250p(port);
    2829                 :            : 
    2830                 :          0 :         return serial8250_request_std_resource(up);
    2831                 :            : }
    2832                 :            : 
    2833                 :          0 : static int fcr_get_rxtrig_bytes(struct uart_8250_port *up)
    2834                 :            : {
    2835                 :          0 :         const struct serial8250_config *conf_type = &uart_config[up->port.type];
    2836                 :          0 :         unsigned char bytes;
    2837                 :            : 
    2838                 :          0 :         bytes = conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(up->fcr)];
    2839                 :            : 
    2840                 :          0 :         return bytes ? bytes : -EOPNOTSUPP;
    2841                 :            : }
    2842                 :            : 
    2843                 :          0 : static int bytes_to_fcr_rxtrig(struct uart_8250_port *up, unsigned char bytes)
    2844                 :            : {
    2845                 :          0 :         const struct serial8250_config *conf_type = &uart_config[up->port.type];
    2846                 :          0 :         int i;
    2847                 :            : 
    2848                 :          0 :         if (!conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(UART_FCR_R_TRIG_00)])
    2849                 :            :                 return -EOPNOTSUPP;
    2850                 :            : 
    2851         [ #  # ]:          0 :         for (i = 1; i < UART_FCR_R_TRIG_MAX_STATE; i++) {
    2852         [ #  # ]:          0 :                 if (bytes < conf_type->rxtrig_bytes[i])
    2853                 :            :                         /* Use the nearest lower value */
    2854                 :          0 :                         return (--i) << UART_FCR_R_TRIG_SHIFT;
    2855                 :            :         }
    2856                 :            : 
    2857                 :            :         return UART_FCR_R_TRIG_11;
    2858                 :            : }
    2859                 :            : 
    2860                 :          0 : static int do_get_rxtrig(struct tty_port *port)
    2861                 :            : {
    2862                 :          0 :         struct uart_state *state = container_of(port, struct uart_state, port);
    2863                 :          0 :         struct uart_port *uport = state->uart_port;
    2864                 :          0 :         struct uart_8250_port *up = up_to_u8250p(uport);
    2865                 :            : 
    2866   [ #  #  #  # ]:          0 :         if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1)
    2867                 :            :                 return -EINVAL;
    2868                 :            : 
    2869         [ #  # ]:          0 :         return fcr_get_rxtrig_bytes(up);
    2870                 :            : }
    2871                 :            : 
    2872                 :          0 : static int do_serial8250_get_rxtrig(struct tty_port *port)
    2873                 :            : {
    2874                 :          0 :         int rxtrig_bytes;
    2875                 :            : 
    2876                 :          0 :         mutex_lock(&port->mutex);
    2877         [ #  # ]:          0 :         rxtrig_bytes = do_get_rxtrig(port);
    2878                 :          0 :         mutex_unlock(&port->mutex);
    2879                 :            : 
    2880                 :          0 :         return rxtrig_bytes;
    2881                 :            : }
    2882                 :            : 
    2883                 :          0 : static ssize_t serial8250_get_attr_rx_trig_bytes(struct device *dev,
    2884                 :            :         struct device_attribute *attr, char *buf)
    2885                 :            : {
    2886                 :          0 :         struct tty_port *port = dev_get_drvdata(dev);
    2887                 :          0 :         int rxtrig_bytes;
    2888                 :            : 
    2889                 :          0 :         rxtrig_bytes = do_serial8250_get_rxtrig(port);
    2890         [ #  # ]:          0 :         if (rxtrig_bytes < 0)
    2891                 :          0 :                 return rxtrig_bytes;
    2892                 :            : 
    2893                 :          0 :         return snprintf(buf, PAGE_SIZE, "%d\n", rxtrig_bytes);
    2894                 :            : }
    2895                 :            : 
    2896                 :          0 : static int do_set_rxtrig(struct tty_port *port, unsigned char bytes)
    2897                 :            : {
    2898                 :          0 :         struct uart_state *state = container_of(port, struct uart_state, port);
    2899                 :          0 :         struct uart_port *uport = state->uart_port;
    2900         [ #  # ]:          0 :         struct uart_8250_port *up = up_to_u8250p(uport);
    2901                 :          0 :         int rxtrig;
    2902                 :            : 
    2903   [ #  #  #  # ]:          0 :         if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1 ||
    2904         [ #  # ]:          0 :             up->fifo_bug)
    2905                 :            :                 return -EINVAL;
    2906                 :            : 
    2907         [ #  # ]:          0 :         rxtrig = bytes_to_fcr_rxtrig(up, bytes);
    2908                 :          0 :         if (rxtrig < 0)
    2909                 :            :                 return rxtrig;
    2910                 :            : 
    2911                 :          0 :         serial8250_clear_fifos(up);
    2912                 :          0 :         up->fcr &= ~UART_FCR_TRIGGER_MASK;
    2913                 :          0 :         up->fcr |= (unsigned char)rxtrig;
    2914                 :          0 :         serial_out(up, UART_FCR, up->fcr);
    2915                 :          0 :         return 0;
    2916                 :            : }
    2917                 :            : 
    2918                 :          0 : static int do_serial8250_set_rxtrig(struct tty_port *port, unsigned char bytes)
    2919                 :            : {
    2920                 :          0 :         int ret;
    2921                 :            : 
    2922                 :          0 :         mutex_lock(&port->mutex);
    2923                 :          0 :         ret = do_set_rxtrig(port, bytes);
    2924                 :          0 :         mutex_unlock(&port->mutex);
    2925                 :            : 
    2926                 :          0 :         return ret;
    2927                 :            : }
    2928                 :            : 
    2929                 :          0 : static ssize_t serial8250_set_attr_rx_trig_bytes(struct device *dev,
    2930                 :            :         struct device_attribute *attr, const char *buf, size_t count)
    2931                 :            : {
    2932         [ #  # ]:          0 :         struct tty_port *port = dev_get_drvdata(dev);
    2933                 :          0 :         unsigned char bytes;
    2934                 :          0 :         int ret;
    2935                 :            : 
    2936         [ #  # ]:          0 :         if (!count)
    2937                 :            :                 return -EINVAL;
    2938                 :            : 
    2939                 :          0 :         ret = kstrtou8(buf, 10, &bytes);
    2940         [ #  # ]:          0 :         if (ret < 0)
    2941                 :          0 :                 return ret;
    2942                 :            : 
    2943                 :          0 :         ret = do_serial8250_set_rxtrig(port, bytes);
    2944         [ #  # ]:          0 :         if (ret < 0)
    2945                 :          0 :                 return ret;
    2946                 :            : 
    2947                 :          0 :         return count;
    2948                 :            : }
    2949                 :            : 
    2950                 :            : static DEVICE_ATTR(rx_trig_bytes, S_IRUSR | S_IWUSR | S_IRGRP,
    2951                 :            :                    serial8250_get_attr_rx_trig_bytes,
    2952                 :            :                    serial8250_set_attr_rx_trig_bytes);
    2953                 :            : 
    2954                 :            : static struct attribute *serial8250_dev_attrs[] = {
    2955                 :            :         &dev_attr_rx_trig_bytes.attr,
    2956                 :            :         NULL,
    2957                 :            :         };
    2958                 :            : 
    2959                 :            : static struct attribute_group serial8250_dev_attr_group = {
    2960                 :            :         .attrs = serial8250_dev_attrs,
    2961                 :            :         };
    2962                 :            : 
    2963                 :         52 : static void register_dev_spec_attr_grp(struct uart_8250_port *up)
    2964                 :            : {
    2965                 :         52 :         const struct serial8250_config *conf_type = &uart_config[up->port.type];
    2966                 :            : 
    2967                 :         52 :         if (conf_type->rxtrig_bytes[0])
    2968                 :         13 :                 up->port.attr_group = &serial8250_dev_attr_group;
    2969                 :            : }
    2970                 :            : 
    2971                 :         52 : static void serial8250_config_port(struct uart_port *port, int flags)
    2972                 :            : {
    2973                 :         52 :         struct uart_8250_port *up = up_to_u8250p(port);
    2974                 :         52 :         int ret;
    2975                 :            : 
    2976                 :            :         /*
    2977                 :            :          * Find the region that we can probe for.  This in turn
    2978                 :            :          * tells us whether we can probe for the type of port.
    2979                 :            :          */
    2980                 :         52 :         ret = serial8250_request_std_resource(up);
    2981         [ +  - ]:         52 :         if (ret < 0)
    2982                 :            :                 return;
    2983                 :            : 
    2984         [ -  + ]:         52 :         if (port->iotype != up->cur_iotype)
    2985                 :          0 :                 set_io_from_upio(port);
    2986                 :            : 
    2987         [ +  - ]:         52 :         if (flags & UART_CONFIG_TYPE)
    2988                 :         52 :                 autoconfig(up);
    2989                 :            : 
    2990                 :            :         /* if access method is AU, it is a 16550 with a quirk */
    2991   [ +  +  -  + ]:         52 :         if (port->type == PORT_16550A && port->iotype == UPIO_AU)
    2992                 :          0 :                 up->bugs |= UART_BUG_NOMSR;
    2993                 :            : 
    2994                 :            :         /* HW bugs may trigger IRQ while IIR == NO_INT */
    2995         [ -  + ]:         52 :         if (port->type == PORT_TEGRA)
    2996                 :          0 :                 up->bugs |= UART_BUG_NOMSR;
    2997                 :            : 
    2998   [ +  +  -  + ]:         52 :         if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
    2999                 :          0 :                 autoconfig_irq(up);
    3000                 :            : 
    3001         [ +  + ]:         52 :         if (port->type == PORT_UNKNOWN)
    3002                 :         39 :                 serial8250_release_std_resource(up);
    3003                 :            : 
    3004         [ +  + ]:         52 :         register_dev_spec_attr_grp(up);
    3005                 :         52 :         up->fcr = uart_config[up->port.type].fcr;
    3006                 :            : }
    3007                 :            : 
    3008                 :            : static int
    3009                 :          0 : serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
    3010                 :            : {
    3011   [ #  #  #  # ]:          0 :         if (ser->irq >= nr_irqs || ser->irq < 0 ||
    3012   [ #  #  #  # ]:          0 :             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
    3013   [ #  #  #  #  :          0 :             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
                   #  # ]
    3014                 :            :             ser->type == PORT_STARTECH)
    3015                 :          0 :                 return -EINVAL;
    3016                 :            :         return 0;
    3017                 :            : }
    3018                 :            : 
    3019                 :         13 : static const char *serial8250_type(struct uart_port *port)
    3020                 :            : {
    3021                 :         13 :         int type = port->type;
    3022                 :            : 
    3023         [ -  + ]:         13 :         if (type >= ARRAY_SIZE(uart_config))
    3024                 :          0 :                 type = 0;
    3025                 :         13 :         return uart_config[type].name;
    3026                 :            : }
    3027                 :            : 
    3028                 :            : static const struct uart_ops serial8250_pops = {
    3029                 :            :         .tx_empty       = serial8250_tx_empty,
    3030                 :            :         .set_mctrl      = serial8250_set_mctrl,
    3031                 :            :         .get_mctrl      = serial8250_get_mctrl,
    3032                 :            :         .stop_tx        = serial8250_stop_tx,
    3033                 :            :         .start_tx       = serial8250_start_tx,
    3034                 :            :         .throttle       = serial8250_throttle,
    3035                 :            :         .unthrottle     = serial8250_unthrottle,
    3036                 :            :         .stop_rx        = serial8250_stop_rx,
    3037                 :            :         .enable_ms      = serial8250_enable_ms,
    3038                 :            :         .break_ctl      = serial8250_break_ctl,
    3039                 :            :         .startup        = serial8250_startup,
    3040                 :            :         .shutdown       = serial8250_shutdown,
    3041                 :            :         .set_termios    = serial8250_set_termios,
    3042                 :            :         .set_ldisc      = serial8250_set_ldisc,
    3043                 :            :         .pm             = serial8250_pm,
    3044                 :            :         .type           = serial8250_type,
    3045                 :            :         .release_port   = serial8250_release_port,
    3046                 :            :         .request_port   = serial8250_request_port,
    3047                 :            :         .config_port    = serial8250_config_port,
    3048                 :            :         .verify_port    = serial8250_verify_port,
    3049                 :            : #ifdef CONFIG_CONSOLE_POLL
    3050                 :            :         .poll_get_char = serial8250_get_poll_char,
    3051                 :            :         .poll_put_char = serial8250_put_poll_char,
    3052                 :            : #endif
    3053                 :            : };
    3054                 :            : 
    3055                 :         52 : void serial8250_init_port(struct uart_8250_port *up)
    3056                 :            : {
    3057                 :         52 :         struct uart_port *port = &up->port;
    3058                 :            : 
    3059                 :         52 :         spin_lock_init(&port->lock);
    3060                 :         52 :         port->ops = &serial8250_pops;
    3061                 :         52 :         port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_8250_CONSOLE);
    3062                 :            : 
    3063                 :         52 :         up->cur_iotype = 0xFF;
    3064                 :         52 : }
    3065                 :            : EXPORT_SYMBOL_GPL(serial8250_init_port);
    3066                 :            : 
    3067                 :         65 : void serial8250_set_defaults(struct uart_8250_port *up)
    3068                 :            : {
    3069                 :         65 :         struct uart_port *port = &up->port;
    3070                 :            : 
    3071         [ -  + ]:         65 :         if (up->port.flags & UPF_FIXED_TYPE) {
    3072                 :          0 :                 unsigned int type = up->port.type;
    3073                 :            : 
    3074         [ #  # ]:          0 :                 if (!up->port.fifosize)
    3075                 :          0 :                         up->port.fifosize = uart_config[type].fifo_size;
    3076         [ #  # ]:          0 :                 if (!up->tx_loadsz)
    3077                 :          0 :                         up->tx_loadsz = uart_config[type].tx_loadsz;
    3078         [ #  # ]:          0 :                 if (!up->capabilities)
    3079                 :          0 :                         up->capabilities = uart_config[type].flags;
    3080                 :            :         }
    3081                 :            : 
    3082                 :         65 :         set_io_from_upio(port);
    3083                 :            : 
    3084                 :            :         /* default dma handlers */
    3085         [ -  + ]:         65 :         if (up->dma) {
    3086         [ #  # ]:          0 :                 if (!up->dma->tx_dma)
    3087                 :          0 :                         up->dma->tx_dma = serial8250_tx_dma;
    3088         [ #  # ]:          0 :                 if (!up->dma->rx_dma)
    3089                 :          0 :                         up->dma->rx_dma = serial8250_rx_dma;
    3090                 :            :         }
    3091                 :         65 : }
    3092                 :            : EXPORT_SYMBOL_GPL(serial8250_set_defaults);
    3093                 :            : 
    3094                 :            : #ifdef CONFIG_SERIAL_8250_CONSOLE
    3095                 :            : 
    3096                 :     273852 : static void serial8250_console_putchar(struct uart_port *port, int ch)
    3097                 :            : {
    3098                 :     273852 :         struct uart_8250_port *up = up_to_u8250p(port);
    3099                 :            : 
    3100                 :     273852 :         wait_for_xmitr(up, UART_LSR_THRE);
    3101                 :     273852 :         serial_port_out(port, UART_TX, ch);
    3102                 :     273852 : }
    3103                 :            : 
    3104                 :            : /*
    3105                 :            :  *      Restore serial console when h/w power-off detected
    3106                 :            :  */
    3107                 :          0 : static void serial8250_console_restore(struct uart_8250_port *up)
    3108                 :            : {
    3109                 :          0 :         struct uart_port *port = &up->port;
    3110                 :          0 :         struct ktermios termios;
    3111                 :          0 :         unsigned int baud, quot, frac = 0;
    3112                 :            : 
    3113                 :          0 :         termios.c_cflag = port->cons->cflag;
    3114   [ #  #  #  # ]:          0 :         if (port->state->port.tty && termios.c_cflag == 0)
    3115                 :          0 :                 termios.c_cflag = port->state->port.tty->termios.c_cflag;
    3116                 :            : 
    3117                 :          0 :         baud = serial8250_get_baud_rate(port, &termios, NULL);
    3118                 :          0 :         quot = serial8250_get_divisor(port, baud, &frac);
    3119                 :            : 
    3120                 :          0 :         serial8250_set_divisor(port, baud, quot, frac);
    3121                 :          0 :         serial_port_out(port, UART_LCR, up->lcr);
    3122                 :          0 :         serial8250_out_MCR(up, UART_MCR_DTR | UART_MCR_RTS);
    3123                 :          0 : }
    3124                 :            : 
    3125                 :            : /*
    3126                 :            :  *      Print a string to the serial port trying not to disturb
    3127                 :            :  *      any possible real use of the port...
    3128                 :            :  *
    3129                 :            :  *      The console_lock must be held when we get here.
    3130                 :            :  */
    3131                 :       4253 : void serial8250_console_write(struct uart_8250_port *up, const char *s,
    3132                 :            :                               unsigned int count)
    3133                 :            : {
    3134                 :       4253 :         struct uart_port *port = &up->port;
    3135                 :       4253 :         unsigned long flags;
    3136                 :       4253 :         unsigned int ier;
    3137                 :       4253 :         int locked = 1;
    3138                 :            : 
    3139         [ -  + ]:       4253 :         touch_nmi_watchdog();
    3140                 :            : 
    3141         [ -  + ]:       4253 :         serial8250_rpm_get(up);
    3142                 :            : 
    3143         [ -  + ]:       4253 :         if (oops_in_progress)
    3144         [ #  # ]:          0 :                 locked = spin_trylock_irqsave(&port->lock, flags);
    3145                 :            :         else
    3146                 :       4253 :                 spin_lock_irqsave(&port->lock, flags);
    3147                 :            : 
    3148                 :            :         /*
    3149                 :            :          *      First save the IER then disable the interrupts
    3150                 :            :          */
    3151                 :       4253 :         ier = serial_port_in(port, UART_IER);
    3152                 :            : 
    3153         [ -  + ]:       4253 :         if (up->capabilities & UART_CAP_UUE)
    3154                 :          0 :                 serial_port_out(port, UART_IER, UART_IER_UUE);
    3155                 :            :         else
    3156                 :       4253 :                 serial_port_out(port, UART_IER, 0);
    3157                 :            : 
    3158                 :            :         /* check scratch reg to see if port powered off during system sleep */
    3159   [ -  +  -  - ]:       4253 :         if (up->canary && (up->canary != serial_port_in(port, UART_SCR))) {
    3160                 :          0 :                 serial8250_console_restore(up);
    3161                 :          0 :                 up->canary = 0;
    3162                 :            :         }
    3163                 :            : 
    3164                 :       4253 :         uart_console_write(port, s, count, serial8250_console_putchar);
    3165                 :            : 
    3166                 :            :         /*
    3167                 :            :          *      Finally, wait for transmitter to become empty
    3168                 :            :          *      and restore the IER
    3169                 :            :          */
    3170                 :       4253 :         wait_for_xmitr(up, BOTH_EMPTY);
    3171                 :       4253 :         serial_port_out(port, UART_IER, ier);
    3172                 :            : 
    3173                 :            :         /*
    3174                 :            :          *      The receive handling will happen properly because the
    3175                 :            :          *      receive ready bit will still be set; it is not cleared
    3176                 :            :          *      on read.  However, modem control will not, we must
    3177                 :            :          *      call it if we have saved something in the saved flags
    3178                 :            :          *      while processing with interrupts off.
    3179                 :            :          */
    3180         [ -  + ]:       4253 :         if (up->msr_saved_flags)
    3181                 :          0 :                 serial8250_modem_status(up);
    3182                 :            : 
    3183         [ +  - ]:       4253 :         if (locked)
    3184                 :       4253 :                 spin_unlock_irqrestore(&port->lock, flags);
    3185                 :       4253 :         serial8250_rpm_put(up);
    3186                 :       4253 : }
    3187                 :            : 
    3188                 :          0 : static unsigned int probe_baud(struct uart_port *port)
    3189                 :            : {
    3190                 :          0 :         unsigned char lcr, dll, dlm;
    3191                 :          0 :         unsigned int quot;
    3192                 :            : 
    3193                 :          0 :         lcr = serial_port_in(port, UART_LCR);
    3194                 :          0 :         serial_port_out(port, UART_LCR, lcr | UART_LCR_DLAB);
    3195                 :          0 :         dll = serial_port_in(port, UART_DLL);
    3196                 :          0 :         dlm = serial_port_in(port, UART_DLM);
    3197                 :          0 :         serial_port_out(port, UART_LCR, lcr);
    3198                 :            : 
    3199                 :          0 :         quot = (dlm << 8) | dll;
    3200                 :          0 :         return (port->uartclk / 16) / quot;
    3201                 :            : }
    3202                 :            : 
    3203                 :         13 : int serial8250_console_setup(struct uart_port *port, char *options, bool probe)
    3204                 :            : {
    3205                 :         13 :         int baud = 9600;
    3206                 :         13 :         int bits = 8;
    3207                 :         13 :         int parity = 'n';
    3208                 :         13 :         int flow = 'n';
    3209                 :            : 
    3210   [ -  +  -  - ]:         13 :         if (!port->iobase && !port->membase)
    3211                 :            :                 return -ENODEV;
    3212                 :            : 
    3213         [ -  + ]:         13 :         if (options)
    3214                 :          0 :                 uart_parse_options(options, &baud, &parity, &bits, &flow);
    3215         [ -  + ]:         13 :         else if (probe)
    3216                 :          0 :                 baud = probe_baud(port);
    3217                 :            : 
    3218                 :         13 :         return uart_set_options(port, port->cons, baud, parity, bits, flow);
    3219                 :            : }
    3220                 :            : 
    3221                 :            : #endif /* CONFIG_SERIAL_8250_CONSOLE */
    3222                 :            : 
    3223                 :            : MODULE_LICENSE("GPL");

Generated by: LCOV version 1.14