Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273// SPDX-License-Identifier: GPL-2.0-or-later/* * Copyright (C) 2011 Instituto Nokia de Tecnologia * * Authors: * Lauro Ramos Venancio <lauro.venancio@openbossa.org> * Aloisio Almeida Jr <aloisio.almeida@openbossa.org> */
#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
#include <linux/init.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/slab.h>#include <linux/rfkill.h>#include <linux/nfc.h>
#include <net/genetlink.h>
#include "nfc.h"
#define VERSION "0.1"
#define NFC_CHECK_PRES_FREQ_MS 2000
int nfc_devlist_generation;DEFINE_MUTEX(nfc_devlist_mutex);
/* NFC device ID bitmap */static DEFINE_IDA(nfc_index_ida);
int nfc_fw_download(struct nfc_dev *dev, const char *firmware_name){ int rc = 0;
pr_debug("%s do firmware %s\n", dev_name(&dev->dev), firmware_name);
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (dev->dev_up) { rc = -EBUSY; goto error; }
if (!dev->ops->fw_download) { rc = -EOPNOTSUPP; goto error; }
dev->fw_download_in_progress = true; rc = dev->ops->fw_download(dev, firmware_name); if (rc) dev->fw_download_in_progress = false;
error: device_unlock(&dev->dev); return rc;}
/** * nfc_fw_download_done - inform that a firmware download was completed * * @dev: The nfc device to which firmware was downloaded * @firmware_name: The firmware filename * @result: The positive value of a standard errno value */int nfc_fw_download_done(struct nfc_dev *dev, const char *firmware_name, u32 result){ dev->fw_download_in_progress = false;
return nfc_genl_fw_download_done(dev, firmware_name, result);}EXPORT_SYMBOL(nfc_fw_download_done);
/** * nfc_dev_up - turn on the NFC device * * @dev: The nfc device to be turned on * * The device remains up until the nfc_dev_down function is called. */int nfc_dev_up(struct nfc_dev *dev){ int rc = 0;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (dev->rfkill && rfkill_blocked(dev->rfkill)) { rc = -ERFKILL; goto error; }
if (dev->fw_download_in_progress) { rc = -EBUSY; goto error; }
if (dev->dev_up) { rc = -EALREADY; goto error; }
if (dev->ops->dev_up) rc = dev->ops->dev_up(dev);
if (!rc) dev->dev_up = true;
/* We have to enable the device before discovering SEs */ if (dev->ops->discover_se && dev->ops->discover_se(dev)) pr_err("SE discovery failed\n");
error: device_unlock(&dev->dev); return rc;}
/** * nfc_dev_down - turn off the NFC device * * @dev: The nfc device to be turned off */int nfc_dev_down(struct nfc_dev *dev){ int rc = 0;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (!dev->dev_up) { rc = -EALREADY; goto error; }
if (dev->polling || dev->active_target) { rc = -EBUSY; goto error; }
if (dev->ops->dev_down) dev->ops->dev_down(dev);
dev->dev_up = false;
error: device_unlock(&dev->dev); return rc;}
static int nfc_rfkill_set_block(void *data, bool blocked){ struct nfc_dev *dev = data;
pr_debug("%s blocked %d", dev_name(&dev->dev), blocked);
if (!blocked) return 0;
nfc_dev_down(dev);
return 0;}
static const struct rfkill_ops nfc_rfkill_ops = { .set_block = nfc_rfkill_set_block,};
/** * nfc_start_poll - start polling for nfc targets * * @dev: The nfc device that must start polling * @im_protocols: bitset of nfc initiator protocols to be used for polling * @tm_protocols: bitset of nfc transport protocols to be used for polling * * The device remains polling for targets until a target is found or * the nfc_stop_poll function is called. */int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols){ int rc;
pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n", dev_name(&dev->dev), im_protocols, tm_protocols);
if (!im_protocols && !tm_protocols) return -EINVAL;
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (!dev->dev_up) { rc = -ENODEV; goto error; }
if (dev->polling) { rc = -EBUSY; goto error; }
rc = dev->ops->start_poll(dev, im_protocols, tm_protocols); if (!rc) { dev->polling = true; dev->rf_mode = NFC_RF_NONE; }
error: device_unlock(&dev->dev); return rc;}
/** * nfc_stop_poll - stop polling for nfc targets * * @dev: The nfc device that must stop polling */int nfc_stop_poll(struct nfc_dev *dev){ int rc = 0;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (!dev->polling) { rc = -EINVAL; goto error; }
dev->ops->stop_poll(dev); dev->polling = false; dev->rf_mode = NFC_RF_NONE;
error: device_unlock(&dev->dev); return rc;}
static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx){ int i;
for (i = 0; i < dev->n_targets; i++) { if (dev->targets[i].idx == target_idx) return &dev->targets[i]; }
return NULL;}
int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode){ struct nfc_target *target; u8 gb[NFC_MAX_GT_LEN]; size_t gb_len = 0; int rc = 0;
pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode);
if (!dev->ops->dep_link_up) return -EOPNOTSUPP;
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (dev->dep_link_up == true) { rc = -EALREADY; goto error; }
nfc_get_local_general_bytes(dev, gb, sizeof(gb), &gb_len); if (gb_len > NFC_MAX_GT_LEN) { rc = -EINVAL; goto error; }
target = nfc_find_target(dev, target_index); if (target == NULL) { rc = -ENOTCONN; goto error; }
rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len); if (!rc) { dev->active_target = target; dev->rf_mode = NFC_RF_INITIATOR; }
error: device_unlock(&dev->dev); return rc;}
int nfc_dep_link_down(struct nfc_dev *dev){ int rc = 0;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
if (!dev->ops->dep_link_down) return -EOPNOTSUPP;
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (dev->dep_link_up == false) { rc = -EALREADY; goto error; }
rc = dev->ops->dep_link_down(dev); if (!rc) { dev->dep_link_up = false; dev->active_target = NULL; dev->rf_mode = NFC_RF_NONE; nfc_llcp_mac_is_down(dev); nfc_genl_dep_link_down_event(dev); }
error: device_unlock(&dev->dev);
return rc;}
int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx, u8 comm_mode, u8 rf_mode){ dev->dep_link_up = true;
if (!dev->active_target && rf_mode == NFC_RF_INITIATOR) { struct nfc_target *target;
target = nfc_find_target(dev, target_idx); if (target == NULL) return -ENOTCONN;
dev->active_target = target; }
dev->polling = false; dev->rf_mode = rf_mode;
nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode);
return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode);}EXPORT_SYMBOL(nfc_dep_link_is_up);
/** * nfc_activate_target - prepare the target for data exchange * * @dev: The nfc device that found the target * @target_idx: index of the target that must be activated * @protocol: nfc protocol that will be used for data exchange */int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol){ int rc; struct nfc_target *target;
pr_debug("dev_name=%s target_idx=%u protocol=%u\n", dev_name(&dev->dev), target_idx, protocol);
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (dev->active_target) { rc = -EBUSY; goto error; }
target = nfc_find_target(dev, target_idx); if (target == NULL) { rc = -ENOTCONN; goto error; }
rc = dev->ops->activate_target(dev, target, protocol); if (!rc) { dev->active_target = target; dev->rf_mode = NFC_RF_INITIATOR;
if (dev->ops->check_presence && !dev->shutting_down) mod_timer(&dev->check_pres_timer, jiffies + msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); }
error: device_unlock(&dev->dev); return rc;}
/** * nfc_deactivate_target - deactivate a nfc target * * @dev: The nfc device that found the target * @target_idx: index of the target that must be deactivated * @mode: idle or sleep? */int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx, u8 mode){ int rc = 0;
pr_debug("dev_name=%s target_idx=%u\n", dev_name(&dev->dev), target_idx);
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (dev->active_target == NULL) { rc = -ENOTCONN; goto error; }
if (dev->active_target->idx != target_idx) { rc = -ENOTCONN; goto error; }
if (dev->ops->check_presence) timer_delete_sync(&dev->check_pres_timer);
dev->ops->deactivate_target(dev, dev->active_target, mode); dev->active_target = NULL;
error: device_unlock(&dev->dev); return rc;}
/** * nfc_data_exchange - transceive data * * @dev: The nfc device that found the target * @target_idx: index of the target * @skb: data to be sent * @cb: callback called when the response is received * @cb_context: parameter for the callback function * * The user must wait for the callback before calling this function again. */int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb, data_exchange_cb_t cb, void *cb_context){ int rc;
pr_debug("dev_name=%s target_idx=%u skb->len=%u\n", dev_name(&dev->dev), target_idx, skb->len);
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; kfree_skb(skb); goto error; }
if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) { if (dev->active_target->idx != target_idx) { rc = -EADDRNOTAVAIL; kfree_skb(skb); goto error; }
if (dev->ops->check_presence) timer_delete_sync(&dev->check_pres_timer);
rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb, cb_context);
if (!rc && dev->ops->check_presence && !dev->shutting_down) mod_timer(&dev->check_pres_timer, jiffies + msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); } else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) { rc = dev->ops->tm_send(dev, skb); } else { rc = -ENOTCONN; kfree_skb(skb); goto error; }
error: device_unlock(&dev->dev); return rc;}
struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx){ struct nfc_se *se;
list_for_each_entry(se, &dev->secure_elements, list) if (se->idx == se_idx) return se;
return NULL;}EXPORT_SYMBOL(nfc_find_se);
int nfc_enable_se(struct nfc_dev *dev, u32 se_idx){ struct nfc_se *se; int rc;
pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (!dev->dev_up) { rc = -ENODEV; goto error; }
if (dev->polling) { rc = -EBUSY; goto error; }
if (!dev->ops->enable_se || !dev->ops->disable_se) { rc = -EOPNOTSUPP; goto error; }
se = nfc_find_se(dev, se_idx); if (!se) { rc = -EINVAL; goto error; }
if (se->state == NFC_SE_ENABLED) { rc = -EALREADY; goto error; }
rc = dev->ops->enable_se(dev, se_idx); if (rc >= 0) se->state = NFC_SE_ENABLED;
error: device_unlock(&dev->dev); return rc;}
int nfc_disable_se(struct nfc_dev *dev, u32 se_idx){ struct nfc_se *se; int rc;
pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
device_lock(&dev->dev);
if (dev->shutting_down) { rc = -ENODEV; goto error; }
if (!dev->dev_up) { rc = -ENODEV; goto error; }
if (!dev->ops->enable_se || !dev->ops->disable_se) { rc = -EOPNOTSUPP; goto error; }
se = nfc_find_se(dev, se_idx); if (!se) { rc = -EINVAL; goto error; }
if (se->state == NFC_SE_DISABLED) { rc = -EALREADY; goto error; }
rc = dev->ops->disable_se(dev, se_idx); if (rc >= 0) se->state = NFC_SE_DISABLED;
error: device_unlock(&dev->dev); return rc;}
int nfc_set_remote_general_bytes(struct nfc_dev *dev, const u8 *gb, u8 gb_len){ pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len);
return nfc_llcp_set_remote_gb(dev, gb, gb_len);}EXPORT_SYMBOL(nfc_set_remote_general_bytes);
u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, u8 *out_gb, size_t gb_max_len, size_t *gb_len){ return nfc_llcp_general_bytes(dev, out_gb, gb_max_len, gb_len);}EXPORT_SYMBOL(nfc_get_local_general_bytes);
int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb){ /* Only LLCP target mode for now */ if (dev->dep_link_up == false) { kfree_skb(skb); return -ENOLINK; }
return nfc_llcp_data_received(dev, skb);}EXPORT_SYMBOL(nfc_tm_data_received);
int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode, const u8 *gb, size_t gb_len){ int rc;
device_lock(&dev->dev);
dev->polling = false;
if (gb != NULL) { rc = nfc_set_remote_general_bytes(dev, gb, gb_len); if (rc < 0) goto out; }
dev->rf_mode = NFC_RF_TARGET;
if (protocol == NFC_PROTO_NFC_DEP_MASK) nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET);
rc = nfc_genl_tm_activated(dev, protocol);
out: device_unlock(&dev->dev);
return rc;}EXPORT_SYMBOL(nfc_tm_activated);
int nfc_tm_deactivated(struct nfc_dev *dev){ dev->dep_link_up = false; dev->rf_mode = NFC_RF_NONE;
return nfc_genl_tm_deactivated(dev);}EXPORT_SYMBOL(nfc_tm_deactivated);
/** * nfc_alloc_send_skb - allocate a skb for data exchange responses * * @dev: device sending the response * @sk: socket sending the response * @flags: MSG_DONTWAIT flag * @size: size to allocate * @err: pointer to memory to store the error code */struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk, unsigned int flags, unsigned int size, unsigned int *err){ struct sk_buff *skb; unsigned int total_size;
total_size = size + dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE;
skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err); if (skb) skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
return skb;}
/** * nfc_alloc_recv_skb - allocate a skb for data exchange responses * * @size: size to allocate * @gfp: gfp flags */struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp){ struct sk_buff *skb; unsigned int total_size;
total_size = size + 1; skb = alloc_skb(total_size, gfp);
if (skb) skb_reserve(skb, 1);
return skb;}EXPORT_SYMBOL(nfc_alloc_recv_skb);
/** * nfc_targets_found - inform that targets were found * * @dev: The nfc device that found the targets * @targets: array of nfc targets found * @n_targets: targets array size * * The device driver must call this function when one or many nfc targets * are found. After calling this function, the device driver must stop * polling for targets. * NOTE: This function can be called with targets=NULL and n_targets=0 to * notify a driver error, meaning that the polling operation cannot complete. * IMPORTANT: this function must not be called from an atomic context. * In addition, it must also not be called from a context that would prevent * the NFC Core to call other nfc ops entry point concurrently. */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);
for (i = 0; i < n_targets; i++) targets[i].idx = dev->target_next_idx++;
device_lock(&dev->dev);
if (dev->polling == false) { device_unlock(&dev->dev); return 0; }
dev->polling = false;
dev->targets_generation++;
kfree(dev->targets); dev->targets = NULL;
if (targets) { dev->targets = kmemdup(targets, n_targets * sizeof(struct nfc_target), GFP_ATOMIC);
if (!dev->targets) { dev->n_targets = 0; device_unlock(&dev->dev); return -ENOMEM; } }
dev->n_targets = n_targets; device_unlock(&dev->dev);
nfc_genl_targets_found(dev);
return 0;}EXPORT_SYMBOL(nfc_targets_found);
/** * nfc_target_lost - inform that an activated target went out of field * * @dev: The nfc device that had the activated target in field * @target_idx: the nfc index of the target * * The device driver must call this function when the activated target * goes out of the field. * IMPORTANT: this function must not be called from an atomic context. * In addition, it must also not be called from a context that would prevent * the NFC Core to call other nfc ops entry point concurrently. */int nfc_target_lost(struct nfc_dev *dev, u32 target_idx){ const struct nfc_target *tg; int i;
pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);
device_lock(&dev->dev);
for (i = 0; i < dev->n_targets; i++) { tg = &dev->targets[i]; if (tg->idx == target_idx) break; }
if (i == dev->n_targets) { device_unlock(&dev->dev); return -EINVAL; }
dev->targets_generation++; dev->n_targets--; dev->active_target = NULL;
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; }
device_unlock(&dev->dev);
nfc_genl_target_lost(dev, target_idx);
return 0;}EXPORT_SYMBOL(nfc_target_lost);
inline void nfc_driver_failure(struct nfc_dev *dev, int err){ nfc_targets_found(dev, NULL, 0);}EXPORT_SYMBOL(nfc_driver_failure);
int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type){ struct nfc_se *se; int rc;
pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
se = nfc_find_se(dev, se_idx); if (se) return -EALREADY;
se = kzalloc_obj(struct nfc_se); if (!se) return -ENOMEM;
se->idx = se_idx; se->type = type; se->state = NFC_SE_DISABLED; INIT_LIST_HEAD(&se->list);
list_add(&se->list, &dev->secure_elements);
rc = nfc_genl_se_added(dev, se_idx, type); if (rc < 0) { list_del(&se->list); kfree(se);
return rc; }
return 0;}EXPORT_SYMBOL(nfc_add_se);
int nfc_remove_se(struct nfc_dev *dev, u32 se_idx){ struct nfc_se *se, *n; int rc;
pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
list_for_each_entry_safe(se, n, &dev->secure_elements, list) if (se->idx == se_idx) { rc = nfc_genl_se_removed(dev, se_idx); if (rc < 0) return rc;
list_del(&se->list); kfree(se);
return 0; }
return -EINVAL;}EXPORT_SYMBOL(nfc_remove_se);
int nfc_se_transaction(struct nfc_dev *dev, u8 se_idx, struct nfc_evt_transaction *evt_transaction){ int rc;
pr_debug("transaction: %x\n", se_idx);
device_lock(&dev->dev);
if (!evt_transaction) { rc = -EPROTO; goto out; }
rc = nfc_genl_se_transaction(dev, se_idx, evt_transaction);out: device_unlock(&dev->dev); return rc;}EXPORT_SYMBOL(nfc_se_transaction);
int nfc_se_connectivity(struct nfc_dev *dev, u8 se_idx){ int rc;
pr_debug("connectivity: %x\n", se_idx);
device_lock(&dev->dev); rc = nfc_genl_se_connectivity(dev, se_idx); device_unlock(&dev->dev); return rc;}EXPORT_SYMBOL(nfc_se_connectivity);
static void nfc_release(struct device *d){ struct nfc_dev *dev = to_nfc_dev(d); struct nfc_se *se, *n;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
nfc_genl_data_exit(&dev->genl_data); kfree(dev->targets);
list_for_each_entry_safe(se, n, &dev->secure_elements, list) { nfc_genl_se_removed(dev, se->idx); list_del(&se->list); kfree(se); }
ida_free(&nfc_index_ida, dev->idx);
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->active_target && timer_pending(&dev->check_pres_timer) == 0) { rc = dev->ops->check_presence(dev, dev->active_target); if (rc == -EOPNOTSUPP) goto exit; if (rc) { u32 active_target_idx = dev->active_target->idx; device_unlock(&dev->dev); nfc_target_lost(dev, active_target_idx); return; }
if (!dev->shutting_down) mod_timer(&dev->check_pres_timer, jiffies + msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); }
exit: device_unlock(&dev->dev);}
static void nfc_check_pres_timeout(struct timer_list *t){ struct nfc_dev *dev = timer_container_of(dev, t, check_pres_timer);
schedule_work(&dev->check_pres_work);}
const struct class nfc_class = { .name = "nfc", .dev_release = nfc_release,};EXPORT_SYMBOL(nfc_class);
static int match_idx(struct device *d, const void *data){ struct nfc_dev *dev = to_nfc_dev(d); const unsigned int *idx = data;
return dev->idx == *idx;}
struct nfc_dev *nfc_get_device(unsigned int idx){ struct device *d;
d = class_find_device(&nfc_class, NULL, &idx, match_idx); if (!d) return NULL;
return to_nfc_dev(d);}
/** * nfc_allocate_device - allocate a new nfc device * * @ops: device operations * @supported_protocols: NFC protocols supported by the device * @tx_headroom: reserved space at beginning of skb * @tx_tailroom: reserved space at end of skb */struct nfc_dev *nfc_allocate_device(const struct nfc_ops *ops, u32 supported_protocols, int tx_headroom, int tx_tailroom){ struct nfc_dev *dev; int rc;
if (!ops->start_poll || !ops->stop_poll || !ops->activate_target || !ops->deactivate_target || !ops->im_transceive) return NULL;
if (!supported_protocols) return NULL;
dev = kzalloc_obj(struct nfc_dev); if (!dev) return NULL;
rc = ida_alloc(&nfc_index_ida, GFP_KERNEL); if (rc < 0) goto err_free_dev; dev->idx = rc;
dev->dev.class = &nfc_class; dev_set_name(&dev->dev, "nfc%d", dev->idx); device_initialize(&dev->dev);
dev->ops = ops; dev->supported_protocols = supported_protocols; dev->tx_headroom = tx_headroom; dev->tx_tailroom = tx_tailroom; INIT_LIST_HEAD(&dev->secure_elements);
nfc_genl_data_init(&dev->genl_data);
dev->rf_mode = NFC_RF_NONE;
/* first generation must not be 0 */ dev->targets_generation = 1;
if (ops->check_presence) { timer_setup(&dev->check_pres_timer, nfc_check_pres_timeout, 0); INIT_WORK(&dev->check_pres_work, nfc_check_pres_work); }
return dev;
err_free_dev: kfree(dev);
return NULL;}EXPORT_SYMBOL(nfc_allocate_device);
/** * nfc_register_device - register a nfc device in the nfc subsystem * * @dev: The nfc device to register */int nfc_register_device(struct nfc_dev *dev){ int rc;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
mutex_lock(&nfc_devlist_mutex); nfc_devlist_generation++; rc = device_add(&dev->dev); mutex_unlock(&nfc_devlist_mutex);
if (rc < 0) return rc;
rc = nfc_llcp_register_device(dev); if (rc) pr_err("Could not register llcp device\n");
device_lock(&dev->dev); dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev, RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev); if (dev->rfkill) { if (rfkill_register(dev->rfkill) < 0) { rfkill_destroy(dev->rfkill); dev->rfkill = NULL; } } dev->shutting_down = false; device_unlock(&dev->dev);
rc = nfc_genl_device_added(dev); if (rc) pr_debug("The userspace won't be notified that the device %s was added\n", dev_name(&dev->dev));
return 0;}EXPORT_SYMBOL(nfc_register_device);
/** * nfc_unregister_rfkill - unregister a nfc device in the rfkill subsystem * * @dev: The nfc device to unregister */void nfc_unregister_rfkill(struct nfc_dev *dev){ struct rfkill *rfk = NULL; int rc;
pr_debug("dev_name=%s\n", dev_name(&dev->dev));
rc = nfc_genl_device_removed(dev); if (rc) pr_debug("The userspace won't be notified that the device %s " "was removed\n", dev_name(&dev->dev));
device_lock(&dev->dev); if (dev->rfkill) { rfk = dev->rfkill; dev->rfkill = NULL; } dev->shutting_down = true; device_unlock(&dev->dev);
if (rfk) { rfkill_unregister(rfk); rfkill_destroy(rfk); }}EXPORT_SYMBOL(nfc_unregister_rfkill);
/** * nfc_remove_device - remove a nfc device in the nfc subsystem * * @dev: The nfc device to remove */void nfc_remove_device(struct nfc_dev *dev){ if (dev->ops->check_presence) { timer_delete_sync(&dev->check_pres_timer); cancel_work_sync(&dev->check_pres_work); }
nfc_llcp_unregister_device(dev);
mutex_lock(&nfc_devlist_mutex); nfc_devlist_generation++; device_del(&dev->dev); mutex_unlock(&nfc_devlist_mutex);}EXPORT_SYMBOL(nfc_remove_device);
/** * nfc_unregister_device - unregister a nfc device in the nfc subsystem * * @dev: The nfc device to unregister */void nfc_unregister_device(struct nfc_dev *dev){ nfc_unregister_rfkill(dev); nfc_remove_device(dev);}EXPORT_SYMBOL(nfc_unregister_device);
static int __init nfc_init(void){ int rc;
pr_info("NFC Core ver %s\n", VERSION);
rc = class_register(&nfc_class); if (rc) return rc;
rc = nfc_genl_init(); if (rc) goto err_genl;
/* the first generation must not be 0 */ nfc_devlist_generation = 1;
rc = rawsock_init(); if (rc) goto err_rawsock;
rc = nfc_llcp_init(); if (rc) goto err_llcp_sock;
rc = af_nfc_init(); if (rc) goto err_af_nfc;
return 0;
err_af_nfc: nfc_llcp_exit();err_llcp_sock: rawsock_exit();err_rawsock: nfc_genl_exit();err_genl: class_unregister(&nfc_class); return rc;}
static void __exit nfc_exit(void){ af_nfc_exit(); nfc_llcp_exit(); rawsock_exit(); nfc_genl_exit(); class_unregister(&nfc_class);}
subsys_initcall(nfc_init);module_exit(nfc_exit);
MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");MODULE_DESCRIPTION("NFC Core ver " VERSION);MODULE_VERSION(VERSION);MODULE_LICENSE("GPL");MODULE_ALIAS_NETPROTO(PF_NFC);MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME);