Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2016, Linaro Ltd.
4 * Copyright (c) 2015, Sony Mobile Communications Inc.
5 */
6
7#include <linux/module.h>
8#include <linux/slab.h>
9#include <linux/rpmsg.h>
10#include <linux/of.h>
11
12#include <linux/soc/qcom/wcnss_ctrl.h>
13#include <linux/platform_device.h>
14
15#include <net/bluetooth/bluetooth.h>
16#include <net/bluetooth/hci_core.h>
17
18#include "btqca.h"
19
20struct btqcomsmd {
21 struct hci_dev *hdev;
22
23 struct rpmsg_endpoint *acl_channel;
24 struct rpmsg_endpoint *cmd_channel;
25};
26
27static int btqcomsmd_recv(struct hci_dev *hdev, unsigned int type,
28 const void *data, size_t count)
29{
30 struct sk_buff *skb;
31
32 /* Use GFP_ATOMIC as we're in IRQ context */
33 skb = bt_skb_alloc(count, GFP_ATOMIC);
34 if (!skb) {
35 hdev->stat.err_rx++;
36 return -ENOMEM;
37 }
38
39 hci_skb_pkt_type(skb) = type;
40 skb_put_data(skb, data, count);
41
42 return hci_recv_frame(hdev, skb);
43}
44
45static int btqcomsmd_acl_callback(struct rpmsg_device *rpdev, void *data,
46 int count, void *priv, u32 addr)
47{
48 struct btqcomsmd *btq = priv;
49
50 btq->hdev->stat.byte_rx += count;
51 return btqcomsmd_recv(btq->hdev, HCI_ACLDATA_PKT, data, count);
52}
53
54static int btqcomsmd_cmd_callback(struct rpmsg_device *rpdev, void *data,
55 int count, void *priv, u32 addr)
56{
57 struct btqcomsmd *btq = priv;
58
59 btq->hdev->stat.byte_rx += count;
60 return btqcomsmd_recv(btq->hdev, HCI_EVENT_PKT, data, count);
61}
62
63static int btqcomsmd_send(struct hci_dev *hdev, struct sk_buff *skb)
64{
65 struct btqcomsmd *btq = hci_get_drvdata(hdev);
66 int ret;
67
68 switch (hci_skb_pkt_type(skb)) {
69 case HCI_ACLDATA_PKT:
70 ret = rpmsg_send(btq->acl_channel, skb->data, skb->len);
71 if (ret) {
72 hdev->stat.err_tx++;
73 break;
74 }
75 hdev->stat.acl_tx++;
76 hdev->stat.byte_tx += skb->len;
77 break;
78 case HCI_COMMAND_PKT:
79 ret = rpmsg_send(btq->cmd_channel, skb->data, skb->len);
80 if (ret) {
81 hdev->stat.err_tx++;
82 break;
83 }
84 hdev->stat.cmd_tx++;
85 hdev->stat.byte_tx += skb->len;
86 break;
87 default:
88 ret = -EILSEQ;
89 break;
90 }
91
92 if (!ret)
93 kfree_skb(skb);
94
95 return ret;
96}
97
98static int btqcomsmd_open(struct hci_dev *hdev)
99{
100 return 0;
101}
102
103static int btqcomsmd_close(struct hci_dev *hdev)
104{
105 return 0;
106}
107
108static int btqcomsmd_setup(struct hci_dev *hdev)
109{
110 struct sk_buff *skb;
111
112 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
113 if (IS_ERR(skb))
114 return PTR_ERR(skb);
115 kfree_skb(skb);
116
117 /* Devices do not have persistent storage for BD address. Retrieve
118 * it from the firmware node property.
119 */
120 set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks);
121
122 return 0;
123}
124
125static int btqcomsmd_probe(struct platform_device *pdev)
126{
127 struct btqcomsmd *btq;
128 struct hci_dev *hdev;
129 void *wcnss;
130 int ret;
131
132 btq = devm_kzalloc(&pdev->dev, sizeof(*btq), GFP_KERNEL);
133 if (!btq)
134 return -ENOMEM;
135
136 wcnss = dev_get_drvdata(pdev->dev.parent);
137
138 btq->acl_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_ACL",
139 btqcomsmd_acl_callback, btq);
140 if (IS_ERR(btq->acl_channel))
141 return PTR_ERR(btq->acl_channel);
142
143 btq->cmd_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_CMD",
144 btqcomsmd_cmd_callback, btq);
145 if (IS_ERR(btq->cmd_channel)) {
146 ret = PTR_ERR(btq->cmd_channel);
147 goto destroy_acl_channel;
148 }
149
150 hdev = hci_alloc_dev();
151 if (!hdev) {
152 ret = -ENOMEM;
153 goto destroy_cmd_channel;
154 }
155
156 hci_set_drvdata(hdev, btq);
157 btq->hdev = hdev;
158 SET_HCIDEV_DEV(hdev, &pdev->dev);
159
160 hdev->bus = HCI_SMD;
161 hdev->open = btqcomsmd_open;
162 hdev->close = btqcomsmd_close;
163 hdev->send = btqcomsmd_send;
164 hdev->setup = btqcomsmd_setup;
165 hdev->set_bdaddr = qca_set_bdaddr_rome;
166
167 ret = hci_register_dev(hdev);
168 if (ret < 0)
169 goto hci_free_dev;
170
171 platform_set_drvdata(pdev, btq);
172
173 return 0;
174
175hci_free_dev:
176 hci_free_dev(hdev);
177destroy_cmd_channel:
178 rpmsg_destroy_ept(btq->cmd_channel);
179destroy_acl_channel:
180 rpmsg_destroy_ept(btq->acl_channel);
181
182 return ret;
183}
184
185static int btqcomsmd_remove(struct platform_device *pdev)
186{
187 struct btqcomsmd *btq = platform_get_drvdata(pdev);
188
189 hci_unregister_dev(btq->hdev);
190 hci_free_dev(btq->hdev);
191
192 rpmsg_destroy_ept(btq->cmd_channel);
193 rpmsg_destroy_ept(btq->acl_channel);
194
195 return 0;
196}
197
198static const struct of_device_id btqcomsmd_of_match[] = {
199 { .compatible = "qcom,wcnss-bt", },
200 { },
201};
202MODULE_DEVICE_TABLE(of, btqcomsmd_of_match);
203
204static struct platform_driver btqcomsmd_driver = {
205 .probe = btqcomsmd_probe,
206 .remove = btqcomsmd_remove,
207 .driver = {
208 .name = "btqcomsmd",
209 .of_match_table = btqcomsmd_of_match,
210 },
211};
212
213module_platform_driver(btqcomsmd_driver);
214
215MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
216MODULE_DESCRIPTION("Qualcomm SMD HCI driver");
217MODULE_LICENSE("GPL v2");
1/*
2 * Copyright (c) 2016, Linaro Ltd.
3 * Copyright (c) 2015, Sony Mobile Communications Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 and
7 * only version 2 as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 */
14
15#include <linux/module.h>
16#include <linux/slab.h>
17#include <linux/rpmsg.h>
18#include <linux/of.h>
19
20#include <linux/soc/qcom/wcnss_ctrl.h>
21#include <linux/platform_device.h>
22
23#include <net/bluetooth/bluetooth.h>
24#include <net/bluetooth/hci_core.h>
25
26#include "btqca.h"
27
28struct btqcomsmd {
29 struct hci_dev *hdev;
30
31 bdaddr_t bdaddr;
32 struct rpmsg_endpoint *acl_channel;
33 struct rpmsg_endpoint *cmd_channel;
34};
35
36static int btqcomsmd_recv(struct hci_dev *hdev, unsigned int type,
37 const void *data, size_t count)
38{
39 struct sk_buff *skb;
40
41 /* Use GFP_ATOMIC as we're in IRQ context */
42 skb = bt_skb_alloc(count, GFP_ATOMIC);
43 if (!skb) {
44 hdev->stat.err_rx++;
45 return -ENOMEM;
46 }
47
48 hci_skb_pkt_type(skb) = type;
49 skb_put_data(skb, data, count);
50
51 return hci_recv_frame(hdev, skb);
52}
53
54static int btqcomsmd_acl_callback(struct rpmsg_device *rpdev, void *data,
55 int count, void *priv, u32 addr)
56{
57 struct btqcomsmd *btq = priv;
58
59 btq->hdev->stat.byte_rx += count;
60 return btqcomsmd_recv(btq->hdev, HCI_ACLDATA_PKT, data, count);
61}
62
63static int btqcomsmd_cmd_callback(struct rpmsg_device *rpdev, void *data,
64 int count, void *priv, u32 addr)
65{
66 struct btqcomsmd *btq = priv;
67
68 return btqcomsmd_recv(btq->hdev, HCI_EVENT_PKT, data, count);
69}
70
71static int btqcomsmd_send(struct hci_dev *hdev, struct sk_buff *skb)
72{
73 struct btqcomsmd *btq = hci_get_drvdata(hdev);
74 int ret;
75
76 switch (hci_skb_pkt_type(skb)) {
77 case HCI_ACLDATA_PKT:
78 ret = rpmsg_send(btq->acl_channel, skb->data, skb->len);
79 hdev->stat.acl_tx++;
80 hdev->stat.byte_tx += skb->len;
81 break;
82 case HCI_COMMAND_PKT:
83 ret = rpmsg_send(btq->cmd_channel, skb->data, skb->len);
84 hdev->stat.cmd_tx++;
85 break;
86 default:
87 ret = -EILSEQ;
88 break;
89 }
90
91 if (!ret)
92 kfree_skb(skb);
93
94 return ret;
95}
96
97static int btqcomsmd_open(struct hci_dev *hdev)
98{
99 return 0;
100}
101
102static int btqcomsmd_close(struct hci_dev *hdev)
103{
104 return 0;
105}
106
107static int btqcomsmd_setup(struct hci_dev *hdev)
108{
109 struct btqcomsmd *btq = hci_get_drvdata(hdev);
110 struct sk_buff *skb;
111 int err;
112
113 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
114 if (IS_ERR(skb))
115 return PTR_ERR(skb);
116 kfree_skb(skb);
117
118 /* Devices do not have persistent storage for BD address. If no
119 * BD address has been retrieved during probe, mark the device
120 * as having an invalid BD address.
121 */
122 if (!bacmp(&btq->bdaddr, BDADDR_ANY)) {
123 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
124 return 0;
125 }
126
127 /* When setting a configured BD address fails, mark the device
128 * as having an invalid BD address.
129 */
130 err = qca_set_bdaddr_rome(hdev, &btq->bdaddr);
131 if (err) {
132 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
133 return 0;
134 }
135
136 return 0;
137}
138
139static int btqcomsmd_probe(struct platform_device *pdev)
140{
141 struct btqcomsmd *btq;
142 struct hci_dev *hdev;
143 void *wcnss;
144 int ret;
145
146 btq = devm_kzalloc(&pdev->dev, sizeof(*btq), GFP_KERNEL);
147 if (!btq)
148 return -ENOMEM;
149
150 wcnss = dev_get_drvdata(pdev->dev.parent);
151
152 btq->acl_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_ACL",
153 btqcomsmd_acl_callback, btq);
154 if (IS_ERR(btq->acl_channel))
155 return PTR_ERR(btq->acl_channel);
156
157 btq->cmd_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_CMD",
158 btqcomsmd_cmd_callback, btq);
159 if (IS_ERR(btq->cmd_channel))
160 return PTR_ERR(btq->cmd_channel);
161
162 /* The local-bd-address property is usually injected by the
163 * bootloader which has access to the allocated BD address.
164 */
165 if (!of_property_read_u8_array(pdev->dev.of_node, "local-bd-address",
166 (u8 *)&btq->bdaddr, sizeof(bdaddr_t))) {
167 dev_info(&pdev->dev, "BD address %pMR retrieved from device-tree",
168 &btq->bdaddr);
169 }
170
171 hdev = hci_alloc_dev();
172 if (!hdev)
173 return -ENOMEM;
174
175 hci_set_drvdata(hdev, btq);
176 btq->hdev = hdev;
177 SET_HCIDEV_DEV(hdev, &pdev->dev);
178
179 hdev->bus = HCI_SMD;
180 hdev->open = btqcomsmd_open;
181 hdev->close = btqcomsmd_close;
182 hdev->send = btqcomsmd_send;
183 hdev->setup = btqcomsmd_setup;
184 hdev->set_bdaddr = qca_set_bdaddr_rome;
185
186 ret = hci_register_dev(hdev);
187 if (ret < 0) {
188 hci_free_dev(hdev);
189 return ret;
190 }
191
192 platform_set_drvdata(pdev, btq);
193
194 return 0;
195}
196
197static int btqcomsmd_remove(struct platform_device *pdev)
198{
199 struct btqcomsmd *btq = platform_get_drvdata(pdev);
200
201 hci_unregister_dev(btq->hdev);
202 hci_free_dev(btq->hdev);
203
204 rpmsg_destroy_ept(btq->cmd_channel);
205 rpmsg_destroy_ept(btq->acl_channel);
206
207 return 0;
208}
209
210static const struct of_device_id btqcomsmd_of_match[] = {
211 { .compatible = "qcom,wcnss-bt", },
212 { },
213};
214MODULE_DEVICE_TABLE(of, btqcomsmd_of_match);
215
216static struct platform_driver btqcomsmd_driver = {
217 .probe = btqcomsmd_probe,
218 .remove = btqcomsmd_remove,
219 .driver = {
220 .name = "btqcomsmd",
221 .of_match_table = btqcomsmd_of_match,
222 },
223};
224
225module_platform_driver(btqcomsmd_driver);
226
227MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
228MODULE_DESCRIPTION("Qualcomm SMD HCI driver");
229MODULE_LICENSE("GPL v2");