linux/drivers/net/wan/fsl_ucc_hdlc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* Freescale QUICC Engine HDLC Device Driver
 *
 * Copyright 2016 Freescale Semiconductor Inc.
 */

#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/hdlc.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/stddef.h>
#include <soc/fsl/qe/qe_tdm.h>
#include <uapi/linux/if_arp.h>

#include "fsl_ucc_hdlc.h"

#define DRV_DESC …
#define DRV_NAME …

#define TDM_PPPOHT_SLIC_MAXIN
#define RX_BD_ERRORS …

static int uhdlc_close(struct net_device *dev);

static struct ucc_tdm_info utdm_primary_info = …;

static struct ucc_tdm_info utdm_info[UCC_MAX_NUM];

static int uhdlc_init(struct ucc_hdlc_private *priv)
{ … }

static netdev_tx_t ucc_hdlc_tx(struct sk_buff *skb, struct net_device *dev)
{ … }

static int hdlc_tx_restart(struct ucc_hdlc_private *priv)
{ … }

static int hdlc_tx_done(struct ucc_hdlc_private *priv)
{ … }

static int hdlc_rx_done(struct ucc_hdlc_private *priv, int rx_work_limit)
{ … }

static int ucc_hdlc_poll(struct napi_struct *napi, int budget)
{ … }

static irqreturn_t ucc_hdlc_irq_handler(int irq, void *dev_id)
{ … }

static int uhdlc_ioctl(struct net_device *dev, struct if_settings *ifs)
{ … }

static int uhdlc_open(struct net_device *dev)
{ … }

static void uhdlc_memclean(struct ucc_hdlc_private *priv)
{ … }

static int uhdlc_close(struct net_device *dev)
{ … }

static int ucc_hdlc_attach(struct net_device *dev, unsigned short encoding,
			   unsigned short parity)
{ … }

#ifdef CONFIG_PM
static void store_clk_config(struct ucc_hdlc_private *priv)
{ … }

static void resume_clk_config(struct ucc_hdlc_private *priv)
{ … }

static int uhdlc_suspend(struct device *dev)
{ … }

static int uhdlc_resume(struct device *dev)
{ … }

static const struct dev_pm_ops uhdlc_pm_ops = …;

#define HDLC_PM_OPS …

#else

#define HDLC_PM_OPS …

#endif
static void uhdlc_tx_timeout(struct net_device *ndev, unsigned int txqueue)
{ … }

static const struct net_device_ops uhdlc_ops = …;

static int hdlc_map_iomem(char *name, int init_flag, void __iomem **ptr)
{ … }

static int ucc_hdlc_probe(struct platform_device *pdev)
{ … }

static void ucc_hdlc_remove(struct platform_device *pdev)
{ … }

static const struct of_device_id fsl_ucc_hdlc_of_match[] = …;

MODULE_DEVICE_TABLE(of, fsl_ucc_hdlc_of_match);

static struct platform_driver ucc_hdlc_driver = …;

module_platform_driver(…) …;
MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…);