A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-30 03:27:44 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next into for-davem

Browse source 
Conflicts:
	drivers/net/wireless/iwlwifi/iwl-testmode.c
	include/net/nfc/nfc.h
	net/nfc/netlink.c
	net/wireless/nl80211.c
This commit is contained in:
John W. Linville 2012-04-18 14:17:13 -04:00
commit 59ef43e681
290 changed files with 14493 additions and 7242 deletions
Download patch file Download diff file Expand all files Collapse all files

1
net/nfc/Kconfig
View file

@ -14,6 +14,7 @@ menuconfig NFC
be called nfc.
source "net/nfc/nci/Kconfig"
source "net/nfc/hci/Kconfig"
source "net/nfc/llcp/Kconfig"
source "drivers/nfc/Kconfig"

1
net/nfc/Makefile
View file

@ -4,6 +4,7 @@
obj-$(CONFIG_NFC) += nfc.o
obj-$(CONFIG_NFC_NCI) += nci/
obj-$(CONFIG_NFC_HCI) += hci/
nfc-objs := core.o netlink.o af_nfc.o rawsock.o
nfc-$(CONFIG_NFC_LLCP) += llcp/llcp.o llcp/commands.o llcp/sock.o

140
net/nfc/core.c
View file

@ -33,6 +33,8 @@
#define VERSION "0.1"
#define NFC_CHECK_PRES_FREQ_MS 2000
int nfc_devlist_generation;
DEFINE_MUTEX(nfc_devlist_mutex);
@ -95,7 +97,7 @@ int nfc_dev_down(struct nfc_dev *dev)
goto error;
}
if (dev->polling || dev->remote_activated) {
if (dev->polling || dev->activated_target_idx != NFC_TARGET_IDX_NONE) {
rc = -EBUSY;
goto error;
}
@ -211,6 +213,8 @@ int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode)
}
rc = dev->ops->dep_link_up(dev, target_index, comm_mode, gb, gb_len);
if (!rc)
dev->activated_target_idx = target_index;
error:
device_unlock(&dev->dev);
@ -246,6 +250,7 @@ int nfc_dep_link_down(struct nfc_dev *dev)
rc = dev->ops->dep_link_down(dev);
if (!rc) {
dev->dep_link_up = false;
dev->activated_target_idx = NFC_TARGET_IDX_NONE;
nfc_llcp_mac_is_down(dev);
nfc_genl_dep_link_down_event(dev);
}
@ -289,8 +294,13 @@ int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
}
rc = dev->ops->activate_target(dev, target_idx, protocol);
if (!rc)
dev->remote_activated = true;
if (!rc) {
dev->activated_target_idx = target_idx;
if (dev->ops->check_presence)
mod_timer(&dev->check_pres_timer, jiffies +
msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
}
error:
device_unlock(&dev->dev);
@ -317,8 +327,11 @@ int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
goto error;
}
if (dev->ops->check_presence)
del_timer_sync(&dev->check_pres_timer);
dev->ops->deactivate_target(dev, target_idx);
dev->remote_activated = false;
dev->activated_target_idx = NFC_TARGET_IDX_NONE;
error:
device_unlock(&dev->dev);
@ -352,8 +365,27 @@ int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb,
goto error;
}
if (dev->activated_target_idx == NFC_TARGET_IDX_NONE) {
rc = -ENOTCONN;
kfree_skb(skb);
goto error;
}
if (target_idx != dev->activated_target_idx) {
rc = -EADDRNOTAVAIL;
kfree_skb(skb);
goto error;
}
if (dev->ops->check_presence)
del_timer_sync(&dev->check_pres_timer);
rc = dev->ops->data_exchange(dev, target_idx, skb, cb, cb_context);
if (!rc && dev->ops->check_presence)
mod_timer(&dev->check_pres_timer, jiffies +
msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
error:
device_unlock(&dev->dev);
return rc;
@ -428,10 +460,15 @@ EXPORT_SYMBOL(nfc_alloc_recv_skb);
int nfc_targets_found(struct nfc_dev *dev,
struct nfc_target *targets, int n_targets)
{
int i;
pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
dev->polling = false;
for (i = 0; i < n_targets; i++)
targets[i].idx = dev->target_next_idx++;
spin_lock_bh(&dev->targets_lock);
dev->targets_generation++;
@ -455,17 +492,92 @@ int nfc_targets_found(struct nfc_dev *dev,
}
EXPORT_SYMBOL(nfc_targets_found);
int nfc_target_lost(struct nfc_dev *dev, u32 target_idx)
{
struct nfc_target *tg;
int i;
pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);
spin_lock_bh(&dev->targets_lock);
for (i = 0; i < dev->n_targets; i++) {
tg = &dev->targets[i];
if (tg->idx == target_idx)
break;
}
if (i == dev->n_targets) {
spin_unlock_bh(&dev->targets_lock);
return -EINVAL;
}
dev->targets_generation++;
dev->n_targets--;
dev->activated_target_idx = NFC_TARGET_IDX_NONE;
if (dev->n_targets) {
memcpy(&dev->targets[i], &dev->targets[i + 1],
(dev->n_targets - i) * sizeof(struct nfc_target));
} else {
kfree(dev->targets);
dev->targets = NULL;
}
spin_unlock_bh(&dev->targets_lock);
nfc_genl_target_lost(dev, target_idx);
return 0;
}
EXPORT_SYMBOL(nfc_target_lost);
static void nfc_release(struct device *d)
{
struct nfc_dev *dev = to_nfc_dev(d);
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
if (dev->ops->check_presence) {
del_timer_sync(&dev->check_pres_timer);
destroy_workqueue(dev->check_pres_wq);
}
nfc_genl_data_exit(&dev->genl_data);
kfree(dev->targets);
kfree(dev);
}
static void nfc_check_pres_work(struct work_struct *work)
{
struct nfc_dev *dev = container_of(work, struct nfc_dev,
check_pres_work);
int rc;
device_lock(&dev->dev);
if (dev->activated_target_idx != NFC_TARGET_IDX_NONE &&
timer_pending(&dev->check_pres_timer) == 0) {
rc = dev->ops->check_presence(dev, dev->activated_target_idx);
if (!rc) {
mod_timer(&dev->check_pres_timer, jiffies +
msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
} else {
nfc_target_lost(dev, dev->activated_target_idx);
dev->activated_target_idx = NFC_TARGET_IDX_NONE;
}
}
device_unlock(&dev->dev);
}
static void nfc_check_pres_timeout(unsigned long data)
{
struct nfc_dev *dev = (struct nfc_dev *)data;
queue_work(dev->check_pres_wq, &dev->check_pres_work);
}
struct class nfc_class = {
.name = "nfc",
.dev_release = nfc_release,
@ -531,6 +643,26 @@ struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
/* first generation must not be 0 */
dev->targets_generation = 1;
dev->activated_target_idx = NFC_TARGET_IDX_NONE;
if (ops->check_presence) {
char name[32];
init_timer(&dev->check_pres_timer);
dev->check_pres_timer.data = (unsigned long)dev;
dev->check_pres_timer.function = nfc_check_pres_timeout;
INIT_WORK(&dev->check_pres_work, nfc_check_pres_work);
snprintf(name, sizeof(name), "nfc%d_check_pres_wq", dev->idx);
dev->check_pres_wq = alloc_workqueue(name, WQ_NON_REENTRANT |
WQ_UNBOUND |
WQ_MEM_RECLAIM, 1);
if (dev->check_pres_wq == NULL) {
kfree(dev);
return NULL;
}
}
return dev;
}
EXPORT_SYMBOL(nfc_allocate_device);

16
net/nfc/hci/Kconfig Normal file
View file

@ -0,0 +1,16 @@
config NFC_HCI
depends on NFC
tristate "NFC HCI implementation"
default n
help
Say Y here if you want to build support for a kernel NFC HCI
implementation. This is mostly needed for devices that only process
HCI frames, like for example the NXP pn544.
config NFC_SHDLC
depends on NFC_HCI
bool "SHDLC link layer for HCI based NFC drivers"
default n
---help---
Say yes if you use an NFC HCI driver that requires SHDLC link layer.
If unsure, say N here.

8
net/nfc/hci/Makefile Normal file
View file

@ -0,0 +1,8 @@
#
# Makefile for the Linux NFC HCI layer.
#
obj-$(CONFIG_NFC_HCI) += hci.o
hci-y := core.o hcp.o command.o
hci-$(CONFIG_NFC_SHDLC) += shdlc.o

354
net/nfc/hci/command.c Normal file
View file

@ -0,0 +1,354 @@
/*
* Copyright (C) 2012 Intel Corporation. All rights reserved.
*
* 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.
*/
#define pr_fmt(fmt) "hci: %s: " fmt, __func__
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <net/nfc/hci.h>
#include "hci.h"
static int nfc_hci_result_to_errno(u8 result)
{
switch (result) {
case NFC_HCI_ANY_OK:
return 0;
case NFC_HCI_ANY_E_TIMEOUT:
return -ETIMEDOUT;
default:
return -1;
}
}
static void nfc_hci_execute_cb(struct nfc_hci_dev *hdev, u8 result,
struct sk_buff *skb, void *cb_data)
{
struct hcp_exec_waiter *hcp_ew = (struct hcp_exec_waiter *)cb_data;
pr_debug("HCI Cmd completed with HCI result=%d\n", result);
hcp_ew->exec_result = nfc_hci_result_to_errno(result);
if (hcp_ew->exec_result == 0)
hcp_ew->result_skb = skb;
else
kfree_skb(skb);
hcp_ew->exec_complete = true;
wake_up(hcp_ew->wq);
}
static int nfc_hci_execute_cmd(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd,
const u8 *param, size_t param_len,
struct sk_buff **skb)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(ew_wq);
struct hcp_exec_waiter hcp_ew;
hcp_ew.wq = &ew_wq;
hcp_ew.exec_complete = false;
hcp_ew.result_skb = NULL;
pr_debug("through pipe=%d, cmd=%d, plen=%zd\n", pipe, cmd, param_len);
/* TODO: Define hci cmd execution delay. Should it be the same
* for all commands?
*/
hcp_ew.exec_result = nfc_hci_hcp_message_tx(hdev, pipe,
NFC_HCI_HCP_COMMAND, cmd,
param, param_len,
nfc_hci_execute_cb, &hcp_ew,
3000);
if (hcp_ew.exec_result < 0)
return hcp_ew.exec_result;
wait_event(ew_wq, hcp_ew.exec_complete == true);
if (hcp_ew.exec_result == 0) {
if (skb)
*skb = hcp_ew.result_skb;
else
kfree_skb(hcp_ew.result_skb);
}
return hcp_ew.exec_result;
}
int nfc_hci_send_event(struct nfc_hci_dev *hdev, u8 gate, u8 event,
const u8 *param, size_t param_len)
{
u8 pipe;
pr_debug("%d to gate %d\n", event, gate);
pipe = hdev->gate2pipe[gate];
if (pipe == NFC_HCI_INVALID_PIPE)
return -EADDRNOTAVAIL;
return nfc_hci_hcp_message_tx(hdev, pipe, NFC_HCI_HCP_EVENT, event,
param, param_len, NULL, NULL, 0);
}
EXPORT_SYMBOL(nfc_hci_send_event);
int nfc_hci_send_response(struct nfc_hci_dev *hdev, u8 gate, u8 response,
const u8 *param, size_t param_len)
{
u8 pipe;
pr_debug("\n");
pipe = hdev->gate2pipe[gate];
if (pipe == NFC_HCI_INVALID_PIPE)
return -EADDRNOTAVAIL;
return nfc_hci_hcp_message_tx(hdev, pipe, NFC_HCI_HCP_RESPONSE,
response, param, param_len, NULL, NULL,
0);
}
EXPORT_SYMBOL(nfc_hci_send_response);
/*
* Execute an hci command sent to gate.
* skb will contain response data if success. skb can be NULL if you are not
* interested by the response.
*/
int nfc_hci_send_cmd(struct nfc_hci_dev *hdev, u8 gate, u8 cmd,
const u8 *param, size_t param_len, struct sk_buff **skb)
{
u8 pipe;
pr_debug("\n");
pipe = hdev->gate2pipe[gate];
if (pipe == NFC_HCI_INVALID_PIPE)
return -EADDRNOTAVAIL;
return nfc_hci_execute_cmd(hdev, pipe, cmd, param, param_len, skb);
}
EXPORT_SYMBOL(nfc_hci_send_cmd);
int nfc_hci_set_param(struct nfc_hci_dev *hdev, u8 gate, u8 idx,
const u8 *param, size_t param_len)
{
int r;
u8 *tmp;
/* TODO ELa: reg idx must be inserted before param, but we don't want
* to ask the caller to do it to keep a simpler API.
* For now, just create a new temporary param buffer. This is far from
* optimal though, and the plan is to modify APIs to pass idx down to
* nfc_hci_hcp_message_tx where the frame is actually built, thereby
* eliminating the need for the temp allocation-copy here.
*/
pr_debug("idx=%d to gate %d\n", idx, gate);
tmp = kmalloc(1 + param_len, GFP_KERNEL);
if (tmp == NULL)
return -ENOMEM;
*tmp = idx;
memcpy(tmp + 1, param, param_len);
r = nfc_hci_send_cmd(hdev, gate, NFC_HCI_ANY_SET_PARAMETER,
tmp, param_len + 1, NULL);
kfree(tmp);
return r;
}
EXPORT_SYMBOL(nfc_hci_set_param);
int nfc_hci_get_param(struct nfc_hci_dev *hdev, u8 gate, u8 idx,
struct sk_buff **skb)
{
pr_debug("gate=%d regidx=%d\n", gate, idx);
return nfc_hci_send_cmd(hdev, gate, NFC_HCI_ANY_GET_PARAMETER,
&idx, 1, skb);
}
EXPORT_SYMBOL(nfc_hci_get_param);
static int nfc_hci_open_pipe(struct nfc_hci_dev *hdev, u8 pipe)
{
struct sk_buff *skb;
int r;
pr_debug("pipe=%d\n", pipe);
r = nfc_hci_execute_cmd(hdev, pipe, NFC_HCI_ANY_OPEN_PIPE,
NULL, 0, &skb);
if (r == 0) {
/* dest host other than host controller will send
* number of pipes already open on this gate before
* execution. The number can be found in skb->data[0]
*/
kfree_skb(skb);
}
return r;
}
static int nfc_hci_close_pipe(struct nfc_hci_dev *hdev, u8 pipe)
{
pr_debug("\n");
return nfc_hci_execute_cmd(hdev, pipe, NFC_HCI_ANY_CLOSE_PIPE,
NULL, 0, NULL);
}
static u8 nfc_hci_create_pipe(struct nfc_hci_dev *hdev, u8 dest_host,
u8 dest_gate, int *result)
{
struct sk_buff *skb;
struct hci_create_pipe_params params;
struct hci_create_pipe_resp *resp;
u8 pipe;
pr_debug("gate=%d\n", dest_gate);
params.src_gate = NFC_HCI_ADMIN_GATE;
params.dest_host = dest_host;
params.dest_gate = dest_gate;
*result = nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE,
NFC_HCI_ADM_CREATE_PIPE,
(u8 *) &params, sizeof(params), &skb);
if (*result == 0) {
resp = (struct hci_create_pipe_resp *)skb->data;
pipe = resp->pipe;
kfree_skb(skb);
pr_debug("pipe created=%d\n", pipe);
return pipe;
} else
return NFC_HCI_INVALID_PIPE;
}
static int nfc_hci_delete_pipe(struct nfc_hci_dev *hdev, u8 pipe)
{
pr_debug("\n");
return nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE,
NFC_HCI_ADM_DELETE_PIPE, &pipe, 1, NULL);
}
static int nfc_hci_clear_all_pipes(struct nfc_hci_dev *hdev)
{
int r;
u8 param[2];
/* TODO: Find out what the identity reference data is
* and fill param with it. HCI spec 6.1.3.5 */
pr_debug("\n");
r = nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE,
NFC_HCI_ADM_CLEAR_ALL_PIPE, param, 2, NULL);
return 0;
}
int nfc_hci_disconnect_gate(struct nfc_hci_dev *hdev, u8 gate)
{
int r;
u8 pipe = hdev->gate2pipe[gate];
pr_debug("\n");
if (pipe == NFC_HCI_INVALID_PIPE)
return -EADDRNOTAVAIL;
r = nfc_hci_close_pipe(hdev, pipe);
if (r < 0)
return r;
if (pipe != NFC_HCI_LINK_MGMT_PIPE && pipe != NFC_HCI_ADMIN_PIPE) {
r = nfc_hci_delete_pipe(hdev, pipe);
if (r < 0)
return r;
}
hdev->gate2pipe[gate] = NFC_HCI_INVALID_PIPE;
return 0;
}
EXPORT_SYMBOL(nfc_hci_disconnect_gate);
int nfc_hci_disconnect_all_gates(struct nfc_hci_dev *hdev)
{
int r;
pr_debug("\n");
r = nfc_hci_clear_all_pipes(hdev);
if (r < 0)
return r;
memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
return 0;
}
EXPORT_SYMBOL(nfc_hci_disconnect_all_gates);
int nfc_hci_connect_gate(struct nfc_hci_dev *hdev, u8 dest_host, u8 dest_gate)
{
u8 pipe = NFC_HCI_INVALID_PIPE;
bool pipe_created = false;
int r;
pr_debug("\n");
if (hdev->gate2pipe[dest_gate] != NFC_HCI_INVALID_PIPE)
return -EADDRINUSE;
switch (dest_gate) {
case NFC_HCI_LINK_MGMT_GATE:
pipe = NFC_HCI_LINK_MGMT_PIPE;
break;
case NFC_HCI_ADMIN_GATE:
pipe = NFC_HCI_ADMIN_PIPE;
break;
default:
pipe = nfc_hci_create_pipe(hdev, dest_host, dest_gate, &r);
if (pipe == NFC_HCI_INVALID_PIPE)
return r;
pipe_created = true;
break;
}
r = nfc_hci_open_pipe(hdev, pipe);
if (r < 0) {
if (pipe_created)
if (nfc_hci_delete_pipe(hdev, pipe) < 0) {
/* TODO: Cannot clean by deleting pipe...
* -> inconsistent state */
}
return r;
}
hdev->gate2pipe[dest_gate] = pipe;
return 0;
}
EXPORT_SYMBOL(nfc_hci_connect_gate);

830
net/nfc/hci/core.c Normal file
View file

@ -0,0 +1,830 @@
/*
* Copyright (C) 2012 Intel Corporation. All rights reserved.
*
* 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.
*/
#define pr_fmt(fmt) "hci: %s: " fmt, __func__
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/nfc.h>
#include <net/nfc/nfc.h>
#include <net/nfc/hci.h>
#include "hci.h"
/* Largest headroom needed for outgoing HCI commands */
#define HCI_CMDS_HEADROOM 1
static void nfc_hci_msg_tx_work(struct work_struct *work)
{
struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
msg_tx_work);
struct hci_msg *msg;
struct sk_buff *skb;
int r = 0;
mutex_lock(&hdev->msg_tx_mutex);
if (hdev->cmd_pending_msg) {
if (timer_pending(&hdev->cmd_timer) == 0) {
if (hdev->cmd_pending_msg->cb)
hdev->cmd_pending_msg->cb(hdev,
NFC_HCI_ANY_E_TIMEOUT,
NULL,
hdev->
cmd_pending_msg->
cb_context);
kfree(hdev->cmd_pending_msg);
hdev->cmd_pending_msg = NULL;
} else
goto exit;
}
next_msg:
if (list_empty(&hdev->msg_tx_queue))
goto exit;
msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, msg_l);
list_del(&msg->msg_l);
pr_debug("msg_tx_queue has a cmd to send\n");
while ((skb = skb_dequeue(&msg->msg_frags)) != NULL) {
r = hdev->ops->xmit(hdev, skb);
if (r < 0) {
kfree_skb(skb);
skb_queue_purge(&msg->msg_frags);
if (msg->cb)
msg->cb(hdev, NFC_HCI_ANY_E_NOK, NULL,
msg->cb_context);
kfree(msg);
break;
}
}
if (r)
goto next_msg;
if (msg->wait_response == false) {
kfree(msg);
goto next_msg;
}
hdev->cmd_pending_msg = msg;
mod_timer(&hdev->cmd_timer, jiffies +
msecs_to_jiffies(hdev->cmd_pending_msg->completion_delay));
exit:
mutex_unlock(&hdev->msg_tx_mutex);
}
static void nfc_hci_msg_rx_work(struct work_struct *work)
{
struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
msg_rx_work);
struct sk_buff *skb;
struct hcp_message *message;
u8 pipe;
u8 type;
u8 instruction;
while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) {
pipe = skb->data[0];
skb_pull(skb, NFC_HCI_HCP_PACKET_HEADER_LEN);
message = (struct hcp_message *)skb->data;
type = HCP_MSG_GET_TYPE(message->header);
instruction = HCP_MSG_GET_CMD(message->header);
skb_pull(skb, NFC_HCI_HCP_MESSAGE_HEADER_LEN);
nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, skb);
}
}
void nfc_hci_resp_received(struct nfc_hci_dev *hdev, u8 result,
struct sk_buff *skb)
{
mutex_lock(&hdev->msg_tx_mutex);
if (hdev->cmd_pending_msg == NULL) {
kfree_skb(skb);
goto exit;
}
del_timer_sync(&hdev->cmd_timer);
if (hdev->cmd_pending_msg->cb)
hdev->cmd_pending_msg->cb(hdev, result, skb,
hdev->cmd_pending_msg->cb_context);
else
kfree_skb(skb);
kfree(hdev->cmd_pending_msg);
hdev->cmd_pending_msg = NULL;
queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work);
exit:
mutex_unlock(&hdev->msg_tx_mutex);
}
void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd,
struct sk_buff *skb)
{
kfree_skb(skb);
}
static u32 nfc_hci_sak_to_protocol(u8 sak)
{
switch (NFC_HCI_TYPE_A_SEL_PROT(sak)) {
case NFC_HCI_TYPE_A_SEL_PROT_MIFARE:
return NFC_PROTO_MIFARE_MASK;
case NFC_HCI_TYPE_A_SEL_PROT_ISO14443:
return NFC_PROTO_ISO14443_MASK;
case NFC_HCI_TYPE_A_SEL_PROT_DEP:
return NFC_PROTO_NFC_DEP_MASK;
case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP:
return NFC_PROTO_ISO14443_MASK | NFC_PROTO_NFC_DEP_MASK;
default:
return 0xffffffff;
}
}
static int nfc_hci_target_discovered(struct nfc_hci_dev *hdev, u8 gate)
{
struct nfc_target *targets;
struct sk_buff *atqa_skb = NULL;
struct sk_buff *sak_skb = NULL;
int r;
pr_debug("from gate %d\n", gate);
targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
if (targets == NULL)
return -ENOMEM;
switch (gate) {
case NFC_HCI_RF_READER_A_GATE:
r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
NFC_HCI_RF_READER_A_ATQA, &atqa_skb);
if (r < 0)
goto exit;
r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
NFC_HCI_RF_READER_A_SAK, &sak_skb);
if (r < 0)
goto exit;
if (atqa_skb->len != 2 || sak_skb->len != 1) {
r = -EPROTO;
goto exit;
}
targets->supported_protocols =
nfc_hci_sak_to_protocol(sak_skb->data[0]);
if (targets->supported_protocols == 0xffffffff) {
r = -EPROTO;
goto exit;
}
targets->sens_res = be16_to_cpu(*(u16 *)atqa_skb->data);
targets->sel_res = sak_skb->data[0];
if (hdev->ops->complete_target_discovered) {
r = hdev->ops->complete_target_discovered(hdev, gate,
targets);
if (r < 0)
goto exit;
}
break;
case NFC_HCI_RF_READER_B_GATE:
targets->supported_protocols = NFC_PROTO_ISO14443_MASK;
break;
default:
if (hdev->ops->target_from_gate)
r = hdev->ops->target_from_gate(hdev, gate, targets);
else
r = -EPROTO;
if (r < 0)
goto exit;
if (hdev->ops->complete_target_discovered) {
r = hdev->ops->complete_target_discovered(hdev, gate,
targets);
if (r < 0)
goto exit;
}
break;
}
targets->hci_reader_gate = gate;
r = nfc_targets_found(hdev->ndev, targets, 1);
if (r < 0)
goto exit;
kfree(hdev->targets);
hdev->targets = targets;
targets = NULL;
hdev->target_count = 1;
exit:
kfree(targets);
kfree_skb(atqa_skb);
kfree_skb(sak_skb);
return r;
}
void nfc_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event,
struct sk_buff *skb)
{
int r = 0;
switch (event) {
case NFC_HCI_EVT_TARGET_DISCOVERED:
if (hdev->poll_started == false) {
r = -EPROTO;
goto exit;
}
if (skb->len < 1) { /* no status data? */
r = -EPROTO;
goto exit;
}
if (skb->data[0] == 3) {
/* TODO: Multiple targets in field, none activated
* poll is supposedly stopped, but there is no
* single target to activate, so nothing to report
* up.
* if we need to restart poll, we must save the
* protocols from the initial poll and reuse here.
*/
}
if (skb->data[0] != 0) {
r = -EPROTO;
goto exit;
}
r = nfc_hci_target_discovered(hdev,
nfc_hci_pipe2gate(hdev, pipe));
break;
default:
/* TODO: Unknown events are hardware specific
* pass them to the driver (needs a new hci_ops) */
break;
}
exit:
kfree_skb(skb);
if (r) {
/* TODO: There was an error dispatching the event,
* how to propagate up to nfc core?
*/
}
}
static void nfc_hci_cmd_timeout(unsigned long data)
{
struct nfc_hci_dev *hdev = (struct nfc_hci_dev *)data;
queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work);
}
static int hci_dev_connect_gates(struct nfc_hci_dev *hdev, u8 gate_count,
u8 gates[])
{
int r;
u8 *p = gates;
while (gate_count--) {
r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID, *p);
if (r < 0)
return r;
p++;
}
return 0;
}
static int hci_dev_session_init(struct nfc_hci_dev *hdev)
{
struct sk_buff *skb = NULL;
int r;
u8 hci_gates[] = { /* NFC_HCI_ADMIN_GATE MUST be first */
NFC_HCI_ADMIN_GATE, NFC_HCI_LOOPBACK_GATE,
NFC_HCI_ID_MGMT_GATE, NFC_HCI_LINK_MGMT_GATE,
NFC_HCI_RF_READER_B_GATE, NFC_HCI_RF_READER_A_GATE
};
r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID,
NFC_HCI_ADMIN_GATE);
if (r < 0)
goto exit;
r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE,
NFC_HCI_ADMIN_SESSION_IDENTITY, &skb);
if (r < 0)
goto disconnect_all;
if (skb->len && skb->len == strlen(hdev->init_data.session_id))
if (memcmp(hdev->init_data.session_id, skb->data,
skb->len) == 0) {
/* TODO ELa: restore gate<->pipe table from
* some TBD location.
* note: it doesn't seem possible to get the chip
* currently open gate/pipe table.
* It is only possible to obtain the supported
* gate list.
*/
/* goto exit
* For now, always do a full initialization */
}
r = nfc_hci_disconnect_all_gates(hdev);
if (r < 0)
goto exit;
r = hci_dev_connect_gates(hdev, sizeof(hci_gates), hci_gates);
if (r < 0)
goto disconnect_all;
r = hci_dev_connect_gates(hdev, hdev->init_data.gate_count,
hdev->init_data.gates);
if (r < 0)
goto disconnect_all;
r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
NFC_HCI_ADMIN_SESSION_IDENTITY,
hdev->init_data.session_id,
strlen(hdev->init_data.session_id));
if (r == 0)
goto exit;
disconnect_all:
nfc_hci_disconnect_all_gates(hdev);
exit:
if (skb)
kfree_skb(skb);
return r;
}
static int hci_dev_version(struct nfc_hci_dev *hdev)
{
int r;
struct sk_buff *skb;
r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
NFC_HCI_ID_MGMT_VERSION_SW, &skb);
if (r < 0)
return r;
if (skb->len != 3) {
kfree_skb(skb);
return -EINVAL;
}
hdev->sw_romlib = (skb->data[0] & 0xf0) >> 4;
hdev->sw_patch = skb->data[0] & 0x0f;
hdev->sw_flashlib_major = skb->data[1];
hdev->sw_flashlib_minor = skb->data[2];
kfree_skb(skb);
r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
NFC_HCI_ID_MGMT_VERSION_HW, &skb);
if (r < 0)
return r;
if (skb->len != 3) {
kfree_skb(skb);
return -EINVAL;
}
hdev->hw_derivative = (skb->data[0] & 0xe0) >> 5;
hdev->hw_version = skb->data[0] & 0x1f;
hdev->hw_mpw = (skb->data[1] & 0xc0) >> 6;
hdev->hw_software = skb->data[1] & 0x3f;
hdev->hw_bsid = skb->data[2];
kfree_skb(skb);
pr_info("SOFTWARE INFO:\n");
pr_info("RomLib : %d\n", hdev->sw_romlib);
pr_info("Patch : %d\n", hdev->sw_patch);
pr_info("FlashLib Major : %d\n", hdev->sw_flashlib_major);
pr_info("FlashLib Minor : %d\n", hdev->sw_flashlib_minor);
pr_info("HARDWARE INFO:\n");
pr_info("Derivative : %d\n", hdev->hw_derivative);
pr_info("HW Version : %d\n", hdev->hw_version);
pr_info("#MPW : %d\n", hdev->hw_mpw);
pr_info("Software : %d\n", hdev->hw_software);
pr_info("BSID Version : %d\n", hdev->hw_bsid);
return 0;
}
static int hci_dev_up(struct nfc_dev *nfc_dev)
{
struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
int r = 0;
if (hdev->ops->open) {
r = hdev->ops->open(hdev);
if (r < 0)
return r;
}
r = hci_dev_session_init(hdev);
if (r < 0)
goto exit;
r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
NFC_HCI_EVT_END_OPERATION, NULL, 0);
if (r < 0)
goto exit;
if (hdev->ops->hci_ready) {
r = hdev->ops->hci_ready(hdev);
if (r < 0)
goto exit;
}
r = hci_dev_version(hdev);
if (r < 0)
goto exit;
exit:
if (r < 0)
if (hdev->ops->close)
hdev->ops->close(hdev);
return r;
}
static int hci_dev_down(struct nfc_dev *nfc_dev)
{
struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
if (hdev->ops->close)
hdev->ops->close(hdev);
memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
return 0;
}
static int hci_start_poll(struct nfc_dev *nfc_dev, u32 protocols)
{
struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
int r;
if (hdev->ops->start_poll)
r = hdev->ops->start_poll(hdev, protocols);
else
r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
if (r == 0)
hdev->poll_started = true;
return r;
}
static void hci_stop_poll(struct nfc_dev *nfc_dev)
{
struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
if (hdev->poll_started) {
nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
NFC_HCI_EVT_END_OPERATION, NULL, 0);
hdev->poll_started = false;
}
}
static struct nfc_target *hci_find_target(struct nfc_hci_dev *hdev,
u32 target_idx)
{
int i;
if (hdev->poll_started == false || hdev->targets == NULL)
return NULL;
for (i = 0; i < hdev->target_count; i++) {
if (hdev->targets[i].idx == target_idx)
return &hdev->targets[i];
}
return NULL;
}
static int hci_activate_target(struct nfc_dev *nfc_dev, u32 target_idx,
u32 protocol)
{
struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
if (hci_find_target(hdev, target_idx) == NULL)
return -ENOMEDIUM;
return 0;
}
static void hci_deactivate_target(struct nfc_dev *nfc_dev, u32 target_idx)
{
}
static int hci_data_exchange(struct nfc_dev *nfc_dev, u32 target_idx,
struct sk_buff *skb, data_exchange_cb_t cb,
void *cb_context)
{
struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
int r;
struct nfc_target *target;
struct sk_buff *res_skb = NULL;
pr_debug("target_idx=%d\n", target_idx);
target = hci_find_target(hdev, target_idx);
if (target == NULL)
return -ENOMEDIUM;
switch (target->hci_reader_gate) {
case NFC_HCI_RF_READER_A_GATE:
case NFC_HCI_RF_READER_B_GATE:
if (hdev->ops->data_exchange) {
r = hdev->ops->data_exchange(hdev, target, skb,
&res_skb);
if (r <= 0) /* handled */
break;
}
*skb_push(skb, 1) = 0; /* CTR, see spec:10.2.2.1 */
r = nfc_hci_send_cmd(hdev, target->hci_reader_gate,
NFC_HCI_WR_XCHG_DATA,
skb->data, skb->len, &res_skb);
/*
* TODO: Check RF Error indicator to make sure data is valid.
* It seems that HCI cmd can complete without error, but data
* can be invalid if an RF error occured? Ignore for now.
*/
if (r == 0)
skb_trim(res_skb, res_skb->len - 1); /* RF Err ind */
break;
default:
if (hdev->ops->data_exchange) {
r = hdev->ops->data_exchange(hdev, target, skb,
&res_skb);
if (r == 1)
r = -ENOTSUPP;
}
else
r = -ENOTSUPP;
}
kfree_skb(skb);
cb(cb_context, res_skb, r);
return 0;
}
struct nfc_ops hci_nfc_ops = {
.dev_up = hci_dev_up,
.dev_down = hci_dev_down,
.start_poll = hci_start_poll,
.stop_poll = hci_stop_poll,
.activate_target = hci_activate_target,
.deactivate_target = hci_deactivate_target,
.data_exchange = hci_data_exchange,
};
struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops,
struct nfc_hci_init_data *init_data,
u32 protocols,
int tx_headroom,
int tx_tailroom,
int max_link_payload)
{
struct nfc_hci_dev *hdev;
if (ops->xmit == NULL)
return NULL;
if (protocols == 0)
return NULL;
hdev = kzalloc(sizeof(struct nfc_hci_dev), GFP_KERNEL);
if (hdev == NULL)
return NULL;
hdev->ndev = nfc_allocate_device(&hci_nfc_ops, protocols,
tx_headroom + HCI_CMDS_HEADROOM,
tx_tailroom);
if (!hdev->ndev) {
kfree(hdev);
return NULL;
}
hdev->ops = ops;
hdev->max_data_link_payload = max_link_payload;
hdev->init_data = *init_data;
nfc_set_drvdata(hdev->ndev, hdev);
memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
return hdev;
}
EXPORT_SYMBOL(nfc_hci_allocate_device);
void nfc_hci_free_device(struct nfc_hci_dev *hdev)
{
nfc_free_device(hdev->ndev);
kfree(hdev);
}
EXPORT_SYMBOL(nfc_hci_free_device);
int nfc_hci_register_device(struct nfc_hci_dev *hdev)
{
struct device *dev = &hdev->ndev->dev;
const char *devname = dev_name(dev);
char name[32];
int r = 0;
mutex_init(&hdev->msg_tx_mutex);
INIT_LIST_HEAD(&hdev->msg_tx_queue);
INIT_WORK(&hdev->msg_tx_work, nfc_hci_msg_tx_work);
snprintf(name, sizeof(name), "%s_hci_msg_tx_wq", devname);
hdev->msg_tx_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND |
WQ_MEM_RECLAIM, 1);
if (hdev->msg_tx_wq == NULL) {
r = -ENOMEM;
goto exit;
}
init_timer(&hdev->cmd_timer);
hdev->cmd_timer.data = (unsigned long)hdev;
hdev->cmd_timer.function = nfc_hci_cmd_timeout;
skb_queue_head_init(&hdev->rx_hcp_frags);
INIT_WORK(&hdev->msg_rx_work, nfc_hci_msg_rx_work);
snprintf(name, sizeof(name), "%s_hci_msg_rx_wq", devname);
hdev->msg_rx_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND |
WQ_MEM_RECLAIM, 1);
if (hdev->msg_rx_wq == NULL) {
r = -ENOMEM;
goto exit;
}
skb_queue_head_init(&hdev->msg_rx_queue);
r = nfc_register_device(hdev->ndev);
exit:
if (r < 0) {
if (hdev->msg_tx_wq)
destroy_workqueue(hdev->msg_tx_wq);
if (hdev->msg_rx_wq)
destroy_workqueue(hdev->msg_rx_wq);
}
return r;
}
EXPORT_SYMBOL(nfc_hci_register_device);
void nfc_hci_unregister_device(struct nfc_hci_dev *hdev)
{
struct hci_msg *msg;
skb_queue_purge(&hdev->rx_hcp_frags);
skb_queue_purge(&hdev->msg_rx_queue);
while ((msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg,
msg_l)) != NULL) {
list_del(&msg->msg_l);
skb_queue_purge(&msg->msg_frags);
kfree(msg);
}
del_timer_sync(&hdev->cmd_timer);
nfc_unregister_device(hdev->ndev);
destroy_workqueue(hdev->msg_tx_wq);
destroy_workqueue(hdev->msg_rx_wq);
}
EXPORT_SYMBOL(nfc_hci_unregister_device);
void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata)
{
hdev->clientdata = clientdata;
}
EXPORT_SYMBOL(nfc_hci_set_clientdata);
void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev)
{
return hdev->clientdata;
}
EXPORT_SYMBOL(nfc_hci_get_clientdata);
void nfc_hci_recv_frame(struct nfc_hci_dev *hdev, struct sk_buff *skb)
{
struct hcp_packet *packet;
u8 type;
u8 instruction;
struct sk_buff *hcp_skb;
u8 pipe;
struct sk_buff *frag_skb;
int msg_len;
if (skb == NULL) {
/* TODO ELa: lower layer had permanent failure, need to
* propagate that up
*/
skb_queue_purge(&hdev->rx_hcp_frags);
return;
}
packet = (struct hcp_packet *)skb->data;
if ((packet->header & ~NFC_HCI_FRAGMENT) == 0) {
skb_queue_tail(&hdev->rx_hcp_frags, skb);
return;
}
/* it's the last fragment. Does it need re-aggregation? */
if (skb_queue_len(&hdev->rx_hcp_frags)) {
pipe = packet->header & NFC_HCI_FRAGMENT;
skb_queue_tail(&hdev->rx_hcp_frags, skb);
msg_len = 0;
skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
msg_len += (frag_skb->len -
NFC_HCI_HCP_PACKET_HEADER_LEN);
}
hcp_skb = nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN +
msg_len, GFP_KERNEL);
if (hcp_skb == NULL) {
/* TODO ELa: cannot deliver HCP message. How to
* propagate error up?
*/
}
*skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe;
skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN;
memcpy(skb_put(hcp_skb, msg_len),
frag_skb->data + NFC_HCI_HCP_PACKET_HEADER_LEN,
msg_len);
}
skb_queue_purge(&hdev->rx_hcp_frags);
} else {
packet->header &= NFC_HCI_FRAGMENT;
hcp_skb = skb;
}
/* if this is a response, dispatch immediately to
* unblock waiting cmd context. Otherwise, enqueue to dispatch
* in separate context where handler can also execute command.
*/
packet = (struct hcp_packet *)hcp_skb->data;
type = HCP_MSG_GET_TYPE(packet->message.header);
if (type == NFC_HCI_HCP_RESPONSE) {
pipe = packet->header;
instruction = HCP_MSG_GET_CMD(packet->message.header);
skb_pull(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN +
NFC_HCI_HCP_MESSAGE_HEADER_LEN);
nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, hcp_skb);
} else {
skb_queue_tail(&hdev->msg_rx_queue, hcp_skb);
queue_work(hdev->msg_rx_wq, &hdev->msg_rx_work);
}
}
EXPORT_SYMBOL(nfc_hci_recv_frame);
MODULE_LICENSE("GPL");

139
net/nfc/hci/hci.h Normal file
View file

@ -0,0 +1,139 @@
/*
* Copyright (C) 2012 Intel Corporation. All rights reserved.
*
* 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.
*/
#ifndef __LOCAL_HCI_H
#define __LOCAL_HCI_H
struct gate_pipe_map {
u8 gate;
u8 pipe;
};
struct hcp_message {
u8 header; /* type -cmd,evt,rsp- + instruction */
u8 data[];
} __packed;
struct hcp_packet {
u8 header; /* cbit+pipe */
struct hcp_message message;
} __packed;
/*
* HCI command execution completion callback.
* result will be one of the HCI response codes.
* skb contains the response data and must be disposed.
*/
typedef void (*hci_cmd_cb_t) (struct nfc_hci_dev *hdev, u8 result,
struct sk_buff *skb, void *cb_data);
struct hcp_exec_waiter {
wait_queue_head_t *wq;
bool exec_complete;
int exec_result;
struct sk_buff *result_skb;
};
struct hci_msg {
struct list_head msg_l;
struct sk_buff_head msg_frags;
bool wait_response;
hci_cmd_cb_t cb;
void *cb_context;
unsigned long completion_delay;
};
struct hci_create_pipe_params {
u8 src_gate;
u8 dest_host;
u8 dest_gate;
} __packed;
struct hci_create_pipe_resp {
u8 src_host;
u8 src_gate;
u8 dest_host;
u8 dest_gate;
u8 pipe;
} __packed;
#define NFC_HCI_FRAGMENT 0x7f
#define HCP_HEADER(type, instr) ((((type) & 0x03) << 6) | ((instr) & 0x3f))
#define HCP_MSG_GET_TYPE(header) ((header & 0xc0) >> 6)
#define HCP_MSG_GET_CMD(header) (header & 0x3f)
int nfc_hci_hcp_message_tx(struct nfc_hci_dev *hdev, u8 pipe,
u8 type, u8 instruction,
const u8 *payload, size_t payload_len,
hci_cmd_cb_t cb, void *cb_data,
unsigned long completion_delay);
u8 nfc_hci_pipe2gate(struct nfc_hci_dev *hdev, u8 pipe);
void nfc_hci_hcp_message_rx(struct nfc_hci_dev *hdev, u8 pipe, u8 type,
u8 instruction, struct sk_buff *skb);
/* HCP headers */
#define NFC_HCI_HCP_PACKET_HEADER_LEN 1
#define NFC_HCI_HCP_MESSAGE_HEADER_LEN 1
#define NFC_HCI_HCP_HEADER_LEN 2
/* HCP types */
#define NFC_HCI_HCP_COMMAND 0x00
#define NFC_HCI_HCP_EVENT 0x01
#define NFC_HCI_HCP_RESPONSE 0x02
/* Generic commands */
#define NFC_HCI_ANY_SET_PARAMETER 0x01
#define NFC_HCI_ANY_GET_PARAMETER 0x02
#define NFC_HCI_ANY_OPEN_PIPE 0x03
#define NFC_HCI_ANY_CLOSE_PIPE 0x04
/* Reader RF commands */
#define NFC_HCI_WR_XCHG_DATA 0x10
/* Admin commands */
#define NFC_HCI_ADM_CREATE_PIPE 0x10
#define NFC_HCI_ADM_DELETE_PIPE 0x11
#define NFC_HCI_ADM_NOTIFY_PIPE_CREATED 0x12
#define NFC_HCI_ADM_NOTIFY_PIPE_DELETED 0x13
#define NFC_HCI_ADM_CLEAR_ALL_PIPE 0x14
#define NFC_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED 0x15
/* Generic responses */
#define NFC_HCI_ANY_OK 0x00
#define NFC_HCI_ANY_E_NOT_CONNECTED 0x01
#define NFC_HCI_ANY_E_CMD_PAR_UNKNOWN 0x02
#define NFC_HCI_ANY_E_NOK 0x03
#define NFC_HCI_ANY_E_PIPES_FULL 0x04
#define NFC_HCI_ANY_E_REG_PAR_UNKNOWN 0x05
#define NFC_HCI_ANY_E_PIPE_NOT_OPENED 0x06
#define NFC_HCI_ANY_E_CMD_NOT_SUPPORTED 0x07
#define NFC_HCI_ANY_E_INHIBITED 0x08
#define NFC_HCI_ANY_E_TIMEOUT 0x09
#define NFC_HCI_ANY_E_REG_ACCESS_DENIED 0x0a
#define NFC_HCI_ANY_E_PIPE_ACCESS_DENIED 0x0b
/* Pipes */
#define NFC_HCI_INVALID_PIPE 0x80
#define NFC_HCI_LINK_MGMT_PIPE 0x00
#define NFC_HCI_ADMIN_PIPE 0x01
#endif /* __LOCAL_HCI_H */

156
net/nfc/hci/hcp.c Normal file
View file

@ -0,0 +1,156 @@
/*
* Copyright (C) 2012 Intel Corporation. All rights reserved.
*
* 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.
*/
#define pr_fmt(fmt) "hci: %s: " fmt, __func__
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <net/nfc/hci.h>
#include "hci.h"
/*
* Payload is the HCP message data only. Instruction will be prepended.
* Guarantees that cb will be called upon completion or timeout delay
* counted from the moment the cmd is sent to the transport.
*/
int nfc_hci_hcp_message_tx(struct nfc_hci_dev *hdev, u8 pipe,
u8 type, u8 instruction,
const u8 *payload, size_t payload_len,
hci_cmd_cb_t cb, void *cb_data,
unsigned long completion_delay)
{
struct nfc_dev *ndev = hdev->ndev;
struct hci_msg *cmd;
const u8 *ptr = payload;
int hci_len, err;
bool firstfrag = true;
cmd = kzalloc(sizeof(struct hci_msg), GFP_KERNEL);
if (cmd == NULL)
return -ENOMEM;
INIT_LIST_HEAD(&cmd->msg_l);
skb_queue_head_init(&cmd->msg_frags);
cmd->wait_response = (type == NFC_HCI_HCP_COMMAND) ? true : false;
cmd->cb = cb;
cmd->cb_context = cb_data;
cmd->completion_delay = completion_delay;
hci_len = payload_len + 1;
while (hci_len > 0) {
struct sk_buff *skb;
int skb_len, data_link_len;
struct hcp_packet *packet;
if (NFC_HCI_HCP_PACKET_HEADER_LEN + hci_len <=
hdev->max_data_link_payload)
data_link_len = hci_len;
else
data_link_len = hdev->max_data_link_payload -
NFC_HCI_HCP_PACKET_HEADER_LEN;
skb_len = ndev->tx_headroom + NFC_HCI_HCP_PACKET_HEADER_LEN +
data_link_len + ndev->tx_tailroom;
hci_len -= data_link_len;
skb = alloc_skb(skb_len, GFP_KERNEL);
if (skb == NULL) {
err = -ENOMEM;
goto out_skb_err;
}
skb_reserve(skb, ndev->tx_headroom);
skb_put(skb, NFC_HCI_HCP_PACKET_HEADER_LEN + data_link_len);
/* Only the last fragment will have the cb bit set to 1 */
packet = (struct hcp_packet *)skb->data;
packet->header = pipe;
if (firstfrag) {
firstfrag = false;
packet->message.header = HCP_HEADER(type, instruction);
if (ptr) {
memcpy(packet->message.data, ptr,
data_link_len - 1);
ptr += data_link_len - 1;
}
} else {
memcpy(&packet->message, ptr, data_link_len);
ptr += data_link_len;
}
/* This is the last fragment, set the cb bit */
if (hci_len == 0)
packet->header |= ~NFC_HCI_FRAGMENT;
skb_queue_tail(&cmd->msg_frags, skb);
}
mutex_lock(&hdev->msg_tx_mutex);
list_add_tail(&hdev->msg_tx_queue, &cmd->msg_l);
mutex_unlock(&hdev->msg_tx_mutex);
queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work);
return 0;
out_skb_err:
skb_queue_purge(&cmd->msg_frags);
kfree(cmd);
return err;
}
u8 nfc_hci_pipe2gate(struct nfc_hci_dev *hdev, u8 pipe)
{
int gate;
for (gate = 0; gate < NFC_HCI_MAX_GATES; gate++)
if (hdev->gate2pipe[gate] == pipe)
return gate;
return 0xff;
}
/*
* Receive hcp message for pipe, with type and cmd.
* skb contains optional message data only.
*/
void nfc_hci_hcp_message_rx(struct nfc_hci_dev *hdev, u8 pipe, u8 type,
u8 instruction, struct sk_buff *skb)
{
switch (type) {
case NFC_HCI_HCP_RESPONSE:
nfc_hci_resp_received(hdev, instruction, skb);
break;
case NFC_HCI_HCP_COMMAND:
nfc_hci_cmd_received(hdev, pipe, instruction, skb);
break;
case NFC_HCI_HCP_EVENT:
nfc_hci_event_received(hdev, pipe, instruction, skb);
break;
default:
pr_err("UNKNOWN MSG Type %d, instruction=%d\n",
type, instruction);
kfree_skb(skb);
break;
}
}

945
net/nfc/hci/shdlc.c Normal file
View file

@ -0,0 +1,945 @@
/*
* Copyright (C) 2012 Intel Corporation. All rights reserved.
*
* 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.
*/
#define pr_fmt(fmt) "shdlc: %s: " fmt, __func__
#include <linux/sched.h>
#include <linux/export.h>
#include <linux/wait.h>
#include <linux/crc-ccitt.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <net/nfc/hci.h>
#include <net/nfc/shdlc.h>
#define SHDLC_LLC_HEAD_ROOM 2
#define SHDLC_LLC_TAIL_ROOM 2
#define SHDLC_MAX_WINDOW 4
#define SHDLC_SREJ_SUPPORT false
#define SHDLC_CONTROL_HEAD_MASK 0xe0
#define SHDLC_CONTROL_HEAD_I 0x80
#define SHDLC_CONTROL_HEAD_I2 0xa0
#define SHDLC_CONTROL_HEAD_S 0xc0
#define SHDLC_CONTROL_HEAD_U 0xe0
#define SHDLC_CONTROL_NS_MASK 0x38
#define SHDLC_CONTROL_NR_MASK 0x07
#define SHDLC_CONTROL_TYPE_MASK 0x18
#define SHDLC_CONTROL_M_MASK 0x1f
enum sframe_type {
S_FRAME_RR = 0x00,
S_FRAME_REJ = 0x01,
S_FRAME_RNR = 0x02,
S_FRAME_SREJ = 0x03
};
enum uframe_modifier {
U_FRAME_UA = 0x06,
U_FRAME_RSET = 0x19
};
#define SHDLC_CONNECT_VALUE_MS 5
#define SHDLC_T1_VALUE_MS(w) ((5 * w) / 4)
#define SHDLC_T2_VALUE_MS 300
#define SHDLC_DUMP_SKB(info, skb) \
do { \
pr_debug("%s:\n", info); \
print_hex_dump(KERN_DEBUG, "shdlc: ", DUMP_PREFIX_OFFSET, \
16, 1, skb->data, skb->len, 0); \
} while (0)
/* checks x < y <= z modulo 8 */
static bool nfc_shdlc_x_lt_y_lteq_z(int x, int y, int z)
{
if (x < z)
return ((x < y) && (y <= z)) ? true : false;
else
return ((y > x) || (y <= z)) ? true : false;
}
/* checks x <= y < z modulo 8 */
static bool nfc_shdlc_x_lteq_y_lt_z(int x, int y, int z)
{
if (x <= z)
return ((x <= y) && (y < z)) ? true : false;
else /* x > z -> z+8 > x */
return ((y >= x) || (y < z)) ? true : false;
}
static struct sk_buff *nfc_shdlc_alloc_skb(struct nfc_shdlc *shdlc,
int payload_len)
{
struct sk_buff *skb;
skb = alloc_skb(shdlc->client_headroom + SHDLC_LLC_HEAD_ROOM +
shdlc->client_tailroom + SHDLC_LLC_TAIL_ROOM +
payload_len, GFP_KERNEL);
if (skb)
skb_reserve(skb, shdlc->client_headroom + SHDLC_LLC_HEAD_ROOM);
return skb;
}
static void nfc_shdlc_add_len_crc(struct sk_buff *skb)
{
u16 crc;
int len;
len = skb->len + 2;
*skb_push(skb, 1) = len;
crc = crc_ccitt(0xffff, skb->data, skb->len);
crc = ~crc;
*skb_put(skb, 1) = crc & 0xff;
*skb_put(skb, 1) = crc >> 8;
}
/* immediately sends an S frame. */
static int nfc_shdlc_send_s_frame(struct nfc_shdlc *shdlc,
enum sframe_type sframe_type, int nr)
{
int r;
struct sk_buff *skb;
pr_debug("sframe_type=%d nr=%d\n", sframe_type, nr);
skb = nfc_shdlc_alloc_skb(shdlc, 0);
if (skb == NULL)
return -ENOMEM;
*skb_push(skb, 1) = SHDLC_CONTROL_HEAD_S | (sframe_type << 3) | nr;
nfc_shdlc_add_len_crc(skb);
r = shdlc->ops->xmit(shdlc, skb);
kfree_skb(skb);
return r;
}
/* immediately sends an U frame. skb may contain optional payload */
static int nfc_shdlc_send_u_frame(struct nfc_shdlc *shdlc,
struct sk_buff *skb,
enum uframe_modifier uframe_modifier)
{
int r;
pr_debug("uframe_modifier=%d\n", uframe_modifier);
*skb_push(skb, 1) = SHDLC_CONTROL_HEAD_U | uframe_modifier;
nfc_shdlc_add_len_crc(skb);
r = shdlc->ops->xmit(shdlc, skb);
kfree_skb(skb);
return r;
}
/*
* Free ack_pending frames until y_nr - 1, and reset t2 according to
* the remaining oldest ack_pending frame sent time
*/
static void nfc_shdlc_reset_t2(struct nfc_shdlc *shdlc, int y_nr)
{
struct sk_buff *skb;
int dnr = shdlc->dnr; /* MUST initially be < y_nr */
pr_debug("release ack pending up to frame %d excluded\n", y_nr);
while (dnr != y_nr) {
pr_debug("release ack pending frame %d\n", dnr);
skb = skb_dequeue(&shdlc->ack_pending_q);
kfree_skb(skb);
dnr = (dnr + 1) % 8;
}
if (skb_queue_empty(&shdlc->ack_pending_q)) {
if (shdlc->t2_active) {
del_timer_sync(&shdlc->t2_timer);
shdlc->t2_active = false;
pr_debug
("All sent frames acked. Stopped T2(retransmit)\n");
}
} else {
skb = skb_peek(&shdlc->ack_pending_q);
mod_timer(&shdlc->t2_timer, *(unsigned long *)skb->cb +
msecs_to_jiffies(SHDLC_T2_VALUE_MS));
shdlc->t2_active = true;
pr_debug
("Start T2(retransmit) for remaining unacked sent frames\n");
}
}
/*
* Receive validated frames from lower layer. skb contains HCI payload only.
* Handle according to algorithm at spec:10.8.2
*/
static void nfc_shdlc_rcv_i_frame(struct nfc_shdlc *shdlc,
struct sk_buff *skb, int ns, int nr)
{
int x_ns = ns;
int y_nr = nr;
pr_debug("recvd I-frame %d, remote waiting frame %d\n", ns, nr);
if (shdlc->state != SHDLC_CONNECTED)
goto exit;
if (x_ns != shdlc->nr) {
nfc_shdlc_send_s_frame(shdlc, S_FRAME_REJ, shdlc->nr);
goto exit;
}
if (shdlc->t1_active == false) {
shdlc->t1_active = true;
mod_timer(&shdlc->t1_timer,
msecs_to_jiffies(SHDLC_T1_VALUE_MS(shdlc->w)));
pr_debug("(re)Start T1(send ack)\n");
}
if (skb->len) {
nfc_hci_recv_frame(shdlc->hdev, skb);
skb = NULL;
}
shdlc->nr = (shdlc->nr + 1) % 8;
if (nfc_shdlc_x_lt_y_lteq_z(shdlc->dnr, y_nr, shdlc->ns)) {
nfc_shdlc_reset_t2(shdlc, y_nr);
shdlc->dnr = y_nr;
}
exit:
if (skb)
kfree_skb(skb);
}
static void nfc_shdlc_rcv_ack(struct nfc_shdlc *shdlc, int y_nr)
{
pr_debug("remote acked up to frame %d excluded\n", y_nr);
if (nfc_shdlc_x_lt_y_lteq_z(shdlc->dnr, y_nr, shdlc->ns)) {
nfc_shdlc_reset_t2(shdlc, y_nr);
shdlc->dnr = y_nr;
}
}
static void nfc_shdlc_requeue_ack_pending(struct nfc_shdlc *shdlc)
{
struct sk_buff *skb;
pr_debug("ns reset to %d\n", shdlc->dnr);
while ((skb = skb_dequeue_tail(&shdlc->ack_pending_q))) {
skb_pull(skb, 2); /* remove len+control */
skb_trim(skb, skb->len - 2); /* remove crc */
skb_queue_head(&shdlc->send_q, skb);
}
shdlc->ns = shdlc->dnr;
}
static void nfc_shdlc_rcv_rej(struct nfc_shdlc *shdlc, int y_nr)
{
struct sk_buff *skb;
pr_debug("remote asks retransmition from frame %d\n", y_nr);
if (nfc_shdlc_x_lteq_y_lt_z(shdlc->dnr, y_nr, shdlc->ns)) {
if (shdlc->t2_active) {
del_timer_sync(&shdlc->t2_timer);
shdlc->t2_active = false;
pr_debug("Stopped T2(retransmit)\n");
}
if (shdlc->dnr != y_nr) {
while ((shdlc->dnr = ((shdlc->dnr + 1) % 8)) != y_nr) {
skb = skb_dequeue(&shdlc->ack_pending_q);
kfree_skb(skb);
}
}
nfc_shdlc_requeue_ack_pending(shdlc);
}
}
/* See spec RR:10.8.3 REJ:10.8.4 */
static void nfc_shdlc_rcv_s_frame(struct nfc_shdlc *shdlc,
enum sframe_type s_frame_type, int nr)
{
struct sk_buff *skb;
if (shdlc->state != SHDLC_CONNECTED)
return;
switch (s_frame_type) {
case S_FRAME_RR:
nfc_shdlc_rcv_ack(shdlc, nr);
if (shdlc->rnr == true) { /* see SHDLC 10.7.7 */
shdlc->rnr = false;
if (shdlc->send_q.qlen == 0) {
skb = nfc_shdlc_alloc_skb(shdlc, 0);
if (skb)
skb_queue_tail(&shdlc->send_q, skb);
}
}
break;
case S_FRAME_REJ:
nfc_shdlc_rcv_rej(shdlc, nr);
break;
case S_FRAME_RNR:
nfc_shdlc_rcv_ack(shdlc, nr);
shdlc->rnr = true;
break;
default:
break;
}
}
static void nfc_shdlc_connect_complete(struct nfc_shdlc *shdlc, int r)
{
pr_debug("result=%d\n", r);
del_timer_sync(&shdlc->connect_timer);
if (r == 0) {
shdlc->ns = 0;
shdlc->nr = 0;
shdlc->dnr = 0;
shdlc->state = SHDLC_CONNECTED;
} else {
shdlc->state = SHDLC_DISCONNECTED;
/*
* TODO: Could it be possible that there are pending
* executing commands that are waiting for connect to complete
* before they can be carried? As connect is a blocking
* operation, it would require that the userspace process can
* send commands on the same device from a second thread before
* the device is up. I don't think that is possible, is it?
*/
}
shdlc->connect_result = r;
wake_up(shdlc->connect_wq);
}
static int nfc_shdlc_connect_initiate(struct nfc_shdlc *shdlc)
{
struct sk_buff *skb;
pr_debug("\n");
skb = nfc_shdlc_alloc_skb(shdlc, 2);
if (skb == NULL)
return -ENOMEM;
*skb_put(skb, 1) = SHDLC_MAX_WINDOW;
*skb_put(skb, 1) = SHDLC_SREJ_SUPPORT ? 1 : 0;
return nfc_shdlc_send_u_frame(shdlc, skb, U_FRAME_RSET);
}
static int nfc_shdlc_connect_send_ua(struct nfc_shdlc *shdlc)
{
struct sk_buff *skb;
pr_debug("\n");
skb = nfc_shdlc_alloc_skb(shdlc, 0);
if (skb == NULL)
return -ENOMEM;
return nfc_shdlc_send_u_frame(shdlc, skb, U_FRAME_UA);
}
static void nfc_shdlc_rcv_u_frame(struct nfc_shdlc *shdlc,
struct sk_buff *skb,
enum uframe_modifier u_frame_modifier)
{
u8 w = SHDLC_MAX_WINDOW;
bool srej_support = SHDLC_SREJ_SUPPORT;
int r;
pr_debug("u_frame_modifier=%d\n", u_frame_modifier);
switch (u_frame_modifier) {
case U_FRAME_RSET:
if (shdlc->state == SHDLC_NEGOCIATING) {
/* we sent RSET, but chip wants to negociate */
if (skb->len > 0)
w = skb->data[0];
if (skb->len > 1)
srej_support = skb->data[1] & 0x01 ? true :
false;
if ((w <= SHDLC_MAX_WINDOW) &&
(SHDLC_SREJ_SUPPORT || (srej_support == false))) {
shdlc->w = w;
shdlc->srej_support = srej_support;
r = nfc_shdlc_connect_send_ua(shdlc);
nfc_shdlc_connect_complete(shdlc, r);
}
} else if (shdlc->state > SHDLC_NEGOCIATING) {
/*
* TODO: Chip wants to reset link
* send ua, empty skb lists, reset counters
* propagate info to HCI layer
*/
}
break;
case U_FRAME_UA:
if ((shdlc->state == SHDLC_CONNECTING &&
shdlc->connect_tries > 0) ||
(shdlc->state == SHDLC_NEGOCIATING))
nfc_shdlc_connect_complete(shdlc, 0);
break;
default:
break;
}
kfree_skb(skb);
}
static void nfc_shdlc_handle_rcv_queue(struct nfc_shdlc *shdlc)
{
struct sk_buff *skb;
u8 control;
int nr;
int ns;
enum sframe_type s_frame_type;
enum uframe_modifier u_frame_modifier;
if (shdlc->rcv_q.qlen)
pr_debug("rcvQlen=%d\n", shdlc->rcv_q.qlen);
while ((skb = skb_dequeue(&shdlc->rcv_q)) != NULL) {
control = skb->data[0];
skb_pull(skb, 1);
switch (control & SHDLC_CONTROL_HEAD_MASK) {
case SHDLC_CONTROL_HEAD_I:
case SHDLC_CONTROL_HEAD_I2:
ns = (control & SHDLC_CONTROL_NS_MASK) >> 3;
nr = control & SHDLC_CONTROL_NR_MASK;
nfc_shdlc_rcv_i_frame(shdlc, skb, ns, nr);
break;
case SHDLC_CONTROL_HEAD_S:
s_frame_type = (control & SHDLC_CONTROL_TYPE_MASK) >> 3;
nr = control & SHDLC_CONTROL_NR_MASK;
nfc_shdlc_rcv_s_frame(shdlc, s_frame_type, nr);
kfree_skb(skb);
break;
case SHDLC_CONTROL_HEAD_U:
u_frame_modifier = control & SHDLC_CONTROL_M_MASK;
nfc_shdlc_rcv_u_frame(shdlc, skb, u_frame_modifier);
break;
default:
pr_err("UNKNOWN Control=%d\n", control);
kfree_skb(skb);
break;
}
}
}
static int nfc_shdlc_w_used(int ns, int dnr)
{
int unack_count;
if (dnr <= ns)
unack_count = ns - dnr;
else
unack_count = 8 - dnr + ns;
return unack_count;
}
/* Send frames according to algorithm at spec:10.8.1 */
static void nfc_shdlc_handle_send_queue(struct nfc_shdlc *shdlc)
{
struct sk_buff *skb;
int r;
unsigned long time_sent;
if (shdlc->send_q.qlen)
pr_debug
("sendQlen=%d ns=%d dnr=%d rnr=%s w_room=%d unackQlen=%d\n",
shdlc->send_q.qlen, shdlc->ns, shdlc->dnr,
shdlc->rnr == false ? "false" : "true",
shdlc->w - nfc_shdlc_w_used(shdlc->ns, shdlc->dnr),
shdlc->ack_pending_q.qlen);
while (shdlc->send_q.qlen && shdlc->ack_pending_q.qlen < shdlc->w &&
(shdlc->rnr == false)) {
if (shdlc->t1_active) {
del_timer_sync(&shdlc->t1_timer);
shdlc->t1_active = false;
pr_debug("Stopped T1(send ack)\n");
}
skb = skb_dequeue(&shdlc->send_q);
*skb_push(skb, 1) = SHDLC_CONTROL_HEAD_I | (shdlc->ns << 3) |
shdlc->nr;
pr_debug("Sending I-Frame %d, waiting to rcv %d\n", shdlc->ns,
shdlc->nr);
/* SHDLC_DUMP_SKB("shdlc frame written", skb); */
nfc_shdlc_add_len_crc(skb);
r = shdlc->ops->xmit(shdlc, skb);
if (r < 0) {
/*
* TODO: Cannot send, shdlc machine is dead, we
* must propagate the information up to HCI.
*/
shdlc->hard_fault = r;
break;
}
shdlc->ns = (shdlc->ns + 1) % 8;
time_sent = jiffies;
*(unsigned long *)skb->cb = time_sent;
skb_queue_tail(&shdlc->ack_pending_q, skb);
if (shdlc->t2_active == false) {
shdlc->t2_active = true;
mod_timer(&shdlc->t2_timer, time_sent +
msecs_to_jiffies(SHDLC_T2_VALUE_MS));
pr_debug("Started T2 (retransmit)\n");
}
}
}
static void nfc_shdlc_connect_timeout(unsigned long data)
{
struct nfc_shdlc *shdlc = (struct nfc_shdlc *)data;
pr_debug("\n");
queue_work(shdlc->sm_wq, &shdlc->sm_work);
}
static void nfc_shdlc_t1_timeout(unsigned long data)
{
struct nfc_shdlc *shdlc = (struct nfc_shdlc *)data;
pr_debug("SoftIRQ: need to send ack\n");
queue_work(shdlc->sm_wq, &shdlc->sm_work);
}
static void nfc_shdlc_t2_timeout(unsigned long data)
{
struct nfc_shdlc *shdlc = (struct nfc_shdlc *)data;
pr_debug("SoftIRQ: need to retransmit\n");
queue_work(shdlc->sm_wq, &shdlc->sm_work);
}
static void nfc_shdlc_sm_work(struct work_struct *work)
{
struct nfc_shdlc *shdlc = container_of(work, struct nfc_shdlc, sm_work);
int r;
pr_debug("\n");
mutex_lock(&shdlc->state_mutex);
switch (shdlc->state) {
case SHDLC_DISCONNECTED:
skb_queue_purge(&shdlc->rcv_q);
skb_queue_purge(&shdlc->send_q);
skb_queue_purge(&shdlc->ack_pending_q);
break;
case SHDLC_CONNECTING:
if (shdlc->connect_tries++ < 5)
r = nfc_shdlc_connect_initiate(shdlc);
else
r = -ETIME;
if (r < 0)
nfc_shdlc_connect_complete(shdlc, r);
else {
mod_timer(&shdlc->connect_timer, jiffies +
msecs_to_jiffies(SHDLC_CONNECT_VALUE_MS));
shdlc->state = SHDLC_NEGOCIATING;
}
break;
case SHDLC_NEGOCIATING:
if (timer_pending(&shdlc->connect_timer) == 0) {
shdlc->state = SHDLC_CONNECTING;
queue_work(shdlc->sm_wq, &shdlc->sm_work);
}
nfc_shdlc_handle_rcv_queue(shdlc);
break;
case SHDLC_CONNECTED:
nfc_shdlc_handle_rcv_queue(shdlc);
nfc_shdlc_handle_send_queue(shdlc);
if (shdlc->t1_active && timer_pending(&shdlc->t1_timer) == 0) {
pr_debug
("Handle T1(send ack) elapsed (T1 now inactive)\n");
shdlc->t1_active = false;
r = nfc_shdlc_send_s_frame(shdlc, S_FRAME_RR,
shdlc->nr);
if (r < 0)
shdlc->hard_fault = r;
}
if (shdlc->t2_active && timer_pending(&shdlc->t2_timer) == 0) {
pr_debug
("Handle T2(retransmit) elapsed (T2 inactive)\n");
shdlc->t2_active = false;
nfc_shdlc_requeue_ack_pending(shdlc);
nfc_shdlc_handle_send_queue(shdlc);
}
if (shdlc->hard_fault) {
/*
* TODO: Handle hard_fault that occured during
* this invocation of the shdlc worker
*/
}
break;
default:
break;
}
mutex_unlock(&shdlc->state_mutex);
}
/*
* Called from syscall context to establish shdlc link. Sleeps until
* link is ready or failure.
*/
static int nfc_shdlc_connect(struct nfc_shdlc *shdlc)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(connect_wq);
pr_debug("\n");
mutex_lock(&shdlc->state_mutex);
shdlc->state = SHDLC_CONNECTING;
shdlc->connect_wq = &connect_wq;
shdlc->connect_tries = 0;
shdlc->connect_result = 1;
mutex_unlock(&shdlc->state_mutex);
queue_work(shdlc->sm_wq, &shdlc->sm_work);
wait_event(connect_wq, shdlc->connect_result != 1);
return shdlc->connect_result;
}
static void nfc_shdlc_disconnect(struct nfc_shdlc *shdlc)
{
pr_debug("\n");
mutex_lock(&shdlc->state_mutex);
shdlc->state = SHDLC_DISCONNECTED;
mutex_unlock(&shdlc->state_mutex);
queue_work(shdlc->sm_wq, &shdlc->sm_work);
}
/*
* Receive an incoming shdlc frame. Frame has already been crc-validated.
* skb contains only LLC header and payload.
* If skb == NULL, it is a notification that the link below is dead.
*/
void nfc_shdlc_recv_frame(struct nfc_shdlc *shdlc, struct sk_buff *skb)
{
if (skb == NULL) {
pr_err("NULL Frame -> link is dead\n");
shdlc->hard_fault = -EREMOTEIO;
} else {
SHDLC_DUMP_SKB("incoming frame", skb);
skb_queue_tail(&shdlc->rcv_q, skb);
}
queue_work(shdlc->sm_wq, &shdlc->sm_work);
}
EXPORT_SYMBOL(nfc_shdlc_recv_frame);
static int nfc_shdlc_open(struct nfc_hci_dev *hdev)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
int r;
pr_debug("\n");
if (shdlc->ops->open) {
r = shdlc->ops->open(shdlc);
if (r < 0)
return r;
}
r = nfc_shdlc_connect(shdlc);
if (r < 0 && shdlc->ops->close)
shdlc->ops->close(shdlc);
return r;
}
static void nfc_shdlc_close(struct nfc_hci_dev *hdev)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
pr_debug("\n");
nfc_shdlc_disconnect(shdlc);
if (shdlc->ops->close)
shdlc->ops->close(shdlc);
}
static int nfc_shdlc_hci_ready(struct nfc_hci_dev *hdev)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
int r = 0;
pr_debug("\n");
if (shdlc->ops->hci_ready)
r = shdlc->ops->hci_ready(shdlc);
return r;
}
static int nfc_shdlc_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
SHDLC_DUMP_SKB("queuing HCP packet to shdlc", skb);
skb_queue_tail(&shdlc->send_q, skb);
queue_work(shdlc->sm_wq, &shdlc->sm_work);
return 0;
}
static int nfc_shdlc_start_poll(struct nfc_hci_dev *hdev, u32 protocols)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
pr_debug("\n");
if (shdlc->ops->start_poll)
return shdlc->ops->start_poll(shdlc, protocols);
return 0;
}
static int nfc_shdlc_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
struct nfc_target *target)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
if (shdlc->ops->target_from_gate)
return shdlc->ops->target_from_gate(shdlc, gate, target);
return -EPERM;
}
static int nfc_shdlc_complete_target_discovered(struct nfc_hci_dev *hdev,
u8 gate,
struct nfc_target *target)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
pr_debug("\n");
if (shdlc->ops->complete_target_discovered)
return shdlc->ops->complete_target_discovered(shdlc, gate,
target);
return 0;
}
static int nfc_shdlc_data_exchange(struct nfc_hci_dev *hdev,
struct nfc_target *target,
struct sk_buff *skb,
struct sk_buff **res_skb)
{
struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
if (shdlc->ops->data_exchange)
return shdlc->ops->data_exchange(shdlc, target, skb, res_skb);
return -EPERM;
}
static struct nfc_hci_ops shdlc_ops = {
.open = nfc_shdlc_open,
.close = nfc_shdlc_close,
.hci_ready = nfc_shdlc_hci_ready,
.xmit = nfc_shdlc_xmit,
.start_poll = nfc_shdlc_start_poll,
.target_from_gate = nfc_shdlc_target_from_gate,
.complete_target_discovered = nfc_shdlc_complete_target_discovered,
.data_exchange = nfc_shdlc_data_exchange,
};
struct nfc_shdlc *nfc_shdlc_allocate(struct nfc_shdlc_ops *ops,
struct nfc_hci_init_data *init_data,
u32 protocols,
int tx_headroom, int tx_tailroom,
int max_link_payload, const char *devname)
{
struct nfc_shdlc *shdlc;
int r;
char name[32];
if (ops->xmit == NULL)
return NULL;
shdlc = kzalloc(sizeof(struct nfc_shdlc), GFP_KERNEL);
if (shdlc == NULL)
return NULL;
mutex_init(&shdlc->state_mutex);
shdlc->ops = ops;
shdlc->state = SHDLC_DISCONNECTED;
init_timer(&shdlc->connect_timer);
shdlc->connect_timer.data = (unsigned long)shdlc;
shdlc->connect_timer.function = nfc_shdlc_connect_timeout;
init_timer(&shdlc->t1_timer);
shdlc->t1_timer.data = (unsigned long)shdlc;
shdlc->t1_timer.function = nfc_shdlc_t1_timeout;
init_timer(&shdlc->t2_timer);
shdlc->t2_timer.data = (unsigned long)shdlc;
shdlc->t2_timer.function = nfc_shdlc_t2_timeout;
shdlc->w = SHDLC_MAX_WINDOW;
shdlc->srej_support = SHDLC_SREJ_SUPPORT;
skb_queue_head_init(&shdlc->rcv_q);
skb_queue_head_init(&shdlc->send_q);
skb_queue_head_init(&shdlc->ack_pending_q);
INIT_WORK(&shdlc->sm_work, nfc_shdlc_sm_work);
snprintf(name, sizeof(name), "%s_shdlc_sm_wq", devname);
shdlc->sm_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND |
WQ_MEM_RECLAIM, 1);
if (shdlc->sm_wq == NULL)
goto err_allocwq;
shdlc->client_headroom = tx_headroom;
shdlc->client_tailroom = tx_tailroom;
shdlc->hdev = nfc_hci_allocate_device(&shdlc_ops, init_data, protocols,
tx_headroom + SHDLC_LLC_HEAD_ROOM,
tx_tailroom + SHDLC_LLC_TAIL_ROOM,
max_link_payload);
if (shdlc->hdev == NULL)
goto err_allocdev;
nfc_hci_set_clientdata(shdlc->hdev, shdlc);
r = nfc_hci_register_device(shdlc->hdev);
if (r < 0)
goto err_regdev;
return shdlc;
err_regdev:
nfc_hci_free_device(shdlc->hdev);
err_allocdev:
destroy_workqueue(shdlc->sm_wq);
err_allocwq:
kfree(shdlc);
return NULL;
}
EXPORT_SYMBOL(nfc_shdlc_allocate);
void nfc_shdlc_free(struct nfc_shdlc *shdlc)
{
pr_debug("\n");
/* TODO: Check that this cannot be called while still in use */
nfc_hci_unregister_device(shdlc->hdev);
nfc_hci_free_device(shdlc->hdev);
destroy_workqueue(shdlc->sm_wq);
skb_queue_purge(&shdlc->rcv_q);
skb_queue_purge(&shdlc->send_q);
skb_queue_purge(&shdlc->ack_pending_q);
kfree(shdlc);
}
EXPORT_SYMBOL(nfc_shdlc_free);
void nfc_shdlc_set_clientdata(struct nfc_shdlc *shdlc, void *clientdata)
{
pr_debug("\n");
shdlc->clientdata = clientdata;
}
EXPORT_SYMBOL(nfc_shdlc_set_clientdata);
void *nfc_shdlc_get_clientdata(struct nfc_shdlc *shdlc)
{
return shdlc->clientdata;
}
EXPORT_SYMBOL(nfc_shdlc_get_clientdata);
struct nfc_hci_dev *nfc_shdlc_get_hci_dev(struct nfc_shdlc *shdlc)
{
return shdlc->hdev;
}
EXPORT_SYMBOL(nfc_shdlc_get_hci_dev);

8
net/nfc/llcp/commands.c
View file

@ -102,7 +102,7 @@ u8 *nfc_llcp_build_tlv(u8 type, u8 *value, u8 value_length, u8 *tlv_length)
length = llcp_tlv_length[type];
if (length == 0 && value_length == 0)
return NULL;
else
else if (length == 0)
length = value_length;
*tlv_length = 2 + length;
@ -248,7 +248,7 @@ int nfc_llcp_disconnect(struct nfc_llcp_sock *sock)
skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
skb = llcp_add_header(skb, sock->ssap, sock->dsap, LLCP_PDU_DISC);
skb = llcp_add_header(skb, sock->dsap, sock->ssap, LLCP_PDU_DISC);
skb_queue_tail(&local->tx_queue, skb);
@ -416,7 +416,7 @@ int nfc_llcp_send_dm(struct nfc_llcp_local *local, u8 ssap, u8 dsap, u8 reason)
skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
skb = llcp_add_header(skb, ssap, dsap, LLCP_PDU_DM);
skb = llcp_add_header(skb, dsap, ssap, LLCP_PDU_DM);
memcpy(skb_put(skb, 1), &reason, 1);
@ -522,7 +522,7 @@ int nfc_llcp_send_rr(struct nfc_llcp_sock *sock)
skb_put(skb, LLCP_SEQUENCE_SIZE);
skb->data[2] = sock->recv_n % 16;
skb->data[2] = sock->recv_n;
skb_queue_head(&local->tx_queue, skb);

21
net/nfc/llcp/llcp.c
View file

@ -307,6 +307,8 @@ static int nfc_llcp_build_gb(struct nfc_llcp_local *local)
u8 *gb_cur, *version_tlv, version, version_length;
u8 *lto_tlv, lto, lto_length;
u8 *wks_tlv, wks_length;
u8 *miux_tlv, miux_length;
__be16 miux;
u8 gb_len = 0;
version = LLCP_VERSION_11;
@ -316,7 +318,7 @@ static int nfc_llcp_build_gb(struct nfc_llcp_local *local)
/* 1500 ms */
lto = 150;
lto_tlv = nfc_llcp_build_tlv(LLCP_TLV_VERSION, &lto, 1, &lto_length);
lto_tlv = nfc_llcp_build_tlv(LLCP_TLV_LTO, &lto, 1, &lto_length);
gb_len += lto_length;
pr_debug("Local wks 0x%lx\n", local->local_wks);
@ -324,6 +326,11 @@ static int nfc_llcp_build_gb(struct nfc_llcp_local *local)
&wks_length);
gb_len += wks_length;
miux = cpu_to_be16(LLCP_MAX_MIUX);
miux_tlv = nfc_llcp_build_tlv(LLCP_TLV_MIUX, (u8 *)&miux, 0,
&miux_length);
gb_len += miux_length;
gb_len += ARRAY_SIZE(llcp_magic);
if (gb_len > NFC_MAX_GT_LEN) {
@ -345,6 +352,9 @@ static int nfc_llcp_build_gb(struct nfc_llcp_local *local)
memcpy(gb_cur, wks_tlv, wks_length);
gb_cur += wks_length;
memcpy(gb_cur, miux_tlv, miux_length);
gb_cur += miux_length;
kfree(version_tlv);
kfree(lto_tlv);
@ -388,6 +398,9 @@ static void nfc_llcp_tx_work(struct work_struct *work)
skb = skb_dequeue(&local->tx_queue);
if (skb != NULL) {
pr_debug("Sending pending skb\n");
print_hex_dump(KERN_DEBUG, "LLCP Tx: ", DUMP_PREFIX_OFFSET,
16, 1, skb->data, skb->len, true);
nfc_data_exchange(local->dev, local->target_idx,
skb, nfc_llcp_recv, local);
} else {
@ -425,7 +438,7 @@ static u8 nfc_llcp_nr(struct sk_buff *pdu)
static void nfc_llcp_set_nrns(struct nfc_llcp_sock *sock, struct sk_buff *pdu)
{
pdu->data[2] = (sock->send_n << 4) | (sock->recv_n % 16);
pdu->data[2] = (sock->send_n << 4) | (sock->recv_n);
sock->send_n = (sock->send_n + 1) % 16;
sock->recv_ack_n = (sock->recv_n - 1) % 16;
}
@ -814,6 +827,10 @@ static void nfc_llcp_rx_work(struct work_struct *work)
pr_debug("ptype 0x%x dsap 0x%x ssap 0x%x\n", ptype, dsap, ssap);
if (ptype != LLCP_PDU_SYMM)
print_hex_dump(KERN_DEBUG, "LLCP Rx: ", DUMP_PREFIX_OFFSET,
16, 1, skb->data, skb->len, true);
switch (ptype) {
case LLCP_PDU_SYMM:
pr_debug("SYMM\n");

2
net/nfc/nci/core.c
View file

@ -477,7 +477,7 @@ static int nci_activate_target(struct nfc_dev *nfc_dev, __u32 target_idx,
}
if (atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) {
param.rf_discovery_id = target->idx;
param.rf_discovery_id = target->logical_idx;
if (protocol == NFC_PROTO_JEWEL)
param.rf_protocol = NCI_RF_PROTOCOL_T1T;

11
net/nfc/nci/ntf.c
View file

@ -227,7 +227,7 @@ static void nci_add_new_target(struct nci_dev *ndev,
for (i = 0; i < ndev->n_targets; i++) {
target = &ndev->targets[i];
if (target->idx == ntf->rf_discovery_id) {
if (target->logical_idx == ntf->rf_discovery_id) {
/* This target already exists, add the new protocol */
nci_add_new_protocol(ndev, target, ntf->rf_protocol,
ntf->rf_tech_and_mode,
@ -248,10 +248,10 @@ static void nci_add_new_target(struct nci_dev *ndev,
ntf->rf_tech_and_mode,
&ntf->rf_tech_specific_params);
if (!rc) {
target->idx = ntf->rf_discovery_id;
target->logical_idx = ntf->rf_discovery_id;
ndev->n_targets++;
pr_debug("target_idx %d, n_targets %d\n", target->idx,
pr_debug("logical idx %d, n_targets %d\n", target->logical_idx,
ndev->n_targets);
}
}
@ -372,10 +372,11 @@ static void nci_target_auto_activated(struct nci_dev *ndev,
if (rc)
return;
target->idx = ntf->rf_discovery_id;
target->logical_idx = ntf->rf_discovery_id;
ndev->n_targets++;
pr_debug("target_idx %d, n_targets %d\n", target->idx, ndev->n_targets);
pr_debug("logical idx %d, n_targets %d\n",
target->logical_idx, ndev->n_targets);
nfc_targets_found(ndev->nfc_dev, ndev->targets, ndev->n_targets);
}

31
net/nfc/netlink.c
View file

@ -188,6 +188,37 @@ free_msg:
return -EMSGSIZE;
}
int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_TARGET_LOST);
if (!hdr)
goto free_msg;
if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
return 0;
nla_put_failure:
genlmsg_cancel(msg, hdr);
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
int nfc_genl_device_added(struct nfc_dev *dev)
{
struct sk_buff *msg;

1
net/nfc/nfc.h
View file

@ -119,6 +119,7 @@ void nfc_genl_data_init(struct nfc_genl_data *genl_data);
void nfc_genl_data_exit(struct nfc_genl_data *genl_data);
int nfc_genl_targets_found(struct nfc_dev *dev);
int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx);
int nfc_genl_device_added(struct nfc_dev *dev);
int nfc_genl_device_removed(struct nfc_dev *dev);

6
net/nfc/rawsock.c
View file

@ -92,6 +92,12 @@ static int rawsock_connect(struct socket *sock, struct sockaddr *_addr,
goto error;
}
if (addr->target_idx > dev->target_next_idx - 1 ||
addr->target_idx < dev->target_next_idx - dev->n_targets) {
rc = -EINVAL;
goto error;
}
rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
if (rc)
goto put_dev;