LCOV - code coverage report
Current view: top level - drivers/tty/serial/8250 - 8250_lpss.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 1 115 0.9 %
Date: 2022-04-01 14:17:54 Functions: 1 11 9.1 %
Branches: 0 157 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * 8250_lpss.c - Driver for UART on Intel Braswell and various other Intel SoCs
       4                 :            :  *
       5                 :            :  * Copyright (C) 2016 Intel Corporation
       6                 :            :  * Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
       7                 :            :  */
       8                 :            : 
       9                 :            : #include <linux/bitops.h>
      10                 :            : #include <linux/module.h>
      11                 :            : #include <linux/pci.h>
      12                 :            : #include <linux/rational.h>
      13                 :            : 
      14                 :            : #include <linux/dmaengine.h>
      15                 :            : #include <linux/dma/dw.h>
      16                 :            : 
      17                 :            : #include "8250_dwlib.h"
      18                 :            : 
      19                 :            : #define PCI_DEVICE_ID_INTEL_QRK_UARTx   0x0936
      20                 :            : 
      21                 :            : #define PCI_DEVICE_ID_INTEL_BYT_UART1   0x0f0a
      22                 :            : #define PCI_DEVICE_ID_INTEL_BYT_UART2   0x0f0c
      23                 :            : 
      24                 :            : #define PCI_DEVICE_ID_INTEL_BSW_UART1   0x228a
      25                 :            : #define PCI_DEVICE_ID_INTEL_BSW_UART2   0x228c
      26                 :            : 
      27                 :            : #define PCI_DEVICE_ID_INTEL_EHL_UART0   0x4b96
      28                 :            : #define PCI_DEVICE_ID_INTEL_EHL_UART1   0x4b97
      29                 :            : #define PCI_DEVICE_ID_INTEL_EHL_UART2   0x4b98
      30                 :            : #define PCI_DEVICE_ID_INTEL_EHL_UART3   0x4b99
      31                 :            : #define PCI_DEVICE_ID_INTEL_EHL_UART4   0x4b9a
      32                 :            : #define PCI_DEVICE_ID_INTEL_EHL_UART5   0x4b9b
      33                 :            : 
      34                 :            : #define PCI_DEVICE_ID_INTEL_BDW_UART1   0x9ce3
      35                 :            : #define PCI_DEVICE_ID_INTEL_BDW_UART2   0x9ce4
      36                 :            : 
      37                 :            : /* Intel LPSS specific registers */
      38                 :            : 
      39                 :            : #define BYT_PRV_CLK                     0x800
      40                 :            : #define BYT_PRV_CLK_EN                  BIT(0)
      41                 :            : #define BYT_PRV_CLK_M_VAL_SHIFT         1
      42                 :            : #define BYT_PRV_CLK_N_VAL_SHIFT         16
      43                 :            : #define BYT_PRV_CLK_UPDATE              BIT(31)
      44                 :            : 
      45                 :            : #define BYT_TX_OVF_INT                  0x820
      46                 :            : #define BYT_TX_OVF_INT_MASK             BIT(1)
      47                 :            : 
      48                 :            : struct lpss8250;
      49                 :            : 
      50                 :            : struct lpss8250_board {
      51                 :            :         unsigned long freq;
      52                 :            :         unsigned int base_baud;
      53                 :            :         int (*setup)(struct lpss8250 *, struct uart_port *p);
      54                 :            :         void (*exit)(struct lpss8250 *);
      55                 :            : };
      56                 :            : 
      57                 :            : struct lpss8250 {
      58                 :            :         struct dw8250_port_data data;
      59                 :            :         struct lpss8250_board *board;
      60                 :            : 
      61                 :            :         /* DMA parameters */
      62                 :            :         struct dw_dma_chip dma_chip;
      63                 :            :         struct dw_dma_slave dma_param;
      64                 :            :         u8 dma_maxburst;
      65                 :            : };
      66                 :            : 
      67                 :          0 : static inline struct lpss8250 *to_lpss8250(struct dw8250_port_data *data)
      68                 :            : {
      69                 :          0 :         return container_of(data, struct lpss8250, data);
      70                 :            : }
      71                 :            : 
      72                 :          0 : static void byt_set_termios(struct uart_port *p, struct ktermios *termios,
      73                 :            :                             struct ktermios *old)
      74                 :            : {
      75                 :          0 :         unsigned int baud = tty_termios_baud_rate(termios);
      76                 :          0 :         struct lpss8250 *lpss = to_lpss8250(p->private_data);
      77                 :          0 :         unsigned long fref = lpss->board->freq, fuart = baud * 16;
      78                 :          0 :         unsigned long w = BIT(15) - 1;
      79                 :          0 :         unsigned long m, n;
      80                 :          0 :         u32 reg;
      81                 :            : 
      82                 :            :         /* Gracefully handle the B0 case: fall back to B9600 */
      83         [ #  # ]:          0 :         fuart = fuart ? fuart : 9600 * 16;
      84                 :            : 
      85                 :            :         /* Get Fuart closer to Fref */
      86   [ #  #  #  #  :          0 :         fuart *= rounddown_pow_of_two(fref / fuart);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
      87                 :            : 
      88                 :            :         /*
      89                 :            :          * For baud rates 0.5M, 1M, 1.5M, 2M, 2.5M, 3M, 3.5M and 4M the
      90                 :            :          * dividers must be adjusted.
      91                 :            :          *
      92                 :            :          * uartclk = (m / n) * 100 MHz, where m <= n
      93                 :            :          */
      94                 :          0 :         rational_best_approximation(fuart, fref, w, w, &m, &n);
      95                 :          0 :         p->uartclk = fuart;
      96                 :            : 
      97                 :            :         /* Reset the clock */
      98                 :          0 :         reg = (m << BYT_PRV_CLK_M_VAL_SHIFT) | (n << BYT_PRV_CLK_N_VAL_SHIFT);
      99                 :          0 :         writel(reg, p->membase + BYT_PRV_CLK);
     100                 :          0 :         reg |= BYT_PRV_CLK_EN | BYT_PRV_CLK_UPDATE;
     101                 :          0 :         writel(reg, p->membase + BYT_PRV_CLK);
     102                 :            : 
     103                 :          0 :         p->status &= ~UPSTAT_AUTOCTS;
     104         [ #  # ]:          0 :         if (termios->c_cflag & CRTSCTS)
     105                 :          0 :                 p->status |= UPSTAT_AUTOCTS;
     106                 :            : 
     107                 :          0 :         serial8250_do_set_termios(p, termios, old);
     108                 :          0 : }
     109                 :            : 
     110                 :          0 : static unsigned int byt_get_mctrl(struct uart_port *port)
     111                 :            : {
     112                 :          0 :         unsigned int ret = serial8250_do_get_mctrl(port);
     113                 :            : 
     114                 :            :         /* Force DCD and DSR signals to permanently be reported as active */
     115                 :          0 :         ret |= TIOCM_CAR | TIOCM_DSR;
     116                 :            : 
     117                 :          0 :         return ret;
     118                 :            : }
     119                 :            : 
     120                 :          0 : static int byt_serial_setup(struct lpss8250 *lpss, struct uart_port *port)
     121                 :            : {
     122                 :          0 :         struct dw_dma_slave *param = &lpss->dma_param;
     123                 :          0 :         struct pci_dev *pdev = to_pci_dev(port->dev);
     124                 :          0 :         unsigned int dma_devfn = PCI_DEVFN(PCI_SLOT(pdev->devfn), 0);
     125                 :          0 :         struct pci_dev *dma_dev = pci_get_slot(pdev->bus, dma_devfn);
     126                 :            : 
     127      [ #  #  # ]:          0 :         switch (pdev->device) {
     128                 :          0 :         case PCI_DEVICE_ID_INTEL_BYT_UART1:
     129                 :            :         case PCI_DEVICE_ID_INTEL_BSW_UART1:
     130                 :            :         case PCI_DEVICE_ID_INTEL_BDW_UART1:
     131                 :          0 :                 param->src_id = 3;
     132                 :          0 :                 param->dst_id = 2;
     133                 :          0 :                 break;
     134                 :          0 :         case PCI_DEVICE_ID_INTEL_BYT_UART2:
     135                 :            :         case PCI_DEVICE_ID_INTEL_BSW_UART2:
     136                 :            :         case PCI_DEVICE_ID_INTEL_BDW_UART2:
     137                 :          0 :                 param->src_id = 5;
     138                 :          0 :                 param->dst_id = 4;
     139                 :          0 :                 break;
     140                 :            :         default:
     141                 :            :                 return -EINVAL;
     142                 :            :         }
     143                 :            : 
     144                 :          0 :         param->dma_dev = &dma_dev->dev;
     145                 :          0 :         param->m_master = 0;
     146                 :          0 :         param->p_master = 1;
     147                 :            : 
     148                 :          0 :         lpss->dma_maxburst = 16;
     149                 :            : 
     150                 :          0 :         port->set_termios = byt_set_termios;
     151                 :          0 :         port->get_mctrl = byt_get_mctrl;
     152                 :            : 
     153                 :            :         /* Disable TX counter interrupts */
     154                 :          0 :         writel(BYT_TX_OVF_INT_MASK, port->membase + BYT_TX_OVF_INT);
     155                 :            : 
     156                 :          0 :         return 0;
     157                 :            : }
     158                 :            : 
     159                 :            : #ifdef CONFIG_SERIAL_8250_DMA
     160                 :            : static const struct dw_dma_platform_data qrk_serial_dma_pdata = {
     161                 :            :         .nr_channels = 2,
     162                 :            :         .chan_allocation_order = CHAN_ALLOCATION_ASCENDING,
     163                 :            :         .chan_priority = CHAN_PRIORITY_ASCENDING,
     164                 :            :         .block_size = 4095,
     165                 :            :         .nr_masters = 1,
     166                 :            :         .data_width = {4},
     167                 :            :         .multi_block = {0},
     168                 :            : };
     169                 :            : 
     170                 :            : static void qrk_serial_setup_dma(struct lpss8250 *lpss, struct uart_port *port)
     171                 :            : {
     172                 :            :         struct uart_8250_dma *dma = &lpss->data.dma;
     173                 :            :         struct dw_dma_chip *chip = &lpss->dma_chip;
     174                 :            :         struct dw_dma_slave *param = &lpss->dma_param;
     175                 :            :         struct pci_dev *pdev = to_pci_dev(port->dev);
     176                 :            :         int ret;
     177                 :            : 
     178                 :            :         chip->pdata = &qrk_serial_dma_pdata;
     179                 :            :         chip->dev = &pdev->dev;
     180                 :            :         chip->id = pdev->devfn;
     181                 :            :         chip->irq = pci_irq_vector(pdev, 0);
     182                 :            :         chip->regs = pci_ioremap_bar(pdev, 1);
     183                 :            :         if (!chip->regs)
     184                 :            :                 return;
     185                 :            : 
     186                 :            :         /* Falling back to PIO mode if DMA probing fails */
     187                 :            :         ret = dw_dma_probe(chip);
     188                 :            :         if (ret)
     189                 :            :                 return;
     190                 :            : 
     191                 :            :         pci_try_set_mwi(pdev);
     192                 :            : 
     193                 :            :         /* Special DMA address for UART */
     194                 :            :         dma->rx_dma_addr = 0xfffff000;
     195                 :            :         dma->tx_dma_addr = 0xfffff000;
     196                 :            : 
     197                 :            :         param->dma_dev = &pdev->dev;
     198                 :            :         param->src_id = 0;
     199                 :            :         param->dst_id = 1;
     200                 :            :         param->hs_polarity = true;
     201                 :            : 
     202                 :            :         lpss->dma_maxburst = 8;
     203                 :            : }
     204                 :            : 
     205                 :          0 : static void qrk_serial_exit_dma(struct lpss8250 *lpss)
     206                 :            : {
     207                 :          0 :         struct dw_dma_chip *chip = &lpss->dma_chip;
     208                 :          0 :         struct dw_dma_slave *param = &lpss->dma_param;
     209                 :            : 
     210         [ #  # ]:          0 :         if (!param->dma_dev)
     211                 :            :                 return;
     212                 :            : 
     213                 :          0 :         dw_dma_remove(chip);
     214                 :            : 
     215                 :          0 :         pci_iounmap(to_pci_dev(chip->dev), chip->regs);
     216                 :            : }
     217                 :            : #else   /* CONFIG_SERIAL_8250_DMA */
     218                 :            : static void qrk_serial_setup_dma(struct lpss8250 *lpss, struct uart_port *port) {}
     219                 :            : static void qrk_serial_exit_dma(struct lpss8250 *lpss) {}
     220                 :            : #endif  /* !CONFIG_SERIAL_8250_DMA */
     221                 :            : 
     222                 :          0 : static int qrk_serial_setup(struct lpss8250 *lpss, struct uart_port *port)
     223                 :            : {
     224                 :          0 :         qrk_serial_setup_dma(lpss, port);
     225                 :          0 :         return 0;
     226                 :            : }
     227                 :            : 
     228                 :          0 : static void qrk_serial_exit(struct lpss8250 *lpss)
     229                 :            : {
     230                 :          0 :         qrk_serial_exit_dma(lpss);
     231                 :          0 : }
     232                 :            : 
     233                 :          0 : static bool lpss8250_dma_filter(struct dma_chan *chan, void *param)
     234                 :            : {
     235                 :          0 :         struct dw_dma_slave *dws = param;
     236                 :            : 
     237         [ #  # ]:          0 :         if (dws->dma_dev != chan->device->dev)
     238                 :            :                 return false;
     239                 :            : 
     240                 :          0 :         chan->private = dws;
     241                 :          0 :         return true;
     242                 :            : }
     243                 :            : 
     244                 :            : static int lpss8250_dma_setup(struct lpss8250 *lpss, struct uart_8250_port *port)
     245                 :            : {
     246                 :            :         struct uart_8250_dma *dma = &lpss->data.dma;
     247                 :            :         struct dw_dma_slave *rx_param, *tx_param;
     248                 :            :         struct device *dev = port->port.dev;
     249                 :            : 
     250                 :            :         if (!lpss->dma_param.dma_dev)
     251                 :            :                 return 0;
     252                 :            : 
     253                 :            :         rx_param = devm_kzalloc(dev, sizeof(*rx_param), GFP_KERNEL);
     254                 :            :         if (!rx_param)
     255                 :            :                 return -ENOMEM;
     256                 :            : 
     257                 :            :         tx_param = devm_kzalloc(dev, sizeof(*tx_param), GFP_KERNEL);
     258                 :            :         if (!tx_param)
     259                 :            :                 return -ENOMEM;
     260                 :            : 
     261                 :            :         *rx_param = lpss->dma_param;
     262                 :            :         dma->rxconf.src_maxburst = lpss->dma_maxburst;
     263                 :            : 
     264                 :            :         *tx_param = lpss->dma_param;
     265                 :            :         dma->txconf.dst_maxburst = lpss->dma_maxburst;
     266                 :            : 
     267                 :            :         dma->fn = lpss8250_dma_filter;
     268                 :            :         dma->rx_param = rx_param;
     269                 :            :         dma->tx_param = tx_param;
     270                 :            : 
     271                 :            :         port->dma = dma;
     272                 :            :         return 0;
     273                 :            : }
     274                 :            : 
     275                 :          0 : static int lpss8250_probe(struct pci_dev *pdev, const struct pci_device_id *id)
     276                 :            : {
     277                 :          0 :         struct uart_8250_port uart;
     278                 :          0 :         struct lpss8250 *lpss;
     279                 :          0 :         int ret;
     280                 :            : 
     281                 :          0 :         ret = pcim_enable_device(pdev);
     282         [ #  # ]:          0 :         if (ret)
     283                 :            :                 return ret;
     284                 :            : 
     285                 :          0 :         pci_set_master(pdev);
     286                 :            : 
     287                 :          0 :         lpss = devm_kzalloc(&pdev->dev, sizeof(*lpss), GFP_KERNEL);
     288         [ #  # ]:          0 :         if (!lpss)
     289                 :            :                 return -ENOMEM;
     290                 :            : 
     291                 :          0 :         ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
     292         [ #  # ]:          0 :         if (ret < 0)
     293                 :            :                 return ret;
     294                 :            : 
     295                 :          0 :         lpss->board = (struct lpss8250_board *)id->driver_data;
     296                 :            : 
     297                 :          0 :         memset(&uart, 0, sizeof(struct uart_8250_port));
     298                 :            : 
     299                 :          0 :         uart.port.dev = &pdev->dev;
     300                 :          0 :         uart.port.irq = pci_irq_vector(pdev, 0);
     301                 :          0 :         uart.port.private_data = &lpss->data;
     302                 :          0 :         uart.port.type = PORT_16550A;
     303                 :          0 :         uart.port.iotype = UPIO_MEM;
     304                 :          0 :         uart.port.regshift = 2;
     305                 :          0 :         uart.port.uartclk = lpss->board->base_baud * 16;
     306                 :          0 :         uart.port.flags = UPF_SHARE_IRQ | UPF_FIXED_PORT | UPF_FIXED_TYPE;
     307                 :          0 :         uart.capabilities = UART_CAP_FIFO | UART_CAP_AFE;
     308                 :          0 :         uart.port.mapbase = pci_resource_start(pdev, 0);
     309                 :          0 :         uart.port.membase = pcim_iomap(pdev, 0, 0);
     310         [ #  # ]:          0 :         if (!uart.port.membase)
     311                 :            :                 return -ENOMEM;
     312                 :            : 
     313                 :          0 :         ret = lpss->board->setup(lpss, &uart.port);
     314         [ #  # ]:          0 :         if (ret)
     315                 :            :                 return ret;
     316                 :            : 
     317                 :          0 :         dw8250_setup_port(&uart.port);
     318                 :            : 
     319                 :          0 :         ret = lpss8250_dma_setup(lpss, &uart);
     320         [ #  # ]:          0 :         if (ret)
     321                 :          0 :                 goto err_exit;
     322                 :            : 
     323                 :          0 :         ret = serial8250_register_8250_port(&uart);
     324         [ #  # ]:          0 :         if (ret < 0)
     325                 :          0 :                 goto err_exit;
     326                 :            : 
     327                 :          0 :         lpss->data.line = ret;
     328                 :            : 
     329                 :          0 :         pci_set_drvdata(pdev, lpss);
     330                 :          0 :         return 0;
     331                 :            : 
     332                 :          0 : err_exit:
     333         [ #  # ]:          0 :         if (lpss->board->exit)
     334                 :          0 :                 lpss->board->exit(lpss);
     335                 :          0 :         pci_free_irq_vectors(pdev);
     336                 :          0 :         return ret;
     337                 :            : }
     338                 :            : 
     339                 :          0 : static void lpss8250_remove(struct pci_dev *pdev)
     340                 :            : {
     341                 :          0 :         struct lpss8250 *lpss = pci_get_drvdata(pdev);
     342                 :            : 
     343                 :          0 :         serial8250_unregister_port(lpss->data.line);
     344                 :            : 
     345         [ #  # ]:          0 :         if (lpss->board->exit)
     346                 :          0 :                 lpss->board->exit(lpss);
     347                 :          0 :         pci_free_irq_vectors(pdev);
     348                 :          0 : }
     349                 :            : 
     350                 :            : static const struct lpss8250_board byt_board = {
     351                 :            :         .freq = 100000000,
     352                 :            :         .base_baud = 2764800,
     353                 :            :         .setup = byt_serial_setup,
     354                 :            : };
     355                 :            : 
     356                 :            : static const struct lpss8250_board ehl_board = {
     357                 :            :         .freq = 200000000,
     358                 :            :         .base_baud = 12500000,
     359                 :            : };
     360                 :            : 
     361                 :            : static const struct lpss8250_board qrk_board = {
     362                 :            :         .freq = 44236800,
     363                 :            :         .base_baud = 2764800,
     364                 :            :         .setup = qrk_serial_setup,
     365                 :            :         .exit = qrk_serial_exit,
     366                 :            : };
     367                 :            : 
     368                 :            : static const struct pci_device_id pci_ids[] = {
     369                 :            :         { PCI_DEVICE_DATA(INTEL, QRK_UARTx, &qrk_board) },
     370                 :            :         { PCI_DEVICE_DATA(INTEL, EHL_UART0, &ehl_board) },
     371                 :            :         { PCI_DEVICE_DATA(INTEL, EHL_UART1, &ehl_board) },
     372                 :            :         { PCI_DEVICE_DATA(INTEL, EHL_UART2, &ehl_board) },
     373                 :            :         { PCI_DEVICE_DATA(INTEL, EHL_UART3, &ehl_board) },
     374                 :            :         { PCI_DEVICE_DATA(INTEL, EHL_UART4, &ehl_board) },
     375                 :            :         { PCI_DEVICE_DATA(INTEL, EHL_UART5, &ehl_board) },
     376                 :            :         { PCI_DEVICE_DATA(INTEL, BYT_UART1, &byt_board) },
     377                 :            :         { PCI_DEVICE_DATA(INTEL, BYT_UART2, &byt_board) },
     378                 :            :         { PCI_DEVICE_DATA(INTEL, BSW_UART1, &byt_board) },
     379                 :            :         { PCI_DEVICE_DATA(INTEL, BSW_UART2, &byt_board) },
     380                 :            :         { PCI_DEVICE_DATA(INTEL, BDW_UART1, &byt_board) },
     381                 :            :         { PCI_DEVICE_DATA(INTEL, BDW_UART2, &byt_board) },
     382                 :            :         { }
     383                 :            : };
     384                 :            : MODULE_DEVICE_TABLE(pci, pci_ids);
     385                 :            : 
     386                 :            : static struct pci_driver lpss8250_pci_driver = {
     387                 :            :         .name           = "8250_lpss",
     388                 :            :         .id_table       = pci_ids,
     389                 :            :         .probe          = lpss8250_probe,
     390                 :            :         .remove         = lpss8250_remove,
     391                 :            : };
     392                 :            : 
     393                 :         11 : module_pci_driver(lpss8250_pci_driver);
     394                 :            : 
     395                 :            : MODULE_AUTHOR("Intel Corporation");
     396                 :            : MODULE_LICENSE("GPL v2");
     397                 :            : MODULE_DESCRIPTION("Intel LPSS UART driver");

Generated by: LCOV version 1.14