1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2013, Intel Corporation. 4 * 5 * MEI Library for mei bus nfc device access 6 */ 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/module.h> 10 #include <linux/slab.h> 11 #include <linux/nfc.h> 12 13 #include "mei_phy.h" 14 15 struct mei_nfc_hdr { 16 u8 cmd; 17 u8 status; 18 u16 req_id; 19 u32 reserved; 20 u16 data_size; 21 } __packed; 22 23 struct mei_nfc_cmd { 24 struct mei_nfc_hdr hdr; 25 u8 sub_command; 26 u8 data[]; 27 } __packed; 28 29 struct mei_nfc_reply { 30 struct mei_nfc_hdr hdr; 31 u8 sub_command; 32 u8 reply_status; 33 u8 data[]; 34 } __packed; 35 36 struct mei_nfc_if_version { 37 u8 radio_version_sw[3]; 38 u8 reserved[3]; 39 u8 radio_version_hw[3]; 40 u8 i2c_addr; 41 u8 fw_ivn; 42 u8 vendor_id; 43 u8 radio_type; 44 } __packed; 45 46 struct mei_nfc_connect { 47 u8 fw_ivn; 48 u8 vendor_id; 49 } __packed; 50 51 struct mei_nfc_connect_resp { 52 u8 fw_ivn; 53 u8 vendor_id; 54 u16 me_major; 55 u16 me_minor; 56 u16 me_hotfix; 57 u16 me_build; 58 } __packed; 59 60 61 #define MEI_NFC_CMD_MAINTENANCE 0x00 62 #define MEI_NFC_CMD_HCI_SEND 0x01 63 #define MEI_NFC_CMD_HCI_RECV 0x02 64 65 #define MEI_NFC_SUBCMD_CONNECT 0x00 66 #define MEI_NFC_SUBCMD_IF_VERSION 0x01 67 68 #define MEI_NFC_MAX_READ (MEI_NFC_HEADER_SIZE + MEI_NFC_MAX_HCI_PAYLOAD) 69 70 #define MEI_DUMP_SKB_IN(info, skb) \ 71 do { \ 72 pr_debug("%s:\n", info); \ 73 print_hex_dump_debug("mei in : ", DUMP_PREFIX_OFFSET, \ 74 16, 1, (skb)->data, (skb)->len, false); \ 75 } while (0) 76 77 #define MEI_DUMP_SKB_OUT(info, skb) \ 78 do { \ 79 pr_debug("%s:\n", info); \ 80 print_hex_dump_debug("mei out: ", DUMP_PREFIX_OFFSET, \ 81 16, 1, (skb)->data, (skb)->len, false); \ 82 } while (0) 83 84 #define MEI_DUMP_NFC_HDR(info, _hdr) \ 85 do { \ 86 pr_debug("%s:\n", info); \ 87 pr_debug("cmd=%02d status=%d req_id=%d rsvd=%d size=%d\n", \ 88 (_hdr)->cmd, (_hdr)->status, (_hdr)->req_id, \ 89 (_hdr)->reserved, (_hdr)->data_size); \ 90 } while (0) 91 92 static int mei_nfc_if_version(struct nfc_mei_phy *phy) 93 { 94 95 struct mei_nfc_cmd cmd; 96 struct mei_nfc_reply *reply = NULL; 97 struct mei_nfc_if_version *version; 98 size_t if_version_length; 99 int bytes_recv, r; 100 101 memset(&cmd, 0, sizeof(struct mei_nfc_cmd)); 102 cmd.hdr.cmd = MEI_NFC_CMD_MAINTENANCE; 103 cmd.hdr.data_size = 1; 104 cmd.sub_command = MEI_NFC_SUBCMD_IF_VERSION; 105 106 MEI_DUMP_NFC_HDR("version", &cmd.hdr); 107 r = mei_cldev_send(phy->cldev, (u8 *)&cmd, sizeof(struct mei_nfc_cmd)); 108 if (r < 0) { 109 pr_err("Could not send IF version cmd\n"); 110 return r; 111 } 112 113 /* to be sure on the stack we alloc memory */ 114 if_version_length = sizeof(struct mei_nfc_reply) + 115 sizeof(struct mei_nfc_if_version); 116 117 reply = kzalloc(if_version_length, GFP_KERNEL); 118 if (!reply) 119 return -ENOMEM; 120 121 bytes_recv = mei_cldev_recv(phy->cldev, (u8 *)reply, if_version_length); 122 if (bytes_recv < 0 || bytes_recv < if_version_length) { 123 pr_err("Could not read IF version\n"); 124 r = -EIO; 125 goto err; 126 } 127 128 version = (struct mei_nfc_if_version *)reply->data; 129 130 phy->fw_ivn = version->fw_ivn; 131 phy->vendor_id = version->vendor_id; 132 phy->radio_type = version->radio_type; 133 134 err: 135 kfree(reply); 136 return r; 137 } 138 139 static int mei_nfc_connect(struct nfc_mei_phy *phy) 140 { 141 struct mei_nfc_cmd *cmd, *reply; 142 struct mei_nfc_connect *connect; 143 struct mei_nfc_connect_resp *connect_resp; 144 size_t connect_length, connect_resp_length; 145 int bytes_recv, r; 146 147 connect_length = sizeof(struct mei_nfc_cmd) + 148 sizeof(struct mei_nfc_connect); 149 150 connect_resp_length = sizeof(struct mei_nfc_cmd) + 151 sizeof(struct mei_nfc_connect_resp); 152 153 cmd = kzalloc(connect_length, GFP_KERNEL); 154 if (!cmd) 155 return -ENOMEM; 156 connect = (struct mei_nfc_connect *)cmd->data; 157 158 reply = kzalloc(connect_resp_length, GFP_KERNEL); 159 if (!reply) { 160 kfree(cmd); 161 return -ENOMEM; 162 } 163 164 connect_resp = (struct mei_nfc_connect_resp *)reply->data; 165 166 cmd->hdr.cmd = MEI_NFC_CMD_MAINTENANCE; 167 cmd->hdr.data_size = 3; 168 cmd->sub_command = MEI_NFC_SUBCMD_CONNECT; 169 connect->fw_ivn = phy->fw_ivn; 170 connect->vendor_id = phy->vendor_id; 171 172 MEI_DUMP_NFC_HDR("connect request", &cmd->hdr); 173 r = mei_cldev_send(phy->cldev, (u8 *)cmd, connect_length); 174 if (r < 0) { 175 pr_err("Could not send connect cmd %d\n", r); 176 goto err; 177 } 178 179 bytes_recv = mei_cldev_recv(phy->cldev, (u8 *)reply, 180 connect_resp_length); 181 if (bytes_recv < 0) { 182 r = bytes_recv; 183 pr_err("Could not read connect response %d\n", r); 184 goto err; 185 } 186 187 MEI_DUMP_NFC_HDR("connect reply", &reply->hdr); 188 189 pr_info("IVN 0x%x Vendor ID 0x%x\n", 190 connect_resp->fw_ivn, connect_resp->vendor_id); 191 192 pr_info("ME FW %d.%d.%d.%d\n", 193 connect_resp->me_major, connect_resp->me_minor, 194 connect_resp->me_hotfix, connect_resp->me_build); 195 196 r = 0; 197 198 err: 199 kfree(reply); 200 kfree(cmd); 201 202 return r; 203 } 204 205 static int mei_nfc_send(struct nfc_mei_phy *phy, const u8 *buf, size_t length) 206 { 207 struct mei_nfc_hdr *hdr; 208 u8 *mei_buf; 209 int err; 210 211 err = -ENOMEM; 212 mei_buf = kzalloc(length + MEI_NFC_HEADER_SIZE, GFP_KERNEL); 213 if (!mei_buf) 214 goto out; 215 216 hdr = (struct mei_nfc_hdr *)mei_buf; 217 hdr->cmd = MEI_NFC_CMD_HCI_SEND; 218 hdr->status = 0; 219 hdr->req_id = phy->req_id; 220 hdr->reserved = 0; 221 hdr->data_size = length; 222 223 MEI_DUMP_NFC_HDR("send", hdr); 224 225 memcpy(mei_buf + MEI_NFC_HEADER_SIZE, buf, length); 226 err = mei_cldev_send(phy->cldev, mei_buf, length + MEI_NFC_HEADER_SIZE); 227 if (err < 0) 228 goto out; 229 230 if (!wait_event_interruptible_timeout(phy->send_wq, 231 phy->recv_req_id == phy->req_id, HZ)) { 232 pr_err("NFC MEI command timeout\n"); 233 err = -ETIME; 234 } else { 235 phy->req_id++; 236 } 237 out: 238 kfree(mei_buf); 239 return err; 240 } 241 242 /* 243 * Writing a frame must not return the number of written bytes. 244 * It must return either zero for success, or <0 for error. 245 * In addition, it must not alter the skb 246 */ 247 static int nfc_mei_phy_write(void *phy_id, struct sk_buff *skb) 248 { 249 struct nfc_mei_phy *phy = phy_id; 250 int r; 251 252 MEI_DUMP_SKB_OUT("mei frame sent", skb); 253 254 r = mei_nfc_send(phy, skb->data, skb->len); 255 if (r > 0) 256 r = 0; 257 258 return r; 259 } 260 261 static int mei_nfc_recv(struct nfc_mei_phy *phy, u8 *buf, size_t length) 262 { 263 struct mei_nfc_hdr *hdr; 264 int received_length; 265 266 received_length = mei_cldev_recv(phy->cldev, buf, length); 267 if (received_length < 0) 268 return received_length; 269 270 hdr = (struct mei_nfc_hdr *) buf; 271 272 MEI_DUMP_NFC_HDR("receive", hdr); 273 if (hdr->cmd == MEI_NFC_CMD_HCI_SEND) { 274 phy->recv_req_id = hdr->req_id; 275 wake_up(&phy->send_wq); 276 277 return 0; 278 } 279 280 return received_length; 281 } 282 283 284 static void nfc_mei_rx_cb(struct mei_cl_device *cldev) 285 { 286 struct nfc_mei_phy *phy = mei_cldev_get_drvdata(cldev); 287 struct sk_buff *skb; 288 int reply_size; 289 290 if (!phy) 291 return; 292 293 if (phy->hard_fault != 0) 294 return; 295 296 skb = alloc_skb(MEI_NFC_MAX_READ, GFP_KERNEL); 297 if (!skb) 298 return; 299 300 reply_size = mei_nfc_recv(phy, skb->data, MEI_NFC_MAX_READ); 301 if (reply_size < MEI_NFC_HEADER_SIZE) { 302 kfree_skb(skb); 303 return; 304 } 305 306 skb_put(skb, reply_size); 307 skb_pull(skb, MEI_NFC_HEADER_SIZE); 308 309 MEI_DUMP_SKB_IN("mei frame read", skb); 310 311 nfc_hci_recv_frame(phy->hdev, skb); 312 } 313 314 static int nfc_mei_phy_enable(void *phy_id) 315 { 316 int r; 317 struct nfc_mei_phy *phy = phy_id; 318 319 if (phy->powered == 1) 320 return 0; 321 322 r = mei_cldev_enable(phy->cldev); 323 if (r < 0) { 324 pr_err("Could not enable device %d\n", r); 325 return r; 326 } 327 328 r = mei_nfc_if_version(phy); 329 if (r < 0) { 330 pr_err("Could not enable device %d\n", r); 331 goto err; 332 } 333 334 r = mei_nfc_connect(phy); 335 if (r < 0) { 336 pr_err("Could not connect to device %d\n", r); 337 goto err; 338 } 339 340 r = mei_cldev_register_rx_cb(phy->cldev, nfc_mei_rx_cb); 341 if (r) { 342 pr_err("Event cb registration failed %d\n", r); 343 goto err; 344 } 345 346 phy->powered = 1; 347 348 return 0; 349 350 err: 351 phy->powered = 0; 352 mei_cldev_disable(phy->cldev); 353 return r; 354 } 355 356 static void nfc_mei_phy_disable(void *phy_id) 357 { 358 struct nfc_mei_phy *phy = phy_id; 359 360 mei_cldev_disable(phy->cldev); 361 362 phy->powered = 0; 363 } 364 365 const struct nfc_phy_ops mei_phy_ops = { 366 .write = nfc_mei_phy_write, 367 .enable = nfc_mei_phy_enable, 368 .disable = nfc_mei_phy_disable, 369 }; 370 EXPORT_SYMBOL_GPL(mei_phy_ops); 371 372 struct nfc_mei_phy *nfc_mei_phy_alloc(struct mei_cl_device *cldev) 373 { 374 struct nfc_mei_phy *phy; 375 376 phy = kzalloc(sizeof(struct nfc_mei_phy), GFP_KERNEL); 377 if (!phy) 378 return NULL; 379 380 phy->cldev = cldev; 381 init_waitqueue_head(&phy->send_wq); 382 mei_cldev_set_drvdata(cldev, phy); 383 384 return phy; 385 } 386 EXPORT_SYMBOL_GPL(nfc_mei_phy_alloc); 387 388 void nfc_mei_phy_free(struct nfc_mei_phy *phy) 389 { 390 mei_cldev_disable(phy->cldev); 391 kfree(phy); 392 } 393 EXPORT_SYMBOL_GPL(nfc_mei_phy_free); 394 395 MODULE_LICENSE("GPL"); 396 MODULE_DESCRIPTION("mei bus NFC device interface"); 397