Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...
authorDavid Vrabel <david.vrabel@csr.com>
Mon, 8 Dec 2008 16:18:47 +0000 (16:18 +0000)
committerDavid Vrabel <david.vrabel@csr.com>
Mon, 8 Dec 2008 16:18:47 +0000 (16:18 +0000)
57 files changed:
Documentation/ABI/testing/sysfs-class-uwb_rc
Documentation/usb/wusb-cbaf
drivers/usb/host/hwa-hc.c
drivers/usb/host/whci/Kbuild
drivers/usb/host/whci/asl.c
drivers/usb/host/whci/debug.c [new file with mode: 0644]
drivers/usb/host/whci/hcd.c
drivers/usb/host/whci/hw.c
drivers/usb/host/whci/int.c
drivers/usb/host/whci/pzl.c
drivers/usb/host/whci/qset.c
drivers/usb/host/whci/whcd.h
drivers/usb/host/whci/whci-hc.h
drivers/usb/host/whci/wusb.c
drivers/usb/wusbcore/cbaf.c
drivers/usb/wusbcore/crypto.c
drivers/usb/wusbcore/devconnect.c
drivers/usb/wusbcore/mmc.c
drivers/usb/wusbcore/pal.c
drivers/usb/wusbcore/reservation.c
drivers/usb/wusbcore/rh.c
drivers/usb/wusbcore/security.c
drivers/usb/wusbcore/wusbhc.h
drivers/uwb/Makefile
drivers/uwb/beacon.c
drivers/uwb/driver.c
drivers/uwb/drp-ie.c
drivers/uwb/drp.c
drivers/uwb/hwa-rc.c
drivers/uwb/i1480/dfu/usb.c
drivers/uwb/i1480/i1480u-wlp/lc.c
drivers/uwb/i1480/i1480u-wlp/netdev.c
drivers/uwb/i1480/i1480u-wlp/sysfs.c
drivers/uwb/ie-rcv.c [new file with mode: 0644]
drivers/uwb/ie.c
drivers/uwb/lc-rc.c
drivers/uwb/neh.c
drivers/uwb/pal.c
drivers/uwb/radio.c [new file with mode: 0644]
drivers/uwb/reset.c
drivers/uwb/rsv.c
drivers/uwb/umc-bus.c
drivers/uwb/umc-dev.c
drivers/uwb/uwb-debug.c
drivers/uwb/uwb-internal.h
drivers/uwb/uwbd.c
drivers/uwb/whc-rc.c
drivers/uwb/whci.c
drivers/uwb/wlp/wlp-internal.h
drivers/uwb/wlp/wlp-lc.c
include/linux/usb/wusb-wa.h
include/linux/uwb.h
include/linux/uwb/debug-cmd.h
include/linux/uwb/debug.h
include/linux/uwb/spec.h
include/linux/uwb/umc.h
include/linux/wlp.h

index a0d18dbeb7a9ea8d02565ebd0c2040c72e224668..6a5fd072849d7d7b402bd0a141a21dc5ece97fe3 100644 (file)
@@ -32,14 +32,16 @@ Contact:        linux-usb@vger.kernel.org
 Description:
                 Write:
 
-                <channel> [<bpst offset>]
+                <channel>
 
-                to start beaconing on a specific channel, or stop
-                beaconing if <channel> is -1.  Valid channels depends
-                on the radio controller's supported band groups.
+                to force a specific channel to be used when beaconing,
+                or, if <channel> is -1, to prohibit beaconing.  If
+                <channel> is 0, then the default channel selection
+                algorithm will be used.  Valid channels depends on the
+                radio controller's supported band groups.
 
-                <bpst offset> may be used to try and join a specific
-                beacon group if more than one was found during a scan.
+                Reading returns the currently active channel, or -1 if
+                the radio controller is not beaconing.
 
 What:           /sys/class/uwb_rc/uwbN/scan
 Date:           July 2008
index 2e78b70f3adccf8bc5f16c13990d042ec8c2b03f..426ddaaef96f423812579908992cc464b15044bf 100644 (file)
@@ -80,12 +80,6 @@ case $1 in
     start)
         for dev in ${2:-$hdevs}
           do
-          uwb_rc=$(readlink -f $dev/uwb_rc)
-          if cat $uwb_rc/beacon | grep -q -- "-1"
-              then
-              echo 13 0 > $uwb_rc/beacon
-              echo I: started beaconing on ch 13 on $(basename $uwb_rc) >&2
-          fi
           echo $host_CHID > $dev/wusb_chid
           echo I: started host $(basename $dev) >&2
         done
@@ -95,9 +89,6 @@ case $1 in
           do
           echo 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 > $dev/wusb_chid
           echo I: stopped host $(basename $dev) >&2
-          uwb_rc=$(readlink -f $dev/uwb_rc)
-          echo -1 | cat > $uwb_rc/beacon
-          echo I: stopped beaconing on $(basename $uwb_rc) >&2
         done
         ;;
     set-chid)
index 64be4d88df1111d23345943555c427e3df629fd6..2a4d36fa70b023971a6025ea82dc1cfbf4be2e3b 100644 (file)
@@ -54,7 +54,6 @@
  *                      DWA).
  */
 #include <linux/kernel.h>
-#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
@@ -171,11 +170,6 @@ static int hwahc_op_start(struct usb_hcd *usb_hcd)
        if (result < 0)
                goto error_set_cluster_id;
 
-       result = wa_nep_arm(&hwahc->wa, GFP_KERNEL);
-       if (result < 0) {
-               dev_err(dev, "cannot listen to notifications: %d\n", result);
-               goto error_stop;
-       }
        usb_hcd->uses_new_polling = 1;
        usb_hcd->poll_rh = 1;
        usb_hcd->state = HC_STATE_RUNNING;
@@ -185,8 +179,6 @@ out:
        d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
        return result;
 
-error_stop:
-       __wa_stop(&hwahc->wa);
 error_set_cluster_id:
        wusb_cluster_id_put(wusbhc->cluster_id);
 error_cluster_id_get:
@@ -194,39 +186,6 @@ error_cluster_id_get:
 
 }
 
-/*
- * FIXME: break this function up
- */
-static int __hwahc_op_wusbhc_start(struct wusbhc *wusbhc)
-{
-       int result;
-       struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
-       struct device *dev = &hwahc->wa.usb_iface->dev;
-
-       /* Set up a Host Info WUSB Information Element */
-       d_fnstart(4, dev, "(hwahc %p)\n", hwahc);
-       result = -ENOSPC;
-
-       result = __wa_set_feature(&hwahc->wa, WA_ENABLE);
-       if (result < 0) {
-               dev_err(dev, "error commanding HC to start: %d\n", result);
-               goto error_stop;
-       }
-       result = __wa_wait_status(&hwahc->wa, WA_ENABLE, WA_ENABLE);
-       if (result < 0) {
-               dev_err(dev, "error waiting for HC to start: %d\n", result);
-               goto error_stop;
-       }
-       result = 0;
-out:
-       d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
-       return result;
-
-error_stop:
-       result = __wa_clear_feature(&hwahc->wa, WA_ENABLE);
-       goto out;
-}
-
 static int hwahc_op_suspend(struct usb_hcd *usb_hcd, pm_message_t msg)
 {
        struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
@@ -246,18 +205,6 @@ static int hwahc_op_resume(struct usb_hcd *usb_hcd)
        return -ENOSYS;
 }
 
-static void __hwahc_op_wusbhc_stop(struct wusbhc *wusbhc)
-{
-       int result;
-       struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
-       struct device *dev = &hwahc->wa.usb_iface->dev;
-
-       d_fnstart(4, dev, "(hwahc %p)\n", hwahc);
-       /* Nothing for now */
-       d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
-       return;
-}
-
 /*
  * No need to abort pipes, as when this is called, all the children
  * has been disconnected and that has done it [through
@@ -274,9 +221,6 @@ static void hwahc_op_stop(struct usb_hcd *usb_hcd)
 
        d_fnstart(4, dev, "(hwahc %p)\n", hwahc);
        mutex_lock(&wusbhc->mutex);
-       wusbhc_stop(wusbhc);
-       wa_nep_disarm(&hwahc->wa);
-       result = __wa_stop(&hwahc->wa);
        wusb_cluster_id_put(wusbhc->cluster_id);
        mutex_unlock(&wusbhc->mutex);
        d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
@@ -325,6 +269,54 @@ static void hwahc_op_endpoint_disable(struct usb_hcd *usb_hcd,
        rpipe_ep_disable(&hwahc->wa, ep);
 }
 
+static int __hwahc_op_wusbhc_start(struct wusbhc *wusbhc)
+{
+       int result;
+       struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
+       struct device *dev = &hwahc->wa.usb_iface->dev;
+
+       result = __wa_set_feature(&hwahc->wa, WA_ENABLE);
+       if (result < 0) {
+               dev_err(dev, "error commanding HC to start: %d\n", result);
+               goto error_stop;
+       }
+       result = __wa_wait_status(&hwahc->wa, WA_ENABLE, WA_ENABLE);
+       if (result < 0) {
+               dev_err(dev, "error waiting for HC to start: %d\n", result);
+               goto error_stop;
+       }
+       result = wa_nep_arm(&hwahc->wa, GFP_KERNEL);
+       if (result < 0) {
+               dev_err(dev, "cannot listen to notifications: %d\n", result);
+               goto error_stop;
+       }
+       return result;
+
+error_stop:
+       __wa_clear_feature(&hwahc->wa, WA_ENABLE);
+       return result;
+}
+
+static void __hwahc_op_wusbhc_stop(struct wusbhc *wusbhc, int delay)
+{
+       struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
+       struct wahc *wa = &hwahc->wa;
+       u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
+       int ret;
+
+       ret = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
+                             WUSB_REQ_CHAN_STOP,
+                             USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                             delay * 1000,
+                             iface_no,
+                             NULL, 0, 1000 /* FIXME: arbitrary */);
+       if (ret == 0)
+               msleep(delay);
+
+       wa_nep_disarm(&hwahc->wa);
+       __wa_stop(&hwahc->wa);
+}
+
 /*
  * Set the UWB MAS allocation for the WUSB cluster
  *
index 26a3871ea0f9058a4bc06fcce79eb124e4292c1f..11e5040b8337f9241740904e3c16dcb87a6aa37b 100644 (file)
@@ -2,6 +2,7 @@ obj-$(CONFIG_USB_WHCI_HCD) += whci-hcd.o
 
 whci-hcd-y := \
        asl.o   \
+       debug.o \
        hcd.o   \
        hw.o    \
        init.o  \
index 4d7078e50572260619f9dabfca4405884431f502..577c0d29849d10d200e3a9f7656198a740677f54 100644 (file)
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
 
 #include "../../wusbcore/wusbhc.h"
 
 #include "whcd.h"
 
-#if D_LOCAL >= 4
-static void dump_asl(struct whc *whc, const char *tag)
-{
-       struct device *dev = &whc->umc->dev;
-       struct whc_qset *qset;
-
-       d_printf(4, dev, "ASL %s\n", tag);
-
-       list_for_each_entry(qset, &whc->async_list, list_node) {
-               dump_qset(qset, dev);
-       }
-}
-#else
-static inline void dump_asl(struct whc *whc, const char *tag)
-{
-}
-#endif
-
-
 static void qset_get_next_prev(struct whc *whc, struct whc_qset *qset,
                               struct whc_qset **next, struct whc_qset **prev)
 {
@@ -179,11 +158,26 @@ void asl_stop(struct whc *whc)
                      1000, "stop ASL");
 }
 
+/**
+ * asl_update - request an ASL update and wait for the hardware to be synced
+ * @whc: the WHCI HC
+ * @wusbcmd: WUSBCMD value to start the update.
+ *
+ * If the WUSB HC is inactive (i.e., the ASL is stopped) then the
+ * update must be skipped as the hardware may not respond to update
+ * requests.
+ */
 void asl_update(struct whc *whc, uint32_t wusbcmd)
 {
-       whc_write_wusbcmd(whc, wusbcmd, wusbcmd);
-       wait_event(whc->async_list_wq,
-                  (le_readl(whc->base + WUSBCMD) & WUSBCMD_ASYNC_UPDATED) == 0);
+       struct wusbhc *wusbhc = &whc->wusbhc;
+
+       mutex_lock(&wusbhc->mutex);
+       if (wusbhc->active) {
+               whc_write_wusbcmd(whc, wusbcmd, wusbcmd);
+               wait_event(whc->async_list_wq,
+                          (le_readl(whc->base + WUSBCMD) & WUSBCMD_ASYNC_UPDATED) == 0);
+       }
+       mutex_unlock(&wusbhc->mutex);
 }
 
 /**
@@ -202,8 +196,6 @@ void scan_async_work(struct work_struct *work)
 
        spin_lock_irq(&whc->lock);
 
-       dump_asl(whc, "before processing");
-
        /*
         * Transerve the software list backwards so new qsets can be
         * safely inserted into the ASL without making it non-circular.
@@ -217,8 +209,6 @@ void scan_async_work(struct work_struct *work)
                update |= process_qset(whc, qset);
        }
 
-       dump_asl(whc, "after processing");
-
        spin_unlock_irq(&whc->lock);
 
        if (update) {
diff --git a/drivers/usb/host/whci/debug.c b/drivers/usb/host/whci/debug.c
new file mode 100644 (file)
index 0000000..cf2d459
--- /dev/null
@@ -0,0 +1,189 @@
+/*
+ * Wireless Host Controller (WHC) debug.
+ *
+ * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/kernel.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+#include "../../wusbcore/wusbhc.h"
+
+#include "whcd.h"
+
+struct whc_dbg {
+       struct dentry *di_f;
+       struct dentry *asl_f;
+       struct dentry *pzl_f;
+};
+
+void qset_print(struct seq_file *s, struct whc_qset *qset)
+{
+       struct whc_std *std;
+       struct urb *urb = NULL;
+       int i;
+
+       seq_printf(s, "qset %08x\n", (u32)qset->qset_dma);
+       seq_printf(s, "  -> %08x\n", (u32)qset->qh.link);
+       seq_printf(s, "  info: %08x %08x %08x\n",
+               qset->qh.info1, qset->qh.info2,  qset->qh.info3);
+       seq_printf(s, "  sts: %04x errs: %d\n", qset->qh.status, qset->qh.err_count);
+       seq_printf(s, "  TD: sts: %08x opts: %08x\n",
+               qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
+
+       for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
+               seq_printf(s, "  %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
+                       i == qset->td_start ? 'S' : ' ',
+                       i == qset->td_end ? 'E' : ' ',
+                       i, qset->qtd[i].status, qset->qtd[i].options,
+                       (u32)qset->qtd[i].page_list_ptr);
+       }
+       seq_printf(s, "  ntds: %d\n", qset->ntds);
+       list_for_each_entry(std, &qset->stds, list_node) {
+               if (urb != std->urb) {
+                       urb = std->urb;
+                       seq_printf(s, "  urb %p transferred: %d bytes\n", urb,
+                               urb->actual_length);
+               }
+               if (std->qtd)
+                       seq_printf(s, "    sTD[%td]: %zu bytes @ %08x\n",
+                               std->qtd - &qset->qtd[0],
+                               std->len, std->num_pointers ?
+                               (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
+               else
+                       seq_printf(s, "    sTD[-]: %zd bytes @ %08x\n",
+                               std->len, std->num_pointers ?
+                               (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
+       }
+}
+
+static int di_print(struct seq_file *s, void *p)
+{
+       struct whc *whc = s->private;
+       char buf[72];
+       int d;
+
+       for (d = 0; d < whc->n_devices; d++) {
+               struct di_buf_entry *di = &whc->di_buf[d];
+
+               bitmap_scnprintf(buf, sizeof(buf),
+                                (unsigned long *)di->availability_info, UWB_NUM_MAS);
+
+               seq_printf(s, "DI[%d]\n", d);
+               seq_printf(s, "  availability: %s\n", buf);
+               seq_printf(s, "  %c%c key idx: %d dev addr: %d\n",
+                          (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
+                          (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
+                          (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
+                          (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
+       }
+       return 0;
+}
+
+static int asl_print(struct seq_file *s, void *p)
+{
+       struct whc *whc = s->private;
+       struct whc_qset *qset;
+
+       list_for_each_entry(qset, &whc->async_list, list_node) {
+               qset_print(s, qset);
+       }
+
+       return 0;
+}
+
+static int pzl_print(struct seq_file *s, void *p)
+{
+       struct whc *whc = s->private;
+       struct whc_qset *qset;
+       int period;
+
+       for (period = 0; period < 5; period++) {
+               seq_printf(s, "Period %d\n", period);
+               list_for_each_entry(qset, &whc->periodic_list[period], list_node) {
+                       qset_print(s, qset);
+               }
+       }
+       return 0;
+}
+
+static int di_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, di_print, inode->i_private);
+}
+
+static int asl_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, asl_print, inode->i_private);
+}
+
+static int pzl_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, pzl_print, inode->i_private);
+}
+
+static struct file_operations di_fops = {
+       .open    = di_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = single_release,
+       .owner   = THIS_MODULE,
+};
+
+static struct file_operations asl_fops = {
+       .open    = asl_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = single_release,
+       .owner   = THIS_MODULE,
+};
+
+static struct file_operations pzl_fops = {
+       .open    = pzl_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = single_release,
+       .owner   = THIS_MODULE,
+};
+
+void whc_dbg_init(struct whc *whc)
+{
+       if (whc->wusbhc.pal.debugfs_dir == NULL)
+               return;
+
+       whc->dbg = kzalloc(sizeof(struct whc_dbg), GFP_KERNEL);
+       if (whc->dbg == NULL)
+               return;
+
+       whc->dbg->di_f = debugfs_create_file("di", 0444,
+                                             whc->wusbhc.pal.debugfs_dir, whc,
+                                             &di_fops);
+       whc->dbg->asl_f = debugfs_create_file("asl", 0444,
+                                             whc->wusbhc.pal.debugfs_dir, whc,
+                                             &asl_fops);
+       whc->dbg->pzl_f = debugfs_create_file("pzl", 0444,
+                                             whc->wusbhc.pal.debugfs_dir, whc,
+                                             &pzl_fops);
+}
+
+void whc_dbg_clean_up(struct whc *whc)
+{
+       if (whc->dbg) {
+               debugfs_remove(whc->dbg->pzl_f);
+               debugfs_remove(whc->dbg->asl_f);
+               debugfs_remove(whc->dbg->di_f);
+               kfree(whc->dbg);
+       }
+}
index ef3ad4dca945222d56e1ceeb4a919c77b6ab0a24..1569afd6245b0311308cfcd84f6628951e5503fe 100644 (file)
@@ -15,7 +15,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/uwb/umc.h>
@@ -92,8 +91,6 @@ static void whc_stop(struct usb_hcd *usb_hcd)
 
        mutex_lock(&wusbhc->mutex);
 
-       wusbhc_stop(wusbhc);
-
        /* stop HC */
        le_writel(0, whc->base + WUSBINTR);
        whc_write_wusbcmd(whc, WUSBCMD_RUN, 0);
@@ -276,6 +273,8 @@ static int whc_probe(struct umc_dev *umc)
                goto error_wusbhc_b_create;
        }
 
+       whc_dbg_init(whc);
+
        return 0;
 
 error_wusbhc_b_create:
@@ -299,6 +298,7 @@ static void whc_remove(struct umc_dev *umc)
        struct whc *whc = wusbhc_to_whc(wusbhc);
 
        if (usb_hcd) {
+               whc_dbg_clean_up(whc);
                wusbhc_b_destroy(wusbhc);
                usb_remove_hcd(usb_hcd);
                wusbhc_destroy(wusbhc);
index ac86e59c1225010b801732f40fd3253c0abbdb0a..d498e72032174dc66e9f00c09541f49267f00028 100644 (file)
@@ -50,6 +50,7 @@ int whc_do_gencmd(struct whc *whc, u32 cmd, u32 params, void *addr, size_t len)
        unsigned long flags;
        dma_addr_t dma_addr;
        int t;
+       int ret = 0;
 
        mutex_lock(&whc->mutex);
 
@@ -61,7 +62,8 @@ int whc_do_gencmd(struct whc *whc, u32 cmd, u32 params, void *addr, size_t len)
                dev_err(&whc->umc->dev, "generic command timeout (%04x/%04x)\n",
                        le_readl(whc->base + WUSBGENCMDSTS),
                        le_readl(whc->base + WUSBGENCMDPARAMS));
-               return -ETIMEDOUT;
+               ret = -ETIMEDOUT;
+               goto out;
        }
 
        if (addr) {
@@ -80,8 +82,8 @@ int whc_do_gencmd(struct whc *whc, u32 cmd, u32 params, void *addr, size_t len)
                  whc->base + WUSBGENCMDSTS);
 
        spin_unlock_irqrestore(&whc->lock, flags);
-
+out:
        mutex_unlock(&whc->mutex);
 
-       return 0;
+       return ret;
 }
index fce01174aa9b21b9335ae5d321a7bf9cf6a9b536..6aae70028101c8563fd9478384a4f5fb38717779 100644 (file)
@@ -15,7 +15,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/uwb/umc.h>
index 8d62df0c330b7a87ced59f71ae851cd05424b9ba..2ae5abf69a6a0693dfea85e3be1f861874efec78 100644 (file)
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
 
 #include "../../wusbcore/wusbhc.h"
 
 #include "whcd.h"
 
-#if D_LOCAL >= 4
-static void dump_pzl(struct whc *whc, const char *tag)
-{
-       struct device *dev = &whc->umc->dev;
-       struct whc_qset *qset;
-       int period = 0;
-
-       d_printf(4, dev, "PZL %s\n", tag);
-
-       for (period = 0; period < 5; period++) {
-               d_printf(4, dev, "Period %d\n", period);
-               list_for_each_entry(qset, &whc->periodic_list[period], list_node) {
-                       dump_qset(qset, dev);
-               }
-       }
-}
-#else
-static inline void dump_pzl(struct whc *whc, const char *tag)
-{
-}
-#endif
-
 static void update_pzl_pointers(struct whc *whc, int period, u64 addr)
 {
        switch (period) {
@@ -195,11 +171,26 @@ void pzl_stop(struct whc *whc)
                      1000, "stop PZL");
 }
 
+/**
+ * pzl_update - request a PZL update and wait for the hardware to be synced
+ * @whc: the WHCI HC
+ * @wusbcmd: WUSBCMD value to start the update.
+ *
+ * If the WUSB HC is inactive (i.e., the PZL is stopped) then the
+ * update must be skipped as the hardware may not respond to update
+ * requests.
+ */
 void pzl_update(struct whc *whc, uint32_t wusbcmd)
 {
-       whc_write_wusbcmd(whc, wusbcmd, wusbcmd);
-       wait_event(whc->periodic_list_wq,
-                  (le_readl(whc->base + WUSBCMD) & WUSBCMD_PERIODIC_UPDATED) == 0);
+       struct wusbhc *wusbhc = &whc->wusbhc;
+
+       mutex_lock(&wusbhc->mutex);
+       if (wusbhc->active) {
+               whc_write_wusbcmd(whc, wusbcmd, wusbcmd);
+               wait_event(whc->periodic_list_wq,
+                          (le_readl(whc->base + WUSBCMD) & WUSBCMD_PERIODIC_UPDATED) == 0);
+       }
+       mutex_unlock(&wusbhc->mutex);
 }
 
 static void update_pzl_hw_view(struct whc *whc)
@@ -235,8 +226,6 @@ void scan_periodic_work(struct work_struct *work)
 
        spin_lock_irq(&whc->lock);
 
-       dump_pzl(whc, "before processing");
-
        for (period = 4; period >= 0; period--) {
                list_for_each_entry_safe(qset, t, &whc->periodic_list[period], list_node) {
                        if (!qset->in_hw_list)
@@ -248,8 +237,6 @@ void scan_periodic_work(struct work_struct *work)
        if (update & (WHC_UPDATE_ADDED | WHC_UPDATE_REMOVED))
                update_pzl_hw_view(whc);
 
-       dump_pzl(whc, "after processing");
-
        spin_unlock_irq(&whc->lock);
 
        if (update) {
index 0420037d2e18b3fefef06e5208c2401f6e98eb0d..7be74314ee1252c0b596e4d5e96ff30773e0d901 100644 (file)
 
 #include "whcd.h"
 
-void dump_qset(struct whc_qset *qset, struct device *dev)
-{
-       struct whc_std *std;
-       struct urb *urb = NULL;
-       int i;
-
-       dev_dbg(dev, "qset %08x\n", (u32)qset->qset_dma);
-       dev_dbg(dev, "  -> %08x\n", (u32)qset->qh.link);
-       dev_dbg(dev, "  info: %08x %08x %08x\n",
-               qset->qh.info1, qset->qh.info2,  qset->qh.info3);
-       dev_dbg(dev, "  sts: %04x errs: %d\n", qset->qh.status, qset->qh.err_count);
-       dev_dbg(dev, "  TD: sts: %08x opts: %08x\n",
-               qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
-
-       for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
-               dev_dbg(dev, "  %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
-                       i == qset->td_start ? 'S' : ' ',
-                       i == qset->td_end ? 'E' : ' ',
-                       i, qset->qtd[i].status, qset->qtd[i].options,
-                       (u32)qset->qtd[i].page_list_ptr);
-       }
-       dev_dbg(dev, "  ntds: %d\n", qset->ntds);
-       list_for_each_entry(std, &qset->stds, list_node) {
-               if (urb != std->urb) {
-                       urb = std->urb;
-                       dev_dbg(dev, "  urb %p transferred: %d bytes\n", urb,
-                               urb->actual_length);
-               }
-               if (std->qtd)
-                       dev_dbg(dev, "    sTD[%td]: %zu bytes @ %08x\n",
-                               std->qtd - &qset->qtd[0],
-                               std->len, std->num_pointers ?
-                               (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
-               else
-                       dev_dbg(dev, "    sTD[-]: %zd bytes @ %08x\n",
-                               std->len, std->num_pointers ?
-                               (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
-       }
-}
-
 struct whc_qset *qset_alloc(struct whc *whc, gfp_t mem_flags)
 {
        struct whc_qset *qset;
index 1d2a53bd39fd856dab31148012d03d385c591017..0f3540f04f5316b9a071f9d4d6a49fc3860bb0b9 100644 (file)
@@ -21,6 +21,7 @@
 #define __WHCD_H
 
 #include <linux/uwb/whci.h>
+#include <linux/uwb/umc.h>
 #include <linux/workqueue.h>
 
 #include "whci-hc.h"
@@ -28,6 +29,7 @@
 /* Generic command timeout. */
 #define WHC_GENCMD_TIMEOUT_MS 100
 
+struct whc_dbg;
 
 struct whc {
        struct wusbhc wusbhc;
@@ -69,6 +71,8 @@ struct whc {
        struct list_head periodic_removed_list;
        wait_queue_head_t periodic_list_wq;
        struct work_struct periodic_work;
+
+       struct whc_dbg *dbg;
 };
 
 #define wusbhc_to_whc(w) (container_of((w), struct whc, wusbhc))
@@ -136,7 +140,7 @@ int whc_do_gencmd(struct whc *whc, u32 cmd, u32 params, void *addr, size_t len);
 
 /* wusb.c */
 int whc_wusbhc_start(struct wusbhc *wusbhc);
-void whc_wusbhc_stop(struct wusbhc *wusbhc);
+void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay);
 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
                  u8 handle, struct wuie_hdr *wuie);
 int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle);
@@ -190,8 +194,11 @@ void process_inactive_qtd(struct whc *whc, struct whc_qset *qset,
                                 struct whc_qtd *qtd);
 enum whc_update qset_add_qtds(struct whc *whc, struct whc_qset *qset);
 void qset_remove_complete(struct whc *whc, struct whc_qset *qset);
-void dump_qset(struct whc_qset *qset, struct device *dev);
 void pzl_update(struct whc *whc, uint32_t wusbcmd);
 void asl_update(struct whc *whc, uint32_t wusbcmd);
 
+/* debug.c */
+void whc_dbg_init(struct whc *whc);
+void whc_dbg_clean_up(struct whc *whc);
+
 #endif /* #ifndef __WHCD_H */
index bff1eb7a35cfed87a0f1cdb267e48a3c9ace6d64..51df7e313b380762d7c9ebc2af88e246814f5a58 100644 (file)
@@ -410,6 +410,8 @@ struct dn_buf_entry {
 #  define WUSBDNTSCTRL_SLOTS(s)    ((s) << 0)
 
 #define WUSBTIME             0x68
+#  define WUSBTIME_CHANNEL_TIME_MASK 0x00ffffff
+
 #define WUSBBPST             0x6c
 #define WUSBDIBUPDATED       0x70
 
index 66e4ddcd961da260769830e03434e5b4b25f245c..f24efdebad177593639e8f41cfb7e130d9971cdf 100644 (file)
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/uwb/umc.h>
-#define D_LOCAL 1
-#include <linux/uwb/debug.h>
 
 #include "../../wusbcore/wusbhc.h"
 
 #include "whcd.h"
 
-#if D_LOCAL >= 1
-static void dump_di(struct whc *whc, int idx)
-{
-       struct di_buf_entry *di = &whc->di_buf[idx];
-       struct device *dev = &whc->umc->dev;
-       char buf[128];
-
-       bitmap_scnprintf(buf, sizeof(buf), (unsigned long *)di->availability_info, UWB_NUM_MAS);
-
-       d_printf(1, dev, "DI[%d]\n", idx);
-       d_printf(1, dev, "  availability: %s\n", buf);
-       d_printf(1, dev, "  %c%c key idx: %d dev addr: %d\n",
-                (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
-                (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
-                (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
-                (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
-}
-#else
-static inline void dump_di(struct whc *whc, int idx)
-{
-}
-#endif
-
 static int whc_update_di(struct whc *whc, int idx)
 {
        int offset = idx / 32;
        u32 bit = 1 << (idx % 32);
 
-       dump_di(whc, idx);
-
        le_writel(bit, whc->base + WUSBDIBUPDATED + offset);
 
        return whci_wait_for(&whc->umc->dev,
@@ -64,8 +36,9 @@ static int whc_update_di(struct whc *whc, int idx)
 }
 
 /*
- * WHCI starts and stops MMCs based on there being a valid GTK so
- * these need only start/stop the asynchronous and periodic schedules.
+ * WHCI starts MMCs based on there being a valid GTK so these need
+ * only start/stop the asynchronous and periodic schedules and send a
+ * channel stop command.
  */
 
 int whc_wusbhc_start(struct wusbhc *wusbhc)
@@ -78,12 +51,20 @@ int whc_wusbhc_start(struct wusbhc *wusbhc)
        return 0;
 }
 
-void whc_wusbhc_stop(struct wusbhc *wusbhc)
+void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay)
 {
        struct whc *whc = wusbhc_to_whc(wusbhc);
+       u32 stop_time, now_time;
+       int ret;
 
        pzl_stop(whc);
        asl_stop(whc);
+
+       now_time = le_readl(whc->base + WUSBTIME) & WUSBTIME_CHANNEL_TIME_MASK;
+       stop_time = (now_time + ((delay * 8) << 7)) & 0x00ffffff;
+       ret = whc_do_gencmd(whc, WUSBGENCMDSTS_CHAN_STOP, stop_time, NULL, 0);
+       if (ret == 0)
+               msleep(delay);
 }
 
 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
index ab4788d1785a72b57bc7296bed0d09b86b50a05e..1335cbe1191db8c7e9f84df77ef72bdf46c3065c 100644 (file)
@@ -88,7 +88,6 @@
  */
 #include <linux/module.h>
 #include <linux/ctype.h>
-#include <linux/version.h>
 #include <linux/usb.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
index c36c4389baae100b08c494049f2fda9314f7b296..0ca860305feb44cdd464e4dc2796051e4a471b50 100644 (file)
 #define D_LOCAL 0
 #include <linux/uwb/debug.h>
 
+static int debug_crypto_verify = 0;
+
+module_param(debug_crypto_verify, int, 0);
+MODULE_PARM_DESC(debug_crypto_verify, "verify the key generation algorithms");
 
 /*
  * Block of data, as understood by AES-CCM
@@ -526,10 +530,13 @@ int wusb_crypto_init(void)
 {
        int result;
 
-       result = wusb_key_derive_verify();
-       if (result < 0)
-               return result;
-       return wusb_oob_mic_verify();
+       if (debug_crypto_verify) {
+               result = wusb_key_derive_verify();
+               if (result < 0)
+                       return result;
+               return wusb_oob_mic_verify();
+       }
+       return 0;
 }
 
 void wusb_crypto_exit(void)
index f45d777bef349039593324f896e928c458a6abdf..26cbc89ea2810cc40ac6a52f92453aa04acd4625 100644 (file)
@@ -57,9 +57,6 @@
  *                              Called by notif.c:wusb_handle_dn_connect()
  *                              when a DN_Connect is received.
  *
- *   wusbhc_devconnect_auth()   Called by rh.c:wusbhc_rh_port_reset() when
- *                              doing the device connect sequence.
- *
  *     wusb_devconnect_acked()  Ack done, release resources.
  *
  *   wusb_handle_dn_alive()     Called by notif.c:wusb_handle_dn()
@@ -69,9 +66,6 @@
  *                              process a disconenct request from a
  *                              device.
  *
- *   wusb_dev_reset()           Called by rh.c:wusbhc_rh_port_reset() when
- *                              resetting a device.
- *
  *   __wusb_dev_disable()       Called by rh.c:wusbhc_rh_clear_port_feat() when
  *                              disabling a port.
  *
@@ -366,12 +360,10 @@ void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc,
        port->wusb_dev = wusb_dev;
        port->status |= USB_PORT_STAT_CONNECTION;
        port->change |= USB_PORT_STAT_C_CONNECTION;
-       port->reset_count = 0;
        /* Now the port status changed to connected; khubd will
         * pick the change up and try to reset the port to bring it to
         * the enabled state--so this process returns up to the stack
-        * and it calls back into wusbhc_rh_port_reset() who will call
-        * devconnect_auth().
+        * and it calls back into wusbhc_rh_port_reset().
         */
 error_unlock:
        mutex_unlock(&wusbhc->mutex);
@@ -413,9 +405,6 @@ static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc,
                wusb_dev_put(wusb_dev);
        }
        port->wusb_dev = NULL;
-       /* don't reset the reset_count to zero or wusbhc_rh_port_reset will get
-        * confused! We only reset to zero when we connect a new device.
-        */
 
        /* After a device disconnects, change the GTK (see [WUSB]
         * section 6.2.11.2). */
@@ -428,39 +417,6 @@ static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc,
         */
 }
 
-/*
- * Authenticate a device into the WUSB Cluster
- *
- * Called from the Root Hub code (rh.c:wusbhc_rh_port_reset()) when
- * asking for a reset on a port that is not enabled (ie: first connect
- * on the port).
- *
- * Performs the 4way handshake to allow the device to comunicate w/ the
- * WUSB Cluster securely; once done, issue a request to the device for
- * it to change to address 0.
- *
- * This mimics the reset step of Wired USB that once resetting a
- * device, leaves the port in enabled state and the dev with the
- * default address (0).
- *
- * WUSB1.0[7.1.2]
- *
- * @port_idx: port where the change happened--This is the index into
- *            the wusbhc port array, not the USB port number.
- */
-int wusbhc_devconnect_auth(struct wusbhc *wusbhc, u8 port_idx)
-{
-       struct device *dev = wusbhc->dev;
-       struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx);
-
-       d_fnstart(3, dev, "(%p, %u)\n", wusbhc, port_idx);
-       port->status &= ~USB_PORT_STAT_RESET;
-       port->status |= USB_PORT_STAT_ENABLE;
-       port->change |= USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_ENABLE;
-       d_fnend(3, dev, "(%p, %u) = 0\n", wusbhc, port_idx);
-       return 0;
-}
-
 /*
  * Refresh the list of keep alives to emit in the MMC
  *
@@ -528,21 +484,15 @@ static void __wusbhc_keep_alive(struct wusbhc *wusbhc)
  */
 static void wusbhc_keep_alive_run(struct work_struct *ws)
 {
-       struct delayed_work *dw =
-               container_of(ws, struct delayed_work, work);
-       struct wusbhc *wusbhc =
-               container_of(dw, struct wusbhc, keep_alive_timer);
-
-       d_fnstart(5, wusbhc->dev, "(wusbhc %p)\n", wusbhc);
-       if (wusbhc->active) {
-               mutex_lock(&wusbhc->mutex);
-               __wusbhc_keep_alive(wusbhc);
-               mutex_unlock(&wusbhc->mutex);
-               queue_delayed_work(wusbd, &wusbhc->keep_alive_timer,
-                                  (wusbhc->trust_timeout * CONFIG_HZ)/1000/2);
-       }
-       d_fnend(5, wusbhc->dev, "(wusbhc %p) = void\n", wusbhc);
-       return;
+       struct delayed_work *dw = container_of(ws, struct delayed_work, work);
+       struct wusbhc *wusbhc = container_of(dw, struct wusbhc, keep_alive_timer);
+
+       mutex_lock(&wusbhc->mutex);
+       __wusbhc_keep_alive(wusbhc);
+       mutex_unlock(&wusbhc->mutex);
+
+       queue_delayed_work(wusbd, &wusbhc->keep_alive_timer,
+                          msecs_to_jiffies(wusbhc->trust_timeout / 2));
 }
 
 /*
@@ -661,60 +611,6 @@ static void wusbhc_handle_dn_disconnect(struct wusbhc *wusbhc, struct wusb_dev *
        mutex_unlock(&wusbhc->mutex);
 }
 
-/*
- * Reset a WUSB device on a HWA
- *
- * @wusbhc
- * @port_idx   Index of the port where the device is
- *
- * In Wireless USB, a reset is more or less equivalent to a full
- * disconnect; so we just do a full disconnect and send the device a
- * Device Reset IE (WUSB1.0[7.5.11]) giving it a few millisecs (6 MMCs).
- *
- * @wusbhc should be refcounted and unlocked
- */
-int wusbhc_dev_reset(struct wusbhc *wusbhc, u8 port_idx)
-{
-       int result;
-       struct device *dev = wusbhc->dev;
-       struct wusb_dev *wusb_dev;
-       struct wuie_reset *ie;
-
-       d_fnstart(3, dev, "(%p, %u)\n", wusbhc, port_idx);
-       mutex_lock(&wusbhc->mutex);
-       result = 0;
-       wusb_dev = wusb_port_by_idx(wusbhc, port_idx)->wusb_dev;
-       if (wusb_dev == NULL) {
-               /* reset no device? ignore */
-               dev_dbg(dev, "RESET: no device at port %u, ignoring\n",
-                       port_idx);
-               goto error_unlock;
-       }
-       result = -ENOMEM;
-       ie = kzalloc(sizeof(*ie), GFP_KERNEL);
-       if (ie == NULL)
-               goto error_unlock;
-       ie->hdr.bLength = sizeof(ie->hdr) + sizeof(ie->CDID);
-       ie->hdr.bIEIdentifier = WUIE_ID_RESET_DEVICE;
-       ie->CDID = wusb_dev->cdid;
-       result = wusbhc_mmcie_set(wusbhc, 0xff, 6, &ie->hdr);
-       if (result < 0) {
-               dev_err(dev, "RESET: cant's set MMC: %d\n", result);
-               goto error_kfree;
-       }
-       __wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, port_idx));
-
-       /* 120ms, hopefully 6 MMCs (FIXME) */
-       msleep(120);
-       wusbhc_mmcie_rm(wusbhc, &ie->hdr);
-error_kfree:
-       kfree(ie);
-error_unlock:
-       mutex_unlock(&wusbhc->mutex);
-       d_fnend(3, dev, "(%p, %u) = %d\n", wusbhc, port_idx, result);
-       return result;
-}
-
 /*
  * Handle a Device Notification coming a host
  *
@@ -1222,8 +1118,7 @@ void wusbhc_devconnect_destroy(struct wusbhc *wusbhc)
  * FIXME: This also enables the keep alives but this is not necessary
  * until there are connected and authenticated devices.
  */
-int wusbhc_devconnect_start(struct wusbhc *wusbhc,
-                           const struct wusb_ckhdid *chid)
+int wusbhc_devconnect_start(struct wusbhc *wusbhc)
 {
        struct device *dev = wusbhc->dev;
        struct wuie_host_info *hi;
@@ -1236,7 +1131,7 @@ int wusbhc_devconnect_start(struct wusbhc *wusbhc,
        hi->hdr.bLength       = sizeof(*hi);
        hi->hdr.bIEIdentifier = WUIE_ID_HOST_INFO;
        hi->attributes        = cpu_to_le16((wusbhc->rsv->stream << 3) | WUIE_HI_CAP_ALL);
-       hi->CHID              = *chid;
+       hi->CHID              = wusbhc->chid;
        result = wusbhc_mmcie_set(wusbhc, 0, 0, &hi->hdr);
        if (result < 0) {
                dev_err(dev, "Cannot add Host Info MMCIE: %d\n", result);
index cfa77a01cebd9ba43df408b5ed8282749f01b0f8..3b52161e6e9cd8d5af017879f78613eb11f7b729 100644 (file)
@@ -159,15 +159,35 @@ found:
 }
 EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);
 
+static int wusbhc_mmc_start(struct wusbhc *wusbhc)
+{
+       int ret;
+
+       mutex_lock(&wusbhc->mutex);
+       ret = wusbhc->start(wusbhc);
+       if (ret >= 0)
+               wusbhc->active = 1;
+       mutex_unlock(&wusbhc->mutex);
+
+       return ret;
+}
+
+static void wusbhc_mmc_stop(struct wusbhc *wusbhc)
+{
+       mutex_lock(&wusbhc->mutex);
+       wusbhc->active = 0;
+       wusbhc->stop(wusbhc, WUSB_CHANNEL_STOP_DELAY_MS);
+       mutex_unlock(&wusbhc->mutex);
+}
+
 /*
  * wusbhc_start - start transmitting MMCs and accepting connections
  * @wusbhc: the HC to start
- * @chid: the CHID to use for this host
  *
  * Establishes a cluster reservation, enables device connections, and
  * starts MMCs with appropriate DNTS parameters.
  */
-int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
+int wusbhc_start(struct wusbhc *wusbhc)
 {
        int result;
        struct device *dev = wusbhc->dev;
@@ -181,7 +201,7 @@ int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
                goto error_rsv_establish;
        }
 
-       result = wusbhc_devconnect_start(wusbhc, chid);
+       result = wusbhc_devconnect_start(wusbhc);
        if (result < 0) {
                dev_err(dev, "error enabling device connections: %d\n", result);
                goto error_devconnect_start;
@@ -199,12 +219,12 @@ int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
                dev_err(dev, "Cannot set DNTS parameters: %d\n", result);
                goto error_set_num_dnts;
        }
-       result = wusbhc->start(wusbhc);
+       result = wusbhc_mmc_start(wusbhc);
        if (result < 0) {
                dev_err(dev, "error starting wusbch: %d\n", result);
                goto error_wusbhc_start;
        }
-       wusbhc->active = 1;
+
        return 0;
 
 error_wusbhc_start:
@@ -218,77 +238,18 @@ error_rsv_establish:
        return result;
 }
 
-/*
- * Disconnect all from the WUSB Channel
- *
- * Send a Host Disconnect IE in the MMC, wait, don't send it any more
- */
-static int __wusbhc_host_disconnect_ie(struct wusbhc *wusbhc)
-{
-       int result = -ENOMEM;
-       struct wuie_host_disconnect *host_disconnect_ie;
-       might_sleep();
-       host_disconnect_ie = kmalloc(sizeof(*host_disconnect_ie), GFP_KERNEL);
-       if (host_disconnect_ie == NULL)
-               goto error_alloc;
-       host_disconnect_ie->hdr.bLength       = sizeof(*host_disconnect_ie);
-       host_disconnect_ie->hdr.bIEIdentifier = WUIE_ID_HOST_DISCONNECT;
-       result = wusbhc_mmcie_set(wusbhc, 0, 0, &host_disconnect_ie->hdr);
-       if (result < 0)
-               goto error_mmcie_set;
-
-       /* WUSB1.0[8.5.3.1 & 7.5.2] */
-       msleep(100);
-       wusbhc_mmcie_rm(wusbhc, &host_disconnect_ie->hdr);
-error_mmcie_set:
-       kfree(host_disconnect_ie);
-error_alloc:
-       return result;
-}
-
 /*
  * wusbhc_stop - stop transmitting MMCs
  * @wusbhc: the HC to stop
  *
- * Send a Host Disconnect IE, wait, remove all the MMCs (stop sending MMCs).
- *
- * If we can't allocate a Host Stop IE, screw it, we don't notify the
- * devices we are disconnecting...
+ * Stops the WUSB channel and removes the cluster reservation.
  */
 void wusbhc_stop(struct wusbhc *wusbhc)
 {
-       if (wusbhc->active) {
-               wusbhc->active = 0;
-               wusbhc->stop(wusbhc);
-               wusbhc_sec_stop(wusbhc);
-               __wusbhc_host_disconnect_ie(wusbhc);
-               wusbhc_devconnect_stop(wusbhc);
-               wusbhc_rsv_terminate(wusbhc);
-       }
-}
-EXPORT_SYMBOL_GPL(wusbhc_stop);
-
-/*
- * Change the CHID in a WUSB Channel
- *
- * If it is just a new CHID, send a Host Disconnect IE and then change
- * the CHID IE.
- */
-static int __wusbhc_chid_change(struct wusbhc *wusbhc,
-                               const struct wusb_ckhdid *chid)
-{
-       int result = -ENOSYS;
-       struct device *dev = wusbhc->dev;
-       dev_err(dev, "%s() not implemented yet\n", __func__);
-       return result;
-
-       BUG_ON(wusbhc->wuie_host_info == NULL);
-       __wusbhc_host_disconnect_ie(wusbhc);
-       wusbhc->wuie_host_info->CHID = *chid;
-       result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->wuie_host_info->hdr);
-       if (result < 0)
-               dev_err(dev, "Can't update Host Info WUSB IE: %d\n", result);
-       return result;
+       wusbhc_mmc_stop(wusbhc);
+       wusbhc_sec_stop(wusbhc);
+       wusbhc_devconnect_stop(wusbhc);
+       wusbhc_rsv_terminate(wusbhc);
 }
 
 /*
@@ -306,16 +267,19 @@ int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
                chid = NULL;
 
        mutex_lock(&wusbhc->mutex);
-       if (wusbhc->active) {
-               if (chid)
-                       result = __wusbhc_chid_change(wusbhc, chid);
-               else
-                       wusbhc_stop(wusbhc);
-       } else {
-               if (chid)
-                       wusbhc_start(wusbhc, chid);
+       if (chid) {
+               if (wusbhc->active) {
+                       mutex_unlock(&wusbhc->mutex);
+                       return -EBUSY;
+               }
+               wusbhc->chid = *chid;
        }
        mutex_unlock(&wusbhc->mutex);
+
+       if (chid)
+               result = uwb_radio_start(&wusbhc->pal);
+       else
+               uwb_radio_stop(&wusbhc->pal);
        return result;
 }
 EXPORT_SYMBOL_GPL(wusbhc_chid_set);
index 7cc51e9905cf81e2234c0435d88630e9b1f558be..d0b172c5ecc77219f885bda14fabd2991b6688d1 100644 (file)
  */
 #include "wusbhc.h"
 
+static void wusbhc_channel_changed(struct uwb_pal *pal, int channel)
+{
+       struct wusbhc *wusbhc = container_of(pal, struct wusbhc, pal);
+
+       if (channel < 0)
+               wusbhc_stop(wusbhc);
+       else
+               wusbhc_start(wusbhc);
+}
+
 /**
  * wusbhc_pal_register - register the WUSB HC as a UWB PAL
  * @wusbhc: the WUSB HC
@@ -28,8 +38,10 @@ int wusbhc_pal_register(struct wusbhc *wusbhc)
 
        wusbhc->pal.name   = "wusbhc";
        wusbhc->pal.device = wusbhc->usb_hcd.self.controller;
+       wusbhc->pal.rc     = wusbhc->uwb_rc;
+       wusbhc->pal.channel_changed = wusbhc_channel_changed;
 
-       return uwb_pal_register(wusbhc->uwb_rc, &wusbhc->pal);
+       return uwb_pal_register(&wusbhc->pal);
 }
 
 /**
@@ -38,5 +50,5 @@ int wusbhc_pal_register(struct wusbhc *wusbhc)
  */
 void wusbhc_pal_unregister(struct wusbhc *wusbhc)
 {
-       uwb_pal_unregister(wusbhc->uwb_rc, &wusbhc->pal);
+       uwb_pal_unregister(&wusbhc->pal);
 }
index fc63e77ded2d41f09f4e310c452a45b6c358ccf2..7b6525dac2f1d34fdf3d2963ff53e29b712d00a3 100644 (file)
@@ -59,7 +59,6 @@ static void wusbhc_rsv_complete_cb(struct uwb_rsv *rsv)
        case UWB_RSV_STATE_NONE:
                dev_dbg(dev, "removed reservation\n");
                wusbhc_bwa_set(wusbhc, 0, NULL);
-               wusbhc->rsv = NULL;
                break;
        default:
                dev_dbg(dev, "unexpected reservation state: %d\n", rsv->state);
@@ -105,11 +104,11 @@ int wusbhc_rsv_establish(struct wusbhc *wusbhc)
 
 
 /**
- * wusbhc_rsv_terminate - terminate any cluster reservation
+ * wusbhc_rsv_terminate - terminate the cluster reservation
  * @wusbhc: the WUSB host whose reservation is to be terminated
  */
 void wusbhc_rsv_terminate(struct wusbhc *wusbhc)
 {
-       if (wusbhc->rsv)
-               uwb_rsv_terminate(wusbhc->rsv);
+       uwb_rsv_terminate(wusbhc->rsv);
+       uwb_rsv_destroy(wusbhc->rsv);
 }
index 267a64325106ce2ab8d4cc4af81bd56fcdc825a1..1c733192ec2a274c9b24ce5462a63c74e5ab0947 100644 (file)
 /*
  * Reset a fake port
  *
- * This can be called to reset a port from any other state or to reset
- * it when connecting. In Wireless USB they are different; when doing
- * a new connect that involves going over the authentication. When
- * just reseting, its a different story.
+ * Using a Reset Device IE is too heavyweight as it causes the device
+ * to enter the UnConnected state and leave the cluster, this can mean
+ * that when the device reconnects it is connected to a different fake
+ * port.
  *
- * The Linux USB stack resets a port twice before it considers it
- * enabled, so we have to detect and ignore that.
+ * Instead, reset authenticated devices with a SetAddress(0), followed
+ * by a SetAddresss(AuthAddr).
+ *
+ * For unauthenticated devices just pretend to reset but do nothing.
+ * If the device initialization continues to fail it will eventually
+ * time out after TrustTimeout and enter the UnConnected state.
  *
  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
  *
@@ -97,20 +101,20 @@ static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx)
 {
        int result = 0;
        struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx);
+       struct wusb_dev *wusb_dev = port->wusb_dev;
+
+       port->status |= USB_PORT_STAT_RESET;
+       port->change |= USB_PORT_STAT_C_RESET;
 
-       d_fnstart(3, wusbhc->dev, "(wusbhc %p port_idx %u)\n",
-                 wusbhc, port_idx);
-       if (port->reset_count == 0) {
-               wusbhc_devconnect_auth(wusbhc, port_idx);
-               port->reset_count++;
-       } else if (port->reset_count == 1)
-               /* see header */
-               d_printf(2, wusbhc->dev, "Ignoring second reset on port_idx "
-                       "%u\n", port_idx);
+       if (wusb_dev->addr & WUSB_DEV_ADDR_UNAUTH)
+               result = 0;
        else
-               result = wusbhc_dev_reset(wusbhc, port_idx);
-       d_fnend(3, wusbhc->dev, "(wusbhc %p port_idx %u) = %d\n",
-               wusbhc, port_idx, result);
+               result = wusb_dev_update_address(wusbhc, wusb_dev);
+
+       port->status &= ~USB_PORT_STAT_RESET;
+       port->status |= USB_PORT_STAT_ENABLE;
+       port->change |= USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_ENABLE; 
+
        return result;
 }
 
index a101cad6a8d41a568b611974328cc0d738838bb6..ac00640bba6408e1dbf7a0a5273060fbd72170d1 100644 (file)
@@ -338,8 +338,7 @@ static void hs_printk(unsigned level, struct device *dev,
  * Before the device's address (as known by it) was usb_dev->devnum |
  * 0x80 (unauthenticated address). With this we update it to usb_dev->devnum.
  */
-static int wusb_dev_update_address(struct wusbhc *wusbhc,
-                                  struct wusb_dev *wusb_dev)
+int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 {
        int result = -ENOMEM;
        struct usb_device *usb_dev = wusb_dev->usb_dev;
index d0c132434f1b16f8d0b9d5abda8bf5aeea6ab79e..797c2453a35bf829ec2fef965d5ac42a37cd33af 100644 (file)
 #include <linux/uwb.h>
 #include <linux/usb/wusb.h>
 
+/*
+ * Time from a WUSB channel stop request to the last transmitted MMC.
+ *
+ * This needs to be > 4.096 ms in case no MMCs can be transmitted in
+ * zone 0.
+ */
+#define WUSB_CHANNEL_STOP_DELAY_MS 8
 
 /**
  * Wireless USB device
@@ -147,7 +154,6 @@ struct wusb_port {
        u16 status;
        u16 change;
        struct wusb_dev *wusb_dev;      /* connected device's info */
-       unsigned reset_count;
        u32 ptk_tkid;
 };
 
@@ -198,21 +204,18 @@ struct wusb_port {
  * @mmcies_max    Max number of Information Elements this HC can send
  *                 in its MMC. Read-only.
  *
+ * @start          Start the WUSB channel.
+ *
+ * @stop           Stop the WUSB channel after the specified number of
+ *                 milliseconds.  Channel Stop IEs should be transmitted
+ *                 as required by [WUSB] 4.16.2.1.
+ *
  * @mmcie_add     HC specific operation (WHCI or HWA) for adding an
  *                 MMCIE.
  *
  * @mmcie_rm      HC specific operation (WHCI or HWA) for removing an
  *                 MMCIE.
  *
- * @enc_types     Array which describes the encryptions methods
- *                 supported by the host as described in WUSB1.0 --
- *                 one entry per supported method. As of WUSB1.0 there
- *                 is only four methods, we make space for eight just in
- *                 case they decide to add some more (and pray they do
- *                 it in sequential order). if 'enc_types[enc_method]
- *                 != 0', then it is supported by the host. enc_method
- *                 is USB_ENC_TYPE*.
- *
  * @set_ptk:       Set the PTK and enable encryption for a device. Or, if
  *                 the supplied key is NULL, disable encryption for that
  *                 device.
@@ -249,7 +252,8 @@ struct wusbhc {
        struct uwb_pal pal;
 
        unsigned trust_timeout;                 /* in jiffies */
-       struct wuie_host_info *wuie_host_info;  /* Includes CHID */
+       struct wusb_ckhdid chid;
+       struct wuie_host_info *wuie_host_info;
 
        struct mutex mutex;                     /* locks everything else */
        u16 cluster_id;                         /* Wireless USB Cluster ID */
@@ -269,7 +273,7 @@ struct wusbhc {
        u8 mmcies_max;
        /* FIXME: make wusbhc_ops? */
        int (*start)(struct wusbhc *wusbhc);
-       void (*stop)(struct wusbhc *wusbhc);
+       void (*stop)(struct wusbhc *wusbhc, int delay);
        int (*mmcie_add)(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
                         u8 handle, struct wuie_hdr *wuie);
        int (*mmcie_rm)(struct wusbhc *wusbhc, u8 handle);
@@ -373,20 +377,17 @@ static inline void wusbhc_put(struct wusbhc *wusbhc)
        usb_put_hcd(&wusbhc->usb_hcd);
 }
 
-int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid);
+int wusbhc_start(struct wusbhc *wusbhc);
 void wusbhc_stop(struct wusbhc *wusbhc);
 extern int wusbhc_chid_set(struct wusbhc *, const struct wusb_ckhdid *);
 
 /* Device connect handling */
 extern int wusbhc_devconnect_create(struct wusbhc *);
 extern void wusbhc_devconnect_destroy(struct wusbhc *);
-extern int wusbhc_devconnect_start(struct wusbhc *wusbhc,
-                                  const struct wusb_ckhdid *chid);
+extern int wusbhc_devconnect_start(struct wusbhc *wusbhc);
 extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc);
-extern int wusbhc_devconnect_auth(struct wusbhc *, u8);
 extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr,
                             struct wusb_dn_hdr *dn_hdr, size_t size);
-extern int wusbhc_dev_reset(struct wusbhc *wusbhc, u8 port);
 extern void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port);
 extern int wusb_usb_ncb(struct notifier_block *nb, unsigned long val,
                        void *priv);
@@ -432,6 +433,7 @@ extern void wusb_dev_sec_rm(struct wusb_dev *) ;
 extern int wusb_dev_4way_handshake(struct wusbhc *, struct wusb_dev *,
                                   struct wusb_ckhdid *ck);
 void wusbhc_gtk_rekey(struct wusbhc *wusbhc);
+int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev);
 
 
 /* WUSB Cluster ID handling */
index 257e6908304cb304075ec42e5a718626d270ab92..ce21a95da04a9cbb092475e8c9d9f7208197ea0a 100644 (file)
@@ -13,10 +13,12 @@ uwb-objs :=         \
        drp-ie.o        \
        est.o           \
        ie.o            \
+       ie-rcv.o        \
        lc-dev.o        \
        lc-rc.o         \
        neh.o           \
        pal.o           \
+       radio.o         \
        reset.o         \
        rsv.o           \
        scan.o          \
index 46b18eec50260789b3084df02397b2c4fd57dc38..d9c60cb9499351d5268e5c9d869068553c15b5e1 100644 (file)
@@ -119,7 +119,6 @@ int uwb_rc_beacon(struct uwb_rc *rc, int channel, unsigned bpst_offset)
        int result;
        struct device *dev = &rc->uwb_dev.dev;
 
-       mutex_lock(&rc->uwb_dev.mutex);
        if (channel < 0)
                channel = -1;
        if (channel == -1)
@@ -128,7 +127,7 @@ int uwb_rc_beacon(struct uwb_rc *rc, int channel, unsigned bpst_offset)
                /* channel >= 0...dah */
                result = uwb_rc_start_beacon(rc, bpst_offset, channel);
                if (result < 0)
-                       goto out_up;
+                       return result;
                if (le16_to_cpu(rc->ies->wIELength) > 0) {
                        result = uwb_rc_set_ie(rc, rc->ies);
                        if (result < 0) {
@@ -137,19 +136,12 @@ int uwb_rc_beacon(struct uwb_rc *rc, int channel, unsigned bpst_offset)
                                result = uwb_rc_stop_beacon(rc);
                                channel = -1;
                                bpst_offset = 0;
-                       } else
-                               result = 0;
+                       }
                }
        }
 
-       if (result < 0)
-               goto out_up;
-       rc->beaconing = channel;
-
-       uwb_notify(rc, NULL, uwb_bg_joined(rc) ? UWB_NOTIF_BG_JOIN : UWB_NOTIF_BG_LEAVE);
-
-out_up:
-       mutex_unlock(&rc->uwb_dev.mutex);
+       if (result >= 0)
+               rc->beaconing = channel;
        return result;
 }
 
@@ -168,12 +160,6 @@ out_up:
  * FIXME: use something faster for search than a list
  */
 
-struct uwb_beca uwb_beca = {
-       .list = LIST_HEAD_INIT(uwb_beca.list),
-       .mutex = __MUTEX_INITIALIZER(uwb_beca.mutex)
-};
-
-
 void uwb_bce_kfree(struct kref *_bce)
 {
        struct uwb_beca_e *bce = container_of(_bce, struct uwb_beca_e, refcnt);
@@ -185,10 +171,11 @@ void uwb_bce_kfree(struct kref *_bce)
 
 /* Find a beacon by dev addr in the cache */
 static
-struct uwb_beca_e *__uwb_beca_find_bydev(const struct uwb_dev_addr *dev_addr)
+struct uwb_beca_e *__uwb_beca_find_bydev(struct uwb_rc *rc,
+                                        const struct uwb_dev_addr *dev_addr)
 {
        struct uwb_beca_e *bce, *next;
-       list_for_each_entry_safe(bce, next, &uwb_beca.list, node) {
+       list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
                d_printf(6, NULL, "looking for addr %02x:%02x in %02x:%02x\n",
                         dev_addr->data[0], dev_addr->data[1],
                         bce->dev_addr.data[0], bce->dev_addr.data[1]);
@@ -202,10 +189,11 @@ out:
 
 /* Find a beacon by dev addr in the cache */
 static
-struct uwb_beca_e *__uwb_beca_find_bymac(const struct uwb_mac_addr *mac_addr)
+struct uwb_beca_e *__uwb_beca_find_bymac(struct uwb_rc *rc, 
+                                        const struct uwb_mac_addr *mac_addr)
 {
        struct uwb_beca_e *bce, *next;
-       list_for_each_entry_safe(bce, next, &uwb_beca.list, node) {
+       list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
                if (!memcmp(bce->mac_addr, mac_addr->data,
                            sizeof(struct uwb_mac_addr)))
                        goto out;
@@ -229,11 +217,11 @@ struct uwb_dev *uwb_dev_get_by_devaddr(struct uwb_rc *rc,
        struct uwb_dev *found = NULL;
        struct uwb_beca_e *bce;
 
-       mutex_lock(&uwb_beca.mutex);
-       bce = __uwb_beca_find_bydev(devaddr);
+       mutex_lock(&rc->uwb_beca.mutex);
+       bce = __uwb_beca_find_bydev(rc, devaddr);
        if (bce)
                found = uwb_dev_try_get(rc, bce->uwb_dev);
-       mutex_unlock(&uwb_beca.mutex);
+       mutex_unlock(&rc->uwb_beca.mutex);
 
        return found;
 }
@@ -249,11 +237,11 @@ struct uwb_dev *uwb_dev_get_by_macaddr(struct uwb_rc *rc,
        struct uwb_dev *found = NULL;
        struct uwb_beca_e *bce;
 
-       mutex_lock(&uwb_beca.mutex);
-       bce = __uwb_beca_find_bymac(macaddr);
+       mutex_lock(&rc->uwb_beca.mutex);
+       bce = __uwb_beca_find_bymac(rc, macaddr);
        if (bce)
                found = uwb_dev_try_get(rc, bce->uwb_dev);
-       mutex_unlock(&uwb_beca.mutex);
+       mutex_unlock(&rc->uwb_beca.mutex);
 
        return found;
 }
@@ -274,7 +262,9 @@ static void uwb_beca_e_init(struct uwb_beca_e *bce)
  * @bf:         Beacon frame (part of b, really)
  * @ts_jiffies: Timestamp (in jiffies) when the beacon was received
  */
-struct uwb_beca_e *__uwb_beca_add(struct uwb_rc_evt_beacon *be,
+static
+struct uwb_beca_e *__uwb_beca_add(struct uwb_rc *rc,
+                                 struct uwb_rc_evt_beacon *be,
                                  struct uwb_beacon_frame *bf,
                                  unsigned long ts_jiffies)
 {
@@ -286,7 +276,7 @@ struct uwb_beca_e *__uwb_beca_add(struct uwb_rc_evt_beacon *be,
        uwb_beca_e_init(bce);
        bce->ts_jiffies = ts_jiffies;
        bce->uwb_dev = NULL;
-       list_add(&bce->node, &uwb_beca.list);
+       list_add(&bce->node, &rc->uwb_beca.list);
        return bce;
 }
 
@@ -295,13 +285,13 @@ struct uwb_beca_e *__uwb_beca_add(struct uwb_rc_evt_beacon *be,
  *
  * Remove associated devicest too.
  */
-void uwb_beca_purge(void)
+void uwb_beca_purge(struct uwb_rc *rc)
 {
        struct uwb_beca_e *bce, *next;
        unsigned long expires;
 
-       mutex_lock(&uwb_beca.mutex);
-       list_for_each_entry_safe(bce, next, &uwb_beca.list, node) {
+       mutex_lock(&rc->uwb_beca.mutex);
+       list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
                expires = bce->ts_jiffies + msecs_to_jiffies(beacon_timeout_ms);
                if (time_after(jiffies, expires)) {
                        uwbd_dev_offair(bce);
@@ -309,19 +299,20 @@ void uwb_beca_purge(void)
                        uwb_bce_put(bce);
                }
        }
-       mutex_unlock(&uwb_beca.mutex);
+       mutex_unlock(&rc->uwb_beca.mutex);
 }
 
 /* Clean up the whole beacon cache. Called on shutdown */
-void uwb_beca_release(void)
+void uwb_beca_release(struct uwb_rc *rc)
 {
        struct uwb_beca_e *bce, *next;
-       mutex_lock(&uwb_beca.mutex);
-       list_for_each_entry_safe(bce, next, &uwb_beca.list, node) {
+
+       mutex_lock(&rc->uwb_beca.mutex);
+       list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
                list_del(&bce->node);
                uwb_bce_put(bce);
        }
-       mutex_unlock(&uwb_beca.mutex);
+       mutex_unlock(&rc->uwb_beca.mutex);
 }
 
 static void uwb_beacon_print(struct uwb_rc *rc, struct uwb_rc_evt_beacon *be,
@@ -349,22 +340,22 @@ ssize_t uwb_bce_print_IEs(struct uwb_dev *uwb_dev, struct uwb_beca_e *bce,
        ssize_t result = 0;
        struct uwb_rc_evt_beacon *be;
        struct uwb_beacon_frame *bf;
-       struct uwb_buf_ctx ctx = {
-               .buf = buf,
-               .bytes = 0,
-               .size = size
-       };
+       int ies_len;
+       struct uwb_ie_hdr *ies;
 
        mutex_lock(&bce->mutex);
+
        be = bce->be;
-       if (be == NULL)
-               goto out;
-       bf = (void *) be->BeaconInfo;
-       uwb_ie_for_each(uwb_dev, uwb_ie_dump_hex, &ctx,
-                       bf->IEData, be->wBeaconInfoLength - sizeof(*bf));
-       result = ctx.bytes;
-out:
+       if (be) {
+               bf = (struct uwb_beacon_frame *)bce->be->BeaconInfo;
+               ies_len = be->wBeaconInfoLength - sizeof(struct uwb_beacon_frame);
+               ies = (struct uwb_ie_hdr *)bf->IEData;
+
+               result = uwb_ie_dump_hex(ies, ies_len, buf, size);
+       }
+
        mutex_unlock(&bce->mutex);
+
        return result;
 }
 
@@ -437,18 +428,18 @@ int uwbd_evt_handle_rc_beacon(struct uwb_event *evt)
        if (uwb_mac_addr_bcast(&bf->Device_Identifier))
                return 0;
 
-       mutex_lock(&uwb_beca.mutex);
-       bce = __uwb_beca_find_bymac(&bf->Device_Identifier);
+       mutex_lock(&rc->uwb_beca.mutex);
+       bce = __uwb_beca_find_bymac(rc, &bf->Device_Identifier);
        if (bce == NULL) {
                /* Not in there, a new device is pinging */
                uwb_beacon_print(evt->rc, be, bf);
-               bce = __uwb_beca_add(be, bf, evt->ts_jiffies);
+               bce = __uwb_beca_add(rc, be, bf, evt->ts_jiffies);
                if (bce == NULL) {
-                       mutex_unlock(&uwb_beca.mutex);
+                       mutex_unlock(&rc->uwb_beca.mutex);
                        return -ENOMEM;
                }
        }
-       mutex_unlock(&uwb_beca.mutex);
+       mutex_unlock(&rc->uwb_beca.mutex);
 
        mutex_lock(&bce->mutex);
        /* purge old beacon data */
@@ -588,19 +579,6 @@ error:
        return result;
 }
 
-/**
- * uwb_bg_joined - is the RC in a beacon group?
- * @rc: the radio controller
- *
- * Returns true if the radio controller is in a beacon group (even if
- * it's the sole member).
- */
-int uwb_bg_joined(struct uwb_rc *rc)
-{
-       return rc->beaconing != -1;
-}
-EXPORT_SYMBOL_GPL(uwb_bg_joined);
-
 /*
  * Print beaconing state.
  */
@@ -619,9 +597,6 @@ static ssize_t uwb_rc_beacon_show(struct device *dev,
 
 /*
  * Start beaconing on the specified channel, or stop beaconing.
- *
- * The BPST offset of when to start searching for a beacon group to
- * join may be specified.
  */
 static ssize_t uwb_rc_beacon_store(struct device *dev,
                                   struct device_attribute *attr,
@@ -630,12 +605,11 @@ static ssize_t uwb_rc_beacon_store(struct device *dev,
        struct uwb_dev *uwb_dev = to_uwb_dev(dev);
        struct uwb_rc *rc = uwb_dev->rc;
        int channel;
-       unsigned bpst_offset = 0;
        ssize_t result = -EINVAL;
 
-       result = sscanf(buf, "%d %u\n", &channel, &bpst_offset);
+       result = sscanf(buf, "%d", &channel);
        if (result >= 1)
-               result = uwb_rc_beacon(rc, channel, bpst_offset);
+               result = uwb_radio_force_channel(rc, channel);
 
        return result < 0 ? result : size;
 }
index 521cdeb849710823f1b14adb466d3b5515a2dab3..f57c26580de2b761865f4659ce23a1718d8f21cf 100644 (file)
@@ -118,7 +118,6 @@ static int __init uwb_subsys_init(void)
        result = class_register(&uwb_rc_class);
        if (result < 0)
                goto error_uwb_rc_class_register;
-       uwbd_start();
        uwb_dbg_init();
        return 0;
 
@@ -132,7 +131,6 @@ module_init(uwb_subsys_init);
 static void __exit uwb_subsys_exit(void)
 {
        uwb_dbg_exit();
-       uwbd_stop();
        class_unregister(&uwb_rc_class);
        uwb_est_destroy();
        return;
index 882724c5f12627490a806355b5cb91d52bc41b8d..75491d47806b5c162795bea661e8682f813b05bd 100644 (file)
@@ -16,7 +16,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/random.h>
 #include <linux/uwb.h>
index c0b1e5e2bd08a7245427516e1e95e57aaeb70470..fe328146adb7844f3ab0ba5efd5e7505d9b2b965 100644 (file)
  *
  * A DRP Availability IE is appended.
  *
- * rc->uwb_dev.mutex is held
+ * rc->rsvs_mutex is held
  *
  * FIXME We currently ignore the returned value indicating the remaining space
  * in beacon. This could be used to deny reservation requests earlier if
  * determined that they would cause the beacon space to be exceeded.
  */
-static
-int uwb_rc_gen_send_drp_ie(struct uwb_rc *rc)
+int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
 {
        int result;
        struct device *dev = &rc->uwb_dev.dev;
@@ -102,25 +101,6 @@ error_cmd:
        kfree(cmd);
 error:
        return result;
-
-}
-/**
- * Send all DRP IEs associated with this host
- *
- * @returns:    >= 0 number of bytes still available in the beacon
- *              < 0 errno code on error.
- *
- * As per the protocol we obtain the host controller device lock to access
- * bandwidth structures.
- */
-int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
-{
-       int result;
-
-       mutex_lock(&rc->uwb_dev.mutex);
-       result = uwb_rc_gen_send_drp_ie(rc);
-       mutex_unlock(&rc->uwb_dev.mutex);
-       return result;
 }
 
 void uwb_drp_handle_timeout(struct uwb_rsv *rsv)
index 3d26fa0f8ae198c2fedd0f9db738cb2dd41421c2..158e98d08af92ccce69319fbb909304e912d5de1 100644 (file)
@@ -51,7 +51,6 @@
  *
  *
  */
-#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/usb.h>
@@ -882,6 +881,24 @@ static void hwarc_disconnect(struct usb_interface *iface)
        uwb_rc_put(uwb_rc);     /* when creating the device, refcount = 1 */
 }
 
+static int hwarc_pre_reset(struct usb_interface *iface)
+{
+       struct hwarc *hwarc = usb_get_intfdata(iface);
+       struct uwb_rc *uwb_rc = hwarc->uwb_rc;
+
+       uwb_rc_pre_reset(uwb_rc);
+       return 0;
+}
+
+static int hwarc_post_reset(struct usb_interface *iface)
+{
+       struct hwarc *hwarc = usb_get_intfdata(iface);
+       struct uwb_rc *uwb_rc = hwarc->uwb_rc;
+
+       uwb_rc_post_reset(uwb_rc);
+       return 0;
+}
+
 /** USB device ID's that we handle */
 static struct usb_device_id hwarc_id_table[] = {
        /* D-Link DUB-1210 */
@@ -898,9 +915,11 @@ MODULE_DEVICE_TABLE(usb, hwarc_id_table);
 
 static struct usb_driver hwarc_driver = {
        .name =         "hwa-rc",
+       .id_table =     hwarc_id_table,
        .probe =        hwarc_probe,
        .disconnect =   hwarc_disconnect,
-       .id_table =     hwarc_id_table,
+       .pre_reset =    hwarc_pre_reset,
+       .post_reset =   hwarc_post_reset,
 };
 
 static int __init hwarc_driver_init(void)
index 98eeeff051aa13c629ff229c7060e2acb6585c32..b7ea525fc06a80243287b1d8ef1cad8ebdf248ff 100644 (file)
@@ -35,7 +35,6 @@
  * the functions are i1480_usb_NAME().
  */
 #include <linux/module.h>
-#include <linux/version.h>
 #include <linux/usb.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
index 737d60cd5b73204476472ad3d6fcf550209d303c..488b2e30a0a8b6d684e9ca686dc074ceb75442ee 100644 (file)
@@ -55,7 +55,6 @@
  *                          is being removed.
  *         i1480u_rm()
  */
-#include <linux/version.h>
 #include <linux/if_arp.h>
 #include <linux/etherdevice.h>
 #include <linux/uwb/debug.h>
@@ -207,7 +206,7 @@ int i1480u_add(struct i1480u *i1480u, struct usb_interface *iface)
        wlp->fill_device_info = i1480u_fill_device_info;
        wlp->stop_queue = i1480u_stop_queue;
        wlp->start_queue = i1480u_start_queue;
-       result = wlp_setup(wlp, rc);
+       result = wlp_setup(wlp, rc, net_dev);
        if (result < 0) {
                dev_err(&iface->dev, "Cannot setup WLP\n");
                goto error_wlp_setup;
index 8802ac43d872360b48bd89259096ddc92f9dadb5..2eafb973cd05ab4d2f107a5a02083b8abf6ac2d8 100644 (file)
@@ -207,6 +207,11 @@ int i1480u_open(struct net_device *net_dev)
        result = i1480u_rx_setup(i1480u);               /* Alloc RX stuff */
        if (result < 0)
                goto error_rx_setup;
+
+       result = uwb_radio_start(&wlp->pal);
+       if (result < 0)
+               goto error_radio_start;
+
        netif_wake_queue(net_dev);
 #ifdef i1480u_FLOW_CONTROL
        result = usb_submit_urb(i1480u->notif_urb, GFP_KERNEL);;
@@ -215,25 +220,20 @@ int i1480u_open(struct net_device *net_dev)
                goto error_notif_urb_submit;
        }
 #endif
-       i1480u->uwb_notifs_handler.cb = i1480u_uwb_notifs_cb;
-       i1480u->uwb_notifs_handler.data = i1480u;
-       if (uwb_bg_joined(rc))
-               netif_carrier_on(net_dev);
-       else
-               netif_carrier_off(net_dev);
-       uwb_notifs_register(rc, &i1480u->uwb_notifs_handler);
        /* Interface is up with an address, now we can create WSS */
        result = wlp_wss_setup(net_dev, &wlp->wss);
        if (result < 0) {
                dev_err(dev, "Can't create WSS: %d. \n", result);
-               goto error_notif_deregister;
+               goto error_wss_setup;
        }
        return 0;
-error_notif_deregister:
-       uwb_notifs_deregister(rc, &i1480u->uwb_notifs_handler);
+error_wss_setup:
 #ifdef i1480u_FLOW_CONTROL
+       usb_kill_urb(i1480u->notif_urb);
 error_notif_urb_submit:
 #endif
+       uwb_radio_stop(&wlp->pal);
+error_radio_start:
        netif_stop_queue(net_dev);
        i1480u_rx_release(i1480u);
 error_rx_setup:
@@ -248,16 +248,15 @@ int i1480u_stop(struct net_device *net_dev)
 {
        struct i1480u *i1480u = netdev_priv(net_dev);
        struct wlp *wlp = &i1480u->wlp;
-       struct uwb_rc *rc = wlp->rc;
 
        BUG_ON(wlp->rc == NULL);
        wlp_wss_remove(&wlp->wss);
-       uwb_notifs_deregister(rc, &i1480u->uwb_notifs_handler);
        netif_carrier_off(net_dev);
 #ifdef i1480u_FLOW_CONTROL
        usb_kill_urb(i1480u->notif_urb);
 #endif
        netif_stop_queue(net_dev);
+       uwb_radio_stop(&wlp->pal);
        i1480u_rx_release(i1480u);
        i1480u_tx_release(i1480u);
        return 0;
@@ -303,34 +302,6 @@ int i1480u_change_mtu(struct net_device *net_dev, int mtu)
        return 0;
 }
 
-
-/**
- * Callback function to handle events from UWB
- * When we see other devices we know the carrier is ok,
- * if we are the only device in the beacon group we set the carrier
- * state to off.
- * */
-void i1480u_uwb_notifs_cb(void *data, struct uwb_dev *uwb_dev,
-                         enum uwb_notifs event)
-{
-       struct i1480u *i1480u = data;
-       struct net_device *net_dev = i1480u->net_dev;
-       struct device *dev = &i1480u->usb_iface->dev;
-       switch (event) {
-       case UWB_NOTIF_BG_JOIN:
-               netif_carrier_on(net_dev);
-               dev_info(dev, "Link is up\n");
-               break;
-       case UWB_NOTIF_BG_LEAVE:
-               netif_carrier_off(net_dev);
-               dev_info(dev, "Link is down\n");
-               break;
-       default:
-               dev_err(dev, "don't know how to handle event %d from uwb\n",
-                               event);
-       }
-}
-
 /**
  * Stop the network queue
  *
index a1d8ca6ac93514ecbd0ffec158c98a9f71207fcc..a92a787725fcc55bdbd478f08fafef61025b1cf5 100644 (file)
@@ -226,7 +226,6 @@ ssize_t wlp_tx_inflight_store(struct i1480u_tx_inflight *inflight,
  * (CLASS_DEVICE_ATTR or DEVICE_ATTR) and i1480u_ATTR_NAME produces a
  * class_device_attr_NAME or device_attr_NAME (for group registration).
  */
-#include <linux/version.h>
 
 #define i1480u_SHOW(name, fn, param)                           \
 static ssize_t i1480u_show_##name(struct device *dev,          \
diff --git a/drivers/uwb/ie-rcv.c b/drivers/uwb/ie-rcv.c
new file mode 100644 (file)
index 0000000..917e6d7
--- /dev/null
@@ -0,0 +1,55 @@
+/*
+ * Ultra Wide Band
+ * IE Received notification handling.
+ *
+ * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/bitmap.h>
+#include "uwb-internal.h"
+
+/*
+ * Process an incoming IE Received notification.
+ */
+int uwbd_evt_handle_rc_ie_rcv(struct uwb_event *evt)
+{
+       int result = -EINVAL;
+       struct device *dev = &evt->rc->uwb_dev.dev;
+       struct uwb_rc_evt_ie_rcv *iercv;
+       size_t iesize;
+
+       /* Is there enough data to decode it? */
+       if (evt->notif.size < sizeof(*iercv)) {
+               dev_err(dev, "IE Received notification: Not enough data to "
+                       "decode (%zu vs %zu bytes needed)\n",
+                       evt->notif.size, sizeof(*iercv));
+               goto error;
+       }
+       iercv = container_of(evt->notif.rceb, struct uwb_rc_evt_ie_rcv, rceb);
+       iesize = le16_to_cpu(iercv->wIELength);
+
+       dev_dbg(dev, "IE received, element ID=%d\n", iercv->IEData[0]);
+
+       if (iercv->IEData[0] == UWB_RELINQUISH_REQUEST_IE) {
+               dev_warn(dev, "unhandled Relinquish Request IE\n");
+       }
+
+       return 0;
+error:
+       return result;
+}
index cf6f3d152b9de05e98fac9a2fbc47a30c467433f..ab976686175be5694589192636d69d685979b90c 100644 (file)
@@ -25,8 +25,6 @@
  */
 
 #include "uwb-internal.h"
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
 
 /**
  * uwb_ie_next - get the next IE in a buffer
@@ -60,6 +58,42 @@ struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len)
 }
 EXPORT_SYMBOL_GPL(uwb_ie_next);
 
+/**
+ * uwb_ie_dump_hex - print IEs to a character buffer
+ * @ies: the IEs to print.
+ * @len: length of all the IEs.
+ * @buf: the destination buffer.
+ * @size: size of @buf.
+ *
+ * Returns the number of characters written.
+ */
+int uwb_ie_dump_hex(const struct uwb_ie_hdr *ies, size_t len,
+                   char *buf, size_t size)
+{
+       void *ptr;
+       const struct uwb_ie_hdr *ie;
+       int r = 0;
+       u8 *d;
+
+       ptr = (void *)ies;
+       for (;;) {
+               ie = uwb_ie_next(&ptr, &len);
+               if (!ie)
+                       break;
+
+               r += scnprintf(buf + r, size - r, "%02x %02x",
+                              (unsigned)ie->element_id,
+                              (unsigned)ie->length);
+               d = (uint8_t *)ie + sizeof(struct uwb_ie_hdr);
+               while (d != ptr && r < size)
+                       r += scnprintf(buf + r, size - r, " %02x", (unsigned)*d++);
+               if (r < size)
+                       buf[r++] = '\n';
+       };
+
+       return r;
+}
+
 /**
  * Get the IEs that a radio controller is sending in its beacon
  *
@@ -70,6 +104,7 @@ EXPORT_SYMBOL_GPL(uwb_ie_next);
  * anything. Once done with the iedata buffer, call
  * uwb_rc_ie_release(iedata). Don't call kfree on it.
  */
+static
 ssize_t uwb_rc_get_ie(struct uwb_rc *uwb_rc, struct uwb_rc_evt_get_ie **pget_ie)
 {
        ssize_t result;
@@ -78,148 +113,35 @@ ssize_t uwb_rc_get_ie(struct uwb_rc *uwb_rc, struct uwb_rc_evt_get_ie **pget_ie)
        struct uwb_rceb *reply = NULL;
        struct uwb_rc_evt_get_ie *get_ie;
 
-       d_fnstart(3, dev, "(%p, %p)\n", uwb_rc, pget_ie);
-       result = -ENOMEM;
        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
        if (cmd == NULL)
-               goto error_kzalloc;
+               return -ENOMEM;
+
        cmd->bCommandType = UWB_RC_CET_GENERAL;
        cmd->wCommand = cpu_to_le16(UWB_RC_CMD_GET_IE);
        result = uwb_rc_vcmd(uwb_rc, "GET_IE", cmd, sizeof(*cmd),
                             UWB_RC_CET_GENERAL, UWB_RC_CMD_GET_IE,
                             &reply);
+       kfree(cmd);
        if (result < 0)
-               goto error_cmd;
+               return result;
+
        get_ie = container_of(reply, struct uwb_rc_evt_get_ie, rceb);
        if (result < sizeof(*get_ie)) {
                dev_err(dev, "not enough data returned for decoding GET IE "
                        "(%zu bytes received vs %zu needed)\n",
                        result, sizeof(*get_ie));
-               result = -EINVAL;
+               return -EINVAL;
        } else if (result < sizeof(*get_ie) + le16_to_cpu(get_ie->wIELength)) {
                dev_err(dev, "not enough data returned for decoding GET IE "
                        "payload (%zu bytes received vs %zu needed)\n", result,
                        sizeof(*get_ie) + le16_to_cpu(get_ie->wIELength));
-               result = -EINVAL;
-       } else
-               *pget_ie = get_ie;
-error_cmd:
-       kfree(cmd);
-error_kzalloc:
-       d_fnend(3, dev, "(%p, %p) = %d\n", uwb_rc, pget_ie, (int)result);
-       return result;
-}
-EXPORT_SYMBOL_GPL(uwb_rc_get_ie);
-
-
-/*
- * Given a pointer to an IE, print it in ASCII/hex followed by a new line
- *
- * @ie_hdr: pointer to the IE header. Length is in there, and it is
- *          guaranteed that the ie_hdr->length bytes following it are
- *          safely accesible.
- *
- * @_data: context data passed from uwb_ie_for_each(), an struct output_ctx
- */
-int uwb_ie_dump_hex(struct uwb_dev *uwb_dev, const struct uwb_ie_hdr *ie_hdr,
-                   size_t offset, void *_ctx)
-{
-       struct uwb_buf_ctx *ctx = _ctx;
-       const u8 *pl = (void *)(ie_hdr + 1);
-       u8 pl_itr;
-
-       ctx->bytes += scnprintf(ctx->buf + ctx->bytes, ctx->size - ctx->bytes,
-                               "%02x %02x ", (unsigned) ie_hdr->element_id,
-                               (unsigned) ie_hdr->length);
-       pl_itr = 0;
-       while (pl_itr < ie_hdr->length && ctx->bytes < ctx->size)
-               ctx->bytes += scnprintf(ctx->buf + ctx->bytes,
-                                       ctx->size - ctx->bytes,
-                                       "%02x ", (unsigned) pl[pl_itr++]);
-       if (ctx->bytes < ctx->size)
-               ctx->buf[ctx->bytes++] = '\n';
-       return 0;
-}
-EXPORT_SYMBOL_GPL(uwb_ie_dump_hex);
-
-
-/**
- * Verify that a pointer in a buffer points to valid IE
- *
- * @start: pointer to start of buffer in which IE appears
- * @itr:   pointer to IE inside buffer that will be verified
- * @top:   pointer to end of buffer
- *
- * @returns: 0 if IE is valid, <0 otherwise
- *
- * Verification involves checking that the buffer can contain a
- * header and the amount of data reported in the IE header can be found in
- * the buffer.
- */
-static
-int uwb_rc_ie_verify(struct uwb_dev *uwb_dev, const void *start,
-                    const void *itr, const void *top)
-{
-       struct device *dev = &uwb_dev->dev;
-       const struct uwb_ie_hdr *ie_hdr;
-
-       if (top - itr < sizeof(*ie_hdr)) {
-               dev_err(dev, "Bad IE: no data to decode header "
-                       "(%zu bytes left vs %zu needed) at offset %zu\n",
-                       top - itr, sizeof(*ie_hdr), itr - start);
-               return -EINVAL;
-       }
-       ie_hdr = itr;
-       itr += sizeof(*ie_hdr);
-       if (top - itr < ie_hdr->length) {
-               dev_err(dev, "Bad IE: not enough data for payload "
-                       "(%zu bytes left vs %zu needed) at offset %zu\n",
-                       top - itr, (size_t)ie_hdr->length,
-                       (void *)ie_hdr - start);
                return -EINVAL;
        }
-       return 0;
-}
 
-
-/**
- * Walk a buffer filled with consecutive IE's a buffer
- *
- * @uwb_dev: UWB device this IEs belong to (for err messages mainly)
- *
- * @fn: function to call with each IE; if it returns 0, we keep
- *      traversing the buffer. If it returns !0, we'll stop and return
- *      that value.
- *
- * @data: pointer passed to @fn
- *
- * @buf: buffer where the consecutive IEs are located
- *
- * @size: size of @buf
- *
- * Each IE is checked for basic correctness (there is space left for
- * the header and the payload). If that test is failed, we stop
- * processing. For every good IE, @fn is called.
- */
-ssize_t uwb_ie_for_each(struct uwb_dev *uwb_dev, uwb_ie_f fn, void *data,
-                       const void *buf, size_t size)
-{
-       ssize_t result = 0;
-       const struct uwb_ie_hdr *ie_hdr;
-       const void *itr = buf, *top = itr + size;
-
-       while (itr < top) {
-               if (uwb_rc_ie_verify(uwb_dev, buf, itr, top) != 0)
-                       break;
-               ie_hdr = itr;
-               itr += sizeof(*ie_hdr) + ie_hdr->length;
-               result = fn(uwb_dev, ie_hdr, itr - buf, data);
-               if (result != 0)
-                       break;
-       }
+       *pget_ie = get_ie;
        return result;
 }
-EXPORT_SYMBOL_GPL(uwb_ie_for_each);
 
 
 /**
@@ -256,70 +178,6 @@ error_cmd:
        return result;
 }
 
-/**
- * Determine by IE id if IE is host settable
- * WUSB 1.0 [8.6.2.8 Table 8.85]
- *
- * EXCEPTION:
- * All but UWB_IE_WLP appears in Table 8.85 from WUSB 1.0. Setting this IE
- * is required for the WLP substack to perform association with its WSS so
- * we hope that the WUSB spec will be changed to reflect this.
- */
-static
-int uwb_rc_ie_is_host_settable(enum uwb_ie element_id)
-{
-       if (element_id == UWB_PCA_AVAILABILITY ||
-           element_id == UWB_BP_SWITCH_IE ||
-           element_id == UWB_MAC_CAPABILITIES_IE ||
-           element_id == UWB_PHY_CAPABILITIES_IE ||
-           element_id == UWB_APP_SPEC_PROBE_IE ||
-           element_id == UWB_IDENTIFICATION_IE ||
-           element_id == UWB_MASTER_KEY_ID_IE ||
-           element_id == UWB_IE_WLP ||
-           element_id == UWB_APP_SPEC_IE)
-               return 1;
-       return 0;
-}
-
-
-/**
- * Extract Host Settable IEs from IE
- *
- * @ie_data: pointer to buffer containing all IEs
- * @size:    size of buffer
- *
- * @returns: length of buffer that only includes host settable IEs
- *
- * Given a buffer of IEs we move all Host Settable IEs to front of buffer
- * by overwriting the IEs that are not Host Settable.
- * Buffer length is adjusted accordingly.
- */
-static
-ssize_t uwb_rc_parse_host_settable_ie(struct uwb_dev *uwb_dev,
-                                     void *ie_data, size_t size)
-{
-       size_t new_len = size;
-       struct uwb_ie_hdr *ie_hdr;
-       size_t ie_length;
-       void *itr = ie_data, *top = itr + size;
-
-       while (itr < top) {
-               if (uwb_rc_ie_verify(uwb_dev, ie_data, itr, top) != 0)
-                       break;
-               ie_hdr = itr;
-               ie_length = sizeof(*ie_hdr) + ie_hdr->length;
-               if (uwb_rc_ie_is_host_settable(ie_hdr->element_id)) {
-                       itr += ie_length;
-               } else {
-                       memmove(itr, itr + ie_length, top - (itr + ie_length));
-                       new_len -= ie_length;
-                       top -= ie_length;
-               }
-       }
-       return new_len;
-}
-
-
 /* Cleanup the whole IE management subsystem */
 void uwb_rc_ie_init(struct uwb_rc *uwb_rc)
 {
@@ -328,49 +186,34 @@ void uwb_rc_ie_init(struct uwb_rc *uwb_rc)
 
 
 /**
- * Set up cache for host settable IEs currently being transmitted
+ * uwb_rc_ie_setup - setup a radio controller's IE manager
+ * @uwb_rc: the radio controller.
  *
- * First we just call GET-IE to get the current IEs being transmitted
- * (or we workaround and pretend we did) and (because the format is
- * the same) reuse that as the IE cache (with the command prefix, as
- * explained in 'struct uwb_rc').
+ * The current set of IEs are obtained from the hardware with a GET-IE
+ * command (since the radio controller is not yet beaconing this will
+ * be just the hardware's MAC and PHY Capability IEs).
  *
- * @returns: size of cache created
+ * Returns 0 on success; -ve on an error.
  */
-ssize_t uwb_rc_ie_setup(struct uwb_rc *uwb_rc)
+int uwb_rc_ie_setup(struct uwb_rc *uwb_rc)
 {
-       struct device *dev = &uwb_rc->uwb_dev.dev;
-       ssize_t result;
-       size_t capacity;
-       struct uwb_rc_evt_get_ie *ie_info;
+       struct uwb_rc_evt_get_ie *ie_info = NULL;
+       int capacity;
+
+       capacity = uwb_rc_get_ie(uwb_rc, &ie_info);
+       if (capacity < 0)
+               return capacity;
 
-       d_fnstart(3, dev, "(%p)\n", uwb_rc);
        mutex_lock(&uwb_rc->ies_mutex);
-       result = uwb_rc_get_ie(uwb_rc, &ie_info);
-       if (result < 0)
-               goto error_get_ie;
-       capacity = result;
-       d_printf(5, dev, "Got IEs %zu bytes (%zu long at %p)\n", result,
-                (size_t)le16_to_cpu(ie_info->wIELength), ie_info);
-
-       /* Remove IEs that host should not set. */
-       result = uwb_rc_parse_host_settable_ie(&uwb_rc->uwb_dev,
-                       ie_info->IEData, le16_to_cpu(ie_info->wIELength));
-       if (result < 0)
-               goto error_parse;
-       d_printf(5, dev, "purged non-settable IEs to %zu bytes\n", result);
-       uwb_rc->ies = (void *) ie_info;
+
+       uwb_rc->ies = (struct uwb_rc_cmd_set_ie *)ie_info;
        uwb_rc->ies->rccb.bCommandType = UWB_RC_CET_GENERAL;
        uwb_rc->ies->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_IE);
        uwb_rc->ies_capacity = capacity;
-       d_printf(5, dev, "IE cache at %p %zu bytes, %zu capacity\n",
-                ie_info, result, capacity);
-       result = 0;
-error_parse:
-error_get_ie:
+
        mutex_unlock(&uwb_rc->ies_mutex);
-       d_fnend(3, dev, "(%p) = %zu\n", uwb_rc, result);
-       return result;
+
+       return 0;
 }
 
 
@@ -383,26 +226,47 @@ void uwb_rc_ie_release(struct uwb_rc *uwb_rc)
 }
 
 
-static
-int __acc_size(struct uwb_dev *uwb_dev, const struct uwb_ie_hdr *ie_hdr,
-              size_t offset, void *_ctx)
+static int uwb_rc_ie_add_one(struct uwb_rc *rc, const struct uwb_ie_hdr *new_ie)
 {
-       size_t *acc_size = _ctx;
-       *acc_size += sizeof(*ie_hdr) + ie_hdr->length;
-       d_printf(6, &uwb_dev->dev, "new acc size %zu\n", *acc_size);
+       struct uwb_rc_cmd_set_ie *new_ies;
+       void *ptr, *prev_ie;
+       struct uwb_ie_hdr *ie;
+       size_t length, new_ie_len, new_capacity, size, prev_size;
+
+       length = le16_to_cpu(rc->ies->wIELength);
+       new_ie_len = sizeof(struct uwb_ie_hdr) + new_ie->length;
+       new_capacity = sizeof(struct uwb_rc_cmd_set_ie) + length + new_ie_len;
+
+       if (new_capacity > rc->ies_capacity) {
+               new_ies = krealloc(rc->ies, new_capacity, GFP_KERNEL);
+               if (!new_ies)
+                       return -ENOMEM;
+               rc->ies = new_ies;
+       }
+
+       ptr = rc->ies->IEData;
+       size = length;
+       for (;;) {
+               prev_ie = ptr;
+               prev_size = size;
+               ie = uwb_ie_next(&ptr, &size);
+               if (!ie || ie->element_id > new_ie->element_id)
+                       break;
+       }
+
+       memmove(prev_ie + new_ie_len, prev_ie, prev_size);
+       memcpy(prev_ie, new_ie, new_ie_len);
+       rc->ies->wIELength = cpu_to_le16(length + new_ie_len);
+
        return 0;
 }
 
-
 /**
- * Add a new IE to IEs currently being transmitted by device
- *
+ * uwb_rc_ie_add - add new IEs to the radio controller's beacon
+ * @uwb_rc: the radio controller.
  * @ies: the buffer containing the new IE or IEs to be added to
- *       the device's beacon. The buffer will be verified for
- *       consistence (meaning the headers should be right) and
- *       consistent with the buffer size.
- * @size: size of @ies (in bytes, total buffer size)
- * @returns: 0 if ok, <0 errno code on error
+ *       the device's beacon.
+ * @size: length of all the IEs.
  *
  * According to WHCI 0.95 [4.13.6] the driver will only receive the RCEB
  * after the device sent the first beacon that includes the IEs specified
@@ -411,66 +275,40 @@ int __acc_size(struct uwb_dev *uwb_dev, const struct uwb_ie_hdr *ie_hdr,
  * we start beaconing.
  *
  * Setting an IE on the device will overwrite all current IEs in device. So
- * we take the current IEs being transmitted by the device, append the
+ * we take the current IEs being transmitted by the device, insert the
  * new one, and call SET IE with all the IEs needed.
  *
- * The local IE cache will only be updated with the new IE if SET IE
- * completed successfully.
+ * Returns 0 on success; or -ENOMEM.
  */
 int uwb_rc_ie_add(struct uwb_rc *uwb_rc,
                  const struct uwb_ie_hdr *ies, size_t size)
 {
        int result = 0;
-       struct device *dev = &uwb_rc->uwb_dev.dev;
-       struct uwb_rc_cmd_set_ie *new_ies;
-       size_t ies_size, total_size, acc_size = 0;
-
-       if (uwb_rc->ies == NULL)
-               return -ESHUTDOWN;
-       uwb_ie_for_each(&uwb_rc->uwb_dev, __acc_size, &acc_size, ies, size);
-       if (acc_size != size) {
-               dev_err(dev, "BUG: bad IEs, misconstructed headers "
-                       "[%zu bytes reported vs %zu calculated]\n",
-                       size, acc_size);
-               WARN_ON(1);
-               return -EINVAL;
-       }
+       void *ptr;
+       const struct uwb_ie_hdr *ie;
+
        mutex_lock(&uwb_rc->ies_mutex);
-       ies_size = le16_to_cpu(uwb_rc->ies->wIELength);
-       total_size = sizeof(*uwb_rc->ies) + ies_size;
-       if (total_size + size > uwb_rc->ies_capacity) {
-               d_printf(4, dev, "Reallocating IE cache from %p capacity %zu "
-                        "to capacity %zu\n", uwb_rc->ies, uwb_rc->ies_capacity,
-                        total_size + size);
-               new_ies = kzalloc(total_size + size, GFP_KERNEL);
-               if (new_ies == NULL) {
-                       dev_err(dev, "No memory for adding new IE\n");
-                       result = -ENOMEM;
-                       goto error_alloc;
-               }
-               memcpy(new_ies, uwb_rc->ies, total_size);
-               uwb_rc->ies_capacity = total_size + size;
-               kfree(uwb_rc->ies);
-               uwb_rc->ies = new_ies;
-               d_printf(4, dev, "New IE cache at %p capacity %zu\n",
-                        uwb_rc->ies, uwb_rc->ies_capacity);
+
+       ptr = (void *)ies;
+       for (;;) {
+               ie = uwb_ie_next(&ptr, &size);
+               if (!ie)
+                       break;
+
+               result = uwb_rc_ie_add_one(uwb_rc, ie);
+               if (result < 0)
+                       break;
        }
-       memcpy((void *)uwb_rc->ies + total_size, ies, size);
-       uwb_rc->ies->wIELength = cpu_to_le16(ies_size + size);
-       if (uwb_rc->beaconing != -1) {
-               result = uwb_rc_set_ie(uwb_rc, uwb_rc->ies);
-               if (result < 0) {
-                       dev_err(dev, "Cannot set new IE on device: %d\n",
-                               result);
-                       uwb_rc->ies->wIELength = cpu_to_le16(ies_size);
+       if (result >= 0) {
+               if (size == 0) {
+                       if (uwb_rc->beaconing != -1)
+                               result = uwb_rc_set_ie(uwb_rc, uwb_rc->ies);
                } else
-                       result = 0;
+                       result = -EINVAL;
        }
-       d_printf(4, dev, "IEs now occupy %hu bytes of %zu capacity at %p\n",
-                le16_to_cpu(uwb_rc->ies->wIELength), uwb_rc->ies_capacity,
-                uwb_rc->ies);
-error_alloc:
+
        mutex_unlock(&uwb_rc->ies_mutex);
+
        return result;
 }
 EXPORT_SYMBOL_GPL(uwb_rc_ie_add);
@@ -489,53 +327,52 @@ EXPORT_SYMBOL_GPL(uwb_rc_ie_add);
  * beacon. We don't reallocate, we just mark the size smaller.
  */
 static
-int uwb_rc_ie_cache_rm(struct uwb_rc *uwb_rc, enum uwb_ie to_remove)
+void uwb_rc_ie_cache_rm(struct uwb_rc *uwb_rc, enum uwb_ie to_remove)
 {
-       struct uwb_ie_hdr *ie_hdr;
-       size_t new_len = le16_to_cpu(uwb_rc->ies->wIELength);
-       void *itr = uwb_rc->ies->IEData;
-       void *top = itr + new_len;
-
-       while (itr < top) {
-               ie_hdr = itr;
-               if (ie_hdr->element_id != to_remove) {
-                       itr += sizeof(*ie_hdr) + ie_hdr->length;
-               } else {
-                       int ie_length;
-                       ie_length = sizeof(*ie_hdr) + ie_hdr->length;
-                       if (top - itr != ie_length)
-                               memmove(itr, itr + ie_length, top - itr + ie_length);
-                       top -= ie_length;
-                       new_len -= ie_length;
+       struct uwb_ie_hdr *ie;
+       size_t len = le16_to_cpu(uwb_rc->ies->wIELength);
+       void *ptr;
+       size_t size;
+
+       ptr = uwb_rc->ies->IEData;
+       size = len;
+       for (;;) {
+               ie = uwb_ie_next(&ptr, &size);
+               if (!ie)
+                       break;
+               if (ie->element_id == to_remove) {
+                       len -= sizeof(struct uwb_ie_hdr) + ie->length;
+                       memmove(ie, ptr, size);
+                       ptr = ie;
                }
        }
-       uwb_rc->ies->wIELength = cpu_to_le16(new_len);
-       return 0;
+       uwb_rc->ies->wIELength = cpu_to_le16(len);
 }
 
 
 /**
- * Remove an IE currently being transmitted by device
+ * uwb_rc_ie_rm - remove an IE from the radio controller's beacon
+ * @uwb_rc: the radio controller.
+ * @element_id: the element ID of the IE to remove.
  *
- * @element_id: id of IE to be removed from device's beacon
+ * Only IEs previously added with uwb_rc_ie_add() may be removed.
+ *
+ * Returns 0 on success; or -ve the SET-IE command to the radio
+ * controller failed.
  */
 int uwb_rc_ie_rm(struct uwb_rc *uwb_rc, enum uwb_ie element_id)
 {
-       struct device *dev = &uwb_rc->uwb_dev.dev;
-       int result;
+       int result = 0;
 
-       if (uwb_rc->ies == NULL)
-               return -ESHUTDOWN;
        mutex_lock(&uwb_rc->ies_mutex);
-       result = uwb_rc_ie_cache_rm(uwb_rc, element_id);
-       if (result < 0)
-               dev_err(dev, "Cannot remove IE from cache.\n");
-       if (uwb_rc->beaconing != -1) {
+
+       uwb_rc_ie_cache_rm(uwb_rc, element_id);
+
+       if (uwb_rc->beaconing != -1)
                result = uwb_rc_set_ie(uwb_rc, uwb_rc->ies);
-               if (result < 0)
-                       dev_err(dev, "Cannot set new IE on device.\n");
-       }
+
        mutex_unlock(&uwb_rc->ies_mutex);
+
        return result;
 }
 EXPORT_SYMBOL_GPL(uwb_rc_ie_rm);
index ee5772f00d4269e6eca5c2125a3701360880824a..9cf21e6bb624e036b6f698bc975f7e66080ca16e 100644 (file)
@@ -36,8 +36,6 @@
 #include <linux/etherdevice.h>
 #include <linux/usb.h>
 
-#define D_LOCAL 1
-#include <linux/uwb/debug.h>
 #include "uwb-internal.h"
 
 static int uwb_rc_index_match(struct device *dev, void *data)
@@ -81,9 +79,7 @@ static void uwb_rc_sys_release(struct device *dev)
        struct uwb_dev *uwb_dev = container_of(dev, struct uwb_dev, dev);
        struct uwb_rc *rc = container_of(uwb_dev, struct uwb_rc, uwb_dev);
 
-       uwb_rc_neh_destroy(rc);
        uwb_rc_ie_release(rc);
-       d_printf(1, dev, "freed uwb_rc %p\n", rc);
        kfree(rc);
 }
 
@@ -100,6 +96,8 @@ void uwb_rc_init(struct uwb_rc *rc)
        rc->scan_type = UWB_SCAN_DISABLED;
        INIT_LIST_HEAD(&rc->notifs_chain.list);
        mutex_init(&rc->notifs_chain.mutex);
+       INIT_LIST_HEAD(&rc->uwb_beca.list);
+       mutex_init(&rc->uwb_beca.mutex);
        uwb_drp_avail_init(rc);
        uwb_rc_ie_init(rc);
        uwb_rsv_init(rc);
@@ -191,9 +189,9 @@ static int uwb_rc_setup(struct uwb_rc *rc)
        int result;
        struct device *dev = &rc->uwb_dev.dev;
 
-       result = uwb_rc_reset(rc);
+       result = uwb_radio_setup(rc);
        if (result < 0) {
-               dev_err(dev, "cannot reset UWB radio: %d\n", result);
+               dev_err(dev, "cannot setup UWB radio: %d\n", result);
                goto error;
        }
        result = uwb_rc_mac_addr_setup(rc);
@@ -250,6 +248,12 @@ int uwb_rc_add(struct uwb_rc *rc, struct device *parent_dev, void *priv)
 
        rc->priv = priv;
 
+       init_waitqueue_head(&rc->uwbd.wq);
+       INIT_LIST_HEAD(&rc->uwbd.event_list);
+       spin_lock_init(&rc->uwbd.event_list_lock);
+
+       uwbd_start(rc);
+
        result = rc->start(rc);
        if (result < 0)
                goto error_rc_start;
@@ -284,7 +288,7 @@ error_sys_add:
 error_dev_add:
 error_rc_setup:
        rc->stop(rc);
-       uwbd_flush(rc);
+       uwbd_stop(rc);
 error_rc_start:
        return result;
 }
@@ -306,25 +310,24 @@ void uwb_rc_rm(struct uwb_rc *rc)
        rc->ready = 0;
 
        uwb_dbg_del_rc(rc);
-       uwb_rsv_cleanup(rc);
-       uwb_rc_ie_rm(rc, UWB_IDENTIFICATION_IE);
-       if (rc->beaconing >= 0)
-               uwb_rc_beacon(rc, -1, 0);
-       if (rc->scan_type != UWB_SCAN_DISABLED)
-               uwb_rc_scan(rc, rc->scanning, UWB_SCAN_DISABLED, 0);
-       uwb_rc_reset(rc);
+       uwb_rsv_remove_all(rc);
+       uwb_radio_shutdown(rc);
 
        rc->stop(rc);
-       uwbd_flush(rc);
+
+       uwbd_stop(rc);
+       uwb_rc_neh_destroy(rc);
 
        uwb_dev_lock(&rc->uwb_dev);
        rc->priv = NULL;
        rc->cmd = NULL;
        uwb_dev_unlock(&rc->uwb_dev);
-       mutex_lock(&uwb_beca.mutex);
+       mutex_lock(&rc->uwb_beca.mutex);
        uwb_dev_for_each(rc, uwb_dev_offair_helper, NULL);
        __uwb_rc_sys_rm(rc);
-       mutex_unlock(&uwb_beca.mutex);
+       mutex_unlock(&rc->uwb_beca.mutex);
+       uwb_rsv_cleanup(rc);
+       uwb_beca_release(rc);
        uwb_dev_rm(&rc->uwb_dev);
 }
 EXPORT_SYMBOL_GPL(uwb_rc_rm);
@@ -468,28 +471,3 @@ void uwb_rc_put(struct uwb_rc *rc)
        __uwb_rc_put(rc);
 }
 EXPORT_SYMBOL_GPL(uwb_rc_put);
-
-/*
- *
- *
- */
-ssize_t uwb_rc_print_IEs(struct uwb_rc *uwb_rc, char *buf, size_t size)
-{
-       ssize_t result;
-       struct uwb_rc_evt_get_ie *ie_info;
-       struct uwb_buf_ctx ctx;
-
-       result = uwb_rc_get_ie(uwb_rc, &ie_info);
-       if (result < 0)
-               goto error_get_ie;
-       ctx.buf = buf;
-       ctx.size = size;
-       ctx.bytes = 0;
-       uwb_ie_for_each(&uwb_rc->uwb_dev, uwb_ie_dump_hex, &ctx,
-                       ie_info->IEData, result - sizeof(*ie_info));
-       result = ctx.bytes;
-       kfree(ie_info);
-error_get_ie:
-       return result;
-}
-
index 9b4eb64327acc2be179f9d6df6a8460178e7d3e7..48b4ece1a627c8fc3a19690d7ac209f4baa65115 100644 (file)
@@ -254,7 +254,6 @@ error_kzalloc:
 
 static void __uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh)
 {
-       del_timer(&neh->timer);
        __uwb_rc_ctx_put(rc, neh);
        list_del(&neh->list_node);
 }
@@ -275,6 +274,7 @@ void uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh)
        __uwb_rc_neh_rm(rc, neh);
        spin_unlock_irqrestore(&rc->neh_lock, flags);
 
+       del_timer_sync(&neh->timer);
        uwb_rc_neh_put(neh);
 }
 
@@ -438,9 +438,10 @@ static void uwb_rc_neh_grok_event(struct uwb_rc *rc, struct uwb_rceb *rceb, size
                                rceb->bEventContext, size);
        } else {
                neh = uwb_rc_neh_lookup(rc, rceb);
-               if (neh)
+               if (neh) {
+                       del_timer_sync(&neh->timer);
                        uwb_rc_neh_cb(neh, rceb, size);
-               else
+               else
                        dev_warn(dev, "event 0x%02x/%04x/%02x (%zu bytes): nobody cared\n",
                                 rceb->bEventType, le16_to_cpu(rceb->wEvent),
                                 rceb->bEventContext, size);
@@ -562,16 +563,22 @@ EXPORT_SYMBOL_GPL(uwb_rc_neh_grok);
  */
 void uwb_rc_neh_error(struct uwb_rc *rc, int error)
 {
-       struct uwb_rc_neh *neh, *next;
+       struct uwb_rc_neh *neh;
        unsigned long flags;
 
-       BUG_ON(error >= 0);
-       spin_lock_irqsave(&rc->neh_lock, flags);
-       list_for_each_entry_safe(neh, next, &rc->neh_list, list_node) {
+       for (;;) {
+               spin_lock_irqsave(&rc->neh_lock, flags);
+               if (list_empty(&rc->neh_list)) {
+                       spin_unlock_irqrestore(&rc->neh_lock, flags);
+                       break;
+               }
+               neh = list_first_entry(&rc->neh_list, struct uwb_rc_neh, list_node);
                __uwb_rc_neh_rm(rc, neh);
+               spin_unlock_irqrestore(&rc->neh_lock, flags);
+
+               del_timer_sync(&neh->timer);
                uwb_rc_neh_cb(neh, NULL, error);
        }
-       spin_unlock_irqrestore(&rc->neh_lock, flags);
 }
 EXPORT_SYMBOL_GPL(uwb_rc_neh_error);
 
@@ -583,10 +590,14 @@ static void uwb_rc_neh_timer(unsigned long arg)
        unsigned long flags;
 
        spin_lock_irqsave(&rc->neh_lock, flags);
-       __uwb_rc_neh_rm(rc, neh);
+       if (neh->context)
+               __uwb_rc_neh_rm(rc, neh);
+       else
+               neh = NULL;
        spin_unlock_irqrestore(&rc->neh_lock, flags);
 
-       uwb_rc_neh_cb(neh, NULL, -ETIMEDOUT);
+       if (neh)
+               uwb_rc_neh_cb(neh, NULL, -ETIMEDOUT);
 }
 
 /** Initializes the @rc's neh subsystem
@@ -605,12 +616,19 @@ void uwb_rc_neh_create(struct uwb_rc *rc)
 void uwb_rc_neh_destroy(struct uwb_rc *rc)
 {
        unsigned long flags;
-       struct uwb_rc_neh *neh, *next;
+       struct uwb_rc_neh *neh;
 
-       spin_lock_irqsave(&rc->neh_lock, flags);
-       list_for_each_entry_safe(neh, next, &rc->neh_list, list_node) {
+       for (;;) {
+               spin_lock_irqsave(&rc->neh_lock, flags);
+               if (list_empty(&rc->neh_list)) {
+                       spin_unlock_irqrestore(&rc->neh_lock, flags);
+                       break;
+               }
+               neh = list_first_entry(&rc->neh_list, struct uwb_rc_neh, list_node);
                __uwb_rc_neh_rm(rc, neh);
+               spin_unlock_irqrestore(&rc->neh_lock, flags);
+
+               del_timer_sync(&neh->timer);
                uwb_rc_neh_put(neh);
        }
-       spin_unlock_irqrestore(&rc->neh_lock, flags);
 }
index 1afb38eacb9a295d55e6356b0ab3b3f8692ce28a..99a19c199095fd817ceb519922389a6a424abba9 100644 (file)
@@ -16,6 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <linux/kernel.h>
+#include <linux/debugfs.h>
 #include <linux/uwb.h>
 
 #include "uwb-internal.h"
@@ -32,13 +33,13 @@ EXPORT_SYMBOL_GPL(uwb_pal_init);
 
 /**
  * uwb_pal_register - register a UWB PAL
- * @rc: the radio controller the PAL will be using
  * @pal: the PAL
  *
  * The PAL must be initialized with uwb_pal_init().
  */
-int uwb_pal_register(struct uwb_rc *rc, struct uwb_pal *pal)
+int uwb_pal_register(struct uwb_pal *pal)
 {
+       struct uwb_rc *rc = pal->rc;
        int ret;
 
        if (pal->device) {
@@ -54,9 +55,11 @@ int uwb_pal_register(struct uwb_rc *rc, struct uwb_pal *pal)
                }
        }
 
-       spin_lock(&rc->pal_lock);
+       pal->debugfs_dir = uwb_dbg_create_pal_dir(pal);
+
+       mutex_lock(&rc->uwb_dev.mutex);
        list_add(&pal->node, &rc->pals);
-       spin_unlock(&rc->pal_lock);
+       mutex_unlock(&rc->uwb_dev.mutex);
 
        return 0;
 }
@@ -64,14 +67,19 @@ EXPORT_SYMBOL_GPL(uwb_pal_register);
 
 /**
  * uwb_pal_register - unregister a UWB PAL
- * @rc: the radio controller the PAL was using
  * @pal: the PAL
  */
-void uwb_pal_unregister(struct uwb_rc *rc, struct uwb_pal *pal)
+void uwb_pal_unregister(struct uwb_pal *pal)
 {
-       spin_lock(&rc->pal_lock);
+       struct uwb_rc *rc = pal->rc;
+
+       uwb_radio_stop(pal);
+
+       mutex_lock(&rc->uwb_dev.mutex);
        list_del(&pal->node);
-       spin_unlock(&rc->pal_lock);
+       mutex_unlock(&rc->uwb_dev.mutex);
+
+       debugfs_remove(pal->debugfs_dir);
 
        if (pal->device) {
                sysfs_remove_link(&rc->uwb_dev.dev.kobj, pal->name);
@@ -86,6 +94,5 @@ EXPORT_SYMBOL_GPL(uwb_pal_unregister);
  */
 void uwb_rc_pal_init(struct uwb_rc *rc)
 {
-       spin_lock_init(&rc->pal_lock);
        INIT_LIST_HEAD(&rc->pals);
 }
diff --git a/drivers/uwb/radio.c b/drivers/uwb/radio.c
new file mode 100644 (file)
index 0000000..f0d5549
--- /dev/null
@@ -0,0 +1,202 @@
+/*
+ * UWB radio (channel) management.
+ *
+ * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/kernel.h>
+#include <linux/uwb.h>
+
+#include "uwb-internal.h"
+
+
+static int uwb_radio_select_channel(struct uwb_rc *rc)
+{
+       /*
+        * Default to channel 9 (BG1, TFC1) unless the user has
+        * selected a specific channel or there are no active PALs.
+        */
+       if (rc->active_pals == 0)
+               return -1;
+       if (rc->beaconing_forced)
+               return rc->beaconing_forced;
+       return 9;
+}
+
+
+/*
+ * Notify all active PALs that the channel has changed.
+ */
+static void uwb_radio_channel_changed(struct uwb_rc *rc, int channel)
+{
+       struct uwb_pal *pal;
+
+       list_for_each_entry(pal, &rc->pals, node) {
+               if (pal->channel && channel != pal->channel) {
+                       pal->channel = channel;
+                       if (pal->channel_changed)
+                               pal->channel_changed(pal, pal->channel);
+               }
+       }
+}
+
+/*
+ * Change to a new channel and notify any active PALs of the new
+ * channel.
+ *
+ * When stopping the radio, PALs need to be notified first so they can
+ * terminate any active reservations.
+ */
+static int uwb_radio_change_channel(struct uwb_rc *rc, int channel)
+{
+       int ret = 0;
+
+       if (channel == -1)
+               uwb_radio_channel_changed(rc, channel);
+
+       if (channel != rc->beaconing) {
+               if (rc->beaconing != -1 && channel != -1) {
+                       /*
+                        * FIXME: should signal the channel change
+                        * with a Channel Change IE.
+                        */
+                       ret = uwb_radio_change_channel(rc, -1);
+                       if (ret < 0)
+                               return ret;
+               }
+               ret = uwb_rc_beacon(rc, channel, 0);
+       }
+
+       if (channel != -1)
+               uwb_radio_channel_changed(rc, rc->beaconing);
+
+       return ret;
+}
+
+/**
+ * uwb_radio_start - request that the radio be started
+ * @pal: the PAL making the request.
+ *
+ * If the radio is not already active, aa suitable channel is selected
+ * and beacons are started.
+ */
+int uwb_radio_start(struct uwb_pal *pal)
+{
+       struct uwb_rc *rc = pal->rc;
+       int ret = 0;
+
+       mutex_lock(&rc->uwb_dev.mutex);
+
+       if (!pal->channel) {
+               pal->channel = -1;
+               rc->active_pals++;
+               ret = uwb_radio_change_channel(rc, uwb_radio_select_channel(rc));
+       }
+
+       mutex_unlock(&rc->uwb_dev.mutex);
+       return ret;
+}
+EXPORT_SYMBOL_GPL(uwb_radio_start);
+
+/**
+ * uwb_radio_stop - request tha the radio be stopped.
+ * @pal: the PAL making the request.
+ *
+ * Stops the radio if no other PAL is making use of it.
+ */
+void uwb_radio_stop(struct uwb_pal *pal)
+{
+       struct uwb_rc *rc = pal->rc;
+
+       mutex_lock(&rc->uwb_dev.mutex);
+
+       if (pal->channel) {
+               rc->active_pals--;
+               uwb_radio_change_channel(rc, uwb_radio_select_channel(rc));
+               pal->channel = 0;
+       }
+
+       mutex_unlock(&rc->uwb_dev.mutex);
+}
+EXPORT_SYMBOL_GPL(uwb_radio_stop);
+
+/*
+ * uwb_radio_force_channel - force a specific channel to be used
+ * @rc: the radio controller.
+ * @channel: the channel to use; -1 to force the radio to stop; 0 to
+ *   use the default channel selection algorithm.
+ */
+int uwb_radio_force_channel(struct uwb_rc *rc, int channel)
+{
+       int ret = 0;
+
+       mutex_lock(&rc->uwb_dev.mutex);
+
+       rc->beaconing_forced = channel;
+       ret = uwb_radio_change_channel(rc, uwb_radio_select_channel(rc));
+
+       mutex_unlock(&rc->uwb_dev.mutex);
+       return ret;
+}
+
+/*
+ * uwb_radio_setup - setup the radio manager
+ * @rc: the radio controller.
+ *
+ * The radio controller is reset to ensure it's in a known state
+ * before it's used.
+ */
+int uwb_radio_setup(struct uwb_rc *rc)
+{
+       return uwb_rc_reset(rc);
+}
+
+/*
+ * uwb_radio_reset_state - reset any radio manager state
+ * @rc: the radio controller.
+ *
+ * All internal radio manager state is reset to values corresponding
+ * to a reset radio controller.
+ */
+void uwb_radio_reset_state(struct uwb_rc *rc)
+{
+       struct uwb_pal *pal;
+
+       mutex_lock(&rc->uwb_dev.mutex);
+
+       list_for_each_entry(pal, &rc->pals, node) {
+               if (pal->channel) {
+                       pal->channel = -1;
+                       if (pal->channel_changed)
+                               pal->channel_changed(pal, -1);
+               }
+       }
+
+       rc->beaconing = -1;
+       rc->scanning = -1;
+
+       mutex_unlock(&rc->uwb_dev.mutex);
+}
+
+/*
+ * uwb_radio_shutdown - shutdown the radio manager
+ * @rc: the radio controller.
+ *
+ * The radio controller is reset.
+ */
+void uwb_radio_shutdown(struct uwb_rc *rc)
+{
+       uwb_radio_reset_state(rc);
+       uwb_rc_reset(rc);
+}
index 8de856fa795871f0e821c97193d519e6aa7f5ae2..ce8283cc8098b693d18f3f7d89244ebc53e5f693 100644 (file)
@@ -323,17 +323,16 @@ int uwbd_msg_handle_reset(struct uwb_event *evt)
        struct uwb_rc *rc = evt->rc;
        int ret;
 
-       /* Need to prevent the RC hardware module going away while in
-          the rc->reset() call. */
-       if (!try_module_get(rc->owner))
-               return 0;
-
        dev_info(&rc->uwb_dev.dev, "resetting radio controller\n");
        ret = rc->reset(rc);
-       if (ret)
+       if (ret) {
                dev_err(&rc->uwb_dev.dev, "failed to reset hardware: %d\n", ret);
-
-       module_put(rc->owner);
+               goto error;
+       }
+       return 0;
+error:
+       /* Nothing can be done except try the reset again. */
+       uwb_rc_reset_all(rc);
        return ret;
 }
 
@@ -360,3 +359,33 @@ void uwb_rc_reset_all(struct uwb_rc *rc)
        uwbd_event_queue(evt);
 }
 EXPORT_SYMBOL_GPL(uwb_rc_reset_all);
+
+void uwb_rc_pre_reset(struct uwb_rc *rc)
+{
+       rc->stop(rc);
+       uwbd_flush(rc);
+
+       uwb_radio_reset_state(rc);
+       uwb_rsv_remove_all(rc);
+}
+EXPORT_SYMBOL_GPL(uwb_rc_pre_reset);
+
+void uwb_rc_post_reset(struct uwb_rc *rc)
+{
+       int ret;
+
+       ret = rc->start(rc);
+       if (ret)
+               goto error;
+       ret = uwb_rc_mac_addr_set(rc, &rc->uwb_dev.mac_addr);
+       if (ret)
+               goto error;
+       ret = uwb_rc_dev_addr_set(rc, &rc->uwb_dev.dev_addr);
+       if (ret)
+               goto error;
+       return;
+error:
+       /* Nothing can be done except try the reset again. */
+       uwb_rc_reset_all(rc);
+}
+EXPORT_SYMBOL_GPL(uwb_rc_post_reset);
index bae16204576db07e1921af4312f9cb756602d20e..1cd84f927540207b4d8a1d7630edb13d2e2a5c40 100644 (file)
@@ -15,7 +15,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/uwb.h>
 
@@ -82,6 +81,23 @@ static void uwb_rsv_dump(struct uwb_rsv *rsv)
        dev_dbg(dev, "rsv %s -> %s: %s\n", owner, target, uwb_rsv_state_str(rsv->state));
 }
 
+static void uwb_rsv_release(struct kref *kref)
+{
+       struct uwb_rsv *rsv = container_of(kref, struct uwb_rsv, kref);
+
+       kfree(rsv);
+}
+
+static void uwb_rsv_get(struct uwb_rsv *rsv)
+{
+       kref_get(&rsv->kref);
+}
+
+static void uwb_rsv_put(struct uwb_rsv *rsv)
+{
+       kref_put(&rsv->kref, uwb_rsv_release);
+}
+
 /*
  * Get a free stream index for a reservation.
  *
@@ -285,7 +301,8 @@ void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
        switch (new_state) {
        case UWB_RSV_STATE_NONE:
                uwb_drp_avail_release(rsv->rc, &rsv->mas);
-               uwb_rsv_put_stream(rsv);
+               if (uwb_rsv_is_owner(rsv))
+                       uwb_rsv_put_stream(rsv);
                uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
                uwb_rsv_callback(rsv);
                break;
@@ -324,6 +341,7 @@ static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
 
        INIT_LIST_HEAD(&rsv->rc_node);
        INIT_LIST_HEAD(&rsv->pal_node);
+       kref_init(&rsv->kref);
        init_timer(&rsv->timer);
        rsv->timer.function = uwb_rsv_timer;
        rsv->timer.data     = (unsigned long)rsv;
@@ -333,14 +351,6 @@ static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
        return rsv;
 }
 
-static void uwb_rsv_free(struct uwb_rsv *rsv)
-{
-       uwb_dev_put(rsv->owner);
-       if (rsv->target.type == UWB_RSV_TARGET_DEV)
-               uwb_dev_put(rsv->target.dev);
-       kfree(rsv);
-}
-
 /**
  * uwb_rsv_create - allocate and initialize a UWB reservation structure
  * @rc: the radio controller
@@ -374,23 +384,23 @@ void uwb_rsv_remove(struct uwb_rsv *rsv)
        if (rsv->state != UWB_RSV_STATE_NONE)
                uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
        del_timer_sync(&rsv->timer);
-       list_del(&rsv->rc_node);
-       uwb_rsv_free(rsv);
+       uwb_dev_put(rsv->owner);
+       if (rsv->target.type == UWB_RSV_TARGET_DEV)
+               uwb_dev_put(rsv->target.dev);
+
+       list_del_init(&rsv->rc_node);
+       uwb_rsv_put(rsv);
 }
 
 /**
  * uwb_rsv_destroy - free a UWB reservation structure
  * @rsv: the reservation to free
  *
- * The reservation will be terminated if it is pending or established.
+ * The reservation must already be terminated.
  */
 void uwb_rsv_destroy(struct uwb_rsv *rsv)
 {
-       struct uwb_rc *rc = rsv->rc;
-
-       mutex_lock(&rc->rsvs_mutex);
-       uwb_rsv_remove(rsv);
-       mutex_unlock(&rc->rsvs_mutex);
+       uwb_rsv_put(rsv);
 }
 EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
 
@@ -422,6 +432,7 @@ int uwb_rsv_establish(struct uwb_rsv *rsv)
                goto out;
        }
 
+       uwb_rsv_get(rsv);
        list_add_tail(&rsv->rc_node, &rc->reservations);
        rsv->owner = &rc->uwb_dev;
        uwb_dev_get(rsv->owner);
@@ -477,9 +488,14 @@ EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
  *
  * Reservation requests from peers are denied unless a PAL accepts it
  * by calling this function.
+ *
+ * The PAL call uwb_rsv_destroy() for all accepted reservations before
+ * calling uwb_pal_unregister().
  */
 void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
 {
+       uwb_rsv_get(rsv);
+
        rsv->callback = cb;
        rsv->pal_priv = pal_priv;
        rsv->state    = UWB_RSV_STATE_T_ACCEPTED;
@@ -532,7 +548,6 @@ static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
        rsv->target.dev  = &rc->uwb_dev;
        rsv->type        = uwb_ie_drp_type(drp_ie);
        rsv->stream      = uwb_ie_drp_stream_index(drp_ie);
-       set_bit(rsv->stream, rsv->owner->streams);
        uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
 
        /*
@@ -540,14 +555,14 @@ static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
         * deny the request.
         */
        rsv->state = UWB_RSV_STATE_T_DENIED;
-       spin_lock(&rc->pal_lock);
+       mutex_lock(&rc->uwb_dev.mutex);
        list_for_each_entry(pal, &rc->pals, node) {
                if (pal->new_rsv)
-                       pal->new_rsv(rsv);
+                       pal->new_rsv(pal, rsv);
                if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
                        break;
        }
-       spin_unlock(&rc->pal_lock);
+       mutex_unlock(&rc->uwb_dev.mutex);
 
        list_add_tail(&rsv->rc_node, &rc->reservations);
        state = rsv->state;
@@ -644,6 +659,25 @@ static void uwb_rsv_timer(unsigned long arg)
        uwb_rsv_sched_update(rsv->rc);
 }
 
+/**
+ * uwb_rsv_remove_all - remove all reservations
+ * @rc: the radio controller
+ *
+ * A DRP IE update is not done.
+ */
+void uwb_rsv_remove_all(struct uwb_rc *rc)
+{
+       struct uwb_rsv *rsv, *t;
+
+       mutex_lock(&rc->rsvs_mutex);
+       list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
+               uwb_rsv_remove(rsv);
+       }
+       mutex_unlock(&rc->rsvs_mutex);
+
+       cancel_work_sync(&rc->rsv_update_work);
+}
+
 void uwb_rsv_init(struct uwb_rc *rc)
 {
        INIT_LIST_HEAD(&rc->reservations);
@@ -667,14 +701,6 @@ int uwb_rsv_setup(struct uwb_rc *rc)
 
 void uwb_rsv_cleanup(struct uwb_rc *rc)
 {
-       struct uwb_rsv *rsv, *t;
-
-       mutex_lock(&rc->rsvs_mutex);
-       list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
-               uwb_rsv_remove(rsv);
-       }
-       mutex_unlock(&rc->rsvs_mutex);
-
-       cancel_work_sync(&rc->rsv_update_work);
+       uwb_rsv_remove_all(rc);
        destroy_workqueue(rc->rsv_workq);
 }
index 2d8d62d9f53e5d2a11624df6bcbc79247d195811..5ad36164c13b374ab26dbdd0e435dcf6f2a40483 100644 (file)
 #include <linux/uwb/umc.h>
 #include <linux/pci.h>
 
-static int umc_bus_unbind_helper(struct device *dev, void *data)
+static int umc_bus_pre_reset_helper(struct device *dev, void *data)
 {
-       struct device *parent = data;
+       int ret = 0;
 
-       if (dev->parent == parent && dev->driver)
-               device_release_driver(dev);
-       return 0;
+       if (dev->driver) {
+               struct umc_dev *umc = to_umc_dev(dev);
+               struct umc_driver *umc_drv = to_umc_driver(dev->driver);
+
+               if (umc_drv->pre_reset)
+                       ret = umc_drv->pre_reset(umc);
+               else
+                       device_release_driver(dev);
+       }
+       return ret;
+}
+
+static int umc_bus_post_reset_helper(struct device *dev, void *data)
+{
+       int ret = 0;
+
+       if (dev->driver) {
+               struct umc_dev *umc = to_umc_dev(dev);
+               struct umc_driver *umc_drv = to_umc_driver(dev->driver);
+
+               if (umc_drv->post_reset)
+                       ret = umc_drv->post_reset(umc);
+       } else
+               ret = device_attach(dev);
+
+       return ret;
 }
 
 /**
  * umc_controller_reset - reset the whole UMC controller
  * @umc: the UMC device for the radio controller.
  *
- * Drivers will be unbound from all UMC devices belonging to the
- * controller and then the radio controller will be rebound.  The
- * radio controller is expected to do a full hardware reset when it is
- * probed.
+ * Drivers or all capabilities of the controller will have their
+ * pre_reset methods called or be unbound from their device.  Then all
+ * post_reset methods will be called or the drivers will be rebound.
+ *
+ * Radio controllers must provide pre_reset and post_reset methods and
+ * reset the hardware in their start method.
  *
  * If this is called while a probe() or remove() is in progress it
  * will return -EAGAIN and not perform the reset.
@@ -35,14 +60,13 @@ static int umc_bus_unbind_helper(struct device *dev, void *data)
 int umc_controller_reset(struct umc_dev *umc)
 {
        struct device *parent = umc->dev.parent;
-       int ret;
+       int ret = 0;
 
-       if (down_trylock(&parent->sem))
+       if(down_trylock(&parent->sem))
                return -EAGAIN;
-       bus_for_each_dev(&umc_bus_type, NULL, parent, umc_bus_unbind_helper);
-       ret = device_attach(&umc->dev);
-       if (ret == 1)
-               ret = 0;
+       ret = device_for_each_child(parent, parent, umc_bus_pre_reset_helper);
+       if (ret >= 0)
+               device_for_each_child(parent, parent, umc_bus_post_reset_helper);
        up(&parent->sem);
 
        return ret;
@@ -75,10 +99,10 @@ static int umc_bus_rescan_helper(struct device *dev, void *data)
        if (!dev->driver)
                ret = device_attach(dev);
 
-       return ret < 0 ? ret : 0;
+       return ret;
 }
 
-static void umc_bus_rescan(void)
+static void umc_bus_rescan(struct device *parent)
 {
        int err;
 
@@ -86,7 +110,7 @@ static void umc_bus_rescan(void)
         * We can't use bus_rescan_devices() here as it deadlocks when
         * it tries to retake the dev->parent semaphore.
         */
-       err = bus_for_each_dev(&umc_bus_type, NULL, NULL, umc_bus_rescan_helper);
+       err = device_for_each_child(parent, NULL, umc_bus_rescan_helper);
        if (err < 0)
                printk(KERN_WARNING "%s: rescan of bus failed: %d\n",
                       KBUILD_MODNAME, err);
@@ -120,7 +144,7 @@ static int umc_device_probe(struct device *dev)
        if (err)
                put_device(dev);
        else
-               umc_bus_rescan();
+               umc_bus_rescan(dev->parent);
 
        return err;
 }
index aa44e1c1a102f542a7562bd9dff503019269b871..53207e14cd8f42bf8ebd94ca67661a1c5aae646f 100644 (file)
@@ -31,8 +31,7 @@ struct umc_dev *umc_device_create(struct device *parent, int n)
 
        umc = kzalloc(sizeof(struct umc_dev), GFP_KERNEL);
        if (umc) {
-               snprintf(umc->dev.bus_id, sizeof(umc->dev.bus_id), "%s-%d",
-                        parent->bus_id, n);
+               dev_set_name(&umc->dev, "%s-%d", dev_name(parent), n);
                umc->dev.parent  = parent;
                umc->dev.bus     = &umc_bus_type;
                umc->dev.release = umc_device_release;
index 6d232c35d07df3ea13b1bed5e1f5877ddc480fda..a6debb9baf38e93321915cb6dcfefb3acc98c8f2 100644 (file)
@@ -33,8 +33,6 @@
 #include <linux/seq_file.h>
 
 #include <linux/uwb/debug-cmd.h>
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
 
 #include "uwb-internal.h"
 
@@ -104,6 +102,11 @@ static void uwb_dbg_rsv_cb(struct uwb_rsv *rsv)
 
        dev_dbg(dev, "debug: rsv %s -> %s: %s\n",
                owner, target, uwb_rsv_state_str(rsv->state));
+
+       if (rsv->state == UWB_RSV_STATE_NONE) {
+               list_del(&rsv->pal_node);
+               uwb_rsv_destroy(rsv);
+       }
 }
 
 static int cmd_rsv_establish(struct uwb_rc *rc,
@@ -119,7 +122,7 @@ static int cmd_rsv_establish(struct uwb_rc *rc,
        if (target == NULL)
                return -ENODEV;
 
-       rsv = uwb_rsv_create(rc, uwb_dbg_rsv_cb, NULL);
+       rsv = uwb_rsv_create(rc, uwb_dbg_rsv_cb, rc->dbg);
        if (rsv == NULL) {
                uwb_dev_put(target);
                return -ENOMEM;
@@ -153,16 +156,28 @@ static int cmd_rsv_terminate(struct uwb_rc *rc,
                        found = rsv;
                        break;
                }
+               i++;
        }
        if (!found)
                return -EINVAL;
 
-       list_del(&found->pal_node);
        uwb_rsv_terminate(found);
 
        return 0;
 }
 
+static int cmd_ie_add(struct uwb_rc *rc, struct uwb_dbg_cmd_ie *ie_to_add)
+{
+       return uwb_rc_ie_add(rc,
+                            (const struct uwb_ie_hdr *) ie_to_add->data,
+                            ie_to_add->len);
+}
+
+static int cmd_ie_rm(struct uwb_rc *rc, struct uwb_dbg_cmd_ie *ie_to_rm)
+{
+       return uwb_rc_ie_rm(rc, ie_to_rm->data[0]);
+}
+
 static int command_open(struct inode *inode, struct file *file)
 {
        file->private_data = inode->i_private;
@@ -175,7 +190,7 @@ static ssize_t command_write(struct file *file, const char __user *buf,
 {
        struct uwb_rc *rc = file->private_data;
        struct uwb_dbg_cmd cmd;
-       int ret;
+       int ret = 0;
 
        if (len != sizeof(struct uwb_dbg_cmd))
                return -EINVAL;
@@ -190,6 +205,18 @@ static ssize_t command_write(struct file *file, const char __user *buf,
        case UWB_DBG_CMD_RSV_TERMINATE:
                ret = cmd_rsv_terminate(rc, &cmd.rsv_terminate);
                break;
+       case UWB_DBG_CMD_IE_ADD:
+               ret = cmd_ie_add(rc, &cmd.ie_add);
+               break;
+       case UWB_DBG_CMD_IE_RM:
+               ret = cmd_ie_rm(rc, &cmd.ie_rm);
+               break;
+       case UWB_DBG_CMD_RADIO_START:
+               ret = uwb_radio_start(&rc->dbg->pal);
+               break;
+       case UWB_DBG_CMD_RADIO_STOP:
+               uwb_radio_stop(&rc->dbg->pal);
+               break;
        default:
                return -EINVAL;
        }
@@ -283,12 +310,24 @@ static struct file_operations drp_avail_fops = {
        .owner   = THIS_MODULE,
 };
 
-static void uwb_dbg_new_rsv(struct uwb_rsv *rsv)
+static void uwb_dbg_channel_changed(struct uwb_pal *pal, int channel)
 {
-       struct uwb_rc *rc = rsv->rc;
+       struct device *dev = &pal->rc->uwb_dev.dev;
 
-       if (rc->dbg->accept)
-               uwb_rsv_accept(rsv, uwb_dbg_rsv_cb, NULL);
+       if (channel > 0)
+               dev_info(dev, "debug: channel %d started\n", channel);
+       else
+               dev_info(dev, "debug: channel stopped\n");
+}
+
+static void uwb_dbg_new_rsv(struct uwb_pal *pal, struct uwb_rsv *rsv)
+{
+       struct uwb_dbg *dbg = container_of(pal, struct uwb_dbg, pal);
+
+       if (dbg->accept) {
+               list_add_tail(&rsv->pal_node, &dbg->rsvs);
+               uwb_rsv_accept(rsv, uwb_dbg_rsv_cb, dbg);
+       }
 }
 
 /**
@@ -304,8 +343,11 @@ void uwb_dbg_add_rc(struct uwb_rc *rc)
        INIT_LIST_HEAD(&rc->dbg->rsvs);
 
        uwb_pal_init(&rc->dbg->pal);
+       rc->dbg->pal.rc = rc;
+       rc->dbg->pal.channel_changed = uwb_dbg_channel_changed;
        rc->dbg->pal.new_rsv = uwb_dbg_new_rsv;
-       uwb_pal_register(rc, &rc->dbg->pal);
+       uwb_pal_register(&rc->dbg->pal);
+
        if (root_dir) {
                rc->dbg->root_d = debugfs_create_dir(dev_name(&rc->uwb_dev.dev),
                                                     root_dir);
@@ -325,7 +367,7 @@ void uwb_dbg_add_rc(struct uwb_rc *rc)
 }
 
 /**
- * uwb_dbg_add_rc - remove a radio controller's debug interface
+ * uwb_dbg_del_rc - remove a radio controller's debug interface
  * @rc: the radio controller
  */
 void uwb_dbg_del_rc(struct uwb_rc *rc)
@@ -336,10 +378,10 @@ void uwb_dbg_del_rc(struct uwb_rc *rc)
                return;
 
        list_for_each_entry_safe(rsv, t, &rc->dbg->rsvs, pal_node) {
-               uwb_rsv_destroy(rsv);
+               uwb_rsv_terminate(rsv);
        }
 
-       uwb_pal_unregister(rc, &rc->dbg->pal);
+       uwb_pal_unregister(&rc->dbg->pal);
 
        if (root_dir) {
                debugfs_remove(rc->dbg->drp_avail_f);
@@ -365,3 +407,16 @@ void uwb_dbg_exit(void)
 {
        debugfs_remove(root_dir);
 }
+
+/**
+ * uwb_dbg_create_pal_dir - create a debugfs directory for a PAL
+ * @pal: The PAL.
+ */
+struct dentry *uwb_dbg_create_pal_dir(struct uwb_pal *pal)
+{
+       struct uwb_rc *rc = pal->rc;
+
+       if (root_dir && rc->dbg && rc->dbg->root_d && pal->name)
+               return debugfs_create_dir(pal->name, rc->dbg->root_d);
+       return NULL;
+}
index 2ad307d12961ae5f8440f296daa742ac2e421923..f0f21f406bf0039bade335d1810e4e9a43fcd1fe 100644 (file)
@@ -66,14 +66,14 @@ extern int uwb_rc_scan(struct uwb_rc *rc,
                       unsigned channel, enum uwb_scan_type type,
                       unsigned bpst_offset);
 extern int uwb_rc_send_all_drp_ie(struct uwb_rc *rc);
-extern ssize_t uwb_rc_print_IEs(struct uwb_rc *rc, char *, size_t);
-extern void uwb_rc_ie_init(struct uwb_rc *);
-extern void uwb_rc_ie_init(struct uwb_rc *);
-extern ssize_t uwb_rc_ie_setup(struct uwb_rc *);
-extern void uwb_rc_ie_release(struct uwb_rc *);
-extern int uwb_rc_ie_add(struct uwb_rc *,
-                        const struct uwb_ie_hdr *, size_t);
-extern int uwb_rc_ie_rm(struct uwb_rc *, enum uwb_ie);
+
+void uwb_rc_ie_init(struct uwb_rc *);
+int uwb_rc_ie_setup(struct uwb_rc *);
+void uwb_rc_ie_release(struct uwb_rc *);
+int uwb_ie_dump_hex(const struct uwb_ie_hdr *ies, size_t len,
+                   char *buf, size_t size);
+int uwb_rc_set_ie(struct uwb_rc *, struct uwb_rc_cmd_set_ie *);
+
 
 extern const char *uwb_rc_strerror(unsigned code);
 
@@ -160,13 +160,14 @@ struct uwb_event {
        };
 };
 
-extern void uwbd_start(void);
-extern void uwbd_stop(void);
+extern void uwbd_start(struct uwb_rc *rc);
+extern void uwbd_stop(struct uwb_rc *rc);
 extern struct uwb_event *uwb_event_alloc(size_t, gfp_t gfp_mask);
 extern void uwbd_event_queue(struct uwb_event *);
 void uwbd_flush(struct uwb_rc *rc);
 
 /* UWB event handlers */
+extern int uwbd_evt_handle_rc_ie_rcv(struct uwb_event *);
 extern int uwbd_evt_handle_rc_beacon(struct uwb_event *);
 extern int uwbd_evt_handle_rc_beacon_size(struct uwb_event *);
 extern int uwbd_evt_handle_rc_bpoie_change(struct uwb_event *);
@@ -193,15 +194,6 @@ int uwbd_evt_handle_rc_dev_addr_conflict(struct uwb_event *evt);
 
 extern unsigned long beacon_timeout_ms;
 
-/** Beacon cache list */
-struct uwb_beca {
-       struct list_head list;
-       size_t entries;
-       struct mutex mutex;
-};
-
-extern struct uwb_beca uwb_beca;
-
 /**
  * Beacon cache entry
  *
@@ -228,9 +220,6 @@ struct uwb_beca_e {
 struct uwb_beacon_frame;
 extern ssize_t uwb_bce_print_IEs(struct uwb_dev *, struct uwb_beca_e *,
                                 char *, size_t);
-extern struct uwb_beca_e *__uwb_beca_add(struct uwb_rc_evt_beacon *,
-                                        struct uwb_beacon_frame *,
-                                        unsigned long);
 
 extern void uwb_bce_kfree(struct kref *_bce);
 static inline void uwb_bce_get(struct uwb_beca_e *bce)
@@ -241,14 +230,19 @@ static inline void uwb_bce_put(struct uwb_beca_e *bce)
 {
        kref_put(&bce->refcnt, uwb_bce_kfree);
 }
-extern void uwb_beca_purge(void);
-extern void uwb_beca_release(void);
+extern void uwb_beca_purge(struct uwb_rc *rc);
+extern void uwb_beca_release(struct uwb_rc *rc);
 
 struct uwb_dev *uwb_dev_get_by_devaddr(struct uwb_rc *rc,
                                       const struct uwb_dev_addr *devaddr);
 struct uwb_dev *uwb_dev_get_by_macaddr(struct uwb_rc *rc,
                                       const struct uwb_mac_addr *macaddr);
 
+int uwb_radio_setup(struct uwb_rc *rc);
+void uwb_radio_reset_state(struct uwb_rc *rc);
+void uwb_radio_shutdown(struct uwb_rc *rc);
+int uwb_radio_force_channel(struct uwb_rc *rc, int channel);
+
 /* -- UWB Sysfs representation */
 extern struct class uwb_rc_class;
 extern struct device_attribute dev_attr_mac_address;
@@ -259,6 +253,7 @@ extern struct device_attribute dev_attr_scan;
 void uwb_rsv_init(struct uwb_rc *rc);
 int uwb_rsv_setup(struct uwb_rc *rc);
 void uwb_rsv_cleanup(struct uwb_rc *rc);
+void uwb_rsv_remove_all(struct uwb_rc *rc);
 
 void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state);
 void uwb_rsv_remove(struct uwb_rsv *rsv);
@@ -289,8 +284,7 @@ void uwb_dbg_init(void);
 void uwb_dbg_exit(void);
 void uwb_dbg_add_rc(struct uwb_rc *rc);
 void uwb_dbg_del_rc(struct uwb_rc *rc);
-
-/* Workarounds for version specific stuff */
+struct dentry *uwb_dbg_create_pal_dir(struct uwb_pal *pal);
 
 static inline void uwb_dev_lock(struct uwb_dev *uwb_dev)
 {
index 78908416e42c9ab88ba3b1e0a3579f4ea4966f8b..ec42ce92dbce8b647d0d95f0d9675a20da2e216a 100644 (file)
@@ -104,6 +104,10 @@ struct uwbd_event {
 /** Table of handlers for and properties of the UWBD Radio Control Events */
 static
 struct uwbd_event uwbd_events[] = {
+       [UWB_RC_EVT_IE_RCV] = {
+               .handler = uwbd_evt_handle_rc_ie_rcv,
+               .name = "IE_RECEIVED"
+       },
        [UWB_RC_EVT_BEACON] = {
                .handler = uwbd_evt_handle_rc_beacon,
                .name = "BEACON_RECEIVED"
@@ -166,8 +170,6 @@ static const struct uwbd_event uwbd_message_handlers[] = {
        },
 };
 
-static DEFINE_MUTEX(uwbd_event_mutex);
-
 /**
  * Handle an URC event passed to the UWB Daemon
  *
@@ -231,19 +233,10 @@ static void uwbd_event_handle_message(struct uwb_event *evt)
                return;
        }
 
-       /* If this is a reset event we need to drop the
-        * uwbd_event_mutex or it deadlocks when the reset handler
-        * attempts to flush the uwbd events. */
-       if (evt->message == UWB_EVT_MSG_RESET)
-               mutex_unlock(&uwbd_event_mutex);
-
        result = uwbd_message_handlers[evt->message].handler(evt);
        if (result < 0)
                dev_err(&rc->uwb_dev.dev, "UWBD: '%s' message failed: %d\n",
                        uwbd_message_handlers[evt->message].name, result);
-
-       if (evt->message == UWB_EVT_MSG_RESET)
-               mutex_lock(&uwbd_event_mutex);
 }
 
 static void uwbd_event_handle(struct uwb_event *evt)
@@ -271,20 +264,6 @@ static void uwbd_event_handle(struct uwb_event *evt)
 
        __uwb_rc_put(rc);       /* for the __uwb_rc_get() in uwb_rc_notif_cb() */
 }
-/* The UWB Daemon */
-
-
-/** Daemon's PID: used to decide if we can queue or not */
-static int uwbd_pid;
-/** Daemon's task struct for managing the kthread */
-static struct task_struct *uwbd_task;
-/** Daemon's waitqueue for waiting for new events */
-static DECLARE_WAIT_QUEUE_HEAD(uwbd_wq);
-/** Daemon's list of events; we queue/dequeue here */
-static struct list_head uwbd_event_list = LIST_HEAD_INIT(uwbd_event_list);
-/** Daemon's list lock to protect concurent access */
-static DEFINE_SPINLOCK(uwbd_event_list_lock);
-
 
 /**
  * UWB Daemon
@@ -298,65 +277,58 @@ static DEFINE_SPINLOCK(uwbd_event_list_lock);
  * FIXME: should change so we don't have a 1HZ timer all the time, but
  *        only if there are devices.
  */
-static int uwbd(void *unused)
+static int uwbd(void *param)
 {
+       struct uwb_rc *rc = param;
        unsigned long flags;
-       struct list_head list = LIST_HEAD_INIT(list);
-       struct uwb_event *evt, *nxt;
+       struct uwb_event *evt;
        int should_stop = 0;
+
        while (1) {
                wait_event_interruptible_timeout(
-                       uwbd_wq,
-                       !list_empty(&uwbd_event_list)
+                       rc->uwbd.wq,
+                       !list_empty(&rc->uwbd.event_list)
                          || (should_stop = kthread_should_stop()),
                        HZ);
                if (should_stop)
                        break;
                try_to_freeze();
 
-               mutex_lock(&uwbd_event_mutex);
-               spin_lock_irqsave(&uwbd_event_list_lock, flags);
-               list_splice_init(&uwbd_event_list, &list);
-               spin_unlock_irqrestore(&uwbd_event_list_lock, flags);
-               list_for_each_entry_safe(evt, nxt, &list, list_node) {
+               spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
+               if (!list_empty(&rc->uwbd.event_list)) {
+                       evt = list_first_entry(&rc->uwbd.event_list, struct uwb_event, list_node);
                        list_del(&evt->list_node);
+               } else
+                       evt = NULL;
+               spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
+
+               if (evt) {
                        uwbd_event_handle(evt);
                        kfree(evt);
                }
-               mutex_unlock(&uwbd_event_mutex);
 
-               uwb_beca_purge();       /* Purge devices that left */
+               uwb_beca_purge(rc);     /* Purge devices that left */
        }
        return 0;
 }
 
 
 /** Start the UWB daemon */
-void uwbd_start(void)
+void uwbd_start(struct uwb_rc *rc)
 {
-       uwbd_task = kthread_run(uwbd, NULL, "uwbd");
-       if (uwbd_task == NULL)
+       rc->uwbd.task = kthread_run(uwbd, rc, "uwbd");
+       if (rc->uwbd.task == NULL)
                printk(KERN_ERR "UWB: Cannot start management daemon; "
                       "UWB won't work\n");
        else
-               uwbd_pid = uwbd_task->pid;
+               rc->uwbd.pid = rc->uwbd.task->pid;
 }
 
 /* Stop the UWB daemon and free any unprocessed events */
-void uwbd_stop(void)
+void uwbd_stop(struct uwb_rc *rc)
 {
-       unsigned long flags;
-       struct uwb_event *evt, *nxt;
-       kthread_stop(uwbd_task);
-       spin_lock_irqsave(&uwbd_event_list_lock, flags);
-       uwbd_pid = 0;
-       list_for_each_entry_safe(evt, nxt, &uwbd_event_list, list_node) {
-               if (evt->type == UWB_EVT_TYPE_NOTIF)
-                       kfree(evt->notif.rceb);
-               kfree(evt);
-       }
-       spin_unlock_irqrestore(&uwbd_event_list_lock, flags);
-       uwb_beca_release();
+       kthread_stop(rc->uwbd.task);
+       uwbd_flush(rc);
 }
 
 /*
@@ -373,18 +345,20 @@ void uwbd_stop(void)
  */
 void uwbd_event_queue(struct uwb_event *evt)
 {
+       struct uwb_rc *rc = evt->rc;
        unsigned long flags;
-       spin_lock_irqsave(&uwbd_event_list_lock, flags);
-       if (uwbd_pid != 0) {
-               list_add(&evt->list_node, &uwbd_event_list);
-               wake_up_all(&uwbd_wq);
+
+       spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
+       if (rc->uwbd.pid != 0) {
+               list_add(&evt->list_node, &rc->uwbd.event_list);
+               wake_up_all(&rc->uwbd.wq);
        } else {
                __uwb_rc_put(evt->rc);
                if (evt->type == UWB_EVT_TYPE_NOTIF)
                        kfree(evt->notif.rceb);
                kfree(evt);
        }
-       spin_unlock_irqrestore(&uwbd_event_list_lock, flags);
+       spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
        return;
 }
 
@@ -392,10 +366,8 @@ void uwbd_flush(struct uwb_rc *rc)
 {
        struct uwb_event *evt, *nxt;
 
-       mutex_lock(&uwbd_event_mutex);
-
-       spin_lock_irq(&uwbd_event_list_lock);
-       list_for_each_entry_safe(evt, nxt, &uwbd_event_list, list_node) {
+       spin_lock_irq(&rc->uwbd.event_list_lock);
+       list_for_each_entry_safe(evt, nxt, &rc->uwbd.event_list, list_node) {
                if (evt->rc == rc) {
                        __uwb_rc_put(rc);
                        list_del(&evt->list_node);
@@ -404,7 +376,5 @@ void uwbd_flush(struct uwb_rc *rc)
                        kfree(evt);
                }
        }
-       spin_unlock_irq(&uwbd_event_list_lock);
-
-       mutex_unlock(&uwbd_event_mutex);
+       spin_unlock_irq(&rc->uwbd.event_list_lock);
 }
index 1711deadb114c99abf699bf4c9e88244ce5d540c..5f00386e26c73f20b81eb6b01785c47514b61692 100644 (file)
@@ -39,7 +39,6 @@
  * them to the hw and transfer the replies/notifications back to the
  * UWB stack through the UWB daemon (UWBD).
  */
-#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/pci.h>
@@ -333,47 +332,23 @@ void whcrc_release_rc_umc(struct whcrc *whcrc)
 static int whcrc_start_rc(struct uwb_rc *rc)
 {
        struct whcrc *whcrc = rc->priv;
-       int result = 0;
        struct device *dev = &whcrc->umc_dev->dev;
-       unsigned long start, duration;
 
        /* Reset the thing */
        le_writel(URCCMD_RESET, whcrc->rc_base + URCCMD);
-       if (d_test(3))
-               start = jiffies;
        if (whci_wait_for(dev, whcrc->rc_base + URCCMD, URCCMD_RESET, 0,
-                         5000, "device to reset at init") < 0) {
-               result = -EBUSY;
-               goto error;
-       } else if (d_test(3)) {
-               duration = jiffies - start;
-               if (duration > msecs_to_jiffies(40))
-                       dev_err(dev, "Device took %ums to "
-                                    "reset. MAX expected: 40ms\n",
-                                    jiffies_to_msecs(duration));
-       }
+                         5000, "hardware reset") < 0)
+               return -EBUSY;
 
        /* Set the event buffer, start the controller (enable IRQs later) */
        le_writel(0, whcrc->rc_base + URCINTR);
        le_writel(URCCMD_RS, whcrc->rc_base + URCCMD);
-       result = -ETIMEDOUT;
-       if (d_test(3))
-               start = jiffies;
        if (whci_wait_for(dev, whcrc->rc_base + URCSTS, URCSTS_HALTED, 0,
-                         5000, "device to start") < 0)
-               goto error;
-       if (d_test(3)) {
-               duration = jiffies - start;
-               if (duration > msecs_to_jiffies(40))
-                       dev_err(dev, "Device took %ums to start. "
-                                    "MAX expected: 40ms\n",
-                                    jiffies_to_msecs(duration));
-       }
+                         5000, "radio controller start") < 0)
+               return -ETIMEDOUT;
        whcrc_enable_events(whcrc);
-       result = 0;
        le_writel(URCINTR_EN_ALL, whcrc->rc_base + URCINTR);
-error:
-       return result;
+       return 0;
 }
 
 
@@ -395,7 +370,7 @@ void whcrc_stop_rc(struct uwb_rc *rc)
 
        le_writel(0, whcrc->rc_base + URCCMD);
        whci_wait_for(&umc_dev->dev, whcrc->rc_base + URCSTS,
-                     URCSTS_HALTED, 0, 40, "URCSTS.HALTED");
+                     URCSTS_HALTED, URCSTS_HALTED, 100, "radio controller stop");
 }
 
 static void whcrc_init(struct whcrc *whcrc)
@@ -489,6 +464,24 @@ static void whcrc_remove(struct umc_dev *umc_dev)
        d_printf(1, &umc_dev->dev, "freed whcrc %p\n", whcrc);
 }
 
+static int whcrc_pre_reset(struct umc_dev *umc)
+{
+       struct whcrc *whcrc = umc_get_drvdata(umc);
+       struct uwb_rc *uwb_rc = whcrc->uwb_rc;
+
+       uwb_rc_pre_reset(uwb_rc);
+       return 0;
+}
+
+static int whcrc_post_reset(struct umc_dev *umc)
+{
+       struct whcrc *whcrc = umc_get_drvdata(umc);
+       struct uwb_rc *uwb_rc = whcrc->uwb_rc;
+
+       uwb_rc_post_reset(uwb_rc);
+       return 0;
+}
+
 /* PCI device ID's that we handle [so it gets loaded] */
 static struct pci_device_id whcrc_id_table[] = {
        { PCI_DEVICE_CLASS(PCI_CLASS_WIRELESS_WHCI, ~0) },
@@ -497,10 +490,12 @@ static struct pci_device_id whcrc_id_table[] = {
 MODULE_DEVICE_TABLE(pci, whcrc_id_table);
 
 static struct umc_driver whcrc_driver = {
-       .name   = "whc-rc",
-       .cap_id = UMC_CAP_ID_WHCI_RC,
-       .probe  = whcrc_probe,
-       .remove = whcrc_remove,
+       .name       = "whc-rc",
+       .cap_id     = UMC_CAP_ID_WHCI_RC,
+       .probe      = whcrc_probe,
+       .remove     = whcrc_remove,
+       .pre_reset  = whcrc_pre_reset,
+       .post_reset = whcrc_post_reset,
 };
 
 static int __init whcrc_driver_init(void)
index 3df2388f908fd713e2b58519b8f4376676362c09..1f8964ed98825914d9b68ebde4a1345dac33a18e 100644 (file)
@@ -67,11 +67,11 @@ int whci_wait_for(struct device *dev, u32 __iomem *reg, u32 mask, u32 result,
                val = le_readl(reg);
                if ((val & mask) == result)
                        break;
-               msleep(10);
                if (t >= max_ms) {
-                       dev_err(dev, "timed out waiting for %s ", tag);
+                       dev_err(dev, "%s timed out\n", tag);
                        return -ETIMEDOUT;
                }
+               msleep(10);
                t += 10;
        }
        return 0;
@@ -111,7 +111,7 @@ static int whci_add_cap(struct whci_card *card, int n)
                + UWBCAPDATA_TO_OFFSET(capdata);
        umc->resource.end    = umc->resource.start
                + (n == 0 ? 0x20 : UWBCAPDATA_TO_SIZE(capdata)) - 1;
-       umc->resource.name   = umc->dev.bus_id;
+       umc->resource.name   = dev_name(&umc->dev);
        umc->resource.flags  = card->pci->resource[bar].flags;
        umc->resource.parent = &card->pci->resource[bar];
        umc->irq             = card->pci->irq;
index 1c94fabfb1a74c429855b1352094e201d41347de..3e8d5de7c5b957ec38f594fe60b7e37101e0c280 100644 (file)
@@ -42,10 +42,6 @@ enum wlp_wss_connect {
 extern struct kobj_type wss_ktype;
 extern struct attribute_group wss_attr_group;
 
-extern int uwb_rc_ie_add(struct uwb_rc *, const struct uwb_ie_hdr *, size_t);
-extern int uwb_rc_ie_rm(struct uwb_rc *, enum uwb_ie);
-
-
 /* This should be changed to a dynamic array where entries are sorted
  * by eth_addr and search is done in a binary form
  *
index 0799402e73fbeace0af949b8f51a93ad4e67813b..e531093c41626407b2743f966821028a9615809f 100644 (file)
@@ -526,7 +526,17 @@ void wlp_uwb_notifs_cb(void *_wlp, struct uwb_dev *uwb_dev,
        }
 }
 
-int wlp_setup(struct wlp *wlp, struct uwb_rc *rc)
+static void wlp_channel_changed(struct uwb_pal *pal, int channel)
+{
+       struct wlp *wlp = container_of(pal, struct wlp, pal);
+
+       if (channel < 0)
+               netif_carrier_off(wlp->ndev);
+       else
+               netif_carrier_on(wlp->ndev);
+}
+
+int wlp_setup(struct wlp *wlp, struct uwb_rc *rc, struct net_device *ndev)
 {
        struct device *dev = &rc->uwb_dev.dev;
        int result;
@@ -537,13 +547,16 @@ int wlp_setup(struct wlp *wlp, struct uwb_rc *rc)
        BUG_ON(wlp->stop_queue == NULL);
        BUG_ON(wlp->start_queue == NULL);
        wlp->rc = rc;
+       wlp->ndev = ndev;
        wlp_eda_init(&wlp->eda);/* Set up address cache */
        wlp->uwb_notifs_handler.cb = wlp_uwb_notifs_cb;
        wlp->uwb_notifs_handler.data = wlp;
        uwb_notifs_register(rc, &wlp->uwb_notifs_handler);
 
        uwb_pal_init(&wlp->pal);
-       result = uwb_pal_register(rc, &wlp->pal);
+       wlp->pal.rc = rc;
+       wlp->pal.channel_changed = wlp_channel_changed;
+       result = uwb_pal_register(&wlp->pal);
        if (result < 0)
                uwb_notifs_deregister(wlp->rc, &wlp->uwb_notifs_handler);
 
@@ -557,7 +570,7 @@ void wlp_remove(struct wlp *wlp)
        struct device *dev = &wlp->rc->uwb_dev.dev;
        d_fnstart(6, dev, "wlp %p\n", wlp);
        wlp_neighbors_release(wlp);
-       uwb_pal_unregister(wlp->rc, &wlp->pal);
+       uwb_pal_unregister(&wlp->pal);
        uwb_notifs_deregister(wlp->rc, &wlp->uwb_notifs_handler);
        wlp_eda_release(&wlp->eda);
        mutex_lock(&wlp->mutex);
index a102561e702664361362371f38bd472f73a1580e..fb7c359bdfba2b26a9cdaf2de3f3b55616f816b5 100644 (file)
@@ -51,6 +51,7 @@ enum {
        WUSB_REQ_GET_TIME       = 25,
        WUSB_REQ_SET_STREAM_IDX = 26,
        WUSB_REQ_SET_WUSB_MAS   = 27,
+       WUSB_REQ_CHAN_STOP      = 28,
 };
 
 
index f9ccbd9a2ced4fd832d6b7c12e7d687c7bcba545..d7ed5201ade656819526638bb8036bd3a725fb71 100644 (file)
@@ -30,6 +30,7 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/timer.h>
+#include <linux/wait.h>
 #include <linux/workqueue.h>
 #include <linux/uwb/spec.h>
 
@@ -86,6 +87,22 @@ struct uwb_notifs_chain {
        struct mutex mutex;
 };
 
+/* Beacon cache list */
+struct uwb_beca {
+       struct list_head list;
+       size_t entries;
+       struct mutex mutex;
+};
+
+/* Event handling thread. */
+struct uwbd {
+       int pid;
+       struct task_struct *task;
+       wait_queue_head_t wq;
+       struct list_head event_list;
+       spinlock_t event_list_lock;
+};
+
 /**
  * struct uwb_mas_bm - a bitmap of all MAS in a superframe
  * @bm: a bitmap of length #UWB_NUM_MAS
@@ -201,6 +218,7 @@ struct uwb_rsv {
        struct uwb_rc *rc;
        struct list_head rc_node;
        struct list_head pal_node;
+       struct kref kref;
 
        struct uwb_dev *owner;
        struct uwb_rsv_target target;
@@ -337,10 +355,14 @@ struct uwb_rc {
        u8 ctx_roll;
 
        int beaconing;                  /* Beaconing state [channel number] */
+       int beaconing_forced;
        int scanning;
        enum uwb_scan_type scan_type:3;
        unsigned ready:1;
        struct uwb_notifs_chain notifs_chain;
+       struct uwb_beca uwb_beca;
+
+       struct uwbd uwbd;
 
        struct uwb_drp_avail drp_avail;
        struct list_head reservations;
@@ -352,8 +374,8 @@ struct uwb_rc {
        struct uwb_rc_cmd_set_ie *ies;
        size_t ies_capacity;
 
-       spinlock_t pal_lock;
        struct list_head pals;
+       int active_pals;
 
        struct uwb_dbg *dbg;
 };
@@ -361,11 +383,19 @@ struct uwb_rc {
 
 /**
  * struct uwb_pal - a UWB PAL
- * @name:    descriptive name for this PAL (wushc, wlp, etc.).
+ * @name:    descriptive name for this PAL (wusbhc, wlp, etc.).
  * @device:  a device for the PAL.  Used to link the PAL and the radio
  *           controller in sysfs.
+ * @rc:      the radio controller the PAL uses.
+ * @channel_changed: called when the channel used by the radio changes.
+ *           A channel of -1 means the channel has been stopped.
  * @new_rsv: called when a peer requests a reservation (may be NULL if
  *           the PAL cannot accept reservation requests).
+ * @channel: channel being used by the PAL; 0 if the PAL isn't using
+ *           the radio; -1 if the PAL wishes to use the radio but
+ *           cannot.
+ * @debugfs_dir: a debugfs directory which the PAL can use for its own
+ *           debugfs files.
  *
  * A Protocol Adaptation Layer (PAL) is a user of the WiMedia UWB
  * radio platform (e.g., WUSB, WLP or Bluetooth UWB AMP).
@@ -384,12 +414,21 @@ struct uwb_pal {
        struct list_head node;
        const char *name;
        struct device *device;
-       void (*new_rsv)(struct uwb_rsv *rsv);
+       struct uwb_rc *rc;
+
+       void (*channel_changed)(struct uwb_pal *pal, int channel);
+       void (*new_rsv)(struct uwb_pal *pal, struct uwb_rsv *rsv);
+
+       int channel;
+       struct dentry *debugfs_dir;
 };
 
 void uwb_pal_init(struct uwb_pal *pal);
-int uwb_pal_register(struct uwb_rc *rc, struct uwb_pal *pal);
-void uwb_pal_unregister(struct uwb_rc *rc, struct uwb_pal *pal);
+int uwb_pal_register(struct uwb_pal *pal);
+void uwb_pal_unregister(struct uwb_pal *pal);
+
+int uwb_radio_start(struct uwb_pal *pal);
+void uwb_radio_stop(struct uwb_pal *pal);
 
 /*
  * General public API
@@ -443,8 +482,6 @@ ssize_t uwb_rc_vcmd(struct uwb_rc *rc, const char *cmd_name,
                    struct uwb_rccb *cmd, size_t cmd_size,
                    u8 expected_type, u16 expected_event,
                    struct uwb_rceb **preply);
-ssize_t uwb_rc_get_ie(struct uwb_rc *, struct uwb_rc_evt_get_ie **);
-int uwb_bg_joined(struct uwb_rc *rc);
 
 size_t __uwb_addr_print(char *, size_t, const unsigned char *, int);
 
@@ -520,6 +557,8 @@ void uwb_rc_rm(struct uwb_rc *);
 void uwb_rc_neh_grok(struct uwb_rc *, void *, size_t);
 void uwb_rc_neh_error(struct uwb_rc *, int);
 void uwb_rc_reset_all(struct uwb_rc *rc);
+void uwb_rc_pre_reset(struct uwb_rc *rc);
+void uwb_rc_post_reset(struct uwb_rc *rc);
 
 /**
  * uwb_rsv_is_owner - is the owner of this reservation the RC?
@@ -531,7 +570,9 @@ static inline bool uwb_rsv_is_owner(struct uwb_rsv *rsv)
 }
 
 /**
- * Events generated by UWB that can be passed to any listeners
+ * enum uwb_notifs - UWB events that can be passed to any listeners
+ * @UWB_NOTIF_ONAIR: a new neighbour has joined the beacon group.
+ * @UWB_NOTIF_OFFAIR: a neighbour has left the beacon group.
  *
  * Higher layers can register callback functions with the radio
  * controller using uwb_notifs_register(). The radio controller
@@ -539,8 +580,6 @@ static inline bool uwb_rsv_is_owner(struct uwb_rsv *rsv)
  * nodes when an event occurs.
  */
 enum uwb_notifs {
-       UWB_NOTIF_BG_JOIN = 0,  /* radio controller joined a beacon group */
-       UWB_NOTIF_BG_LEAVE = 1, /* radio controller left a beacon group */
        UWB_NOTIF_ONAIR,
        UWB_NOTIF_OFFAIR,
 };
@@ -652,22 +691,9 @@ static inline int edc_inc(struct edc *err_hist, u16 max_err, u16 timeframe)
 
 /* Information Element handling */
 
-/* For representing the state of writing to a buffer when iterating */
-struct uwb_buf_ctx {
-       char *buf;
-       size_t bytes, size;
-};
-
-typedef int (*uwb_ie_f)(struct uwb_dev *, const struct uwb_ie_hdr *,
-                       size_t, void *);
-struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len);
-ssize_t uwb_ie_for_each(struct uwb_dev *uwb_dev, uwb_ie_f fn, void *data,
-                       const void *buf, size_t size);
-int uwb_ie_dump_hex(struct uwb_dev *, const struct uwb_ie_hdr *,
-                   size_t, void *);
-int uwb_rc_set_ie(struct uwb_rc *, struct uwb_rc_cmd_set_ie *);
 struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len);
-
+int uwb_rc_ie_add(struct uwb_rc *uwb_rc, const struct uwb_ie_hdr *ies, size_t size);
+int uwb_rc_ie_rm(struct uwb_rc *uwb_rc, enum uwb_ie element_id);
 
 /*
  * Transmission statistics
index 1141f41bab5c6c15b7446437671bc6179c7a0b8d..07efbe17db533f997944d24a70494ae979082faa 100644 (file)
 enum uwb_dbg_cmd_type {
        UWB_DBG_CMD_RSV_ESTABLISH = 1,
        UWB_DBG_CMD_RSV_TERMINATE = 2,
+       UWB_DBG_CMD_IE_ADD = 3,
+       UWB_DBG_CMD_IE_RM = 4,
+       UWB_DBG_CMD_RADIO_START = 5,
+       UWB_DBG_CMD_RADIO_STOP = 6,
 };
 
 struct uwb_dbg_cmd_rsv_establish {
@@ -46,11 +50,18 @@ struct uwb_dbg_cmd_rsv_terminate {
        int index;
 };
 
+struct uwb_dbg_cmd_ie {
+       __u8 data[128];
+       int len;
+};
+
 struct uwb_dbg_cmd {
        __u32 type;
        union {
                struct uwb_dbg_cmd_rsv_establish rsv_establish;
                struct uwb_dbg_cmd_rsv_terminate rsv_terminate;
+               struct uwb_dbg_cmd_ie ie_add;
+               struct uwb_dbg_cmd_ie ie_rm;
        };
 };
 
index a86a73fe303fc6a59ce1c3280ac2229de8bab912..67a240527145f8c40fbc1b7ab2fd68d0f2e7749e 100644 (file)
@@ -60,7 +60,7 @@ do {                                                                  \
                                snprintf(__head, sizeof(__head),        \
                                         "%s %s: ",                     \
                                         dev_driver_string(__dev),      \
-                                        __dev->bus_id);                \
+                                        dev_name(__dev));              \
                }                                                       \
                printk(KERN_ERR "%s%s" _tag ": " f, __head,             \
                        __func__, ## a);                                \
index 198c15f8e25175570957041ae79ab27c1423cf8c..a30436ea53aa8d82d1177a24e708754a91b77f8d 100644 (file)
@@ -200,6 +200,12 @@ enum uwb_drp_reason {
        UWB_DRP_REASON_MODIFIED,
 };
 
+/** Relinquish Request Reason Codes ([ECMA-368] table 113) */
+enum uwb_relinquish_req_reason {
+       UWB_RELINQUISH_REQ_REASON_NON_SPECIFIC = 0,
+       UWB_RELINQUISH_REQ_REASON_OVER_ALLOCATION,
+};
+
 /**
  *  DRP Notification Reason Codes (WHCI 0.95 [3.1.4.9])
  */
@@ -252,6 +258,7 @@ enum uwb_ie {
        UWB_APP_SPEC_PROBE_IE = 15,
        UWB_IDENTIFICATION_IE = 19,
        UWB_MASTER_KEY_ID_IE = 20,
+       UWB_RELINQUISH_REQUEST_IE = 21,
        UWB_IE_WLP = 250, /* WiMedia Logical Link Control Protocol WLP 0.99 */
        UWB_APP_SPEC_IE = 255,
 };
@@ -365,6 +372,27 @@ struct uwb_ie_drp_avail {
        DECLARE_BITMAP(bmp, UWB_NUM_MAS);
 } __attribute__((packed));
 
+/* Relinqish Request IE ([ECMA-368] section 16.8.19). */
+struct uwb_relinquish_request_ie {
+        struct uwb_ie_hdr       hdr;
+        __le16                  relinquish_req_control;
+        struct uwb_dev_addr     dev_addr;
+        struct uwb_drp_alloc    allocs[];
+} __attribute__((packed));
+
+static inline int uwb_ie_relinquish_req_reason_code(struct uwb_relinquish_request_ie *ie)
+{
+       return (le16_to_cpu(ie->relinquish_req_control) >> 0) & 0xf;
+}
+
+static inline void uwb_ie_relinquish_req_set_reason_code(struct uwb_relinquish_request_ie *ie,
+                                                        int reason_code)
+{
+       u16 ctrl = le16_to_cpu(ie->relinquish_req_control);
+       ctrl = (ctrl & ~(0xf << 0)) | (reason_code << 0);
+       ie->relinquish_req_control = cpu_to_le16(ctrl);
+}
+
 /**
  * The Vendor ID is set to an OUI that indicates the vendor of the device.
  * ECMA-368 [16.8.10]
index 36a39e34f8d7dd47ff54690f4b255ed88f613a58..4b4fc0f4385578548b70e1bb841599a387b454d9 100644 (file)
@@ -89,6 +89,8 @@ struct umc_driver {
        void (*remove)(struct umc_dev *);
        int  (*suspend)(struct umc_dev *, pm_message_t state);
        int  (*resume)(struct umc_dev *);
+       int  (*pre_reset)(struct umc_dev *);
+       int  (*post_reset)(struct umc_dev *);
 
        struct device_driver driver;
 };
index 033545e145c779f3aa1d84f5a4e62c85bfc97b32..ac95ce6606ac1c0ac3ae35842deead4ad0cdb606 100644 (file)
@@ -646,6 +646,7 @@ struct wlp_wss {
 struct wlp {
        struct mutex mutex;
        struct uwb_rc *rc;              /* UWB radio controller */
+       struct net_device *ndev;
        struct uwb_pal pal;
        struct wlp_eda eda;
        struct wlp_uuid uuid;
@@ -675,7 +676,7 @@ struct wlp_wss_attribute {
 static struct wlp_wss_attribute wss_attr_##_name = __ATTR(_name, _mode,        \
                                                          _show, _store)
 
-extern int wlp_setup(struct wlp *, struct uwb_rc *);
+extern int wlp_setup(struct wlp *, struct uwb_rc *, struct net_device *ndev);
 extern void wlp_remove(struct wlp *);
 extern ssize_t wlp_neighborhood_show(struct wlp *, char *);
 extern int wlp_wss_setup(struct net_device *, struct wlp_wss *);