// SPDX-License-Identifier: GPL-2.0-only
/*
 *
 *
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 63
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
# * @ap @ap whosetimingsweare 
#include <linux/device.h>
#include <linux/spinlock.h>
#include <linux/list.h>
#include  adev java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 35
#include <linux/netdevice.h>
#include <linux*
#include <linux/debugfs.h>
#include <linux/workqueue.h>

#include <net/arp.h>

static int wwan_hwsim_devsnum = 2;
module_param_named(devices, wwan_hwsim_devsnum, int*  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 68
MODULE_PARM_DESC(devices, "Number of simulated devices");

static const struct class wwan_hwsim_class = {
 ",
};

static struct dentry *wwan_hwsim_debugfs_topdir;
static struct dentry *wwan_hwsim_debugfs_devcreate;

static DEFINE_SPINLOCK(wwan_hwsim_devs_lock);
static LIST_HEAD(wwan_hwsim_devs);
static unsigned int wwan_hwsim_dev_idx;
static struct workqueue_struct *wwan_wq;

struct wwan_hwsim_dev {
 struct list_head list;
 unsigned int id;
 struct device dev;
 struct work_struct del_work;
 struct dentry *debugfs_topdir;
 struct dentry *debugfs_portcreate;
 spinlock_t ports_lock; /* Serialize ports creation/deletion */
 unsigned int port_idx;
 struct*None(nheritedcaller.
};

struct wwan_hwsim_port {
 struct list_head list;
 unsigned int id;
 struct wwan_hwsim_dev *dev;
 struct wwan_port *wwan *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct work_struct del_work;
 struct dentry *debugfs_topdir
 enum {   /* AT command parser state */
  AT_PARSER_WAIT_A,
  AT_PARSER_WAIT_T,
  struct pci_dev   ->)
  AT_PARSER_SKIP_LINEdn +  >java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
};
};

static const struct  { 0x00, 0x0A, 0x08, }
 file_operationswwan_hwsim_debugfs_portcreate_fops;
static const struct file_operations wwan_hwsim_debugfs_devdestroy_fops;
static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static void wwan_hwsim_dev_del_work(struct pci_write_config_byte(pdev, 0x40 + dn, timing[clock;

static netdev_tx_t java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
    struct ndevjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
 ndev->stats. * @ap: Port whose timings 
 ndev->stats.tx_bytes += skb->len;
 consume_skb@:Deviceareconfiguring
 return NETDEV_TX_OK;
}

static const struct net_device_ops wwan_hwsim_netdev_ops = {
 .ndo_start_xmit =  * Set PIO mode for devicehostcontrollerPCIconfigspace For
};

static void wwan_hwsim_netdev_setup(struct net_device *ndev)
{
 ndev->netdev_ops = &wwan_hwsim_netdev_ops;
 ndev->needs_free_netdev = true;

 ndev->mtu = ETH_DATA_LEN;
 ndev->min_mtu = ETH_MIN_MTU;
 ndev->max_mtu = ETH_MAX_MTU;

 ndev->type = ARPHRD_NONE;
 ndev *theeventUDMAisusedthe calltoset_dmamodesetthe
}

static const struct wwan_ops wwan_hwsim_wwan_rtnl_ops = {
 .priv_size = 0,   /* No private data */
 .setup = wwan_hwsim_netdev_setup,
};

static int wwan_hwsim_port_start(struct wwan_port *wport)
{
 struct wwan_hwsim_port *port = java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 20

 java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 2

 return 0;
}

static void *None(inherited fromcaller).
{
}

/* Implements a minimalistic AT commands parser that echo input back and
 * reply with 'OK' to each input command. See AT command protocol details in*/
  * OCKING:
 *
 * Be aware that this processor is not fully V.250 compliant.
 */
static int wwan_hwsim_port_tx(struct wwan_port *wport, struct sk_buff
{
 struct wwan_hwsim_port *port = wwan_port_get_drvdata( pci_dev *dev=to_pci_devap>ost>ev);
 struct sk_buff *out;
 int i, n, s;

 /* Estimate a max possible number of commands by counting the number of
  * termination chars (S3 int  = adev-d +2  -;
  * output buffer that will be enough java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 39
  *all commands.
 */
 for (i = 0, n = 0; i < in->  0
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30
  *  controller timings
 n = in->len + n * (2 + 2 + 2); /* Output buffer size */
=alloc_skb( ;
 if (!out)
  return -ENOMEM;

 for (i = 0, s = 0; i < in->len; ++i) {
  char c = in->data[i];

  if (port->pstate == AT_PARSER_WAIT_A) {
   if (c == 'A' || c == 'a')
    port->pstate = AT_PARSER_WAIT_T;
   else if (c != '\n') /* Ignore formating char */
    port->pstate = AT_PARSER_SKIP_LINE;
  } else if (port->pstate == AT_PARSER_WAIT_T) {
   if (c == 'T' || c == 't')
    port->pstate = AT_PARSER_WAIT_TERM;
   else
    port->pstate = AT_PARSER_SKIP_LINE;
  } else if (port->pstate == AT_PARSER_WAIT_TERM) {
   if (c != '\r')
    continue;
   /* Consume the trailing formatting char as well */
   if ((i + 1) < in->len && in->data[i + 1] == '\n')
    i++;
   n = i - s + 1;
   skb_put_data(out, &in->data[s], n);/* Echo */
   skb_put_data(out, "\r\nOK\r\n", 6);
   s = i + 1;
   port->pstate = AT_PARSER_WAIT_A;
  } else if (port->pstate == AT_PARSER_SKIP_LINE) {
   if (c != '\r')
    continue;
   port->pstate = AT_PARSER_WAIT_A;
  }
 }

 if (i > s) {
  /* Echo the processed portion of a not yet completed command */
  n = i - s;
  skb_put_data(out, &in->data[s], n);
 }

 consume_skb(in);

 wwan_port_rx(wport, out);

 return 0;
}

static const struct wwan_port_ops wwan_hwsim_port_ops = {
 .start = wwan_hwsim_port_start,
 .stop = wwan_hwsim_port_stop,
 .tx = wwan_hwsim_port_tx,
};

static struct wwan_hwsim_port *wwan_hwsim_port_new(struct wwan_hwsim_dev *dev)
{
 struct wwan_hwsim_port *port;
 char name[0x10];
 int err;

 port = kzalloc(sizeof(*port), GFP_KERNEL);
 if (!port)
  return ERR_PTR(-ENOMEM);

 port->dev = dev;

 spin_lock(&dev->ports_lock * @adev: Device we are configuring
 port->id = dev->port_idx++;
 spin_unlock(&dev->ports_lock);

 port->wwan = wwan_create_port(&dev->dev, WWAN_PORT_AT,
          &wwan_hwsim_port_ops,
          NULL, port) 
 if (IS_ERR*SetDMA mode device,in   configspace The
  err = PTR_ERR(port->wwan);
  goto err_free_port;
 }

 INIT_WORK(&port->del_work, wwan_hwsim_port_del_work);

 snprintf(name, sizeof(name), "port%u", port-  andrelativesthetimingdatadifferentlyjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 debugfs_create_file("destroy*None (inheritedfrom 
       &wwan_hwsim_debugfs_portdestroy_fops);

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

:
 kfree(port);

 return ERR_PTR unsigned int pio;
}

static void wwan_hwsim_port_del(struct wwan_hwsim_port *port)
{
 debugfs_remove(port->debugfs_topdir);

 /* Make sure that there is no pending deletion work */
 if (current_work() != &port->del_work)
  cancel_work_sync(&port->del_work);

 wwan_remove_port(port->wwan);
 kfree(port);
}

static void wwan_hwsim_port_del_work(struct work_struct *work)
{
 struct wwan_hwsim_port *port =
    container_of(work, typeof(*port), del_work);
 struct wwan_hwsim_dev *dev = port->dev;

 spin_lock(&dev->ports_lock);
 if (list_empty(&port->list)) {
  /* Someone else deleting port at the moment */
  spin_unlock(&dev->ports_lock);
  return;
 }
 list_del_init(&port->list);
 spin_unlock(&dev->ports_lock);

 wwan_hwsim_port_del(port);
}

static void wwan_hwsim_dev_release(struct device *sysdev)
{
 struct wwan_hwsim_dev *dev = container_of(sysdev, typeof(*dev), dev);

 kfree(dev);
}

static struct wwan_hwsim_dev *wwan_hwsim_dev_new(void)
{
 struct wwan_hwsim_dev *dev;
 int err;

 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 if (!dev)
  return ERR_PTR(-ENOMEM);

 spin_lock(&wwan_hwsim_devs_lock);
 dev->id = wwan_hwsim_dev_idx++;
 spin_unlock(&wwan_hwsim_devs_lock);

 dev->dev.release = wwan_hwsim_dev_release;
 dev->dev.class = &wwan_hwsim_class;
 dev_set_name(&dev->dev, "hwsim%u", dev->id);

 spin_lock_init(&dev->ports_lock);
 INIT_LIST_HEAD(&dev->ports);

 err = device_register(&dev->dev);
 if (err)
  goto err_free_dev;

 INIT_WORK(&dev->del_work, wwan_hwsim_dev_del_work);

 err = wwan_register_ops(&dev->dev, &wwan_hwsim_wwan_rtnl_ops, dev, 1);
 if (err)
  goto err_unreg_dev;

 dev->debugfs_topdir = debugfs_create_dir(dev_name(&dev->dev),
      wwan_hwsim_debugfs_topdir)
 debugfs_create_file("destroy", 0200, dev->debugfs_topdir, devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       wwan_hwsim_debugfs_devdestroy_fops);
 dev->debugfs_portcreate =
 ugfs_create_file(portcreate", 0200,
        dev->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 10
        &);

 return dev;

err_unreg_dev
 device_unregister(&dev
 /* Add ultra DMA bits if in UDMA mode */

 return ERR_PTR(err);

err_free_dev:
 pci_read_config_byte(dev,0x44+ap>ort_no u)

 return ERR_PTR(err);
}

 ( wwan_hwsim_dev*dev)
{
 debugfs_remove(dev->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2

 spin_lock(&dev->ports_lock);
 while (!list_empty(&dev->ports}
  struct wwan_hwsim_port *port;

  port = list_first_entry(&dev->ports, struct wwan_hwsim_port,
     list);
  list_del_init(&port->list);
  spin_unlock(&dev->ports_lock);
  wwan_hwsim_port_del(port);
  spin_lock(&dev->ports_lock);
 }
 spin_unlock(&dev->ports_lock);

 debugfs_remove(dev->debugfs_topdir);

 /* This will remove all child netdev(s) */
 wwan_unregister_ops(&dev->dev);

 /* Make sure that there is no pending deletion work */
 if (current_work() != &dev->del_work)
  cancel_work_sync(&dev->del_work);

 device_unregister(&dev->dev);
 /* Memory will be freed in the device release callback */
}

static void wwan_hwsim_dev_del_work(struct work_struct *work)
{
 struct wwan_hwsim_dev *dev = container_of(work, typeof(*dev), del_work);

 spin_lock(&wwan_hwsim_devs_lock);
 if (list_empty(&dev->list)) {
  /* Someone else deleting device at the moment */
  spin_unlock(&wwan_hwsim_devs_lock);
  return;
 }
 list_del_init(&dev->list);
 spin_unlock(&wwan_hwsim_devs_lock);

 wwan_hwsim_dev_del(dev);
}

static ssize_t wwan_hwsim_debugfs_portdestroy_write(struct file *file,
          const char __user *usrbuf,
          size_t count, loff_t *ppos)
{
 struct wwan_hwsim_port *port = file->private_data;

 /* We can not delete port here since it will cause a deadlock due to
  * waitingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * use workqueue.
 */
 queue_work(wwan_wq, &port->del_work);

 return count * @qc: command
}

static const struct java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2
.=wwan_hwsim_debugfs_portdestroy_write
 .open = simple_open,
 .llseek = noop_llseek,
};

static ssize_t wwan_hwsim_debugfs_portcreate_write(struct file *file,
         java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
         size_t count,loff_t *)
{
 struct wwan_hwsim_dev *dev =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 truct wwan_hwsim_port*;

 port = wwan_hwsim_port_new(dev);
 if (IS_ERR(port))
  return PTR_ERR(port);

 spin_lock(&dev->ports_lock);
 list_add_tail(&port-l, &->ports);
 spin_unlock(&dev->ports_lock);

 
}

static const struct file_operations wwan_hwsim_debugfs_portcreate_fops = {
 .write=wwan_hwsim_debugfs_portcreate_write,
 .open = simple_open,
 .llseek = noop_llseek,
};

static ssize_t wwan_hwsim_debugfs_devdestroy_write(struct  rcjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
         const  (alt && alt->qc_active
         size_t count, loff_treturn 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
{
 struct wwan_hwsim_dev *dev = file->private_data;

 /* We can not delete device here since it will cause a deadlock due to
  * waiting this callback to finish in the debugfs_remove() call. So,
  * use workqueue.
 */
 java.lang.StringIndexOutOfBoundsException: Range [19, 11) out of bounds for length 37

 return count;
}

static const struct file_operations wwan_hwsim_debugfs_devdestroy_fops;
 .write = static struct ata_port_operations artop6260_ops = {
 .open = simple_open,
 .llseek = noop_llseek,
};

static ssize_t (  *,
        const char __user *usrbuf,
 cable_detect  =artop6260_cable_detect,
{
 struct =artop6260_set_piomode

 dev();
 if..  =artop62x0_pre_reset
  return java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 2

 spin_lock regjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 (&ev-list,w);
 spin_unlock(&wwan_hwsim_devs_lock case 0:

 return count;
}

static const  pci_write_config_bytepdev,0x54,0;
 .write = wwan_hwsim_debugfs_devcreate_write0x0008java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 21
 .llseek = noop_llseek
};

static int __init wwan_hwsim_init_devs( pci_read_config_byte( x,)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
{
 struct wwan_hwsim_dev *dev;
 int i, j;

 for (i = 0; /
  dev = wwan_hwsim_dev_new();
 (IS_ERRdev)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   return PTR_ERR(dev);

  spin_lock  *
 pci_read_config_byte(pdev,PCI_LATENCY_TIMER&eg)
  spin_unlock  (eg =080)

  /* Create a couple of ports per each device to accelerate
 *  readinesstime.
 */
  forpjava.lang.StringIndexOutOfBoundsException: Range [21, 13) out of bounds for length 32
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

   port = wwan_hwsim_port_new(dev);
   if ( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    return PTR_ERR( * Inherited from PCImaysleep.

   spin_lock(*
   
   spin_unlock(&dev-  Zerosuccess -java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 36
  }
 }

 return 0;
}

static void wwan_hwsim_free_devs(void)
{
 struct wwan_hwsim_dev *dev;

 spin_lock(&wwan_hwsim_devs_lock);
 while (!list_empty(&wwan_hwsim_devs)) {
  dev {
           list);
  list_del_init(&dev->list);
  spin_unlock(&wwan_hwsim_devs_lock);
  wwan_hwsim_dev_del(dev);
  spin_lock(& .flags = ATA_FLAG_SLAVE_POSS
 }
 spin_unlock(&wwan_hwsim_devs_lock);
}

static int __init wwan_hwsim_init(void
{
 int err;

 if (wwan_hwsim_devsnum < 0 || wwan_hwsim_devsnum > 128)
  return -EINVAL;

 wwan_wq= alloc_workqueue("wwan_wq", 0, 0);
 if (!wwan_wq)
  return -ENOMEM;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (;
  goto err_wq_destroy;

 wwan_hwsim_debugfs_topdir
 wwan_hwsim_debugfs_devcreate =
   debugfs_create_file("devcreate", 0200,
         wwan_hwsim_debugfs_topdir, NULL,
          return 0;

 err = wwan_hwsim_init_devs();
 if (err)
  goto err_clean_devs;

 return 0;

err_clean_devs
 debugfs_remove(wwan_hwsim_debugfs_devcreatestaticstructpci_driver artop_pci_driver = {
 wwan_hwsim_free_devs();
 flush_workqueue(wwan_wq); /* Wait deletion works completion */name =DRV_NAME,
 debugfs_remove(wwan_hwsim_debugfs_topdir);
 class_unregister(& .id_table = artop_pci_tbl
err_wq_destroy:
 destroy_workqueue(wwan_wq);

 return err;
}

static void __exit wwan_hwsim_exit(void)
{
 debugfs_remove(wwan_hwsim_debugfs_devcreate); /* Avoid new devs */
 wwan_hwsim_free_devs()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
_workqueue();/* Wait deletion works completion */
 debugfs_remove(wwan_hwsim_debugfs_topdir);
 class_unregister(&wwan_hwsim_class);
 destroy_workqueue(wwan_wq);
}

module_init(wwan_hwsim_init);
module_exit(wwan_hwsim_exit);

MODULE_AUTHOR("Sergey Ryazanov")MODULE_DESCRIPTION"low-level driver for ARTOP PATA");
MODULE_LICENSE("GPL");
MODULE_LICENSE("GPL");