cregit-Linux how code gets into the kernel

Release 4.7 drivers/bluetooth/hci_ldisc.c

/*
 *
 *  Bluetooth HCI UART driver
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/poll.h>

#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/signal.h>
#include <linux/ioctl.h>
#include <linux/skbuff.h>
#include <linux/firmware.h>

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

#include "btintel.h"
#include "btbcm.h"
#include "hci_uart.h"


#define VERSION "2.3"


static const struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];


int hci_uart_register_proto(const struct hci_uart_proto *p) { if (p->id >= HCI_UART_MAX_PROTO) return -EINVAL; if (hup[p->id]) return -EEXIST; hup[p->id] = p; BT_INFO("HCI UART protocol %s registered", p->name); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy4782.46%133.33%
marcel holtmannmarcel holtmann1017.54%266.67%
Total57100.00%3100.00%


int hci_uart_unregister_proto(const struct hci_uart_proto *p) { if (p->id >= HCI_UART_MAX_PROTO) return -EINVAL; if (!hup[p->id]) return -EINVAL; hup[p->id] = NULL; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy4897.96%150.00%
marcel holtmannmarcel holtmann12.04%150.00%
Total49100.00%2100.00%


static const struct hci_uart_proto *hci_uart_get_proto(unsigned int id) { if (id >= HCI_UART_MAX_PROTO) return NULL; return hup[id]; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy2796.43%266.67%
marcel holtmannmarcel holtmann13.57%133.33%
Total28100.00%3100.00%


static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type) { struct hci_dev *hdev = hu->hdev; /* Update HCI stat counters */ switch (pkt_type) { case HCI_COMMAND_PKT: hdev->stat.cmd_tx++; break; case HCI_ACLDATA_PKT: hdev->stat.acl_tx++; break; case HCI_SCODATA_PKT: hdev->stat.sco_tx++; break; } }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy4976.56%250.00%
linus torvaldslinus torvalds1421.88%125.00%
karl beldankarl beldan11.56%125.00%
Total64100.00%4100.00%


static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu) { struct sk_buff *skb = hu->tx_skb; if (!skb) skb = hu->proto->dequeue(hu); else hu->tx_skb = NULL; return skb; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy3979.59%266.67%
linus torvaldslinus torvalds1020.41%133.33%
Total49100.00%3100.00%


int hci_uart_tx_wakeup(struct hci_uart *hu) { if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) { set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); return 0; } BT_DBG(""); schedule_work(&hu->write_work); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy3667.92%133.33%
felipe balbifelipe balbi1222.64%133.33%
linus torvaldslinus torvalds59.43%133.33%
Total53100.00%3100.00%


static void hci_uart_write_work(struct work_struct *work) { struct hci_uart *hu = container_of(work, struct hci_uart, write_work); struct tty_struct *tty = hu->tty; struct hci_dev *hdev = hu->hdev; struct sk_buff *skb; /* REVISIT: should we cope with bad skbs or ->write() returning * and error value ? */ restart: clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); while ((skb = hci_uart_dequeue(hu))) { int len; set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); len = tty->ops->write(tty, skb->data, skb->len); hdev->stat.byte_tx += len; skb_pull(skb, len); if (skb->len) { hu->tx_skb = skb; break; } hci_uart_tx_complete(hu, hci_skb_pkt_type(skb)); kfree_skb(skb); } if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)) goto restart; clear_bit(HCI_UART_SENDING, &hu->tx_state); }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy10358.19%225.00%
felipe balbifelipe balbi4927.68%112.50%
linus torvaldslinus torvalds2011.30%112.50%
marcel holtmannmarcel holtmann31.69%225.00%
al viroal viro10.56%112.50%
alan coxalan cox10.56%112.50%
Total177100.00%8100.00%


static void hci_uart_init_work(struct work_struct *work) { struct hci_uart *hu = container_of(work, struct hci_uart, init_ready); int err; if (!test_and_clear_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) return; err = hci_register_dev(hu->hdev); if (err < 0) { BT_ERR("Can't register HCI device"); hci_free_dev(hu->hdev); hu->hdev = NULL; hu->proto->close(hu); } set_bit(HCI_UART_REGISTERED, &hu->flags); }

Contributors

PersonTokensPropCommitsCommitProp
johan hedbergjohan hedberg97100.00%1100.00%
Total97100.00%1100.00%


int hci_uart_init_ready(struct hci_uart *hu) { if (!test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) return -EALREADY; schedule_work(&hu->init_ready); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
johan hedbergjohan hedberg38100.00%1100.00%
Total38100.00%1100.00%

/* ------- Interface to HCI layer ------ */ /* Initialize device */
static int hci_uart_open(struct hci_dev *hdev) { BT_DBG("%s %p", hdev->name, hdev); /* Nothing to do for UART driver */ return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds1765.38%133.33%
maksim krasnyanskiymaksim krasnyanskiy934.62%266.67%
Total26100.00%3100.00%

/* Reset device */
static int hci_uart_flush(struct hci_dev *hdev) { struct hci_uart *hu = hci_get_drvdata(hdev); struct tty_struct *tty = hu->tty; BT_DBG("hdev %p tty %p", hdev, tty); if (hu->tx_skb) { kfree_skb(hu->tx_skb); hu->tx_skb = NULL; } /* Flush any pending characters in the driver and discipline. */ tty_ldisc_flush(tty); tty_driver_flush_buffer(tty); if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) hu->proto->flush(hu); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy5658.95%228.57%
linus torvaldslinus torvalds3334.74%114.29%
david herrmanndavid herrmann33.16%114.29%
alan coxalan cox22.11%228.57%
loic poulainloic poulain11.05%114.29%
Total95100.00%7100.00%

/* Close device */
static int hci_uart_close(struct hci_dev *hdev) { BT_DBG("hdev %p", hdev); hci_uart_flush(hdev); hdev->flush = NULL; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy1546.88%133.33%
linus torvaldslinus torvalds1134.38%133.33%
david newalldavid newall618.75%133.33%
Total32100.00%3100.00%

/* Send frames from HCI layer */
static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb) { struct hci_uart *hu = hci_get_drvdata(hdev); BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb), skb->len); hu->proto->enqueue(hu, skb); hci_uart_tx_wakeup(hu); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds3961.90%114.29%
maksim krasnyanskiymaksim krasnyanskiy1219.05%228.57%
marcel holtmannmarcel holtmann1219.05%457.14%
Total63100.00%7100.00%

/* Flow control or un-flow control the device */
void hci_uart_set_flow_control(struct hci_uart *hu, bool enable) { struct tty_struct *tty = hu->tty; struct ktermios ktermios; int status; unsigned int set = 0; unsigned int clear = 0; if (enable) { /* Disable hardware flow control */ ktermios = tty->termios; ktermios.c_cflag &= ~CRTSCTS; status = tty_set_termios(tty, &ktermios); BT_DBG("Disabling hardware flow control: %s", status ? "failed" : "success"); /* Clear RTS to prevent the device from sending */ /* Most UARTs need OUT2 to enable interrupts */ status = tty->driver->ops->tiocmget(tty); BT_DBG("Current tiocm 0x%x", status); set &= ~(TIOCM_OUT2 | TIOCM_RTS); clear = ~set; set &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 | TIOCM_OUT2 | TIOCM_LOOP; clear &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 | TIOCM_OUT2 | TIOCM_LOOP; status = tty->driver->ops->tiocmset(tty, set, clear); BT_DBG("Clearing RTS: %s", status ? "failed" : "success"); } else { /* Set RTS to allow the device to send again */ status = tty->driver->ops->tiocmget(tty); BT_DBG("Current tiocm 0x%x", status); set |= (TIOCM_OUT2 | TIOCM_RTS); clear = ~set; set &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 | TIOCM_OUT2 | TIOCM_LOOP; clear &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 | TIOCM_OUT2 | TIOCM_LOOP; status = tty->driver->ops->tiocmset(tty, set, clear); BT_DBG("Setting RTS: %s", status ? "failed" : "success"); /* Re-enable hardware flow control */ ktermios = tty->termios; ktermios.c_cflag |= CRTSCTS; status = tty_set_termios(tty, &ktermios); BT_DBG("Enabling hardware flow control: %s", status ? "failed" : "success"); } }

Contributors

PersonTokensPropCommitsCommitProp
ilya faensonilya faenson28496.93%150.00%
frederic danisfrederic danis93.07%150.00%
Total293100.00%2100.00%


void hci_uart_set_speeds(struct hci_uart *hu, unsigned int init_speed, unsigned int oper_speed) { hu->init_speed = init_speed; hu->oper_speed = oper_speed; }

Contributors

PersonTokensPropCommitsCommitProp
ilya faensonilya faenson30100.00%1100.00%
Total30100.00%1100.00%


void hci_uart_init_tty(struct hci_uart *hu) { struct tty_struct *tty = hu->tty; struct ktermios ktermios; /* Bring the UART into a known 8 bits no parity hw fc state */ ktermios = tty->termios; ktermios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON); ktermios.c_oflag &= ~OPOST; ktermios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); ktermios.c_cflag &= ~(CSIZE | PARENB); ktermios.c_cflag |= CS8; ktermios.c_cflag |= CRTSCTS; /* tty_set_termios() return not checked as it is always 0 */ tty_set_termios(tty, &ktermios); }

Contributors

PersonTokensPropCommitsCommitProp
ilya faensonilya faenson7871.56%150.00%
frederic danisfrederic danis3128.44%150.00%
Total109100.00%2100.00%


void hci_uart_set_baudrate(struct hci_uart *hu, unsigned int speed) { struct tty_struct *tty = hu->tty; struct ktermios ktermios; ktermios = tty->termios; ktermios.c_cflag &= ~CBAUD; tty_termios_encode_baud_rate(&ktermios, speed, speed); /* tty_set_termios() return not checked as it is always 0 */ tty_set_termios(tty, &ktermios); BT_DBG("%s: New tty speeds: %d/%d", hu->hdev->name, tty->termios.c_ispeed, tty->termios.c_ospeed); }

Contributors

PersonTokensPropCommitsCommitProp
ilya faensonilya faenson4554.88%150.00%
frederic danisfrederic danis3745.12%150.00%
Total82100.00%2100.00%


static int hci_uart_setup(struct hci_dev *hdev) { struct hci_uart *hu = hci_get_drvdata(hdev); struct hci_rp_read_local_version *ver; struct sk_buff *skb; unsigned int speed; int err; /* Init speed if any */ if (hu->init_speed) speed = hu->init_speed; else if (hu->proto->init_speed) speed = hu->proto->init_speed; else speed = 0; if (speed) hci_uart_set_baudrate(hu, speed); /* Operational speed if any */ if (hu->oper_speed) speed = hu->oper_speed; else if (hu->proto->oper_speed) speed = hu->proto->oper_speed; else speed = 0; if (hu->proto->set_baudrate && speed) { err = hu->proto->set_baudrate(hu, speed); if (!err) hci_uart_set_baudrate(hu, speed); } if (hu->proto->setup) return hu->proto->setup(hu); if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags)) return 0; skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL, HCI_INIT_TIMEOUT); if (IS_ERR(skb)) { BT_ERR("%s: Reading local version information failed (%ld)", hdev->name, PTR_ERR(skb)); return 0; } if (skb->len != sizeof(*ver)) { BT_ERR("%s: Event length mismatch for version information", hdev->name); goto done; } ver = (struct hci_rp_read_local_version *)skb->data; switch (le16_to_cpu(ver->manufacturer)) { #ifdef CONFIG_BT_HCIUART_INTEL case 2: hdev->set_bdaddr = btintel_set_bdaddr; btintel_check_bdaddr(hdev); break; #endif #ifdef CONFIG_BT_HCIUART_BCM case 15: hdev->set_bdaddr = btbcm_set_bdaddr; btbcm_check_bdaddr(hdev); break; #endif } done: kfree_skb(skb); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
marcel holtmannmarcel holtmann16249.24%555.56%
ilya faensonilya faenson7021.28%111.11%
frederic danisfrederic danis5516.72%222.22%
loic poulainloic poulain4212.77%111.11%
Total329100.00%9100.00%

/* ------ LDISC part ------ */ /* hci_uart_tty_open * * Called when line discipline changed to HCI_UART. * * Arguments: * tty pointer to tty info structure * Return Value: * 0 if success, otherwise error code */
static int hci_uart_tty_open(struct tty_struct *tty) { struct hci_uart *hu; BT_DBG("tty %p", tty); /* Error if the tty has no write op instead of leaving an exploitable hole */ if (tty->ops->write == NULL) return -EOPNOTSUPP; hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL); if (!hu) { BT_ERR("Can't allocate control structure"); return -ENFILE; } tty->disc_data = hu; hu->tty = tty; tty->receive_room = 65536; INIT_WORK(&hu->init_ready, hci_uart_init_work); INIT_WORK(&hu->write_work, hci_uart_write_work); /* Flush any pending characters in the driver */ tty_driver_flush_buffer(tty); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds5548.25%18.33%
alan coxalan cox2219.30%325.00%
felipe balbifelipe balbi108.77%18.33%
johan hedbergjohan hedberg108.77%18.33%
maksim krasnyanskiymaksim krasnyanskiy97.89%216.67%
valentin ilievalentin ilie54.39%18.33%
peter hurleypeter hurley10.88%18.33%
deepak saxenadeepak saxena10.88%18.33%
marcel holtmannmarcel holtmann10.88%18.33%
Total114100.00%12100.00%

/* hci_uart_tty_close() * * Called when the line discipline is changed to something * else, the tty is closed, or the tty detects a hangup. */
static void hci_uart_tty_close(struct tty_struct *tty) { struct hci_uart *hu = tty->disc_data; struct hci_dev *hdev; BT_DBG("tty %p", tty); /* Detach from the tty */ tty->disc_data = NULL; if (!hu) return; hdev = hu->hdev; if (hdev) hci_uart_close(hdev); cancel_work_sync(&hu->write_work); if (test_and_clear_bit(HCI_UART_PROTO_READY, &hu->flags)) { if (hdev) { if (test_bit(HCI_UART_REGISTERED, &hu->flags)) hci_unregister_dev(hdev); hci_free_dev(hdev); } hu->proto->close(hu); } clear_bit(HCI_UART_PROTO_SET, &hu->flags); kfree(hu); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds3425.37%18.33%
maksim krasnyanskiymaksim krasnyanskiy3223.88%216.67%
johan hedbergjohan hedberg2115.67%216.67%
loic poulainloic poulain118.21%18.33%
marcel holtmannmarcel holtmann96.72%216.67%
johan hovoldjohan hovold96.72%18.33%
felipe balbifelipe balbi85.97%18.33%
david herrmanndavid herrmann53.73%18.33%
jun niejun nie53.73%18.33%
Total134100.00%12100.00%

/* hci_uart_tty_wakeup() * * Callback for transmit wakeup. Called when low level * device driver can accept more send data. * * Arguments: tty pointer to associated tty instance data * Return Value: None */
static void hci_uart_tty_wakeup(struct tty_struct *tty) { struct hci_uart *hu = tty->disc_data; BT_DBG(""); if (!hu) return; clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); if (tty != hu->tty) return; if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) hci_uart_tx_wakeup(hu); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds3958.21%120.00%
maksim krasnyanskiymaksim krasnyanskiy2740.30%360.00%
loic poulainloic poulain11.49%120.00%
Total67100.00%5100.00%

/* hci_uart_tty_receive() * * Called by tty low level driver when receive data is * available. * * Arguments: tty pointer to tty isntance data * data pointer to received data * flags pointer to flags for data * count count of received data in bytes * * Return Value: None */
static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data, char *flags, int count) { struct hci_uart *hu = tty->disc_data; if (!hu || tty != hu->tty) return; if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) return; /* It does not need a lock here as it is already protected by a mutex in * tty caller */ hu->proto->recv(hu, data, count); if (hu->hdev) hu->hdev->stat.byte_rx += count; tty_unthrottle(tty); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds4447.31%220.00%
maksim krasnyanskiymaksim krasnyanskiy3840.86%220.00%
chan-yeol parkchan-yeol park66.45%110.00%
marcel holtmannmarcel holtmann22.15%220.00%
alan coxalan cox11.08%110.00%
frederic danisfrederic danis11.08%110.00%
loic poulainloic poulain11.08%110.00%
Total93100.00%10100.00%


static int hci_uart_register_dev(struct hci_uart *hu) { struct hci_dev *hdev; BT_DBG(""); /* Initialize and register HCI device */ hdev = hci_alloc_dev(); if (!hdev) { BT_ERR("Can't allocate HCI device"); return -ENOMEM; } hu->hdev = hdev; hdev->bus = HCI_UART; hci_set_drvdata(hdev, hu); /* Only when vendor specific setup callback is provided, consider * the manufacturer information valid. This avoids filling in the * value for Ericsson when nothing is specified. */ if (hu->proto->setup) hdev->manufacturer = hu->proto->manufacturer; hdev->open = hci_uart_open; hdev->close = hci_uart_close; hdev->flush = hci_uart_flush; hdev->send = hci_uart_send_frame; hdev->setup = hci_uart_setup; SET_HCIDEV_DEV(hdev, hu->tty->dev); if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags)) set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags)) set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks); if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags)) set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags)) hdev->dev_type = HCI_AMP; else hdev->dev_type = HCI_BREDR; if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) return 0; if (hci_register_dev(hdev) < 0) { BT_ERR("Can't register HCI device"); hci_free_dev(hdev); return -ENODEV; } set_bit(HCI_UART_REGISTERED, &hu->flags); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
marcel holtmannmarcel holtmann11743.82%741.18%
maksim krasnyanskiymaksim krasnyanskiy6022.47%211.76%
johan hedbergjohan hedberg4516.85%211.76%
linus torvaldslinus torvalds248.99%15.88%
david herrmanndavid herrmann83.00%211.76%
loic poulainloic poulain62.25%15.88%
andrei warkentinandrei warkentin62.25%15.88%
szymon jancszymon janc10.37%15.88%
Total267100.00%17100.00%


static int hci_uart_set_proto(struct hci_uart *hu, int id) { const struct hci_uart_proto *p; int err; p = hci_uart_get_proto(id); if (!p) return -EPROTONOSUPPORT; err = p->open(hu); if (err) return err; hu->proto = p; set_bit(HCI_UART_PROTO_READY, &hu->flags); err = hci_uart_register_dev(hu); if (err) { clear_bit(HCI_UART_PROTO_READY, &hu->flags); p->close(hu); return err; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy5551.40%240.00%
linus torvaldslinus torvalds3128.97%120.00%
loic poulainloic poulain2018.69%120.00%
marcel holtmannmarcel holtmann10.93%120.00%
Total107100.00%5100.00%


static int hci_uart_set_flags(struct hci_uart *hu, unsigned long flags) { unsigned long valid_flags = BIT(HCI_UART_RAW_DEVICE) | BIT(HCI_UART_RESET_ON_INIT) | BIT(HCI_UART_CREATE_AMP) | BIT(HCI_UART_INIT_PENDING) | BIT(HCI_UART_EXT_CONFIG) | BIT(HCI_UART_VND_DETECT); if (flags & ~valid_flags) return -EINVAL; hu->hdev_flags = flags; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
marcel holtmannmarcel holtmann69100.00%3100.00%
Total69100.00%3100.00%

/* hci_uart_tty_ioctl() * * Process IOCTL system call for the tty device. * * Arguments: * * tty pointer to tty instance data * file pointer to open file object for device * cmd IOCTL command code * arg argument for IOCTL call (cmd dependent) * * Return Value: Command dependent */
static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) { struct hci_uart *hu = tty->disc_data; int err = 0; BT_DBG(""); /* Verify the status of the device */ if (!hu) return -EBADF; switch (cmd) { case HCIUARTSETPROTO: if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) { err = hci_uart_set_proto(hu, arg); if (err) { clear_bit(HCI_UART_PROTO_SET, &hu->flags); return err; } } else return -EBUSY; break; case HCIUARTGETPROTO: if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) return hu->proto->id; return -EUNATCH; case HCIUARTGETDEVICE: if (test_bit(HCI_UART_REGISTERED, &hu->flags)) return hu->hdev->id; return -EUNATCH; case HCIUARTSETFLAGS: if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) return -EBUSY; err = hci_uart_set_flags(hu, arg); if (err) return err; break; case HCIUARTGETFLAGS: return hu->hdev_flags; default: err = n_tty_ioctl_helper(tty, file, cmd, arg); break; } return err; }

Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy8738.67%222.22%
linus torvaldslinus torvalds6629.33%111.11%
marcel holtmannmarcel holtmann4017.78%444.44%
johan hedbergjohan hedberg3113.78%111.11%
alan coxalan cox10.44%111.11%
Total225100.00%9100.00%

/* * We don't provide read/write/poll interface for user space. */
static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char __user *buf, size_t nr) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds2692.86%133.33%
al viroal viro13.57%133.33%
maksim krasnyanskiymaksim krasnyanskiy13.57%133.33%
Total28100.00%3100.00%


static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds2796.43%150.00%
maksim krasnyanskiymaksim krasnyanskiy13.57%150.00%
Total28100.00%2100.00%


static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds2395.83%150.00%
maksim krasnyanskiymaksim krasnyanskiy14.17%150.00%
Total24100.00%2100.00%


static int __init hci_uart_init(void) { static struct tty_ldisc_ops hci_uart_ldisc; int err; BT_INFO("HCI UART driver ver %s", VERSION); /* Register the tty discipline */ memset(&hci_uart_ldisc, 0, sizeof(hci_uart_ldisc)); hci_uart_ldisc.magic = TTY_LDISC_MAGIC; hci_uart_ldisc.name = "n_hci"; hci_uart_ldisc.open = hci_uart_tty_open; hci_uart_ldisc.close = hci_uart_tty_close; hci_uart_ldisc.read = hci_uart_tty_read; hci_uart_ldisc.write = hci_uart_tty_write; hci_uart_ldisc.ioctl = hci_uart_tty_ioctl; hci_uart_ldisc.poll = hci_uart_tty_poll; hci_uart_ldisc.receive_buf = hci_uart_tty_receive; hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup; hci_uart_ldisc.owner = THIS_MODULE; err = tty_register_ldisc(N_HCI, &hci_uart_ldisc); if (err) { BT_ERR("HCI line discipline registration failed. (%d)", err); return err; } #ifdef CONFIG_BT_HCIUART_H4 h4_init(); #endif #ifdef CONFIG_BT_HCIUART_BCSP bcsp_init(); #endif #ifdef CONFIG_BT_HCIUART_LL ll_init(); #endif #ifdef CONFIG_BT_HCIUART_ATH3K ath_init(); #endif #ifdef CONFIG_BT_HCIUART_3WIRE h5_init(); #endif #ifdef CONFIG_BT_HCIUART_INTEL intel_init(); #endif #ifdef CONFIG_BT_HCIUART_BCM bcm_init(); #endif #ifdef CONFIG_BT_HCIUART_QCA qca_init(); #endif #ifdef CONFIG_BT_HCIUART_AG6XX ag6xx_init(); #endif return 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds9445.85%211.76%
maksim krasnyanskiymaksim krasnyanskiy4923.90%529.41%
loic poulainloic poulain167.80%211.76%
marcel holtmannmarcel holtmann94.39%211.76%
ohad ben-cohenohad ben-cohen83.90%15.88%
suraj sumangalasuraj sumangala83.90%15.88%
johan hedbergjohan hedberg83.90%15.88%
ben young tae kimben young tae kim83.90%15.88%
valentin ilievalentin ilie41.95%15.88%
alan coxalan cox10.49%15.88%
Total205100.00%17100.00%


static void __exit hci_uart_exit(void) { int err; #ifdef CONFIG_BT_HCIUART_H4 h4_deinit(); #endif #ifdef CONFIG_BT_HCIUART_BCSP bcsp_deinit(); #endif #ifdef CONFIG_BT_HCIUART_LL ll_deinit(); #endif #ifdef CONFIG_BT_HCIUART_ATH3K ath_deinit(); #endif #ifdef CONFIG_BT_HCIUART_3WIRE h5_deinit(); #endif #ifdef CONFIG_BT_HCIUART_INTEL intel_deinit(); #endif #ifdef CONFIG_BT_HCIUART_BCM bcm_deinit(); #endif #ifdef CONFIG_BT_HCIUART_QCA qca_deinit(); #endif #ifdef CONFIG_BT_HCIUART_AG6XX ag6xx_deinit(); #endif /* Release tty registration of line discipline */ err = tty_unregister_ldisc(N_HCI); if (err) BT_ERR("Can't unregister HCI line discipline (%d)", err); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds2221.36%17.14%
maksim krasnyanskiymaksim krasnyanskiy1716.50%321.43%
loic poulainloic poulain1615.53%214.29%
marcel holtmannmarcel holtmann1110.68%214.29%
ohad ben-cohenohad ben-cohen87.77%17.14%
suraj sumangalasuraj sumangala87.77%17.14%
johan hedbergjohan hedberg87.77%17.14%
ben young tae kimben young tae kim87.77%17.14%
valentin ilievalentin ilie43.88%17.14%
alexey dobriyanalexey dobriyan10.97%17.14%
Total103100.00%14100.00%

module_init(hci_uart_init); module_exit(hci_uart_exit); MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION); MODULE_VERSION(VERSION); MODULE_LICENSE("GPL"); MODULE_ALIAS_LDISC(N_HCI);

Overall Contributors

PersonTokensPropCommitsCommitProp
maksim krasnyanskiymaksim krasnyanskiy83725.66%67.32%
linus torvaldslinus torvalds71221.83%44.88%
ilya faensonilya faenson50815.57%11.22%
marcel holtmannmarcel holtmann46714.32%3036.59%
johan hedbergjohan hedberg2587.91%44.88%
frederic danisfrederic danis1364.17%44.88%
loic poulainloic poulain1143.49%44.88%
felipe balbifelipe balbi792.42%11.22%
alan coxalan cox280.86%78.54%
ben young tae kimben young tae kim160.49%11.22%
ohad ben-cohenohad ben-cohen160.49%11.22%
suraj sumangalasuraj sumangala160.49%11.22%
david herrmanndavid herrmann160.49%33.66%
valentin ilievalentin ilie130.40%11.22%
johan hovoldjohan hovold90.28%11.22%
chan-yeol parkchan-yeol park80.25%22.44%
andrei warkentinandrei warkentin60.18%11.22%
david newalldavid newall60.18%11.22%
jun niejun nie50.15%11.22%
andrew mortonandrew morton50.15%11.22%
al viroal viro20.06%22.44%
alexey dobriyanalexey dobriyan10.03%11.22%
karl beldankarl beldan10.03%11.22%
peter hurleypeter hurley10.03%11.22%
deepak saxenadeepak saxena10.03%11.22%
szymon jancszymon janc10.03%11.22%
Total3262100.00%82100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}