/** gpsdrv_release Function * This function will un-registers from the ST driver. * * Parameters : * @file : File pointer for GPS char driver * @inod : * Returns GPS_SUCCESS - on success * else suitable error code */ int gpsdrv_release(struct inode *inod, struct file *file) { struct gpsdrv_data *hgps = file->private_data; GPSDRV_DBG(" Inside %s", __func__); /* Disabling task-let 1st & then un-reg to avoid * tasklet getting scheduled */ tasklet_disable(&hgps->gpsdrv_tx_tsklet); tasklet_kill(&hgps->gpsdrv_tx_tsklet); /* Cleat registered bit if already registered */ if (test_and_clear_bit(GPS_ST_REGISTERED, &hgps->state)) { if (st_unregister(&gpsdrv_proto) < 0) { GPSDRV_ERR(" st_unregister failed"); /* Re-Enable the task-let if un-register fails */ tasklet_enable(&hgps->gpsdrv_tx_tsklet); return GPS_ERR_FAILURE; } } /* Reset Tx count value and st_write function pointer */ hgps->tx_count = 0; hgps->st_write = NULL; clear_bit(GPS_ST_RUNNING, &hgps->state); GPSDRV_VER(" st_unregister success"); skb_queue_purge(&hgps->rx_list); skb_queue_purge(&hgps->tx_list); kfree(hgps); file->private_data = NULL; return GPS_SUCCESS; }
/* Close device */ static int hci_st_close(struct hci_dev *hdev) { int err; BTDRV_API_START(); err = 0; /* Unregister from ST layer */ if (test_and_clear_bit(BT_ST_REGISTERED, &hst->flags)) { err = st_unregister(ST_BT); if (err != 0) { BT_DRV_ERR("st_unregister failed %d", err); BTDRV_API_EXIT(-EBUSY); return -EBUSY; } } hst->st_write = NULL; /* ST layer would have moved chip to inactive state. * So,clear HCI device RUNNING flag. */ if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) { BTDRV_API_EXIT(0); return 0; } BTDRV_API_EXIT(err); return err; }
static int nfcwilink_close(struct nci_dev *ndev) { struct nfcwilink *drv = nci_get_drvdata(ndev); int rc; if (!test_and_clear_bit(NFCWILINK_RUNNING, &drv->flags)) return 0; rc = st_unregister(&nfcwilink_proto); if (rc) nfc_err(&drv->pdev->dev, "st_unregister failed %d\n", rc); drv->st_write = NULL; return rc; }
/* Close device */ static int ti_st_close(struct hci_dev *hdev) { int err, i; struct ti_st *hst = hci_get_drvdata(hdev); for (i = MAX_BT_CHNL_IDS-1; i >= 0; i--) { err = st_unregister(&ti_st_proto[i]); if (err) BT_ERR("st_unregister(%d) failed with error %d", ti_st_proto[i].chnl_id, err); } hst->st_write = NULL; return err; }
/* Close device */ static int ti_st_close(struct hci_dev *hdev) { int err, i; struct ti_st *hst = hdev->driver_data; if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) return 0; for (i = 0; i < MAX_BT_CHNL_IDS; i++) { err = st_unregister(&ti_st_proto[i]); if (err) BT_ERR("st_unregister(%d) failed with error %d", ti_st_proto[i].chnl_id, err); } hst->st_write = NULL; return err; }
/** hci_tty_release Function * This function will un-registers from the ST driver. * * Parameters : * @file : File pointer for BT char driver * @inod : * Returns 0 - on success * else suitable error code */ int hci_tty_release(struct inode *inod, struct file *file) { int err, i; struct ti_st *hst = file->private_data; pr_info("inside %s (%p, %p)\n", __func__, inod, file); for (i = 0; i < MAX_BT_CHNL_IDS; i++) { err = st_unregister(&ti_st_proto[i]); if (err) pr_err("st_unregister(%d) failed with error %d", ti_st_proto[i].chnl_id, err); } hst->st_write = NULL; skb_queue_purge(&hst->rx_list); kfree(hst); return err; }
/* Unregister FM Driver from Shared Transport */ int fm_st_unregister(void) { int ret; FMDRV_API_START(); /* Unregister FM Driver from ST */ ret = st_unregister(8); if (ret != ST_SUCCESS) { FM_DRV_ERR("st_unregister failed %d", ret); FMDRV_API_EXIT(-EBUSY); return -EBUSY; } g_rx_task = NULL; g_rx_q = NULL; FMDRV_API_EXIT(0); return 0; }
/* Called from HCI core to initialize the device */ static int ti_st_open(struct hci_dev *hdev) { unsigned long timeleft; struct ti_st *hst; int err, i; BT_DBG("%s %p", hdev->name, hdev); if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) return -EBUSY; /* provide contexts for callbacks from ST */ hst = hdev->driver_data; for (i = 0; i < MAX_BT_CHNL_IDS; i++) { ti_st_proto[i].priv_data = hst; ti_st_proto[i].max_frame_size = HCI_MAX_FRAME_SIZE; ti_st_proto[i].recv = st_receive; ti_st_proto[i].reg_complete_cb = st_reg_completion_cb; /* Prepare wait-for-completion handler */ init_completion(&hst->wait_reg_completion); /* Reset ST registration callback status flag, * this value will be updated in * st_reg_completion_cb() * function whenever it called from ST driver. */ hst->reg_status = -EINPROGRESS; err = st_register(&ti_st_proto[i]); if (!err) goto done; if (err != -EINPROGRESS) { clear_bit(HCI_RUNNING, &hdev->flags); BT_ERR("st_register failed %d", err); return err; } /* ST is busy with either protocol * registration or firmware download. */ BT_DBG("waiting for registration " "completion signal from ST"); timeleft = wait_for_completion_timeout (&hst->wait_reg_completion, msecs_to_jiffies(BT_REGISTER_TIMEOUT)); if (!timeleft) { clear_bit(HCI_RUNNING, &hdev->flags); BT_ERR("Timeout(%d sec),didn't get reg " "completion signal from ST", BT_REGISTER_TIMEOUT / 1000); return -ETIMEDOUT; } /* Is ST registration callback * called with ERROR status? */ if (hst->reg_status != 0) { clear_bit(HCI_RUNNING, &hdev->flags); BT_ERR("ST registration completed with invalid " "status %d", hst->reg_status); return -EAGAIN; } done: hst->st_write = ti_st_proto[i].write; if (!hst->st_write) { BT_ERR("undefined ST write function"); clear_bit(HCI_RUNNING, &hdev->flags); for (i = 0; i < MAX_BT_CHNL_IDS; i++) { /* Undo registration with ST */ err = st_unregister(&ti_st_proto[i]); if (err) BT_ERR("st_unregister() failed with " "error %d", err); hst->st_write = NULL; } return -EIO; } } return 0; }
/* Called from HCI core to initialize the device */ static int hci_st_open(struct hci_dev *hdev) { static struct st_proto_s hci_st_proto; unsigned long timeleft; int err; BTDRV_API_START(); err = 0; BT_DRV_DBG("%s %p", hdev->name, hdev); /* Already registered with ST ? */ if (test_bit(BT_ST_REGISTERED, &hst->flags)) { BT_DRV_ERR("Registered with ST already,open called again?"); BTDRV_API_EXIT(0); return 0; } /* Populate BT driver info required by ST */ memset(&hci_st_proto, 0, sizeof(hci_st_proto)); /* BT driver ID */ hci_st_proto.type = ST_BT; /* Receive function which called from ST */ hci_st_proto.recv = hci_st_receive; /* Packet match function may used in future */ hci_st_proto.match_packet = NULL; /* Callback to be called when registration is pending */ hci_st_proto.reg_complete_cb = hci_st_registration_completion_cb; /* This is write function pointer of ST. BT driver will make use of this * for sending any packets to chip. ST will assign and give to us, so * make it as NULL */ hci_st_proto.write = NULL; /* send in the hst to be received at registration complete callback * and during st's receive */ hci_st_proto.priv_data = hst; /* Register with ST layer */ err = st_register(&hci_st_proto); if (err == -EINPROGRESS) { /* Prepare wait-for-completion handler data structures. * Needed to syncronize this and st_registration_completion_cb() * functions. */ init_completion(&hst->wait_for_btdrv_reg_completion); /* Reset ST registration callback status flag , this value * will be updated in hci_st_registration_completion_cb() * function whenever it called from ST driver. */ hst->streg_cbdata = -EINPROGRESS; /* ST is busy with other protocol registration(may be busy with * firmware download).So,Wait till the registration callback * (passed as a argument to st_register() function) getting * called from ST. */ BT_DRV_DBG(" %s waiting for reg completion signal from ST", __func__); timeleft = wait_for_completion_timeout (&hst->wait_for_btdrv_reg_completion, msecs_to_jiffies(BT_REGISTER_TIMEOUT)); if (!timeleft) { BT_DRV_ERR("Timeout(%ld sec),didn't get reg" "completion signal from ST", BT_REGISTER_TIMEOUT / 1000); BTDRV_API_EXIT(-ETIMEDOUT); return -ETIMEDOUT; } /* Is ST registration callback called with ERROR value? */ if (hst->streg_cbdata != 0) { BT_DRV_ERR("ST reg completion CB called with invalid" "status %d", hst->streg_cbdata); BTDRV_API_EXIT(-EAGAIN); return -EAGAIN; } err = 0; } else if (err == -1) { BT_DRV_ERR("st_register failed %d", err); BTDRV_API_EXIT(-EAGAIN); return -EAGAIN; } /* Do we have proper ST write function? */ if (hci_st_proto.write != NULL) { /* We need this pointer for sending any Bluetooth pkts */ hst->st_write = hci_st_proto.write; } else { BT_DRV_ERR("failed to get ST write func pointer"); /* Undo registration with ST */ err = st_unregister(ST_BT); if (err < 0) BT_DRV_ERR("st_unregister failed %d", err); hst->st_write = NULL; BTDRV_API_EXIT(-EAGAIN); return -EAGAIN; } /* Registration with ST layer is completed successfully, * now chip is ready to accept commands from HCI CORE. * Mark HCI Device flag as RUNNING */ set_bit(HCI_RUNNING, &hdev->flags); /* Registration with ST successful */ set_bit(BT_ST_REGISTERED, &hst->flags); BTDRV_API_EXIT(err); return err; }
static int ti_st_open(struct hci_dev *hdev) { unsigned long timeleft; struct ti_st *hst; int err, i; BT_DBG("%s %p", hdev->name, hdev); if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) return -EBUSY; hst = hdev->driver_data; for (i = 0; i < MAX_BT_CHNL_IDS; i++) { ti_st_proto[i].priv_data = hst; ti_st_proto[i].max_frame_size = HCI_MAX_FRAME_SIZE; ti_st_proto[i].recv = st_receive; ti_st_proto[i].reg_complete_cb = st_reg_completion_cb; init_completion(&hst->wait_reg_completion); hst->reg_status = -EINPROGRESS; err = st_register(&ti_st_proto[i]); if (!err) goto done; if (err != -EINPROGRESS) { clear_bit(HCI_RUNNING, &hdev->flags); BT_ERR("st_register failed %d", err); return err; } BT_DBG("waiting for registration " "completion signal from ST"); timeleft = wait_for_completion_timeout (&hst->wait_reg_completion, msecs_to_jiffies(BT_REGISTER_TIMEOUT)); if (!timeleft) { clear_bit(HCI_RUNNING, &hdev->flags); BT_ERR("Timeout(%d sec),didn't get reg " "completion signal from ST", BT_REGISTER_TIMEOUT / 1000); return -ETIMEDOUT; } if (hst->reg_status != 0) { clear_bit(HCI_RUNNING, &hdev->flags); BT_ERR("ST registration completed with invalid " "status %d", hst->reg_status); return -EAGAIN; } done: hst->st_write = ti_st_proto[i].write; if (!hst->st_write) { BT_ERR("undefined ST write function"); clear_bit(HCI_RUNNING, &hdev->flags); for (i = 0; i < MAX_BT_CHNL_IDS; i++) { err = st_unregister(&ti_st_proto[i]); if (err) BT_ERR("st_unregister() failed with " "error %d", err); hst->st_write = NULL; } return -EIO; } } return 0; }
/** hci_tty_open Function * This function will perform an register on ST driver. * * Parameters : * @file : File pointer for BT char driver * @inod : * Returns 0 - on success * else suitable error code */ int hci_tty_open(struct inode *inod, struct file *file) { int i = 0, err = 0; unsigned long timeleft; struct ti_st *hst; pr_info("inside %s (%p, %p)\n", __func__, inod, file); hst = kzalloc(sizeof(*hst), GFP_KERNEL); file->private_data = hst; hst = file->private_data; for (i = 0; i < MAX_BT_CHNL_IDS; i++) { ti_st_proto[i].priv_data = hst; ti_st_proto[i].max_frame_size = 1026; ti_st_proto[i].recv = st_receive; ti_st_proto[i].reg_complete_cb = st_reg_completion_cb; /* Prepare wait-for-completion handler */ init_completion(&hst->wait_reg_completion); /* Reset ST registration callback status flag, * this value will be updated in * st_reg_completion_cb() * function whenever it called from ST driver. */ hst->reg_status = -EINPROGRESS; err = st_register(&ti_st_proto[i]); if (!err) goto done; if (err != -EINPROGRESS) { pr_err("st_register failed %d", err); goto error; } /* ST is busy with either protocol * registration or firmware download. */ pr_debug("waiting for registration " "completion signal from ST"); timeleft = wait_for_completion_timeout (&hst->wait_reg_completion, msecs_to_jiffies(BT_REGISTER_TIMEOUT)); if (!timeleft) { pr_err("Timeout(%d sec),didn't get reg " "completion signal from ST", BT_REGISTER_TIMEOUT / 1000); err = -ETIMEDOUT; goto error; } /* Is ST registration callback * called with ERROR status? */ if (hst->reg_status != 0) { pr_err("ST registration completed with invalid " "status %d", hst->reg_status); err = -EAGAIN; goto error; } done: hst->st_write = ti_st_proto[i].write; if (!hst->st_write) { pr_err("undefined ST write function"); for (i = 0; i < MAX_BT_CHNL_IDS; i++) { /* Undo registration with ST */ err = st_unregister(&ti_st_proto[i]); if (err) pr_err("st_unregister() failed with " "error %d", err); hst->st_write = NULL; } return -EIO; } } skb_queue_head_init(&hst->rx_list); init_waitqueue_head(&hst->data_q); return 0; error: kfree(hst); return err; }