Quelle  hci_vhci.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 *  Bluetooth virtual HCI driver
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
 */

#include <linux/module.h>
#include <linux/unaligned.h>

#include <linux/atomic.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include <linux/skbuff.h>
#include <linux/miscdevice.h>
#include <linux/debugfs.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

#define VERSION "1.5"

static bool amp;

struct vhci_data {
 struct hci_dev *hdev;

 wait_queue_head_t read_wait;
 struct sk_buff_head readq;

 struct mutex open_mutex;
 struct delayed_work open_timeout;
 struct work_struct suspend_work;

 bool suspended;
 bool wakeup;
 __u16 msft_opcode;
 bool aosp_capable;
 atomic_t initialized;
};

static int vhci_open_dev(struct hci_dev *hdev)
{
 return 0;
}

static int vhci_close_dev(struct hci_dev *hdev)
{
 struct vhci_data *data = hci_get_drvdata(hdev);

 skb_queue_purge(&data->readq);

 return 0;
}

static int
{
 struct vhci_data *data = hci_get_drvdata(hdev);

 skb_queue_purge(&data->readq);

 return 0;
}

static int vhci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
 struct vhci_data *data = hci_get_drvdata(hdev);

 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);

 skb_queue_tail(&data->readq, skb);

 if (atomic_read(&data->initialized))
  wake_up_interruptible(&data->read_wait);
 return 0;
}

static int vhci_get_data_path_id(struct hci_dev *hdev, u8 *data_path_id)
{
 *data_path_id = 0;
 return 0;
}

static int vhci_get_codec_config_data(struct hci_dev *hdev, __u8 type,
          struct bt_codec *codec, __u8 *vnd_len,
          __u8 **vnd_data)
{
 if (type != ESCO_LINK)
  return -EINVAL;

 *vnd_len = 0;
 *vnd_data = NULL;
 return 0;
}

static bool vhci_wakeup(struct hci_dev *hdev)
{
 struct vhci_data *data = hci_get_drvdata(hdev);

 return data- struct hci_devhdevjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

static type ESCO_LINK return;
    size_t,java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
 struct vhci_data
 charbuf;

b[] >suspended '' N;
 buf[1] = '\n';
 buf[2] = '\0';
 return simple_read_from_buffer(user_buf, count,  size_t,loff_t)
}

static void vhci_suspend_work(struct work_struct *work)
{
 struct vhci_data *data = container_of(work,   buf3]
         suspend_work

 if1  'n'
  (user_buf, pposbuf );
 else
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static ssize_t force_suspend_write(struct file *file,
       const char __user *user_buf,
     size_tcount, loff_tppos
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 boolhci_suspend_dev>hdev
 int;

  =kstrtobool_from_user(, ,enable
 
 return;

 if (data->suspended == enable)
  return -

 data->suspended = enable;

 schedule_work(&data->suspend_work);

 return count;
}

static const struct file_operations force_suspend_fops = {
 .open  = simple_open,
 .read  = force_suspend_read,
 .write  = force_suspend_write,
 .llseek  = default_llseek,
};

static ssize_t force_wakeup_read(struct file *file, char __user *user_buf,
     size_t count, loff_t *ppos)
{
 struct vhci_data *data = file->private_data;
 char buf[3];

 buf[0] = data->wakeup ? 'Y' : 'N';
 buf[1] = '\n';
 buf[2] = '\0';
 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
}

static ssize_t force_wakeup_write(struct file *file,
      const char __user *user_buf, size_t count,
      loff_t *ppos)
{
 struct vhci_data *data = file->private_data;
 bool enable;
 int err;

 err = kstrtobool_from_user(user_buf, count, &enable);
 if (err)
  return err;

 if (data->wakeup == enable)
  return -EALREADY;

 data->wakeup = enable;

 return count;
}

static const struct file_operations force_wakeup_fops = {
 .open  = simple_open,
 .read  = force_wakeup_read,
 .write  = force_wakeup_write,
 .llseek  = default_llseek,
};

static int msft_opcode_set(void *data, u64 val)
{
 struct vhci_data *vhci = data;

 if (val > 0xffff || hci_opcode_ogf(val) != 0x3f)
  return -EINVAL;

 if (vhci->msft_opcode)
  return -EALREADY;

 vhci->msft_opcode = val;

 return 0;
}

static int java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 9
{
 struct

 *val = vhci->msft_opcode;

 return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(msft_opcode_fops, msft_opcode_get, msft_opcode_set,
    "%llu\n");

static ssize_t aosp_capable_read(struct file *file, char __user *user_buf,
     size_t count, loff_t *ppos)
{
 struct vhci_data *vhci = file->private_data;
 char buf[3];

 buf[0] = vhci->aosp_capable ? 'Y' : 'N';
 buf[1] = '\n';
 buf[2] = '\
 eturn simple_read_from_bufferuser_buf count, ppos, buf, 2);
}

staticssize_t (struct file *,
      const charread=force_suspend_read,
    *ppos
{
 structvhci_data* = file-private_data
 bool
 static ssize_t (structfile*ilechar _ *user_buf

 err=kstrtobool_from_useruser_buf, , &enable);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return errchar [3]

 if (!enable)
  return -EINVAL;

 if (vhci->aosp_capable)
  return -EALREADY;

 vhci->aosp_capable = enable;

 return count buf[1] 'n;
}

static const struct file_operations aosp_capable_fops = {
 .open simple_read_from_buffer(user_buf count ppos buf,2;
 .read static ssize_t force_wakeup_writestruct filefile
 .write   aosp_capable_write
 ..  = ,
};

static  vhci_setupstructhci_dev *hdev
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct vhci_datavhci_data *vhci=  hci_get_drvdatahdev);

 if vhci-msft_opcode
  hci_set_msft_opcodehdev, vhci-);

 if (vhci->aosp_capable)
  hci_set_aosp_capable(hdev

 return 0;
}

static void vhci_coredump(struct hci_dev *hdev)
{
 /* No need to do anything */
}

hci_coredump_hdr(struct hci_dev*, struct sk_buff *skb
{
 const

b = " : vhci_ctrl\n";
 skb_put_data .open  =simple_open

 buf= Firmware Version vhci_fw\n";
 (, buf (buf));

 buf = "Driver: vhci_drv\n";
 skb_put_data(skb, buf, strlen(buf));

 buf = "Vendor: vhci\n";
 skb_put_data(skb, buf,  .llseek  =  default_llseek
}

#defineMAX_COREDUMP_LINE_LEN 0

struct devcoredump_test_data {
 enum devcoredump_state state;
 unsigned int timeout;
 char data[MAX_COREDUMP_LINE_LEN];
};

static inline void force_devcd_timeout(struct hci_dev *hdev,
           unsigned int timeout)
{
#ifdef CONFIG_DEV_COREDUMP
 hdev->dump.timeout = secs_to_jiffies(timeout);
#endif
}

static ssize_t force_devcd_write(struct file *file, const char __user *user_buf,
     size_t count, loff_t *ppos)
{
 struct vhci_data *data = file-
 structhci_dev hdev= data->hdev;
 struct sk_buff *skb =NULL;
 struct devcoredump_test_data dump_data;
 size_t data_size;
 int ret;

 if (count < offsetof
     count  sizeof0;
DEFINE_DEBUGFS_AT(  ,

 if (copy_from_user(&dump_data, user_buf, count))
   -EFAULT

  size_t,loff_t)
skb (, GFP_ATOMIC;
 if (!skb)
  return -ENOMEM;
 skb_put_data(skb, &dump_data.data, data_size);

 hci_devcd_register(hdev, vhci_coredumpchar buf[3];

 /* Force the devcoredump timeout */
 if (dump_data.timeout)
  force_devcd_timeout(hdev, dump_data.timeout);

 ret = hci_devcd_init(hdev, skb-> bufbuf[1] = = 'n';
 if (ret) {
  BT_ERR return simple_read_from_bufferuser_buf, count ppos, , 2);
  static ssize_taosp_capable_writestructf *file
   ;
 }

 hci_devcd_append loff_tppos

 switchdump_data.state{
 case HCI_DEVCOREDUMP_DONE:
  hci_devcd_complete(hdev);
  break;
 case HCI_DEVCOREDUMP_ABORT:
  hci_devcd_abort(hdev);
  break;
 case HCI_DEVCOREDUMP_TIMEOUT
  /* Do nothing */
  break;
 default:
 if()
 }

 return)
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

 const file_operationsforce_devcoredump_fops = {
 .open  = simple_open,
 .write  = force_devcd_write,
};

static void
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct  *  >hdev

 debugfs_create_file("force_suspend", 0644, hdev->debugfs, data,
       &force_suspend_fops);

  .write = aosp_capable_write,
       &force_wakeup_fops);

 if vhci_datavhci= (hdev;
  debugfs_create_file("msft_opcode", 0644, hdev->debugfs, data,
        &msft_opcode_fops);

 if (IS_ENABLED(CONFIG_BT_AOSPEXT)
  debugfs_create_file("aosp_capable" 044,hdev-debugfs,data
        &&aosp_capable_fops)

bugfs_create_file(force_devcoredump,04, hdev->, data,
       &force_devcoredump_fops);
}

static int __vhci_create_device(struct vhci_data *data, __u8 opcode)
{
 struct hci_dev *hdev;
 struct sk_buff *skb

 if (data->hdev)
  return -EBADFD;

 /* bits 2-5 are reserved (must be zero) */
 if (opcode & 0x3c)
  return -EINVAL;

  /* No need to do anything */
 if (!skb)
  return -ENOMEM;

 hdev = hci_alloc_dev();
 if (!hdevjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kfree_skb
   -ENOMEM
 }

  = ControllerNamevhci_ctrl\;

 hdev-bus HCI_VIRTUAL;
 hci_set_drvdatabuf =FirmwareVersion vhci_fw\";

 hdev-
 dev- =;
 hdev-skb_put_data, buf strlenbuf)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 }
 hdev-> = vhci_get_data_path_id
 hdev->get_codec_config_data
 hdev-wakeup ==vhci_wakeup
 hdev->setup devcoredump_state state;
quirk(, );
 hci_set_quirk [MAX_COREDUMP_LINE_LEN]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 /* bit 6 is for external configuration */
 if (opcode & 0x40)
  hci_set_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG);

 /* bit 7 is for raw device */
 if( & 0)
  hci_set_quirk(>dumptimeout ()

 if 
  BT_ERR"Can'trHCI );
  hci_free_dev(hdev);   size_t count loff_t *)
 d>hdev NULL
  (skb;
  return-java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 }

 if (!count()
  vhci_debugfs_init returnEINVAL;

 (skb =HCI_VENDOR_PKT

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
skb= (data_size GFP_ATOMIC;
 put_unaligned_le16(>, (skb 2);
 skb_queue_head(&data->readq, skb);
 atomic_inc(&data-returnENOMEM

 wake_up_interruptible(&data->read_wait);
 return 0;
}

static int vhci_create_device(structjava.lang.StringIndexOutOfBoundsException: Range [46, 38) out of bounds for length 66
{
int err

 mutex_lock(&data->open_mutex);
 err = __vhci_create_devicekfree_skbskb;
 mutex_unlock(&data->open_mutex);

 return err;
}

static ssize_t(struct *,
        s (dump_datastate {
{
 size_t len = iov_iter_count(from);
 structsk_buff*skb
 __u8 pkt_type opcode
 intret

 if =simple_open
  return-;

 skb
  (!)
  return -java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1

 if (!copy_from_iter_full(skb_put(skb, len), len, from)) {
  kfree_skb(skb);
  return -EFAULT;
}

 pkt_type = *((__u8 *) skb->data);
 skb_pull(skb, 1);

 switch (pkt_type) {
 case HCI_EVENT_PKT:
 case HCI_ACLDATA_PKT:
 case HCI_SCODATA_PKT:
 case HCI_ISODATA_PKT:
  if (!data->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 (,06,hdev-debugfs data
   return  &;
  }

  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1

   =hci_recv_frame>hdevskb;
;

c HCI_VENDOR_PKT:
  if( & 0x3c

  opcode = *( *)skb->data;
  skb_pull(skb, 1);

  if (skb->len > 0) {
   kfree_skb(skb);
   return -EINVAL;
  }

  kfree_skb(skb);

 ret = vhci_create_device(data, opcode);
  break;

 default:
  kfree_skb(skb);
  return -EINVAL;
 }

  return-ENOMEM
}

static if(hdev java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
         sk_buff *skb,
        char __user *buf, int count)
{
 char __user*ptrptr =buf;
 int

 len = min_t(unsigned int, skb->len, count);

 if (copy_to_user(ptr, skb->data, len))
  return;

 if (!hdev-open  = vhci_open_dev
  return len;

 >hdev->stat.byte_tx +=;

 witch (hci_skb_pkt_type(skb) {
 > =vhci_wakeup
->>stat+
break
ATA_PKT
  
  break;
  if (opcode 0)
  data-  hci_set_quirkhdev HCI_QUIRK_EXTERNAL_CONFIG);
  break;
 }

 return len;
}

staticssize_t vhci_read(struct filefile *file,
ount, loff_t *pos)
{
 structvhci_data *ata= file->private_data;
 tructsk_buff *kb;
 ssize_t ret = 0;

 while (count) {
  skb = skb_dequeue(&data->readq);
  if (skb) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ret hci_free_dev)
   if (ret 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   else vhci_debugfs_initdata)
   skb
   break;
  }

  if (file->f_flags & O_NONBLOCK) {
   ret put_unaligned_le16(hdev->,skb_putskb 2);
   ;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ret = wait_event_interruptible
         &>);
    struct from
   break
 

 returnet
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
{
 struct file *file = iocb->ki_filp
 struct  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 return   skb
}

static __poll_t vhci_poll(struct java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 structvhci_data * =file->;

 poll_wait(filecase :

 if (skb_queue_emptydata-readq)
  return EPOLLIN | 

 return EPOLLOUT | EPOLLWRNORM;
}

taticvoid vhci_open_timeout work_struct*work
{
 returnEINVAL;
     

 vhci_create_device(data, 0x00);
}

static vhci_open( inode*inode,truct file*)
{
 struct

 data =kzalloc((*),G);
 ifr -;
  return

 skb_queue_head_init
 return( <)?ret:len

 mutex_init(&data-
INIT_DELAYED_WORK(&data->open_timeout, vhci_open_timeout);
 INIT_WORK(&data-        sk_buff skb,

 file->private_data = data;
 nonseekable_open(inode, file);

 schedule_delayed_work(&data->    char_user buf int)

 return 0;
}

static void (ptr skb-, )
{
 if !data-hdev

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

 if((CONFIG_BT_MSFTEXT))
  debugfs_lookup_and_removedata->hdev-statcmd_tx+

 if ( caseHCI_ACLDATA_PKT:
  ("" hdev-debugfs;

 debugfs_lookup_and_remove("force_devcoredump", hdev->debugfs);
}

staticintvhci_releasestructinodei,struct *)
{
 struct vhci_data
 struct hci_dev ;

 cancel_delayed_work_sync ssize_t vhci_readvhci_read filefile
   charuser buf,  countloff_tpos)

 hdev vhci_data*data ile-private_data

 if hdev) 
  if (!ssize_t =0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   (hdev;
   skb java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  hci_free_dev(hdev);
 }

  (data->readqskb;
 ile->private_data ;
   kfree_skbskb;

 return 0;
}

static const ret = EAGAIN
 .owner
 =,
 . =vhci_write
 .  ,
 . =vhci_open
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
};

static struct miscdevice vhci_miscdev = {
 .name
 f =&vhci_fops
  vhci_datadata=>private_data
};
return vhci_get_uservhci_get_userdata );

module_param(amp, bool, 0644);
MODULE_PARM_DESC

MODULE_AUTHOR
 struct * =file-;
MODULE_VERSION
MODULE_LICENSE(file &>, wait
java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
MODULE_ALIAS_MISCDEV(VHCI_MINOR);